中金转债｜左右开弓，择时策略的逻辑闭环与Python建议

def stateMatrix(obj):
    mat01 = obj.matNormal # 剔除双高



    
    close = (obj.Close * mat01).median(axis=1).fillna(method='pad') 
    impv = (obj.ImpliedVol * mat01).median(axis=1).fillna(method="pad")
    srsStrbPrem = (obj.StrbPrem * 
               mat01).mean(axis=1).fillna(method="pad") 

    srsStrbPrem_bias = srsStrbPrem - srsStrbPrem.rolling(20).mean()
    
    dfMat = pd.DataFrame({'median_price': close,
    'impv': impv,
    'srsStrbPrem_bias': srsStrbPrem_bias})

    return dfMat

class Agent:
    def __init__(self, input_size, hidden_size, action_size, lr=0.001, gamma=0.9,
                 weight_decay=0.0005):
        self.net = DQN_InOne(input_size, hidden_size, action_size)
        self.optimizer = optim.Adam(self.net.parameters(), lr=lr, weight_decay=weight_decay)
        self.gamma = gamma # discount factor
        self.loss_fn = nn.MSELoss()

    def get_action(self, state, action_space, epsilon=0.1):
        if


    
 np.random.random() < epsilon:  # exploration
            return np.random.choice(action_space), True
        else:  
            with torch.no_grad():
                q_values = self.net(state)
                return torch.argmax(q_values).item(), False

    def update(self, state, action, reward, next_state):
        q_values = self.net(state)
        with torch.no_grad():
            q_next = self.net(next_state)
        q_target = reward + self.gamma * torch.max(q_next)

        loss = self.loss_fn(q_values[action], q_target)
        self.optimizer.zero_grad()
        loss.backward()
        self.optimizer.step()

def train_finetune(model, dataloader): 
    param_need_update = ['fc1.weight', 'fc1.bias']
    # 冻结模型不需要调整的参数
    for name， param in model.parameters():
        if not name in param_need_update:
            param.requires_grad = False
    
    # 只有存在梯度的参数，即第一层
    optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
    # 定义损失函数，以交叉熵为例
    criterion = nn.CrossEntropyLoss()
    # 假设我们有一个数据加载器 dataloader
    for epoch in range(5): # 训练5个epoch
        for inputs, labels in dataloader:
            optimizer.zero_grad() 
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            
            # 反向传播和优化
            loss.backward()
            optimizer.step()
        



    
        print(f'Epoch {epoch+1}, Loss: {loss.item()}')
    
    print("微调完成")