DDQN 股票交易代码实际代码

Question

我想寻找DDQN 用于股票交易的代码模板或者实战，是进行T+1期的股票交易，我自己弄代码结果跑完后结果都是负值没能跑赢buy and hold策略，效果很差，我想了解一下别人的代码设置以及相关参数的具体设置

Answer 1

上午好☀️☀️☀️️
本答案参考通义千问

你提到使用 DDQN（Double Deep Q-Network） 用于股票交易，但结果不如 Buy and Hold 策略，这说明在模型训练、环境设计或参数设置上可能存在一些问题。下面我将从几个方面详细分析，并提供一个适用于 T+1 股票交易 的 DDQN 模板代码和相关建议。

---

一、DDQN 在股票交易中的常见问题

1. 环境设计不合理

• 状态空间（State Space）：需要合理选择特征，如历史价格、技术指标（MACD、RSI、KDJ等）、成交量等。
• 动作空间（Action Space）：通常为买入、卖出、持有，也可以是仓位比例（如0%、50%、100%）。
• 奖励函数（Reward Function）：直接影响模型学习效果。常见的有：
  • 盈亏差
  • 收益率
  • 风险调整后的收益（如 Sharpe Ratio）

2. 数据预处理不充分

• 未进行归一化或标准化，导致神经网络难以收敛。
• 数据缺失或噪声未处理，影响模型学习。

3. 超参数设置不当

• 学习率（learning rate）过高或过低
• 奖励衰减因子（gamma）设置不合理
• 批次大小（batch size）太小
• 网络结构不合理（如层数太少或激活函数不合适）

4. 训练策略问题

• 未使用经验回放（Experience Replay）
• 未使用双网络结构（DDQN 的核心）
• 训练时间不足，模型未收敛

---

二、DDQN 用于 T+1 股票交易的模板代码

以下是一个基于 PyTorch 的 DDQN 用于 T+1 股票交易 的简化代码模板，包含完整的训练流程与关键参数设置。

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from collections import deque
import random

# 1. 定义环境类（简化版）
class StockEnv:
    def __init__(self, data, lookback=5):
        self.data = data
        self.lookback = lookback
        self.n = len(data)
        self.state_size = lookback * 5  # 假设每一步包含5个特征（如开盘、收盘、最高、最低、成交量）
        self.action_space = [0, 1, 2]  # 0: hold, 1: buy, 2: sell
        self.current_step = lookback

    def reset(self):
        self.current_step = self.lookback
        return self._get_state()

    def _get_state(self):
        return self.data[self.current_step - self.lookback : self.current_step].flatten()

    def step(self, action):
        if action == 1:  # buy
            reward = self.data[self.current_step][1] - self.data[self.current_step - 1][1]
        elif action == 2:  # sell
            reward = self.data[self.current_step - 1][1] - self.data[self.current_step][1]
        else:
            reward = 0
        self.current_step += 1
        done = self.current_step >= self.n
        next_state = self._get_state()
        return next_state, reward, done

# 2. 定义 DDQN 网络
class DQN(nn.Module):
    def __init__(self, state_size, action_size):
        super(DQN, self).__init__()
        self.fc1 = nn.Linear(state_size, 64)
        self.fc2 = nn.Linear(64, 64)
        self.fc3 = nn.Linear(64, action_size)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        return self.fc3(x)

# 3. 定义 DDQN Agent
class DDQNAgent:
    def __init__(self, state_size, action_size):
        self.state_size = state_size
        self.action_size = action_size
        self.gamma = 0.95  # 奖励衰减因子
        self.lr = 0.001  # 学习率
        self.batch_size = 64
        self.memory = deque(maxlen=10000)  # 经验回放缓冲区
        self.model = DQN(state_size, action_size)
        self.target_model = DQN(state_size, action_size)
        self.optimizer = optim.Adam(self.model.parameters(), lr=self.lr)

    def act(self, state, epsilon=0.1):
        if random.random() < epsilon:
            return random.randint(0, self.action_size - 1)
        else:
            with torch.no_grad():
                state = torch.FloatTensor(state)
                q_values = self.model(state)
                return torch.argmax(q_values).item()

    def remember(self, state, action, reward, next_state, done):
        self.memory.append((state, action, reward, next_state, done))

    def train(self):
        if len(self.memory) < self.batch_size:
            return
        batch = random.sample(self.memory, self.batch_size)
        states, actions, rewards, next_states, dones = zip(*batch)

        states = torch.FloatTensor(np.array(states))
        actions = torch.LongTensor(actions)
        rewards = torch.FloatTensor(rewards)
        next_states = torch.FloatTensor(np.array(next_states))
        dones = torch.FloatTensor(dones)

        # 计算 Q 值
        q_values = self.model(states).gather(1, actions.unsqueeze(1)).squeeze()
        next_q_values = self.target_model(next_states).max(dim=1)[0]
        expected_q_values = rewards + (1 - dones) * self.gamma * next_q_values

        loss = nn.MSELoss()(q_values, expected_q_values)
        self.optimizer.zero_grad()
        loss.backward()
        self.optimizer.step()

    def update_target_network(self):
        self.target_model.load_state_dict(self.model.state_dict())

# 4. 主程序
def train_ddqn(data, episodes=1000, lookback=5):
    env = StockEnv(data, lookback=lookback)
    agent = DDQNAgent(env.state_size, len(env.action_space))
    for episode in range(episodes):
        state = env.reset()
        total_reward = 0
        done = False
        while not done:
            action = agent.act(state, epsilon=0.1)
            next_state, reward, done = env.step(action)
            agent.remember(state, action, reward, next_state, done)
            state = next_state
            total_reward += reward
        agent.train()
        if episode % 10 == 0:
            agent.update_target_network()
        print(f"Episode {episode}, Total Reward: {total_reward}")

---

三、关键参数设置建议

| 参数 | 推荐值 | 说明 | |------|--------|------| | lookback | 5~20 | 用于构造状态的历史数据长度 | | gamma | 0.95~0.99 | 奖励衰减因子，越大表示更关注长期收益 | | lr | 0.001~0.0001 | 学习率，需根据数据量调整 | | batch_size | 32~64 | 太小易波动，太大可能内存不足 | | epsilon | 0.1~0.5 | 控制探索与利用的比例 | | episodes | 1000~5000 | 训练轮数，越多越可能收敛 |

---

四、优化建议

1. 改进奖励函数

• 使用 收益率 或 风险调整后收益（如 Sharpe Ratio）作为奖励
• 避免只用绝对收益，防止模型过于贪婪

2. 增加特征维度

• 添加技术指标（如 RSI、MACD、Bollinger Bands）
• 可以尝试多窗口特征（如 5 日、20 日、60 日均线）

3. 使用更复杂的网络结构

• 增加隐藏层数量或使用 LSTM 来处理时序信息
• 尝试使用注意力机制增强模型对关键特征的识别能力

4. 加入正则化与早停机制

• 防止过拟合
• 在验证集上监控性能，避免训练过多导致性能下降

---

五、参考代码来源

你可以参考以下开源项目或论文：

• Deep Reinforcement Learning for Stock Trading
• DDQN with Python for Stock Market Prediction
• 论文：Deep Reinforcement Learning for Automated Stock Trading

---

六、总结

重点部分：

• DDQN 在股票交易中需要合理设计状态、动作和奖励函数。
• 数据预处理和特征工程是提升模型表现的关键。
• 超参数调优（如学习率、折扣因子、探索率）对模型最终效果至关重要。

如果你能按照上述模板进行实验并逐步优化，相信你的模型会比 Buy and Hold 更好。欢迎继续提问！