强化学习实战：用 PPO 算法实现动态资产配置策略 —— 从原理到代码的量化投资指南

强化学习实战：用 PPO 算法实现动态资产配置策略 —— 从原理到代码的量化投资指南

---

前言

在量化投资领域，如何在动态变化的市场中实现收益与风险的平衡，始终是研究者和从业者的核心课题。传统的资产配置方法（如均值-方差优化、风险平价模型）依赖固定规则和历史统计特性，难以实时适应市场波动和新兴趋势。而强化学习（Reinforcement Learning, RL）的出现，为这一问题提供了全新的解决方案——它能让算法像人类交易员一样，通过与市场环境的持续互动，自主学习最优的动态调仓策略。
作为RL中最稳定且高效的算法之一，**近端策略优化（PPO）**特别适合处理连续动作空间问题（如资产权重的精细调整）。它通过“试错-评估-改进”的循环，自动捕捉市场状态（如资产波动率、行业轮动强度）与调仓动作（如权重增减）之间的映射关系，无需预设交易规则即可实现自适应决策。
本文将从原理解析、代码实现到可视化评估，完整拆解基于PPO的动态调仓策略。无论你是量化投资的初学者，还是希望将AI技术落地到实盘的从业者，都能通过本文掌握核心逻辑，并获得可直接运行的完整代码框架。让我们一起走进强化学习与金融市场的交互世界，探索数据驱动的智能投资新范式。

1. 策略原理深度解析

核心逻辑：
通过Proximal Policy Optimization（PPO）算法与市场环境持续交互，学习动态调整多资产权重的策略，实现收益-风险平衡。关键要素：

• 状态空间（State）：
  • 持仓权重向量（n_assets维）
  • 各资产近期收益率（n_assets×5维，5日窗口）
  • 市场宽基指标（波动率、流动性、行业轮动强度）
• 动作空间（Action）：
  • 连续动作：资产权重调整方向与幅度（Δw ∈ [-0.1, 0.1]^n_assets）
  • 约束条件：∑(w + Δw) = 1，w ≥ 0（禁止做空）
• 奖励函数（Reward）：

  reward = portfolio_return - 0.5 * portfolio_volatility - 2.0 * max_drawdown  
  

技术优势：

• 自适应市场环境变化，无需预设交易规则
• 通过重要性采样实现稳定策略更新
• 剪切目标函数防止策略突变

---

2. 完整策略实现代码

步骤1：构建交易环境（PyTorch实现）

import os

os.environ["KMP_DUPLICATE_LIB_OK"] = "True"

import numpy as np
import pandas as pd
import torch
import torch.nn as nn
import torch.optim as optim
from torch.distributions import Normal
import matplotlib.pyplot as plt


class PortfolioEnv:
    def __init__(self, prices, lookback=30, init_balance=1e6):
        self.prices = prices
        self.n_assets = prices.shape[1]
        self.lookback = lookback
        self.init_balance = init_balance
        self.reset()

    def reset(self):
        self.current_step = self.lookback
        self.weights = np.ones(self.n_assets) / self.n_assets
        self.portfolio_value = self.init_balance
        return self._get_state()

    def _get_state(self):
        returns = (
            self.prices.iloc[self.current_step - self.lookback : self.current_step]
            .pct_change()
            .dropna()
        )
        vol = returns.std().values * np.sqrt(252)
        liquidity = self.prices.iloc[self.current_step].values / 1e6
        return np.concatenate(
            [self.weights, returns.tail(5).values.flatten(), vol, liquidity]
        )

    def step(self, action):
        new_weights = self.weights + action
        new_weights = np.clip(new_weights, 0, None)
        new_weights = np.minimum(new_weights, 0.3)

        if new_weights.sum() == 0:
            new_weights = np.ones(self.n_assets) / self.n_assets
        else:
            new_weights /= new_weights.sum()

        prev_prices = self.prices.iloc[self.current_step - 1].values
        curr_prices = self.prices.iloc[self.current_step].values
        returns = (curr_prices / prev_prices - 1) * new_weights
        portfolio_return = np.sum(returns)

        turnover = np.abs(new_weights - self.weights).sum()
        reward = portfolio_return - 0.5 * np.std(returns) - 0.001 * turnover

        if np.any(curr_prices / prev_prices < 0.9):
            new_weights = np.ones(self.n_assets) / self.n_assets

        self.portfolio_value *= 1 + portfolio_return
        self.weights = new_weights
        self.current_step += 1

        done = self.current_step >= len(self.prices) - 1
        return self._get_state(), reward, done, {}

步骤2：PPO策略网络与训练循环

class PPOPolicy(nn.Module):
    def __init__(self, state_dim, action_dim):
        super().__init__()
        self.actor = nn.Sequential(
            nn.Linear(state_dim, 256),
            nn.ReLU(),
            nn.Linear(256, action_dim * 2),
        )
        self.critic = nn.Sequential(
            nn.Linear(state_dim, 256), nn.ReLU(), nn.Linear(256, 1)
        )

    def forward(self, state):
        action_params = self.actor(state)
        mu, log_std = action_params.chunk(2, dim=-1)
        mu = torch.tanh(mu) * 0.1  # 限制动作范围
        std = log_std.exp().clamp(max=0.2)
        return mu, std, self.critic(state)


def train_ppo(
    env,
    policy,
    optimizer,
    episodes=1000,
    gamma=0.99,
    clip_epsilon=0.2,
    epochs=4,
    batch_size=64,
):
    episode_rewards = []

    for episode in range(episodes):
        state = env.reset()
        states, actions, rewards, log_probs = [], [], [], []
        done = False

        # 数据收集
        while not done:
            with torch.no_grad():
                state_tensor = torch.FloatTensor(state).unsqueeze(0)
                mu, std, val = policy(state_tensor)

                if torch.isnan(mu).any() or torch.isnan(std).any():
                    print("NaN detected, skipping episode")
                    break

                dist = Normal(mu, std)
                action = dist.sample()
                log_prob = dist.log_prob(action).sum(-1)

            next_state, reward, done, _ = env.step(action.squeeze(0).numpy())

            states.append(state)
            actions.append(action.squeeze(0))
            rewards.append(reward)
            log_probs.append(log_prob)
            state = next_state

        if len(rewards) == 0:
            continue

        # 转换数据为tensor
        states_np = np.array(states)
        states_t = torch.FloatTensor(states_np)
        actions_t = torch.stack(actions)
        log_probs_t = torch.stack(log_probs)
        rewards_t = torch.FloatTensor(rewards)

        # 计算returns和advantages
        returns = []
        R = 0
        for r in reversed(rewards_t):
            R = r + gamma * R
            returns.insert(0, R)
        returns_t = torch.FloatTensor(returns)

        with torch.no_grad():
            _, _, values = policy(states_t)
        values_t = values.squeeze()
        advantages = returns_t - values_t

        # 归一化advantages
        advantages = (advantages - advantages.mean()) / (advantages.std() + 1e-8)

        # PPO优化
        for _ in range(epochs):
            indices = torch.randperm(len(states_t))
            for i in range(0, len(states_t), batch_size):
                idx = indices[i : i + batch_size]

                batch_states = states_t[idx]
                batch_actions = actions_t[idx]
                batch_old_log_probs = log_probs_t[idx]
                batch_returns = returns_t[idx]
                batch_advantages = advantages[idx]

                # 计算新策略参数
                mu_new, std_new, values_new = policy(batch_states)
                dist_new = Normal(mu_new, std_new)
                new_log_probs = dist_new.log_prob(batch_actions).sum(-1)

                # 计算ratio
                ratio = (new_log_probs - batch_old_log_probs).exp()
                surr1 = ratio * batch_advantages
                surr2 = (
                    ratio.clamp(1 - clip_epsilon, 1 + clip_epsilon) * batch_advantages
                )
                actor_loss = -torch.min(surr1, surr2).mean()

                # Critic损失
                critic_loss = nn.MSELoss()(values_new.squeeze(), batch_returns)

                # 总损失
                loss = actor_loss + 0.5 * critic_loss

                # 优化步骤
                optimizer.zero_grad()
                loss.backward()
                torch.nn.utils.clip_grad_norm_(policy.parameters(), max_norm=0.5)
                optimizer.step()

        episode_rewards.append(sum(rewards))
        print(f"Episode {episode+1}, Reward: {sum(rewards):.4f}")

    return episode_rewards


def evaluate_policy(env, policy):
    state = env.reset()
    portfolio_values = [env.init_balance]
    weights_history = [env.weights.copy()]

    while True:
        with torch.no_grad():
            state_tensor = torch.FloatTensor(state).unsqueeze(0)
            mu, _, _ = policy(state_tensor)
            action = mu.squeeze(0).numpy()

        next_state, _, done, _ = env.step(action)
        portfolio_values.append(env.portfolio_value)
        weights_history.append(env.weights.copy())
        state = next_state

        if done:
            break

    returns = pd.Series(portfolio_values).pct_change().dropna()
    sharpe = returns.mean() / returns.std() * np.sqrt(252)
    max_drawdown = (
        pd.Series(portfolio_values) / pd.Series(portfolio_values).cummax() - 1
    ).min()
    return sharpe, max_drawdown, weights_history

---

3. 可视化代码与解析

可视化1：训练过程奖励曲线（Training Performance - Cumulative Reward per Episode）

# 示例数据生成
np.random.seed(42)
n_assets = 5
n_days = 250
prices = pd.DataFrame(
    np.random.randn(n_days, n_assets).cumsum(axis=0) + 100,
    columns=[f"Asset_{i}" for i in range(n_assets)],
)

# 初始化环境和策略
env = PortfolioEnv(prices)
state_dim = len(env.reset())
action_dim = env.n_assets
policy = PPOPolicy(state_dim, action_dim)
optimizer = optim.Adam(policy.parameters(), lr=3e-4)

# 训练策略
rewards = train_ppo(env, policy, optimizer, episodes=100)

# 可视化训练结果
plt.figure(figsize=(12, 5))
plt.plot(rewards, color="#2ca02c", alpha=0.7)
plt.title("Training Performance - Cumulative Reward per Episode")
plt.xlabel("Episode")
plt.ylabel("Total Reward")
plt.grid(alpha=0.3)
plt.show()

图表说明：

• 横轴：训练轮次（Episode），表示算法与环境交互的次数。
• 纵轴：单轮总奖励（Total Reward），综合了组合收益、波动率惩罚、交易成本等因素。
• 曲线含义：
  • 若曲线整体上升，说明策略通过学习逐渐优化，能在多数市场状态下获得正奖励。
  • 波动反映算法的 “探索 - 利用” 过程：前期波动大（尝试不同策略），后期趋稳（收敛到有效策略）。
• 关键观察：
  • 奖励是否稳定增长？若长期低于 0，可能需调整奖励函数权重（如增加收益权重或降低风险惩罚）。
  • 是否存在 NaN 导致的中断？代码中的NaN检测可避免此类问题。

可视化2：资产权重动态调整（Dynamic Asset Allocation）

# 评估策略
env_eval = PortfolioEnv(prices)  # 创建新的评估环境
sharpe, max_dd, weights = evaluate_policy(env_eval, policy)
print(f"Sharpe Ratio: {sharpe:.4f}")
print(f"Max Drawdown: {max_dd:.4f}")

# 可视化资产配置
weights = np.array(weights[:-1])
plt.figure(figsize=(14, 6))
plt.stackplot(
    prices.index[env.lookback : -1],
    weights.T,
    labels=[f"Asset {i}" for i in range(n_assets)],
)
plt.title("Dynamic Asset Allocation")
plt.xlabel("Date")
plt.ylabel("Weight")
plt.legend(loc="upper left")
plt.grid(alpha=0.3)
plt.show()

图表说明：

• 横轴：时间（Date），基于示例数据的日期索引（代码中为随机生成的 250 天数据）。
• 纵轴：资产权重（Portfolio Weight），各资产权重之和始终为 1（堆叠面积总和为 1）。
• 颜色：不同颜色代表不同资产（如 Asset 0 到 Asset 4），面积变化反映权重调整。
• 核心价值：
  • 直观展示策略的 “行业轮动” 能力：若某资产近期收益高（如股票），权重可能增加；若波动大（如加密货币），权重可能降低。
  • 约束效果可视化：单资产权重不会超过 30%（代码中np.minimum限制），且无负权重（禁止做空）。
• 典型模式：
  • 牛市场景：高风险资产（如股票）权重上升，低风险资产（如债券）权重下降。
  • 熊市场景：权重向低波动资产集中，或触发熔断机制（重置等权重）。

---

4. 关键风险控制

1. 仓位限制：

   # 单资产权重不超过30%  
   new_weights = np.minimum(new_weights, 0.3)  
   new_weights /= new_weights.sum()  
   

2. 交易成本模型：

   turnover = np.abs(new_weights - self.weights).sum()  
   reward -= 0.001 * turnover  # 加入换手率惩罚  
   

3. 极端市场熔断：

   if np.any(curr_prices / prev_prices < 0.9):  
       new_weights = np.ones(n_assets) / n_assets  # 强制分散持仓  
   

---

5. 策略评估指标

def evaluate_policy(env, policy):  
    state = env.reset()  
    portfolio_values = [env.init_balance]  

    while True:  
        state_tensor = torch.FloatTensor(state).unsqueeze(0)  
        with torch.no_grad():  
            mu, std, _ = policy(state_tensor)  
            action = mu.squeeze().numpy()  

        state, reward, done, _ = env.step(action)  
        portfolio_values.append(env.portfolio_value)  
        if done:  
            break  

    returns = pd.Series(portfolio_values).pct_change().dropna()  
    sharpe = returns.mean() / returns.std() * np.sqrt(252)  
    max_drawdown = (pd.Series(portfolio_values) / pd.Series(portfolio_values).cummax() - 1).min()  
    return sharpe, max_drawdown  

---

结语

从“状态-动作-奖励”的核心循环，到代码中对风险控制、极端场景的工程化处理，我们见证了PPO算法如何从理论转化为可落地的动态调仓策略。其核心价值在于**“数据驱动的自适应能力”**——无需人为设定复杂规则，算法即可通过与市场的互动，自主学习出兼顾收益、风险与交易成本的最优配置方案。

当然，实际应用中仍需面对诸多挑战：历史数据与未来市场的分布差异（过拟合风险）、超参数调优的复杂性（如奖励函数权重、PPO剪切参数），以及真实交易中的滑点、流动性冲击等工程问题。这些都需要结合具体场景进一步打磨，但本文提供的代码框架和思路，为后续优化奠定了坚实基础。

对于希望实践的读者，建议从简单场景入手（如3-5只资产、短期历史数据），逐步验证策略有效性。你可以尝试调整奖励函数的风险权重，观察策略对“激进”或“保守”风格的适应；也可以替换真实金融数据（如股票、ETF收盘价），分析权重调整是否符合市场逻辑（如牛市增加股票仓位，熊市提高债券比例）。

强化学习在量化投资中的应用仍处于快速发展阶段，从单策略优化到多agent协同，从历史数据训练到实时在线学习，还有无数未知领域等待探索。希望本文能成为你踏入这一前沿领域的起点，让数据智能真正赋能投资决策，在复杂市场中找到属于自己的“最优解”。

立即动手运行代码，观察资产权重如何随市场波动动态调整，开启你的量化AI之旅吧！