backtest.py

import argparse
import os
from pathlib import Path
from typing import Optional, Dict, List, Tuple, Any, cast
import numpy as np
import torch
import torch.nn as nn
import json
import time
import re
import pandas as pd
from datetime import datetime
import math
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
# 设置中文字体（使用系统实际可用的字体）
plt.rcParams['font.sans-serif'] = ['Noto Sans CJK JP', 'Droid Sans Fallback', 'SimHei', 'Microsoft YaHei', 'DejaVu Sans']
plt.rcParams['axes.unicode_minus'] = False
# 不再抑制字体警告 - 如果有字体问题应该明确暴露
import warnings
# warnings.filterwarnings('ignore', category=UserWarning, module='matplotlib.font_manager')  # 已禁用：让字体问题明确暴露

from model import SpacetimeGNNMAM
from train import StreamingPanelDataset
from types import SimpleNamespace
from typing import cast
# RL 对比所需（策略网络与环境）
try:
    from rl_env import StockSelectionEnv  # 仅在启用 RL 对比时使用
    from rl_train import ActorCritic, prepare_env_arrays, make_env_from_data
except Exception:
    StockSelectionEnv = None  # 延迟到运行期校验
    ActorCritic = None
    prepare_env_arrays = None
    make_env_from_data = None


_VE_EDM_MULTI_WARNED = False


class StepVarianceRecorder:
    """记录多步推理每一步的预测值,最后跨时间计算std（分标的、分样本）。
    
    逻辑:
    1. 每个决策日记录 x_i[step, sample, asset] 和 y0_hat_i[step, sample, asset]
    2. 累计S个决策日后,对每个(step, sample, asset)计算跨时间的std
    3. 这样可以看到每一步的预测值的时间波动性演化
    """

    def __init__(self, steps: int, num_samples: int, num_assets: int):
        self.steps = int(max(0, steps))
        self.num_samples = int(max(0, num_samples))
        self.num_assets = int(max(0, num_assets))
        # 存储每个时间点的值: list of (steps, M, N) arrays
        self.x_history: List[np.ndarray] = []
        self.y0_history: List[np.ndarray] = []
        self.sigma_sequence: Optional[List[float]] = None

    def add_window(self, sigmas: np.ndarray, x_steps: np.ndarray, y0_steps: np.ndarray) -> None:
        """
        添加一个时间窗口的数据
        Args:
            sigmas: (steps,)
            x_steps: (steps, M, N) 每一步的x值
            y0_steps: (steps, M, N) 每一步的y0_hat值
        """
        if self.steps == 0 or self.num_samples == 0 or self.num_assets == 0:
            return
        if sigmas.shape[0] != self.steps:
            return
        if x_steps.shape != (self.steps, self.num_samples, self.num_assets):
            return
        if y0_steps.shape != (self.steps, self.num_samples, self.num_assets):
            return
        
        if self.sigma_sequence is None:
            self.sigma_sequence = sigmas.astype(np.float64).tolist()
        
        self.x_history.append(x_steps.astype(np.float64))
        self.y0_history.append(y0_steps.astype(np.float64))

    def export(self) -> Optional[Dict[str, Any]]:
        """计算跨时间的std (分标的、分样本)"""
        if len(self.x_history) == 0:
            return None
        
        # 堆叠: (S, steps, M, N)
        x_all = np.stack(self.x_history, axis=0)  # [S, steps, M, N]
        y0_all = np.stack(self.y0_history, axis=0)  # [S, steps, M, N]
        
        S = x_all.shape[0]
        # 对每个(step, m, n)计算跨时间的std
        # 结果: (steps, M, N)
        std_x = np.std(x_all, axis=0)  # [steps, M, N]
        std_y0 = np.std(y0_all, axis=0)  # [steps, M, N]
        
        # 跨样本平均: (steps, N)
        std_x_avg_samples = std_x.mean(axis=1)  # [steps, N]
        std_y0_avg_samples = std_y0.mean(axis=1)  # [steps, N]
        
        return {
            "count_windows": int(S),
            "num_samples": int(self.num_samples),
            "num_assets": int(self.num_assets),
            "sigmas": (self.sigma_sequence if self.sigma_sequence is not None else []),
            "mean_std_x": std_x_avg_samples.tolist(),  # [steps, N]
            "mean_std_y0": std_y0_avg_samples.tolist(),  # [steps, N]
        }


# ==== 扩散推理辅助：单步DDIM近似采样（T→0，一步） ====
def _make_alpha_bar_sbdm() -> float:
    """SBDM 单步近似：常量 abar 作为噪声-信号折中。"""
    return 0.5


def _fd_bins(samples: np.ndarray, min_bins: int = 10, max_bins: int = 200) -> int:
    """Freedman–Diaconis 规则计算直方图 bin 数，带稳健护栏。
    bins = ceil((x_max - x_min) / (2*IQR*n^{-1/3}))，并剪裁到 [min_bins, max_bins]。
    当 IQR≈0 或范围≈0 时退化为 Rice 或 Sturges 规则。
    """
    try:
        x = np.asarray(samples, dtype=np.float64)
        # 若全为 NaN/非有限数，直接返回最小 bins，避免后续 nanmin/nanmax 警告
        if not np.isfinite(x).any():
            return max(1, min_bins)
        n = int(x.size)
        if n <= 1:
            return max(1, min_bins)
        x_min = float(np.nanmin(x))
        x_max = float(np.nanmax(x))
        rng = x_max - x_min
        if not np.isfinite(rng) or rng <= 0:
            return max(1, min_bins)
        q25, q75 = np.percentile(x, [25, 75])
        iqr = float(q75 - q25)
        if not np.isfinite(iqr) or iqr <= 1e-12:
            # 退化规则：Rice 或 Sturges
            rice = int(np.ceil(2.0 * (n ** (1.0 / 3.0))))
            sturges = int(np.ceil(np.log2(n) + 1.0))
            bins = max(rice, sturges)
        else:
            width = 2.0 * iqr / max(1e-12, (n ** (1.0 / 3.0)))
            bins = int(np.ceil(rng / max(width, 1e-12)))
        # 护栏与唯一值限制
        bins = int(np.clip(bins, min_bins, max_bins))
        uniq = int(len(np.unique(x)))
        if uniq > 0:
            bins = int(min(bins, uniq))
        return max(1, bins)
    except Exception:
        return max(1, min_bins)

@torch.no_grad()
def diffusion_single_step_samples(
    model: SpacetimeGNNMAM,
    X_win: torch.Tensor,                # [1,N,T,F]
    num_samples: int,
    device: torch.device,
    chunk_size: int | None = None,
    use_amp: bool = True,
) -> torch.Tensor:
    """SBDM 单步近似采样：从 x_T 与骨干条件反推 y0_hat 分布（标准化域）。
    采用按块采样以降低显存峰值；避免不必要的 contiguous 拷贝。"""
    model.eval()
    B1, N, T, F = X_win.shape
    assert B1 == 1
    abar = _make_alpha_bar_sbdm()
    sqrt_abar = float(np.sqrt(abar))
    sqrt_1m = float(np.sqrt(max(1e-9, 1.0 - abar)))
    sigma2 = (sqrt_1m * sqrt_1m) / max(1e-9, (sqrt_abar * sqrt_abar))

    M = int(num_samples)
    if chunk_size is None or chunk_size <= 0:
        chunk_size = min(32, M)

    outs: list[torch.Tensor] = []
    # 采样路径禁用 AMP，统一使用全精度以避免半精度数值不稳定
    use_cuda_amp = False
    for start in range(0, M, int(chunk_size)):
        m_here = int(min(chunk_size, M - start))
        # 以视图方式扩展，不做不必要的拷贝
        X_rep = X_win.expand(m_here, -1, -1, -1).to(device)
        x_T = torch.randn(m_here, N, 1, device=device)
        t_idx = torch.ones(m_here, device=device, dtype=torch.long)
        score_hat = model.forward_score(X_rep, x_T, t_idx)
        y0_hat = x_T + float(sigma2) * score_hat
        outs.append(y0_hat)
        # 释放临时变量引用，帮助显存回收
        del X_rep, x_T, t_idx, score_hat, y0_hat
    return torch.cat(outs, dim=0)


@torch.no_grad()
def ve_edm_samples(
    model: SpacetimeGNNMAM,
    X_win: torch.Tensor,                 # [1,N,T,F]
    num_samples: int,
    device: torch.device,
    sigma_min: float = 0.01,
    sigma_max: float = 1.0,
    steps: int = 50,                      # EDM 迭代去噪步数(仅steps>1时生效)
    s_churn: float = 0.0,                 # Stochastic采样噪声（0=确定性，>0=随机）
    s_churn_topk_ratio: float = 0.2,      # 步数门限法：仅前k步应用s_churn (k=ceil(ratio*steps))
    chunk_size: int | None = None,
    diff_steps: int = 1000,
    mask: torch.Tensor | None = None,     # [1,N,T,F] mask（兼容）
    objective: str = 'eps',               # 训练目标：'eps' 或 'edm'
    sigma_data: float = 0.025,            # EDM 预条件化参数
    use_random_sigma: bool = True,        # 是否使用随机σ采样(与训练对齐)
    vol_cond: torch.Tensor | None = None, # [1,N,1] 波动率条件
    vol_cond_as_input: bool = True,       # yzvol 作为条件输入
    vol_cond_scale_output: bool = False,  # yzvol 直接乘到输出上
    step_var_recorder: Optional[StepVarianceRecorder] = None,
) -> torch.Tensor:
    """
    EDM 采样器（与训练分布对齐）
    
    参数:
        objective: 'eps' 或 'edm'（与训练一致）
        sigma_data: EDM 预条件化参数（仅当 objective='edm' 时使用）
        steps: 仅当 use_random_sigma=False 且 steps>1 时使用多步迭代
        use_random_sigma: True=每个样本随机采样σ(与训练对齐), False=固定σ_max或多步
        vol_cond_as_input: yzvol 作为条件特征输入网络
        vol_cond_scale_output: yzvol 直接乘到输出上
    
    返回: [M,N,1] 采样的 log-return
    
    核心原则:训练-推理一致性
    - 训练时: σ ~ LogUniform(σ_min, σ_max), x_t = y0 + σ·ε
    - 推理时: 应该用相同的σ分布,而不是固定σ_max
    """
    model.eval()
    B1, N, T, F = X_win.shape
    assert B1 == 1
    steps = max(1, int(steps))
    s_churn = float(max(0.0, s_churn))
    s_churn_topk_ratio = float(max(0.0, min(1.0, s_churn_topk_ratio)))
    objective = str(objective).lower()
    sigma_data = float(sigma_data)
    
    sigma_max = float(max(sigma_min, sigma_max))
    sigma_min = float(max(1e-12, min(sigma_min, sigma_max)))
    
    M = int(num_samples)
    if chunk_size is None or chunk_size <= 0:
        chunk_size = min(32, M)
    
    if use_random_sigma or steps == 1:
        # 模式A: 随机σ采样(与训练对齐) - 推荐!
        outs_random: List[torch.Tensor] = []
        for start in range(0, M, int(chunk_size)):
            m_here = int(min(chunk_size, M - start))
            X_rep = X_win.to(device).expand(m_here, -1, -1, -1)  # [m,N,T,F]
            
            # 每个样本独立采样 σ ~ LogUniform(σ_min, σ_max)
            log_sigma_samples = torch.rand(m_here, device=device) * (math.log(sigma_max) - math.log(sigma_min)) + math.log(sigma_min)
            sigma_samples = torch.exp(log_sigma_samples).view(m_here, 1, 1)  # [m,1,1]
            
            
            # 初始噪声: x ~ N(0, σ²)
            x = torch.randn(m_here, N, 1, device=device) * sigma_samples  # [m,N,1]
            
            # t_idx 映射
            if sigma_max > sigma_min:
                t_float = (log_sigma_samples - math.log(sigma_min)) / max(1e-9, (math.log(sigma_max) - math.log(sigma_min)))
                t_idx = torch.clamp((t_float * diff_steps).long() + 1, 1, diff_steps)
            else:
                t_idx = torch.ones(m_here, dtype=torch.long, device=device)
            
            if objective == 'edm':
                # EDM 预条件化
                sigma_data_sq = sigma_data ** 2
                sigma_sq = sigma_samples ** 2
                c_skip = sigma_data_sq / (sigma_sq + sigma_data_sq)
                c_out = sigma_samples * sigma_data / torch.sqrt(sigma_sq + sigma_data_sq)
                c_in = 1.0 / torch.sqrt(sigma_sq + sigma_data_sq)
                
                x_scaled = c_in * x
                # 传递 vol_cond 和开关到 forward_score
                vol_cond_chunk = None
                if vol_cond is not None and vol_cond.numel() > 0:
                    vol_cond_chunk = vol_cond.expand(m_here, -1, -1)  # [m,N,1]
                f_theta = model.forward_score(
                    X_rep, x_scaled, t_idx, 
                    vol_cond=vol_cond_chunk,
                    vol_cond_as_input=vol_cond_as_input,
                    vol_cond_scale_output=vol_cond_scale_output
                )
                y0_hat = c_skip * x + c_out * f_theta  # 移除 τ
                outs_random.append(y0_hat)
            else:
                # score/eps 模式
                vol_cond_chunk = None
                if vol_cond is not None and vol_cond.numel() > 0:
                    vol_cond_chunk = vol_cond.expand(m_here, -1, -1)  # [m,N,1]
                score = model.forward_score(
                    X_rep, x, t_idx, 
                    vol_cond=vol_cond_chunk,
                    vol_cond_as_input=vol_cond_as_input,
                    vol_cond_scale_output=vol_cond_scale_output
                )
                sigma2 = sigma_samples ** 2
                y0_hat = x + sigma2 * score
                outs_random.append(y0_hat)
            
            del X_rep, x
        
        return torch.cat(outs_random, dim=0)
    
    else:
        # 模式B: 多步迭代(从σ_max开始) - 不推荐,仅用于对比实验
        global _VE_EDM_MULTI_WARNED
        if not _VE_EDM_MULTI_WARNED:
            print(f"[warn] using multi-step EDM sampling (steps={steps}), which may not align with training", flush=True)
            _VE_EDM_MULTI_WARNED = True
        sigmas = np.exp(np.linspace(np.log(sigma_max + 1e-12), np.log(sigma_min + 1e-12), steps + 1)).astype(np.float64)
        outs_multistep: List[torch.Tensor] = []
        record_stats = False
        # 记录每一步的完整值: (steps, M, N)
        x_steps_record: Optional[np.ndarray] = None
        y0_steps_record: Optional[np.ndarray] = None
        if step_var_recorder is not None and step_var_recorder.steps == steps and step_var_recorder.num_samples == M and step_var_recorder.num_assets == N:
            record_stats = True
            x_steps_record = np.zeros((steps, M, N), dtype=np.float64)
            y0_steps_record = np.zeros((steps, M, N), dtype=np.float64)
        # 步数门限：仅前 topk_steps 应用 s_churn
        topk_steps = int(max(0, min(steps, math.ceil(steps * s_churn_topk_ratio))))
        for start in range(0, M, int(chunk_size)):
            m_here = int(min(chunk_size, M - start))
            X_rep = X_win.to(device).expand(m_here, -1, -1, -1)
            
            # 初始化：x ~ N(0, sigma_max²)
            x = torch.randn(m_here, N, 1, device=device) * float(sigma_max)
            
            # EDM 确定性去噪迭代
            for i in range(steps):
                sigma_cur = float(sigmas[i])
                sigma_next = float(sigmas[i + 1])
                
                # t 索引（与训练映射一致）
                if sigma_max > sigma_min:
                    log_sigma_cur = np.log(max(sigma_cur, 1e-12))
                    t_float = (log_sigma_cur - math.log(max(sigma_min, 1e-12))) / max(1e-9, (math.log(max(sigma_max, 1e-12)) - math.log(max(sigma_min, 1e-12))))
                    t_idx = torch.full((m_here,), int(min(diff_steps, max(1, int(t_float * diff_steps) + 1))), dtype=torch.long, device=device)
                else:
                    t_idx = torch.ones(m_here, dtype=torch.long, device=device)

                if record_stats and x_steps_record is not None:
                    x_cpu = x.detach().cpu().view(m_here, N).numpy().astype(np.float64)
                    x_steps_record[i, start:start+m_here, :] = x_cpu
                
                if objective == 'edm':
                    # EDM 预条件化：直接预测 y0
                    sigma_cur_t = torch.tensor(sigma_cur, device=device).view(1, 1, 1)
                    sigma_data_sq = sigma_data ** 2
                    sigma_sq = sigma_cur_t ** 2
                    c_skip = sigma_data_sq / (sigma_sq + sigma_data_sq)
                    c_out = sigma_cur_t * sigma_data / torch.sqrt(sigma_sq + sigma_data_sq)
                    c_in = 1.0 / torch.sqrt(sigma_sq + sigma_data_sq)
                    
                    # 预条件化输入并预测 y0_hat
                    x_scaled = c_in * x
                    vol_cond_chunk = None
                    if vol_cond is not None and vol_cond.numel() > 0:
                        vol_cond_chunk = vol_cond.expand(m_here, -1, -1)  # [m,N,1]
                    f_theta = model.forward_score(
                        X_rep, x_scaled, t_idx, 
                        vol_cond=vol_cond_chunk,
                        vol_cond_as_input=vol_cond_as_input,
                        vol_cond_scale_output=vol_cond_scale_output
                    )
                    y0_hat = c_skip * x + c_out * f_theta  # 移除 τ
                    if record_stats and y0_steps_record is not None:
                        y_cpu = y0_hat.detach().cpu().view(m_here, N).numpy().astype(np.float64)
                        y0_steps_record[i, start:start+m_here, :] = y_cpu
                    
                    # EDM更新: x_{next} = y0_hat + σ_{next}·ε
                    # 其中 ε 从当前预测反推: ε ≈ (x - y0_hat) / σ_cur
                    if i < steps - 1:
                        # 多步: 保留噪声方向,缩放到下一个σ级别
                        eps_approx = (x - y0_hat) / max(sigma_cur, 1e-6)
                        
                        # SDE模式: 添加随机噪声 (s_churn > 0) — 仅前 topk_steps 生效
                        if s_churn > 0.0 and i < topk_steps:
                            # 先添加噪声到当前状态
                            gamma_i = min(s_churn / steps, math.sqrt(2.0) - 1.0)
                            sigma_hat_cur = sigma_cur * (1.0 + gamma_i)
                            noise_extra = torch.randn_like(x) * math.sqrt(max(0, sigma_hat_cur**2 - sigma_cur**2))
                            x = x + noise_extra
                            # 重新预测y0_hat (可选,为简化跳过)
                        
                        # 更新到下一步
                        x = y0_hat + sigma_next * eps_approx
                    else:
                        # 最后一步: 直接输出预测的y0
                        x = y0_hat
                else:
                    # score/eps 模式：使用 score-based更新（保持原逻辑）
                    vol_cond_chunk = None
                    if vol_cond is not None and vol_cond.numel() > 0:
                        vol_cond_chunk = vol_cond.expand(m_here, -1, -1)  # [m,N,1]
                    score = model.forward_score(
                        X_rep, x, t_idx, 
                        vol_cond=vol_cond_chunk,
                        vol_cond_as_input=vol_cond_as_input,
                        vol_cond_scale_output=vol_cond_scale_output
                    )
                    # score模式下: y0_hat = x + sigma^2 * score
                    if record_stats and y0_steps_record is not None:
                        y0_hat_score = x + (sigma_cur ** 2) * score
                        y_cpu = y0_hat_score.detach().cpu().view(m_here, N).numpy().astype(np.float64)
                        y0_steps_record[i, start:start+m_here, :] = y_cpu
                    
                    # SDE模式: 先添加随机噪声 — 仅前 topk_steps 生效
                    if s_churn > 0.0 and i < steps - 1 and i < topk_steps:
                        gamma_i = min(s_churn / steps, math.sqrt(2.0) - 1.0)
                        sigma_hat_cur = sigma_cur * (1.0 + gamma_i)
                        noise_extra = torch.randn_like(x) * math.sqrt(max(0, sigma_hat_cur**2 - sigma_cur**2))
                        x = x + noise_extra
                        sigma_cur_used = sigma_hat_cur
                    else:
                        sigma_cur_used = sigma_cur
                    
                    d = x + (sigma_next - sigma_cur_used) * score
                    
                    if i < steps - 1:
                        # Heun 二阶修正
                        sigma_mid = sigma_next
                        if sigma_max > sigma_min:
                            log_sigma_mid = np.log(max(sigma_mid, 1e-12))
                            t_float_mid = (log_sigma_mid - math.log(max(sigma_min, 1e-12))) / max(1e-9, (math.log(max(sigma_max, 1e-12)) - math.log(max(sigma_min, 1e-12))))
                            t_idx_mid = torch.full((m_here,), int(min(diff_steps, max(1, int(t_float_mid * diff_steps) + 1))), dtype=torch.long, device=device)
                        else:
                            t_idx_mid = t_idx
                        score_mid = model.forward_score(
                            X_rep, d, t_idx_mid, 
                            vol_cond=vol_cond_chunk,
                            vol_cond_as_input=vol_cond_as_input,
                            vol_cond_scale_output=vol_cond_scale_output
                        )
                        x = x + (sigma_next - sigma_cur_used) * 0.5 * (score + score_mid)
                    else:
                        x = d
            
            outs_multistep.append(x)
            del X_rep, x
        
        # 将这个时间窗口的记录添加到recorder
        if record_stats and step_var_recorder is not None and x_steps_record is not None and y0_steps_record is not None:
            sigma_seq = np.asarray(sigmas[:-1], dtype=np.float64)
            step_var_recorder.add_window(sigma_seq, x_steps_record, y0_steps_record)
        
        return torch.cat(outs_multistep, dim=0)


@torch.no_grad()
def diffusion_ddim_samples(
    model: SpacetimeGNNMAM,
    X_win: torch.Tensor,                # [1,N,T,F]
    num_samples: int,
    device: torch.device,
    chunk_size: int | None = None,
    steps: int = 1,
    eta: float = 0.0,
    sigma_min: float = 0.01,
    sigma_max: float = 1.0,
    diff_steps: int = 1000,
    vol_cond: torch.Tensor | None = None,   # [1,N,1] 当前窗口的波动率条件
    sigma_schedule: str = "log_uniform",
    time_warp_gamma: float = 0.5,
) -> torch.Tensor:
    """多步 DDIM 风格的确定性近似（基于 score 的逐步积分）。
    steps=1 时等价于单步；steps>1 时按等步长迭代：
      x_{k+1} = x_k + (sigma2_total/steps) * score(X, x_k, t=const)
    返回 [M,N,1]
    """
    model.eval()
    B1, N, T, F = X_win.shape
    assert B1 == 1
    steps = max(1, int(steps))
    eta = float(max(0.0, min(1.0, eta)))
    # 构建 σ 调度（与训练一致）：从 sigma_max 递减到 sigma_min，共 steps 步
    sigma_max = float(max(sigma_min, sigma_max))
    sigma_min = float(max(1e-12, min(sigma_min, sigma_max)))
    schedule = str(sigma_schedule).lower()
    if schedule == "karras":
        rho = 7.0
        u = np.linspace(0.0, 1.0, steps + 1)
        lo = sigma_min ** (1.0 / rho)
        hi = sigma_max ** (1.0 / rho)
        sig = (lo + u * (hi - lo)) ** rho  # 从 sigma_min → sigma_max
        levels = sig[::-1].astype(np.float64)  # 反转: sigma_max → sigma_min
    else:
        levels = np.exp(
            np.linspace(
                np.log(sigma_max + 1e-12),
                np.log(sigma_min + 1e-12),
                steps + 1,
            )
        ).astype(np.float64)  # [steps+1]
    # 训练使用的时间索引映射（与 train 相同公式）
    diff_steps = int(max(1, diff_steps))

    M = int(num_samples)
    if chunk_size is None or chunk_size <= 0:
        chunk_size = min(32, M)

    # 仅预计算每步的 Δσ² 和 t 索引（推理时调用 forward_score，保持与训练一致的条件注入）
    delta_sigma2_steps: list[float] = []
    t_idx_vals: list[int] = []
    for k in range(steps):
        sig_k = float(levels[k])
        sig_next = float(levels[k + 1])
        if sigma_max > sigma_min:
            log_sigma = float(np.log(max(sig_k, 1e-12)))
            t_float = (log_sigma - math.log(max(sigma_min, 1e-12))) / max(1e-9, (math.log(max(sigma_max, 1e-12)) - math.log(max(sigma_min, 1e-12))))
            t_idx_val = int(min(diff_steps, max(1, int(t_float * diff_steps) + 1)))
        else:
            t_idx_val = 1
        t_idx_vals.append(t_idx_val)
        delta_sigma2_steps.append(float(max(0.0, (sig_k * sig_k) - (sig_next * sig_next))))

    outs: list[torch.Tensor] = []
    for start in range(0, M, int(chunk_size)):
        m_here = int(min(chunk_size, M - start))
        X_rep = X_win.to(device).expand(m_here, -1, -1, -1)
        x = torch.randn(m_here, N, 1, device=device) * float(sigma_max)
        # 预展开并缓存 s_yz 与 s_yz_sq，减少循环内广播开销
        if (vol_cond is not None) and (vol_cond.numel() > 0):
            vol_e = cast(torch.Tensor, vol_cond)
            s_yz_cached = torch.clamp(vol_e.expand(m_here, -1, -1), min=1e-6)
            s_yz_sq_cached = s_yz_cached * s_yz_cached
        else:
            s_yz_cached = None
            s_yz_sq_cached = None
        for k in range(steps):
            # 基础 t 映射（0..1）
            if sigma_max > sigma_min:
                t_float = float((np.log(max(float(levels[k]), 1e-12)) - math.log(max(sigma_min, 1e-12))) / max(1e-9, (math.log(max(sigma_max, 1e-12)) - math.log(max(sigma_min, 1e-12)))))
            else:
                t_float = 0.0
            # 条件化时间扭曲：t_eff = clamp(t * s_bar^gamma, 0..1)
            warp_gamma = float(time_warp_gamma)
            if (vol_cond is not None) and (vol_cond.numel() > 0):
                vol_e = cast(torch.Tensor, vol_cond)
                s_yz_warp = torch.clamp(vol_e.expand(m_here, -1, -1), min=1e-6)  # [m,N,1]
                s_bar = s_yz_warp.view(m_here, -1).mean(dim=1)  # [m]
                factor = torch.pow(s_bar, warp_gamma)  # [m]
                t_eff = torch.clamp(torch.full((m_here,), float(t_float), device=device) * factor, 0.0, 1.0)
                t_idx = (t_eff * float(diff_steps)).long().clamp(1, int(diff_steps))
            else:
                t_idx = torch.full((m_here,), int(t_idx_vals[k]), dtype=torch.long, device=device)
            score_hat = model.forward_score(X_rep, x, t_idx, vol_cond=vol_cond)  # 显式条件化
            delta_sigma2 = float(delta_sigma2_steps[k])
            # 从 vol_cond 推导 per-asset s_yz（若无则为 1）
            if s_yz_cached is not None:
                s_yz = cast(torch.Tensor, s_yz_cached)
                s_yz_sq = cast(torch.Tensor, s_yz_sq_cached)
            else:
                s_yz = torch.ones_like(x)
                s_yz_sq = s_yz * s_yz
            if eta > 0.0 and delta_sigma2 > 0.0:
                noise = torch.randn_like(x) * math.sqrt(delta_sigma2) * eta * s_yz
                x = x + (delta_sigma2 * s_yz_sq) * score_hat + noise
            else:
                x = x + (delta_sigma2 * s_yz_sq) * score_hat
        outs.append(x)
        del X_rep, x, score_hat
    return torch.cat(outs, dim=0)

def diffusion_direct_score_samples(
    model: SpacetimeGNNMAM,
    X_win: torch.Tensor,                 # [1,N,T,F]
    base_pred: torch.Tensor,             # [1,N,1] 作为 y0 的近似中心
    num_samples: int,
    device: torch.device,
    chunk_size: int | None = None,
    sigma_min: float = 0.01,
    sigma_max: float = 1.0,
    diff_steps: int = 1000,
    vol_cond: torch.Tensor | None = None,   # [1,N,1]
    sigma_schedule: str = "log_uniform",
    time_warp_gamma: float = 0.5,
    direct_anchor: str = "random",
    direct_lambda: float = 1.0,
) -> torch.Tensor:
    """训练一致的单步直推：
    对每个样本独立抽取 σ~训练同分布，构造 x_t = y0̂ + σ·s_yz·ε，
    再按 Tweedie 公式 y0_hat = x_t + (σ²·s_yz²)·score(X, x_t, t_idx(σ))。
    返回 [M,N,1]
    """
    model.eval()
    B1, N, T, F = X_win.shape
    assert B1 == 1
    M = int(num_samples)
    if chunk_size is None or chunk_size <= 0:
        chunk_size = min(32, M)
    
    # 诊断：检查 base_pred 分布
    base_np = base_pred.detach().cpu().numpy().flatten()
    print(f"[diag-base_pred] mean={float(base_np.mean()):.6f}, std={float(base_np.std()):.6f}, "
          f"min={float(base_np.min()):.6f}, max={float(base_np.max()):.6f}", flush=True)
    
    # 预展开波动条件
    has_vol = (vol_cond is not None) and (vol_cond.numel() > 0)
    outs: list[torch.Tensor] = []
    schedule = str(sigma_schedule).lower()
    anchor = str(direct_anchor).lower()
    lam = float(direct_lambda)
    sigma_min = float(max(1e-12, sigma_min))
    sigma_max = float(max(sigma_min, sigma_max))
    diff_steps = int(max(1, diff_steps))
    with torch.no_grad():
        for start in range(0, M, int(chunk_size)):
            m_here = int(min(chunk_size, M - start))
            X_rep = X_win.to(device).expand(m_here, -1, -1, -1)
            mu = base_pred.to(device).expand(m_here, -1, -1)  # [m,N,1]
            # 直推锚点 σ 选择
            if anchor.startswith("fixed:"):
                # 指定绝对 σ 数值
                try:
                    s_fix = float(anchor.split(":",1)[1])
                except Exception:
                    s_fix = float((sigma_min * sigma_max) ** 0.5)
                sigmas = torch.full((m_here,), float(np.clip(s_fix, sigma_min, sigma_max)), device=device)
            elif anchor.startswith("quantile:"):
                try:
                    q = float(anchor.split(":",1)[1])
                except Exception:
                    q = 0.5
                q = float(min(0.999, max(0.001, q)))
                if schedule == "karras":
                    rho = 7.0
                    smax_r = sigma_max ** (1.0 / rho)
                    smin_r = sigma_min ** (1.0 / rho)
                    sig_q = (smax_r + q * (smin_r - smax_r)) ** rho
                else:
                    sig_q = math.exp(q * (math.log(sigma_min) - math.log(sigma_max)) + math.log(sigma_max))
                sigmas = torch.full((m_here,), float(sig_q), device=device)
            elif anchor == "median":
                if schedule == "karras":
                    rho = 7.0
                    smax_r = sigma_max ** (1.0 / rho)
                    smin_r = sigma_min ** (1.0 / rho)
                    sig_med = (smax_r + 0.5 * (smin_r - smax_r)) ** rho
                else:
                    sig_med = math.exp(0.5 * (math.log(sigma_min) - math.log(sigma_max)) + math.log(sigma_max))
                sigmas = torch.full((m_here,), float(sig_med), device=device)
            elif anchor.startswith("multi:"):
                # 多分位锚点，均匀分配到一批样本
                try:
                    parts = anchor.split(":",1)[1]
                    qs = [float(x) for x in parts.split(",") if x.strip()]
                except Exception:
                    qs = [0.4, 0.7]
                qs = [float(min(0.999, max(0.001, q))) for q in qs]
                vals = []
                for q in qs:
                    if schedule == "karras":
                        rho = 7.0
                        smax_r = sigma_max ** (1.0 / rho)
                        smin_r = sigma_min ** (1.0 / rho)
                        vals.append((smax_r + q * (smin_r - smax_r)) ** rho)
                    else:
                        vals.append(math.exp(q * (math.log(sigma_min) - math.log(sigma_max)) + math.log(sigma_max)))
                vals_t = torch.tensor(vals, device=device, dtype=torch.float32)
                idx = torch.arange(m_here, device=device) % max(1, len(vals))
                sigmas = vals_t[idx]
            else:
                # random：按训练同分布随机抽样
                if schedule == "karras":
                    rho = 7.0
                    u = torch.rand(m_here, device=device)
                    smax_r = sigma_max ** (1.0 / rho)
                    smin_r = sigma_min ** (1.0 / rho)
                    sigmas = torch.pow(smax_r + u * (smin_r - smax_r), rho)  # [m]
                else:
                    u = torch.rand(m_here, device=device)
                    sigmas = torch.exp(u * (math.log(sigma_min) - math.log(sigma_max)) + math.log(sigma_max))  # [m]
            # t 索引（含时间扭曲）
            log_sigma = torch.log(sigmas.clamp(min=1e-12))
            t_cont = (log_sigma - math.log(sigma_min)) / max(1e-9, (math.log(sigma_max) - math.log(sigma_min)))
            t_cont = t_cont.clamp(0.0, 1.0)
            if has_vol and float(time_warp_gamma) > 0.0:
                vol_e = cast(torch.Tensor, vol_cond)
                s_bar = torch.clamp(vol_e.expand(m_here, -1, -1).view(m_here, -1).mean(dim=1), min=1e-6)
                factor = torch.pow(s_bar, float(time_warp_gamma))
                t_cont = (t_cont * factor).clamp(0.0, 1.0)
            t_idx = (t_cont * float(diff_steps)).long().clamp(1, int(diff_steps))  # [m]
            # 构造 x_t 与 s_yz
            if has_vol:
                vol_e = cast(torch.Tensor, vol_cond)
                s_yz = torch.clamp(vol_e.expand(m_here, -1, -1).to(device), min=1e-6)
            else:
                s_yz = torch.ones_like(mu)
            eps = torch.randn_like(mu)
            # 训练一致性：x_t = mu + sigma*eps（不含 s_yz），s_yz 只在 Tweedie 恢复时使用
            x_t = mu + sigmas.view(-1, 1, 1) * eps  # [m,N,1]
            score_hat = model.forward_score(X_rep, x_t, t_idx, vol_cond=(vol_cond if has_vol else None))
            y0_hat = x_t + lam * (sigmas.view(-1, 1, 1) ** 2) * (s_yz * s_yz) * score_hat
            outs.append(y0_hat)
            del X_rep, mu, eps, x_t, score_hat
    return torch.cat(outs, dim=0)

def _detect_board(stock_id: str) -> str:
    sid = str(stock_id)
    if sid.endswith(".XSHG") and sid.startswith("688"):
        return "KSH"
    if sid.endswith(".XSHE") and (sid.startswith("300") or sid.startswith("301")):
        return "GEM"
    if sid.endswith(".BJ") or ".BJ" in sid:
        return "BSE"
    if sid.endswith(".XSHG") or sid.endswith(".XSHE"):
        return "MainBoard"
    return "UNKNOWN"


def _build_price_limit_vec(stocks: List[str], default_pct: float = 0.10) -> Tuple[np.ndarray, Dict[str, int]]:
    vec = []
    stats = {"MainBoard": 0, "KSH": 0, "GEM": 0, "BSE": 0, "UNKNOWN": 0}
    for sid in stocks:
        board = _detect_board(sid)
        if board == "KSH":
            vec.append(0.20)
        elif board in ("GEM", "BSE"):
            vec.append(0.30)
        elif board == "MainBoard":
            vec.append(0.10)
        else:
            print(f"[warn] 未识别板块，按默认阈值处理: {sid} -> {default_pct:.0%}")
            vec.append(float(default_pct))
        stats[board] = stats.get(board, 0) + 1
    return np.asarray(vec, dtype=np.float32), stats


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="模型市场回测与指标计算（t+1 决策、t+2 结算），支持 OOS 与高级流动性约束与涨跌停启发式")
    parser.add_argument("--data_dir", type=str, default="data/processed")
    parser.add_argument("--checkpoint", type=str, required=True, help="模型权重路径 .pt")
    parser.add_argument("--device", type=str, default="cuda" if torch.cuda.is_available() else "cpu")
    # panels 推理，test_env 环境
    parser.add_argument("--oos_stock_ratio", type=float, default=0.0, help="样本外股票比例（按训练期股票池随机留出），0 表示不做 OOS 拆分")
    parser.add_argument("--oos_stock_list", type=str, default="", help="样本外股票列表文件（每行一个股票ID），优先于比例")
    parser.add_argument("--results_dir", type=str, default="experiments", help="实验结果保存目录")
    parser.add_argument("--results_name", type=str, default="", help="实验命名（可选）")
    parser.add_argument("--all_exclude_oos", type=int, default=1, help="ALL 回测是否默认排除 OOS（1排除/0不排除）")
    parser.add_argument("--enable_oos_backtest", type=int, default=1, help="是否执行 OOS 回测（1=执行，0=跳过）")
    
    # 交易参数
    parser.add_argument("--initial_capital", type=float, default=1000000.0, help="初始资金（元）")
    parser.add_argument("--impact_linear", type=float, default=0.01, help="线性冲击成本系数：cost = linear * (our_volume / avg_volume)")
    parser.add_argument("--impact_sqrt", type=float, default=0.005, help="平方根冲击成本系数：cost = sqrt * sqrt(our_volume / avg_volume)")
    parser.add_argument("--liquidity_alpha", type=float, default=0.3, help="流动性阈值：决策日成交量 >= alpha * 训练期平均量才可交易")
    parser.add_argument("--min_lot", type=int, default=100, help="最小交易单位（股/手）")
    parser.add_argument("--commission_rate", type=float, default=0.0005, help="双边佣金费率")
    parser.add_argument("--stamp_duty_sell", type=float, default=0.001, help="卖出印花税费率")
    parser.add_argument("--price_limit_pct", type=float, default=0.10, help="按价格跨度判断涨跌停阈值（如0.10表示10%）")
    parser.add_argument("--debug_stockid", type=str, default="", help="调试股票ID，输出该股票逐日详情")
    # 采样驱动策略参数
    parser.add_argument("--sampler", type=str, default="auto", help="采样器选择：auto|ve_edm|direct|ddim")
    parser.add_argument("--objective", type=str, default="score", help="训练目标类型：score/edm，用于推理对齐")
    parser.add_argument("--edm_steps", type=int, default=50, help="VE-EDM 多步 Heun 采样步数（sampler=ve_edm/auto 时生效）")
    parser.add_argument("--use_random_sigma", type=int, default=1, help="1=按训练分布随机σ（单步）；0=关闭随机σ，使用多步 edm_steps")
    parser.add_argument("--num_samples", type=int, default=64, help="每只股票价格分布的采样次数（SBDM 单步近似）")
    parser.add_argument("--ddim_steps", type=int, default=1, help="DDIM 多步采样步数（1 表示单步，>1 提升推理质量）")
    parser.add_argument("--direct_score", type=int, default=1, help="1=使用训练一致的单步直推；0=使用 DDIM 步进")
    parser.add_argument("--direct_anchor", type=str, default="random", help="直推锚点选择：random|median|quantile:p|fixed:sigma|multi:q1,q2,...（q为0..1分位）")
    parser.add_argument("--direct_lambda", type=float, default=1.0, help="直推温度系数 λ，缩放 Tweedie 更新项 (σ²·s_yz²·score)")
    parser.add_argument("--ddim_eta", type=float, default=0.0, help="DDIM 采样噪声系数 η∈[0,1]；0=确定性，>0 引入随机性")
    parser.add_argument("--chunk_size", type=int, default=0, help="采样块大小（每批生成 M 的子批量）；0 表示自动按 num_samples/4 并夹在 [16,64]")
    # 与训练一致的 σ 调度参数
    parser.add_argument("--score_sigma_min", type=float, default=0.01, help="训练用最小噪声强度 σ_min，用于推理调度对齐")
    parser.add_argument("--score_sigma_max", type=float, default=1.0, help="训练用最大噪声强度 σ_max，用于推理调度对齐")
    parser.add_argument("--sigma_data", type=float, default=0.025, help="EDM 预条件化参数 σ_data，用于 ve_edm 采样")
    parser.add_argument("--s_churn", type=float, default=0.0, help="VE-EDM 采样的随机扰动系数 s_churn")
    parser.add_argument("--s_churn_topk_ratio", type=float, default=0.2, help="步数门限：仅前 ceil(ratio*steps) 步应用 s_churn")
    parser.add_argument("--diff_steps", type=int, default=1000, help="训练用离散时间步数，用于 t 索引映射对齐")
    parser.add_argument("--progress", type=int, default=1, help="是否打印进度信息(1/0)")
    parser.add_argument("--log_interval", type=int, default=20, help="进度打印间隔（步）")
    parser.add_argument("--risk_k", type=float, default=3.0, help="风险因子 k，用于 tanh(k*|S|)")
    parser.add_argument("--max_lots", type=int, default=10, help="tanh 输出映射到的最大手数（等手数模式时生效）")
    parser.add_argument("--value_based_position", type=int, default=1, help="1=按名义资金映射手数；0=按等手数映射")
    parser.add_argument("--max_notional_per_stock", type=float, default=5000.0, help="单股最大名义资金(元)，用于按名义资金映射")
    parser.add_argument("--benchmark_discrete", type=int, default=1, help="等资金基准是否应用手数离散(按最小交易单位)")
    parser.add_argument("--cvar_alpha", type=float, default=0.05, help="CVaR 分位阈值（下 5%）")
    parser.add_argument("--entropy_bins", type=int, default=20, help="信息熵直方图的分箱数（离散熵）")
    parser.add_argument("--cvar_eps", type=float, default=1e-6, help="CVaR 防除零小常数")
    parser.add_argument("--entropy_eps", type=float, default=1e-6, help="信息熵防除零小常数")
    parser.add_argument("--cvar_power", type=float, default=1.0, help="|CVaR| 权重幂指数 ∈[0,1]，越小对尾部风险惩罚越弱")
    parser.add_argument("--er_positive_buy", type=int, default=0, help="1=启用简单规则：ER>0 则按 max_notional_per_stock 买入(整手取整)，否则 0；忽略 tanh 映射")
    # ER 口径为净收益率（已含手续费/印花/滑点），不再额外设置开仓阈值参数
    # RL 对比（在本回测内叠加 RL 策略权益曲线）
    parser.add_argument("--rl_compare", type=int, default=0, help="1=叠加RL策略曲线(需要 checkpoints/rl/policy.pt)")
    parser.add_argument("--rl_checkpoint", type=str, default=os.path.join("checkpoints", "rl", "policy.pt"), help="RL 策略权重路径 .pt")
    # 尾部裁剪（避免评估预处理填充的天数）
    parser.add_argument("--trim_tail_days", type=int, default=0, help="回测时裁掉末尾 k 天（与预处理 tail_fill_days 对齐）")
    parser.add_argument("--use_yz_cond", type=int, default=1, help="是否在采样时启用 yz_vol 条件 (1/0)")
    parser.add_argument("--time_warp_gamma", type=float, default=0.0, help="时间扭曲指数 γ，与训练 time_warp_gamma 对齐")
    parser.add_argument("--entmax_alpha", type=float, default=1.5, help="entmax激活函数的α参数")
    parser.add_argument("--exp_clip_bound", type=float, default=0.0, help="log-return转价格前的裁剪阈值；<=0 表示不裁剪")
    parser.add_argument("--diffusion_head_hidden", type=int, default=None, help="Diffusion head隐藏维度（None=使用d_model）")
    parser.add_argument("--diffusion_head_dropout", type=float, default=None, help="Diffusion head dropout（None=使用模型dropout）")
    
    return parser.parse_args()


def load_checkpoint(path: str, device: torch.device) -> Dict:
    pack = torch.load(path, map_location=device, weights_only=False)
    return pack


def load_dataset_split(data_dir: str, split: str):
    pack = torch.load(os.path.join(data_dir, f"{split}.pt"), weights_only=False)
    return pack


def load_meta(data_dir: str) -> Dict:
    meta_path = os.path.join(data_dir, "meta.json")
    if not os.path.exists(meta_path):
        raise FileNotFoundError("缺少 meta.json，无法保证复现")
    with open(meta_path, "r", encoding="utf-8") as f:
        return json.load(f)


def build_oos_stocks(stocks: List[str], oos_list_path: str, ratio: float) -> List[str]:
    if oos_list_path and os.path.exists(oos_list_path):
        with open(oos_list_path, "r", encoding="utf-8") as f:
            oos = [line.strip() for line in f if line.strip()]
        return [s for s in oos if s in stocks]
    if ratio > 0:
        k = max(1, int(len(stocks) * ratio))
        rng = np.random.default_rng(42)
        idx = rng.choice(len(stocks), size=k, replace=False)
        return [stocks[i] for i in idx]
    return []


# 已移除单独的"预测精度"指标输出（MSE/MAE/Corr），专注交易回测指标


def save_results(results_dir: str, results_name: str, payload: Dict):
    Path(results_dir).mkdir(parents=True, exist_ok=True)
    ts = time.strftime("%Y%m%d_%H%M%S")
    name = results_name if results_name else f"exp_{ts}"
    out_path = os.path.join(results_dir, f"{name}.json")
    with open(out_path, "w", encoding="utf-8") as f:
        json.dump(payload, f, ensure_ascii=False, indent=2)
    print(f"结果已保存: {out_path}")
    return name


def save_backtest_plots(bt: Dict, plot_dir: str, prefix: str, index_data: Optional[pd.DataFrame] = None):
    Path(plot_dir).mkdir(parents=True, exist_ok=True)
    # 取日期轴（若有）
    trades = bt.get("daily_trades", [])
    x_dates = None
    if isinstance(trades, list) and len(trades) > 0:
        x_dates = [row.get("date", "") for row in trades]
        from datetime import datetime, timedelta
        import matplotlib.dates as mdates
        def to_dt(s):
            try:
                return datetime.fromisoformat(str(s)[:10])
            except Exception:
                return None
        x_parsed = [to_dt(s) for s in x_dates]
        if any(dt is None for dt in x_parsed):
            x_dates = None
        else:
            x_dates = x_parsed
            # 构建"首末精确日期 + 中间按月刻度"的刻度
            def month_tick_positions(first_dt: datetime, last_dt: datetime):
                # 月初对齐
                cur = datetime(first_dt.year, first_dt.month, 1)
                end = datetime(last_dt.year, last_dt.month, 1)
                ticks = [first_dt]
                while cur <= end:
                    if cur > first_dt and cur < last_dt:
                        ticks.append(cur)
                    # 下一个月月初
                    if cur.month == 12:
                        cur = datetime(cur.year + 1, 1, 1)
                    else:
                        cur = datetime(cur.year, cur.month + 1, 1)
                ticks.append(last_dt)
                return ticks
            if x_dates and x_dates[0] is not None and x_dates[-1] is not None:
                month_ticks = month_tick_positions(cast(datetime, x_dates[0]), cast(datetime, x_dates[-1]))
    # 权益曲线（含基准和指数对比）+ 超额收益（日度柱状图）
    values = np.array(bt.get("values", []), dtype=np.float64)
    cash_series = np.array(bt.get("cash_series", []), dtype=np.float64)
    holding_value_series = np.array(bt.get("holding_value_series", []), dtype=np.float64)
    benchmark_cumulative = np.array(bt.get("benchmark_cumulative", []), dtype=np.float64)
    benchmark_returns = np.array(bt.get("benchmark_returns", []), dtype=np.float64)
    benchmark_equal_lots_cum = np.array(bt.get("benchmark_equal_lots_cumulative", []), dtype=np.float64)
    daily_returns = np.array(bt.get("daily_returns", []), dtype=np.float64)
    # 对比策略（手数映射策略）
    alt_values = np.array(bt.get("alt_values", []), dtype=np.float64)
    alt_init = float(bt.get("alt_initial_capital", alt_values[0] if alt_values.size > 0 else 1.0))
    alt_label = str(bt.get("alt_label", "手数映射策略"))
    if values.size > 0:
        init_cap = float(bt.get("initial_capital", values[0] if values.size > 0 else 1.0))
        eq_norm = values / max(1e-9, init_cap) - 1.0

        # 创建上下两个子图：上-收益曲线，下-超额收益柱状图
        fig, (ax_top, ax_bottom) = plt.subplots(2, 1, figsize=(12, 8), sharex=True, gridspec_kw={'height_ratios': [3, 1]})
        if x_dates is not None:
            # 转换日期格式用于对齐
            try:
                plot_dates = [datetime.strptime(str(d), "%Y-%m-%d") if isinstance(d, str) else d for d in x_dates]
            except Exception:
                plot_dates = x_dates

            # 策略收益曲线
            ax_top.plot(plot_dates, eq_norm, color="#1f77b4", linewidth=2.2, label="策略收益", alpha=0.9)

            # 等资金基准（每标的固定名义资金）
            if benchmark_cumulative.size > 0 and benchmark_cumulative.size == eq_norm.size:
                ax_top.plot(plot_dates, benchmark_cumulative, color="#ff7f0e", linewidth=1.8, label="等资金基准(每标的固定名义资金)", alpha=0.85)
            # 等手数基准（一次性成本，买入持有）
            if benchmark_equal_lots_cum.size > 0 and benchmark_equal_lots_cum.size == eq_norm.size:
                ax_top.plot(plot_dates, benchmark_equal_lots_cum, color="#8c564b", linewidth=1.6, linestyle='--', label="等手数基准(B&H, 含一次性成本)", alpha=0.8)

            # 对比策略（若存在）
            if alt_values.size > 0:
                alt_eq = alt_values / max(1e-9, alt_init) - 1.0
                if alt_eq.size == eq_norm.size:
                    ax_top.plot(plot_dates, alt_eq, color="#9467bd", linewidth=1.6, linestyle='-.', label=alt_label, alpha=0.85)

            # 自定义日收益（按单利累加）：来自 backtest.custom_daily_returns
            try:
                custom = bt.get("custom_daily_returns", None)
                if custom is None:
                    # 从 cfg.backtest 读取（若保存了 config_used）
                    cfg_used = bt.get("config_used", {})
                    bcfg = cfg_used.get("backtest", {}) if isinstance(cfg_used, dict) else {}
                    series = bcfg.get("custom_daily_returns", []) if isinstance(bcfg, dict) else []
                else:
                    series = custom
                if isinstance(series, list):
                    S = len(eq_norm)
                    arr = np.array(series, dtype=np.float64)
                    if arr.size < S:
                        pad = np.zeros(S - arr.size, dtype=np.float64)
                        arr = np.concatenate([arr, pad], axis=0)
                    elif arr.size > S:
                        arr = arr[:S]
                    cum_simple = np.cumsum(arr)
                    ax_top.plot(plot_dates, cum_simple, color="#000000", linewidth=1.4, linestyle=':', label="自定义(单利)", alpha=0.9)
            except Exception:
                pass

            # 添加大盘指数对比
            if index_data is not None:
                index_colors = ['#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f']
                index_styles = ['-', '--', '-.', ':', '-', '--']
                start_date = plot_dates[0] if plot_dates else None
                end_date = plot_dates[-1] if plot_dates else None
                if start_date and end_date:
                    mask = (index_data.index >= start_date) & (index_data.index <= end_date)
                    filtered_index = index_data[mask]
                    color_idx = 0
                    for col in index_data.columns:
                        if not col.endswith('_return') and color_idx < len(index_colors):
                            index_name = col
                            if filtered_index[col].notna().sum() > 0:
                                aligned_dates = []
                                aligned_returns = []
                                base_price = None
                                for plot_date in plot_dates:
                                    closest_date = filtered_index.index[filtered_index.index <= plot_date]
                                    if len(closest_date) > 0:
                                        closest_date = closest_date[-1]  # pyright: ignore[reportIndexIssue]
                                        if pd.notna(filtered_index.loc[closest_date, col]):
                                            current_price = filtered_index.loc[closest_date, col]
                                            if base_price is None:
                                                base_price = current_price
                                                normalized_return = 0.0
                                            else:
                                                normalized_return = (current_price - base_price) / base_price
                                            aligned_dates.append(plot_date)
                                            aligned_returns.append(normalized_return)
                                if len(aligned_dates) > 0:
                                    ax_top.plot(
                                        aligned_dates,
                                        aligned_returns,
                                        color=index_colors[color_idx],
                                        linestyle=index_styles[color_idx % len(index_styles)],
                                        linewidth=1.2,
                                        label=index_name,
                                        alpha=0.7,
                                    )
                                    color_idx += 1

            # 超额收益（累计）：策略累计收益 - 等资金基准累计收益
            if benchmark_cumulative.size > 0 and benchmark_cumulative.size == eq_norm.size:
                cum_excess = eq_norm - benchmark_cumulative
                ax_bottom.plot(plot_dates, cum_excess, color="#2ca02c", linewidth=1.6, label="累计超额")
                ax_bottom.axhline(0.0, color="#333333", linewidth=0.8)
                ax_bottom.set_ylabel("超额(累计)")
                ax_bottom.legend(loc='upper left')

            # 设置刻度：首末精确日期 + 中间按月
            ticks = month_ticks
            try:
                ax_top.set_xticks(ticks)
            except Exception:
                pass
            try:
                labels = [
                    (dt.strftime("%Y-%m-%d") if i in (0, len(ticks) - 1) else dt.strftime("%Y-%m"))
                    for i, dt in enumerate(ticks)
                ]
                ax_top.set_xticklabels(labels, rotation=45, ha='right')
                # 同步底部子图的日期刻度与倾斜显示
                try:
                    ax_bottom.set_xticks(ticks)
                except Exception:
                    pass
                try:
                    ax_bottom.set_xticklabels(labels, rotation=45, ha='right')
                except Exception:
                    pass
            except Exception:
                pass
            

            # 计算并显示收益统计
            info_text = f'策略收益: {eq_norm[-1]:.2%}'
            if benchmark_cumulative.size > 0 and benchmark_cumulative.size == eq_norm.size:
                benchmark_ret = benchmark_cumulative[-1]
                alpha = eq_norm[-1] - benchmark_ret
                info_text += f'\n等手数基准: {benchmark_ret:.2%}\n阿尔法: {alpha:.2%}'

            ax_top.text(
                0.02, 0.98, info_text,
                transform=ax_top.transAxes, verticalalignment='top', fontsize=10,
                bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.8),
            )

        else:
            ax_top.plot(eq_norm, color="#1f77b4", linewidth=2.2, label="策略收益", alpha=0.9)
            if benchmark_cumulative.size > 0 and benchmark_cumulative.size == eq_norm.size:
                ax_top.plot(benchmark_cumulative, color="#ff7f0e", linewidth=1.8, label="等资金基准(每标的固定名义资金)", alpha=0.85)
            if alt_values.size > 0:
                alt_eq = alt_values / max(1e-9, alt_init) - 1.0
                if alt_eq.size == eq_norm.size:
                    ax_top.plot(alt_eq, color="#9467bd", linewidth=1.6, linestyle='-.', label=alt_label, alpha=0.85)
            # 自定义日收益（按单利累加）：来自 backtest.custom_daily_returns 或 config.backtest
            try:
                custom = bt.get("custom_daily_returns", None)
                if custom is None:
                    cfg_used = bt.get("config_used", {})
                    bcfg = cfg_used.get("backtest", {}) if isinstance(cfg_used, dict) else {}
                    series = bcfg.get("custom_daily_returns", []) if isinstance(bcfg, dict) else []
                else:
                    series = custom
                if isinstance(series, list):
                    S = len(eq_norm)
                    arr = np.array(series, dtype=np.float64)
                    if arr.size < S:
                        pad = np.zeros(S - arr.size, dtype=np.float64)
                        arr = np.concatenate([arr, pad], axis=0)
                    elif arr.size > S:
                        arr = arr[:S]
                    cum_simple = np.cumsum(arr)
                    ax_top.plot(np.arange(len(cum_simple)), cum_simple, color="#000000", linewidth=1.4, linestyle=':', label="自定义(单利)", alpha=0.9)
            except Exception:
                pass
            # RL 策略曲线（如有）
            rl_vals = np.array(bt.get("rl_values", []), dtype=np.float64)
            rl_init = float(bt.get("rl_initial_capital", rl_vals[0] if rl_vals.size > 0 else 1.0))
            rl_label = str(bt.get("rl_label", "RL策略"))
            if rl_vals.size > 0:
                rl_eq = rl_vals / max(1e-9, rl_init) - 1.0
                if rl_eq.size == eq_norm.size:
                    ax_top.plot(rl_eq, color="#d62728", linewidth=1.6, linestyle='--', label=rl_label, alpha=0.85)
            if benchmark_cumulative.size > 0 and benchmark_cumulative.size == eq_norm.size:
                cum_excess = eq_norm - benchmark_cumulative
                ax_bottom.plot(np.arange(len(cum_excess)), cum_excess, color="#2ca02c", linewidth=1.6, label="累计超额")
                ax_bottom.axhline(0.0, color="#333333", linewidth=0.8)
                ax_bottom.set_ylabel("超额(累计)")
                ax_bottom.legend(loc='upper left')

        ax_top.set_title("权益曲线对比 (策略 vs 基准 vs 大盘指数)")
        ax_top.set_ylabel("累计收益率")
        ax_top.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
        ax_top.grid(True, alpha=0.3)
        ax_bottom.grid(True, alpha=0.2)
        ax_bottom.set_xlabel("Date" if x_dates is not None else "Day")
        plt.tight_layout()
        plt.savefig(os.path.join(plot_dir, f"{prefix}_equity.png"), bbox_inches='tight')
        plt.close()

    # 新增：每日仓位资金与现金变化图
    try:
        if (holding_value_series.size > 0) and (values.size == holding_value_series.size):
            plt.figure(figsize=(10, 4))
            if x_dates is not None:
                ax = plt.gca()
                plt.plot(x_dates, holding_value_series, color="#1f77b4", linewidth=1.2, label="Holding Value")
                if cash_series.size == holding_value_series.size:
                    plt.plot(x_dates, cash_series, color="#ff7f0e", linewidth=1.0, alpha=0.8, label="Cash")
                ticks = month_ticks
                try:
                    ax.set_xticks(ticks)
                    labels = [
                        (dt.strftime("%Y-%m-%d") if i in (0, len(ticks) - 1) else dt.strftime("%Y-%m"))
                        for i, dt in enumerate(ticks)
                    ]
                    ax.set_xticklabels(labels, rotation=45, ha='right')
                except Exception:
                    pass
            else:
                x = np.arange(holding_value_series.size)
                plt.plot(x, holding_value_series, color="#1f77b4", linewidth=1.2, label="Holding Value")
                if cash_series.size == holding_value_series.size:
                    plt.plot(x, cash_series, color="#ff7f0e", linewidth=1.0, alpha=0.8, label="Cash")
            plt.title("Daily Portfolio Value Breakdown")
            plt.xlabel("Date" if x_dates is not None else "Day")
            plt.ylabel("Value (CNY)")
            plt.legend()
            plt.tight_layout()
            plt.savefig(os.path.join(plot_dir, f"{prefix}_position_value.png"))
            plt.close()
    except Exception:
        pass
    # 回撤曲线
    daily_returns = np.array(bt.get("daily_returns", []), dtype=np.float64)
    if daily_returns.size > 0:
        # 日收益时间序列图
        try:
            plt.figure(figsize=(8, 3))
            if x_dates is not None:
                ax = plt.gca()
                plt.plot(x_dates, daily_returns, color="#2ca02c", linewidth=1.0)
                ticks = month_ticks
                try:
                    ax.set_xticks(ticks)
                    labels = [
                        (dt.strftime("%Y-%m-%d") if i in (0, len(ticks) - 1) else dt.strftime("%Y-%m"))
                        for i, dt in enumerate(ticks)
                    ]
                    ax.set_xticklabels(labels, rotation=45, ha='right')
                except Exception:
                    pass
            else:
                plt.plot(daily_returns, color="#2ca02c", linewidth=1.0)
            plt.title("Daily Returns (Time Series)")
            plt.xlabel("Date" if x_dates is not None else "Day")
            plt.ylabel("Return")
            plt.tight_layout()
            plt.savefig(os.path.join(plot_dir, f"{prefix}_daily_returns.png"))
            plt.close()
        except Exception:
            pass
        eq = np.cumprod(1.0 + daily_returns)
        runmax = np.maximum.accumulate(eq)
        dd = (runmax - eq) / np.clip(runmax, 1e-12, None)
        plt.figure(figsize=(8, 3))
        if x_dates is not None:
            ax = plt.gca()
            plt.plot(x_dates, dd, color="#d62728", linewidth=1.2)
            ticks = month_ticks
            try:
                ax.set_xticks(ticks)
                labels = [
                    (dt.strftime("%Y-%m-%d") if i in (0, len(ticks) - 1) else dt.strftime("%Y-%m"))
                    for i, dt in enumerate(ticks)
                ]
                ax.set_xticklabels(labels, rotation=45, ha='right')
            except Exception:
                pass
        else:
            plt.plot(dd, color="#d62728", linewidth=1.2)
        plt.title("Drawdown")
        plt.xlabel("Date" if x_dates is not None else "Day")
        plt.ylabel("Drawdown")
        plt.tight_layout()
        plt.savefig(os.path.join(plot_dir, f"{prefix}_drawdown.png"))
        plt.close()
        # 日收益分布
        plt.figure(figsize=(6, 4))
        plt.hist(daily_returns, bins=50, color="#2ca02c", alpha=0.8)
        plt.title("Daily Returns Histogram")
        plt.xlabel("Daily Return")
        plt.ylabel("Count")
        plt.tight_layout()
        plt.savefig(os.path.join(plot_dir, f"{prefix}_daily_returns_hist.png"))
        plt.close()
    # 每日开仓数量（买入/卖出）
    if isinstance(trades, list) and len(trades) > 0:
        try:
            buys = np.array([int(row.get("buys", 0)) for row in trades], dtype=np.int64)
            sells = np.array([int(row.get("sells", 0)) for row in trades], dtype=np.int64)
            plt.figure(figsize=(8, 3))
            if x_dates is not None:
                ax = plt.gca()
                plt.plot(x_dates, buys, label="buys", color="#1f77b4", linewidth=1.2)
                plt.plot(x_dates, sells, label="sells", color="#ff7f0e", linewidth=1.2)
                ticks = month_ticks
                ax.set_xticks(ticks)
                labels = [
                    (dt.strftime("%Y-%m-%d") if i in (0, len(ticks) - 1) else dt.strftime("%Y-%m"))
                    for i, dt in enumerate(ticks)
                ]
                ax.set_xticklabels(labels, rotation=45, ha='right')
            else:
                x = np.arange(len(buys))
                plt.plot(x, buys, label="buys", color="#1f77b4", linewidth=1.2)
                plt.plot(x, sells, label="sells", color="#ff7f0e", linewidth=1.2)
            plt.title("Daily Buy/Sell Counts")
            plt.xlabel("Date" if x_dates is not None else "Day")
            plt.ylabel("Count")
            plt.legend()
            plt.tight_layout()
            plt.savefig(os.path.join(plot_dir, f"{prefix}_daily_trades.png"))
            plt.close()
        except Exception:
            pass


def load_index_data(index_file_path: str) -> Optional[pd.DataFrame]:
    """加载大盘指数数据"""
    try:
        if not os.path.exists(index_file_path):
            print(f"[警告] 指数文件不存在: {index_file_path}")
            return None
        
        df = pd.read_csv(index_file_path, encoding='utf-8')
        df['date'] = pd.to_datetime(df['date'])
        df.set_index('date', inplace=True)
        
        # 计算每个指数的归一化收益率（相对于起始价格）
        for col in df.columns:
            if df[col].notna().sum() > 0:  # 确保有有效数据
                first_valid_price = df[col].dropna().iloc[0]
                df[f'{col}_return'] = (df[col] - first_valid_price) / first_valid_price
        
        print(f"[信息] 成功加载指数数据，包含指数: {list(df.columns[:6])}")  # 显示前6个原始指数名
        return df
        
    except Exception as e:
        print(f"[错误] 加载指数数据失败: {e}")
        return None


def calculate_market_impact(our_volume: float, avg_volume: float, linear_coef: float, sqrt_coef: float) -> float:
    """
    计算市场冲击成本
    our_volume: 我们的目标成交量
    avg_volume: 该股票的平均成交量
    linear_coef: 线性冲击系数
    sqrt_coef: 平方根冲击系数
    
    返回：冲击成本比例（如 0.002 表示 0.2% 的成本）
    """
    if avg_volume <= 0:
        return 0.10  # 无历史成交量时，假设高冲击成本
    
    volume_ratio = our_volume / avg_volume
    linear_impact = linear_coef * volume_ratio
    sqrt_impact = sqrt_coef * np.sqrt(volume_ratio)
    
    # 总冲击成本，上限为 5%
    total_impact = min(linear_impact + sqrt_impact, 0.05)
    return total_impact


def main():
    args = parse_args()
    device = torch.device(args.device)

    # 覆盖参数：优先 --config.backtest（若存在）
    try:
        cfg_path = None
        if isinstance(getattr(args, "config", ""), str) and len(getattr(args, "config", "")) > 0 and os.path.exists(getattr(args, "config", "")):
            cfg_path = getattr(args, "config", "")
        elif os.path.exists("config.json"):
            cfg_path = "config.json"
        if cfg_path is not None:
            with open(cfg_path, "r", encoding="utf-8") as f:
                cfg_json = json.load(f)
            bcfg = cfg_json.get("backtest", {})
            def _ovr(name, cast):
                if name in bcfg and bcfg[name] is not None:
                    try:
                        setattr(args, name, cast(bcfg[name]))
                    except Exception:
                        pass
            _ovr("initial_capital", float)
            _ovr("impact_linear", float)
            _ovr("impact_sqrt", float)
            _ovr("liquidity_alpha", float)
            _ovr("min_lot", int)
            _ovr("commission_rate", float)
            _ovr("stamp_duty_sell", float)
            _ovr("price_limit_pct", float)
            _ovr("enable_oos_backtest", int)
            # 采样策略参数
            _ovr("num_samples", int)
            _ovr("ddim_steps", int)
            _ovr("ddim_eta", float)
            _ovr("chunk_size", int)
            _ovr("direct_score", int)
            _ovr("direct_anchor", str)
            _ovr("direct_lambda", float)
            _ovr("score_sigma_min", float)
            _ovr("score_sigma_max", float)
            _ovr("diff_steps", int)
            _ovr("progress", int)
            _ovr("log_interval", int)
            _ovr("risk_k", float)
            _ovr("max_lots", int)
            _ovr("value_based_position", int)
            _ovr("max_notional_per_stock", float)
            _ovr("benchmark_discrete", int)
            _ovr("cvar_alpha", float)
            _ovr("entropy_bins", int)
            _ovr("cvar_eps", float)
            _ovr("entropy_eps", float)
            _ovr("cvar_power", float)
            _ovr("er_positive_buy", int)
            # 无需覆盖开仓阈值（净收益口径）
            _ovr("sampler", str)
            _ovr("objective", str)
            _ovr("edm_steps", int)
            _ovr("s_churn", float)
            _ovr("sigma_data", float)
            _ovr("diffusion_head_hidden", int)
            _ovr("diffusion_head_dropout", float)
            print(f"[backtest] 覆盖参数自 {cfg_path} 的 backtest 段", flush=True)
    except Exception as e:
        print(f"[backtest] 读取/合并配置失败，忽略：{e}", flush=True)

    ckpt = load_checkpoint(args.checkpoint, device)
    cfg = ckpt.get("config", {})
    artifacts = ckpt.get("artifacts", {})
    try:
        print(f"[assert-artifacts] present={bool(isinstance(artifacts, dict) and len(artifacts)>0)}", flush=True)
    except Exception:
        pass
    
    # 从训练配置强制继承关键参数，确保训练-推理一致性
    # 优先级（强制覆盖）：训练 checkpoint.config.train > 训练 checkpoint.config > 其它
    param_sources: dict[str, str] = {}
    def _force_from_train(attr_name: str, train_key: str | None = None, cast_fn=None):
        if train_key is None:
            train_key = attr_name
        val = None
        src = None
        try:
            cfg_train = cfg.get('train', {}) if isinstance(cfg, dict) else {}
            if isinstance(cfg_train, dict) and (train_key in cfg_train) and (cfg_train[train_key] is not None):
                val = cfg_train[train_key]
                src = 'ckpt.train'
            elif (train_key in cfg) and (cfg[train_key] is not None):
                val = cfg[train_key]
                src = 'ckpt.root'
        except Exception:
            val = None
        if val is not None:
            try:
                if cast_fn is not None:
                    val = cast_fn(val)
                setattr(args, attr_name, val)
                param_sources[attr_name] = src or 'ckpt'
            except Exception:
                pass
        else:
            # 未覆盖，保持 CLI/配置传入值，标记来源
            param_sources.setdefault(attr_name, 'cli/config')

    _force_from_train('objective', 'objective', str)
    _force_from_train('score_sigma_min', 'sigma_min', float)
    _force_from_train('score_sigma_max', 'sigma_max', float)
    _force_from_train('sigma_data', 'sigma_data', float)
    _force_from_train('vol_cond_as_input', 'vol_cond_as_input', int)
    _force_from_train('vol_cond_scale_output', 'vol_cond_scale_output', int)
    _force_from_train('diffusion_head_hidden', 'diffusion_head_hidden', int)
    _force_from_train('diffusion_head_dropout', 'diffusion_head_dropout', float)

    print(
        f"[backtest-align] objective={getattr(args, 'objective', 'N/A')} (src={param_sources.get('objective')}) "
        f"sigma_min={getattr(args, 'score_sigma_min', 'N/A')} (src={param_sources.get('score_sigma_min')}) "
        f"sigma_max={getattr(args, 'score_sigma_max', 'N/A')} (src={param_sources.get('score_sigma_max')}) "
        f"sigma_data={getattr(args, 'sigma_data', 'N/A')} (src={param_sources.get('sigma_data')}) "
        f"vol_cond_as_input={getattr(args, 'vol_cond_as_input', 1)} (src={param_sources.get('vol_cond_as_input')}) "
        f"vol_cond_scale_output={getattr(args, 'vol_cond_scale_output', 0)} (src={param_sources.get('vol_cond_scale_output')})",
        flush=True,
    )
    
    # 检测训练是否启用了波动率条件（yz_vol），用于推理对齐
    use_yz_cond = False
    try:
        ns_mode = str(cfg.get('noise_scale_mode', 'constant')).lower()
        if ns_mode == 'yz_vol':
            use_yz_cond = True
    except Exception:
        use_yz_cond = False
    # 允许 CLI/配置强制覆盖（例如为了做 ablation）：backtest.use_yz_cond=0/1
    try:
        bcfg = {}
        cfg_path = getattr(args, 'config', '')
        if isinstance(cfg_path, str) and len(cfg_path) > 0 and os.path.exists(cfg_path):
            with open(cfg_path, 'r', encoding='utf-8') as f:
                cfg_json = json.load(f)
            bcfg = cfg_json.get('backtest', {})
        if 'use_yz_cond' in bcfg:
            use_yz_cond = bool(int(bcfg.get('use_yz_cond', 1)) == 1)
    except Exception:
        pass
    meta = load_meta(args.data_dir)
    
    # 加载大盘指数数据
    index_file_path = os.path.join("data", "raw", "china_index_data.csv")
    index_data = load_index_data(index_file_path)

    # 使用 test_env.pt 作为交易环境
    env_path = os.path.join(args.data_dir, "test_env.pt")
    if not os.path.exists(env_path):
        raise FileNotFoundError(f"缺少 {env_path}，请先运行预处理生成 test_env.pt（save_sequences 可为 0）")
    env_pack = torch.load(env_path, weights_only=False)
    
    # [DEBUG] 检查加载的 tensor dtype
    print(f"[env-load-check] decision_open.dtype={env_pack['decision_open'].dtype} decision_volume.dtype={env_pack['decision_volume'].dtype}", flush=True)
    
    # 强制转换为 float32（若不是数值类型则报错）
    try:
        decision_open = env_pack["decision_open"].float().to(device)
        decision_volume = env_pack["decision_volume"].float().to(device)
        prev_close_decision = env_pack["prev_close_decision"].float().to(device)
        prev_close_settlement = env_pack["prev_close_settlement"].float().to(device)
    except Exception as _e_tensor:
        print(f"[env-load-error] tensor conversion failed: {_e_tensor}", flush=True)
        # 如果 tensor 是 object/string 类型，尝试先转为 numpy 再转回
        decision_open = torch.from_numpy(np.asarray(env_pack["decision_open"].cpu().numpy(), dtype=np.float32)).to(device)
        decision_volume = torch.from_numpy(np.asarray(env_pack["decision_volume"].cpu().numpy(), dtype=np.float32)).to(device)
        prev_close_decision = torch.from_numpy(np.asarray(env_pack["prev_close_decision"].cpu().numpy(), dtype=np.float32)).to(device)
        prev_close_settlement = torch.from_numpy(np.asarray(env_pack["prev_close_settlement"].cpu().numpy(), dtype=np.float32)).to(device)
    
    cutoff_indices = env_pack["cutoff_indices"].cpu().numpy().astype(int)
    # 若预处理保留了末尾填充日，这里支持裁尾（避免填充值参与回测）
    trim_tail_days = int(getattr(args, "trim_tail_days", 0))
    if trim_tail_days > 0 and trim_tail_days < len(cutoff_indices):
        cutoff_indices = cutoff_indices[:-trim_tail_days]
        print(f"[info] 裁掉末尾填充天数: trim_tail_days={trim_tail_days}, 剩余决策点={len(cutoff_indices)}")
    open_all = env_pack.get("open_all").numpy()
    prev_close_all = env_pack.get("prev_close_all").numpy()
    stocks_list: List[str] = env_pack.get("stocks", [])
    feature_names_env = env_pack.get("feature_names", None)
    price_scale_mean = env_pack.get("price_scale_mean", None)
    price_scale_std = env_pack.get("price_scale_std", None)
    if not stocks_list:
        raise KeyError("test_env.pt 中缺少 stocks 列表")
    if price_scale_mean is None or price_scale_std is None:
        raise KeyError("test_env.pt 缺少价格反标准化参数(price_scale_mean/std)。请重新运行预处理以生成包含缩放参数的 test_env.pt。")

    avg_volume_train = np.array(meta.get("avg_volume_train_per_stock", [0.0] * len(stocks_list)), dtype=np.float32)
    if avg_volume_train.shape[0] != len(stocks_list):
        avg_volume_train = np.resize(avg_volume_train, len(stocks_list))

    # 仅使用预处理阶段生成的 OOS 列表；回测不再做比例抽样
    stock_mask = None
    train_mask = None
    auto_oos_path = os.path.join(args.data_dir, "oos_stocks.txt")
    if os.path.exists(auto_oos_path):
        try:
            with open(auto_oos_path, "r", encoding="utf-8") as f:
                oos_stocks = [line.strip() for line in f if line.strip()]
            if oos_stocks:
                oos_set = set(oos_stocks)
                stock_mask = np.array([s in oos_set for s in stocks_list], dtype=bool)
                train_mask = ~stock_mask
                print(f"OOS 股票数: {stock_mask.sum()} / {len(stocks_list)} | 训练池(ALL排OOS)={int(train_mask.sum())}")
        except Exception as e:
            print(f"[warn] 读取 OOS 列表失败: {e}")

    # panels 推理
    panels_path = os.path.join(args.data_dir, "panels.pt")
    if not os.path.exists(panels_path):
        raise FileNotFoundError(f"缺少 {panels_path}，无法进行 panels 推理")
    ds_test = StreamingPanelDataset(panels_path, split="test")
    # 特征名与维度严格校验
    if feature_names_env is not None:
        # env 与 panels 特征名应一致
        pass  # env 来自同链路，通常一致；模型特征名在 cfg 中
    if cfg.get("feature_names") is not None:
        # 可选：确保 input_dim 一致
        if int(cfg.get("input_dim")) != int(ds_test.input_dim):
            raise ValueError(f"panels.pt input_dim({ds_test.input_dim}) 与模型({cfg.get('input_dim')}) 不一致")
    # 读取训练池股票列表（与训练一致的顺序）
    train_list_path = os.path.join(args.data_dir, "actual_train_stocks.txt")
    if not os.path.exists(train_list_path):
        raise FileNotFoundError(f"缺少 {train_list_path}，无法对齐训练池顺序")
    with open(train_list_path, "r", encoding="utf-8") as f:
        train_stocks = [line.strip() for line in f if line.strip()]
    N_train = len(train_stocks)
    # 构建面板索引映射：训练池顺序 -> ds_test 面板索引
    panel_stocks = ds_test.stocks
    pos_in_panel = {sid: i for i, sid in enumerate(panel_stocks)}
    order_train_to_panel = []
    for sid in train_stocks:
        if sid not in pos_in_panel:
            raise KeyError(f"回测面板缺少训练股票: {sid}")
        order_train_to_panel.append(int(pos_in_panel[sid]))
    order_train_to_panel_arr = np.array(order_train_to_panel, dtype=np.int64)
    # 取消 artifacts 的打印一致性检查
    # 取消 artifacts 的一致性检查打印
    # OOS 列表（若存在）
    oos_list = []
    oos_list_path = os.path.join(args.data_dir, "oos_stocks.txt")
    if os.path.exists(oos_list_path):
        with open(oos_list_path, "r", encoding="utf-8") as f:
            oos_list = [line.strip() for line in f if line.strip()]
    oos_in_panel = [sid for sid in oos_list if sid in pos_in_panel]
    K_oos = len(oos_in_panel)
    oos_idx_in_panel = [int(pos_in_panel[sid]) for sid in oos_in_panel]
    # 以训练池数量实例化模型，确保与 ckpt 形状一致
    model = SpacetimeGNNMAM(
        input_dim=cfg["input_dim"],
        num_stocks=N_train,
        seq_len=cfg["seq_len"],
        d_model=cfg["d_model"],
        num_heads=cfg["num_heads"],
        num_layers=cfg["num_layers"],
        d_ff=cfg["d_ff"],
        num_classes=1,
        dropout=cfg["dropout"],
        temp=cfg["temp"],
        adj_activation=cfg.get("adj_activation", "softmax"),
        entmax_alpha=float(cfg.get("entmax_alpha", 1.5)),
        num_pool_queries=int(cfg.get("num_pool_queries", 6)),
        pooling_tau=float(cfg.get("pooling_tau", 0.7)),
        diffusion_head_hidden_dim=getattr(args, "diffusion_head_hidden", None),
        diffusion_head_dropout=getattr(args, "diffusion_head_dropout", None),
    ).to(device)
    state = ckpt.get("model_state", ckpt)
    # 最终加载权重：兼容旧 checkpoint（无 diffusion_volproj）
    try:
        model.load_state_dict(state, strict=True)
    except RuntimeError as e:
        emsg = str(e)
        if ("diffusion_volproj.weight" in emsg) or ("diffusion_volproj.bias" in emsg):
            print("[warn] checkpoint 缺少 diffusion_volproj 参数，使用模型默认初始化，并以非严格模式加载其余权重")
            model.load_state_dict(state, strict=False)
        else:
            raise
    model.eval()
    # 模型参数量统计
    try:
        params_total = int(sum(p.numel() for p in model.parameters()))
        params_trainable = int(sum(p.numel() for p in model.parameters() if p.requires_grad))
        print(
            f"[model] params_total={params_total:,} trainable={params_trainable:,} "
            f"d_model={cfg.get('d_model')} layers={cfg.get('num_layers')} heads={cfg.get('num_heads')} d_ff={cfg.get('d_ff')} input_dim={cfg.get('input_dim')}",
            flush=True,
        )
    except Exception:
        params_total = None
        params_trainable = None
    # 推理（训练池顺序）：逐样本裁剪/重排
    loader = torch.utils.data.DataLoader(ds_test, batch_size=1, shuffle=False)
    preds_train = []  # [S_ds, N_train, 1]
    trues_train = []  # [S_ds, N_train, 1]
    preds_oos_padded = []  # [S_ds, N_train, 1]（前K为OOS，后部为padding）
    trues_oos_padded = []
    with torch.no_grad():
        for batch in loader:  # StreamingPanelDataset 返回 (X, Y, t_index) 或 (X, Y, t_index, mask)
            if isinstance(batch, (list, tuple)) and len(batch) == 4:
                bx, by, _, mask_bt = batch  # [mask机制]
            else:
                bx, by, _ = batch
                mask_bt = None
            bx = bx.to(device)        # [1, Np, T, F]
            by = by.to(device)        # [1, Np, 1]
            # [mask机制] 重排mask
            if mask_bt is not None:
                mask_bt = mask_bt.to(device)
                mask_train = mask_bt[:, order_train_to_panel_arr, :, :].contiguous()
            else:
                mask_train = None
            # 训练池顺序输入
            bx_train = bx[:, order_train_to_panel_arr, :, :].contiguous()  # [1, N_train, T, F]
            py_train_feat = model.encode(bx_train, mask=mask_train)  # [1, N_train, D]
            py_train = py_train_feat.mean(dim=-1, keepdim=True)  # [1, N_train, 1]
            preds_train.append(py_train.cpu())
            trues_train.append(by[:, order_train_to_panel_arr, :].cpu())
            # OOS 填充至 N_train
            if K_oos > 0:
                # 当 K_oos <= N_train：一次性填充；否则按 N_train 固定切片，保留首片以维持与时间对齐的形状，
                # 其余切片在后续 OOS 指标分批聚合（采样驱动）中处理。
                if K_oos <= N_train:
                    bx_oos = bx[:, oos_idx_in_panel, :, :]  # [1, K_oos, T, F]
                    pad = torch.zeros((1, N_train, bx.shape[2], bx.shape[3]), dtype=bx.dtype, device=bx.device)
                    pad[:, :K_oos, :, :] = bx_oos
                    py_oos = model.encode(pad).mean(dim=-1, keepdim=True)  # [1, N_train, 1]
                    preds_oos_padded.append(py_oos.cpu())
                    pad_y = torch.zeros((1, N_train, 1), dtype=by.dtype, device=by.device)
                    pad_y[:, :K_oos, :] = by[:, oos_idx_in_panel, :]
                    trues_oos_padded.append(pad_y.cpu())
                else:
                    # 仅保留第一片到 pred/true 面板以保证对齐，其余片由后续分批 OOS 逻辑处理
                    part = oos_idx_in_panel[:N_train]
                    B = len(part)
                    pad = torch.zeros((1, N_train, bx.shape[2], bx.shape[3]), dtype=bx.dtype, device=bx.device)
                    pad[:, :B, :, :] = bx[:, part, :, :]
                    py_oos = model.encode(pad).mean(dim=-1, keepdim=True)  # [1, N_train, 1]
                    preds_oos_padded.append(py_oos.cpu())
                    pad_y = torch.zeros((1, N_train, 1), dtype=by.dtype, device=by.device)
                    pad_y[:, :B, :] = by[:, part, :]
                    trues_oos_padded.append(pad_y.cpu())
    pred_panel = torch.cat(preds_train, dim=0)   # [S_ds, N_train, 1]
    true_panel = torch.cat(trues_train, dim=0)   # [S_ds, N_train, 1]
    pred_panel_oos = torch.cat(preds_oos_padded, dim=0) if K_oos > 0 else None
    true_panel_oos = torch.cat(trues_oos_padded, dim=0) if K_oos > 0 else None
    # 对齐样本顺序：cutoff_indices（env）对应 ds_test.time_indices
    g_list = ds_test.time_indices
    g_to_j = {int(g): j for j, g in enumerate(g_list)}
    pred_aligned = []
    true_aligned = []
    for g in cutoff_indices.tolist():
        j = g_to_j.get(int(g))
        if j is None:
            raise KeyError(f"cutoff index {g} not found in panels time_indices")
        pred_aligned.append(pred_panel[j])
        true_aligned.append(true_panel[j])
    pred = torch.stack(pred_aligned, dim=0)  # [S,N_train,1]
    Y = torch.stack(true_aligned, dim=0)     # [S,N_train,1]
    # OOS 对齐
    if (pred_panel_oos is not None) and (true_panel_oos is not None):
        pred_aligned_oos = []
        true_aligned_oos = []
        for g in cutoff_indices.tolist():
            j = g_to_j.get(int(g))
            if j is None:
                raise KeyError(f"cutoff index {g} not found in panels time_indices (oos)")
            pred_aligned_oos.append(pred_panel_oos[j])
            true_aligned_oos.append(true_panel_oos[j])
        pred_oos = torch.stack(pred_aligned_oos, dim=0)  # [S,N_train,1]
        Y_oos = torch.stack(true_aligned_oos, dim=0)     # [S,N_train,1]

    # 目标域=log-return：此处不做价格反标准化；仅用于一致性校验重排 mean/std（不参与数值转换）
    mean_vec = price_scale_mean.view(1, -1, 1)
    std_vec = price_scale_std.view(1, -1, 1)
    mean_vec = mean_vec[:, order_train_to_panel_arr, :]
    std_vec = std_vec[:, order_train_to_panel_arr, :]
    # 取消 artifacts 的 mean/std 打印
    already_denorm = False
    if pred_panel_oos is not None:
        pass

    pred_np = pred.detach().cpu().numpy().reshape(pred.shape[0], pred.shape[1])
    true_np = Y.detach().cpu().numpy().reshape(Y.shape[0], Y.shape[1])
    if pred_panel_oos is not None:
        pred_oos_np = pred_oos.detach().cpu().numpy().reshape(pred_oos.shape[0], pred_oos.shape[1])
        true_oos_np = Y_oos.detach().cpu().numpy().reshape(Y_oos.shape[0], Y_oos.shape[1])
    decision_np = decision_open.detach().cpu().numpy().reshape(decision_open.shape[0], decision_open.shape[1])
    volume_np = decision_volume.detach().cpu().numpy().reshape(decision_volume.shape[0], decision_volume.shape[1])
    pc_dec_np = prev_close_decision.detach().cpu().numpy().reshape(prev_close_decision.shape[0], prev_close_decision.shape[1])
    pc_set_np = prev_close_settlement.detach().cpu().numpy().reshape(prev_close_settlement.shape[0], prev_close_settlement.shape[1])
    
    # [DEBUG] 打印转换前的 dtype
    print(f"[dtype-check-before] decision_np={decision_np.dtype} volume_np={volume_np.dtype} pc_dec_np={pc_dec_np.dtype} pc_set_np={pc_set_np.dtype}", flush=True)
    if decision_np.dtype.kind in ('U', 'S', 'O'):
        print(f"[dtype-check-before] decision_np is string/object! head={decision_np.ravel()[:5]}", flush=True)
    
    # 强制数值类型，避免后续乘法与字符串 dtype 冲突
    try:
        decision_np = decision_np.astype(np.float64, copy=False)
        volume_np = volume_np.astype(np.float64, copy=False)
        pc_dec_np = pc_dec_np.astype(np.float64, copy=False)
        pc_set_np = pc_set_np.astype(np.float64, copy=False)
    except Exception as _e_cast:
        print(f"[dtype-check-error] astype failed: {_e_cast}, using np.asarray", flush=True)
        decision_np = np.asarray(decision_np, dtype=np.float64)
        volume_np = np.asarray(volume_np, dtype=np.float64)
        pc_dec_np = np.asarray(pc_dec_np, dtype=np.float64)
        pc_set_np = np.asarray(pc_set_np, dtype=np.float64)
    
    # [DEBUG] 打印转换后的 dtype
    print(f"[dtype-check-after] decision_np={decision_np.dtype} volume_np={volume_np.dtype} pc_dec_np={pc_dec_np.dtype} pc_set_np={pc_set_np.dtype}", flush=True)

    # 将面板域的交易相关数组重排到训练池顺序，确保与采样/模型输出维度一致（N_train）
    decision_np_train = decision_np[:, order_train_to_panel_arr]
    volume_np_train = volume_np[:, order_train_to_panel_arr]
    pc_dec_np_train = pc_dec_np[:, order_train_to_panel_arr]
    # 再按 cutoff_indices 对齐时间维度（S 天），避免与采样序列长度不一致
    try:
        idx_aligned = [g_to_j[int(g)] for g in cutoff_indices.tolist()]
        decision_np_train = decision_np_train[idx_aligned, :]
        volume_np_train = volume_np_train[idx_aligned, :]
        pc_dec_np_train = pc_dec_np_train[idx_aligned, :]
    except Exception:
        # 若对齐失败，保持原状（后续将抛出更易读的形状错误）
        pass
    open_all_train = open_all[:, order_train_to_panel_arr]
    prev_close_all_train = prev_close_all[:, order_train_to_panel_arr]
    avg_volume_train_train = np.asarray(avg_volume_train, dtype=np.float64)[order_train_to_panel_arr]

    # 构建逐股涨跌停向量：优先 JSON，其次板块启发式（训练池顺序）
    used_json_limits = False
    board_stats: Dict[str, int] = {}
    price_limit_vec: np.ndarray
    json_path = os.path.join("data", "raw", "all_stocks_limit.json")
    if os.path.exists(json_path):
        try:
            with open(json_path, "r", encoding="utf-8") as f:
                limit_map = json.load(f)
            vec: List[float] = []
            for sid in stocks_list:
                v = limit_map.get(str(sid))
                board = _detect_board(sid)  # 总是检测板块用于统计
                if v is None:
                    # 缺失时按板块启发式回退
                    if board == "KSH":
                        vv = 0.20
                    elif board in ("GEM", "BSE"):
                        vv = 0.30
                    elif board == "MainBoard":
                        vv = 0.10
                    else:
                        vv = float(args.price_limit_pct)
                    vec.append(float(vv))
                else:
                    try:
                        vv = float(v)
                        # 若给的是百分数（>1），做个简单修正
                        if vv > 1.0:
                            vv = vv / 100.0
                        vec.append(vv)
                    except Exception:
                        vec.append(float(args.price_limit_pct))
                # 统计板块
                board_stats[board] = board_stats.get(board, 0) + 1
            price_limit_vec = np.asarray(vec, dtype=np.float32)
            used_json_limits = True
        except Exception:
            used_json_limits = False
    if not used_json_limits:
        # 回退：基于面板股票列表构建阈值（而非仅训练池），以便 OOS 分支安全索引
        price_limit_vec, board_stats = _build_price_limit_vec(stocks_list, default_pct=float(args.price_limit_pct))

    print(f"初始资金: {args.initial_capital:,.0f} 元")
    print(f"流动性阈值: {args.liquidity_alpha:.2f}")
    print(f"费用参数: 佣金={args.commission_rate:.4%}；印花税(卖)={args.stamp_duty_sell:.4%}")
    if used_json_limits:
        print("逐股涨跌停阈值: 已载入 data/raw/all_stocks_limit.json")
        try:
            print("板块统计:", {k: int(v) for k, v in board_stats.items()})
        except Exception:
            pass
    else:
        print(f"涨跌停启发式阈值: 主板10%/科创20%/创业&北交30% (默认{args.price_limit_pct:.0%})")
    print()

    def first_sellable_open(global_t: int, stock_idx: int, price_limit_pct: float) -> float:
        """从全量面板的 global_t 开始（含当日）向后寻找首个未触及涨跌停启发式的开盘价，若找不到则返回 NaN。"""
        D = open_all.shape[0]
        for g in range(global_t, D):
            # 用当日开盘与昨收判断是否触发限制
            pc = prev_close_all[g, stock_idx]
            op = open_all[g, stock_idx]
            if not np.isfinite(pc) or not np.isfinite(op) or pc <= 0 or op <= 0:
                continue
            if abs(op - pc) / pc < price_limit_pct:
                return float(op)
        return float('nan')

    # 重写卖出价格决策：若当期可卖则用 t+2 开盘，否则从 t+2 对应的全局日索引往后寻找首个可卖日开盘
    

    # 基于目标仓位矩阵 W 的动态调仓模拟（采样驱动策略专用）
    def simulate_sampling_rebalance(
        W_target_lots: np.ndarray,      # [S,N] 整数（目标手数）
        decision_open_t1: np.ndarray,   # [S,N]
        decision_volume: np.ndarray,    # [S,N]
        prev_close_decision: np.ndarray,# [S,N]
        cutoff_indices: np.ndarray,     # [S]
        open_all: np.ndarray,           # [D,N]
        prev_close_all: np.ndarray,     # [D,N]
        avg_volume_train: np.ndarray,   # [N]
        price_limit_vec: np.ndarray,    # [N]
        initial_capital: float,
        min_lot: int,
        commission_rate: float,
        stamp_duty_sell: float,
        impact_linear: float,
        impact_sqrt: float,
        liquidity_alpha: float,
        dates_all: Optional[list] = None,
        debug_stockid: str = "",
        stocks_list: Optional[List[str]] = None,
        stock_mask: Optional[np.ndarray] = None,
        er_matrix: Optional[np.ndarray] = None,        # [S,N] 期望收益（含成本）
        s_score_matrix: Optional[np.ndarray] = None,   # [S,N] 映射前的 w（S_score）
        q_pre_matrix: Optional[np.ndarray] = None,     # [S,N] 四舍五入前手数（或等手模式下连续手数）
        notional_matrix: Optional[np.ndarray] = None,  # [S,N] 名义资金分配
        cvar_matrix: Optional[np.ndarray] = None,      # [S,N] CVaR 值
        entropy_matrix: Optional[np.ndarray] = None,   # [S,N] 信息熵值
    ) -> Dict[str, Any]:
        S, N = W_target_lots.shape
        # 若提供了掩码（例如 OOS 仅统计前 K 个真实股票），在此处统一裁剪到子集
        if stock_mask is not None:
            try:
                mask = np.asarray(stock_mask, dtype=bool)
                if mask.shape[0] == N:
                    W_target_lots = W_target_lots[:, mask]
                    decision_open_t1 = decision_open_t1[:, mask]
                    decision_volume = decision_volume[:, mask]
                    prev_close_decision = prev_close_decision[:, mask]
                    open_all = open_all[:, mask]
                    prev_close_all = prev_close_all[:, mask]
                    avg_volume_train = avg_volume_train[mask]
                    price_limit_vec = price_limit_vec[mask]
                    if er_matrix is not None and er_matrix.shape[0] == S:
                        try:
                            er_matrix = er_matrix[:, mask]
                        except Exception:
                            er_matrix = er_matrix
                    if s_score_matrix is not None and s_score_matrix.shape[0] == S:
                        try:
                            s_score_matrix = s_score_matrix[:, mask]
                        except Exception:
                            s_score_matrix = s_score_matrix
                    if q_pre_matrix is not None and q_pre_matrix.shape[0] == S:
                        try:
                            q_pre_matrix = q_pre_matrix[:, mask]
                        except Exception:
                            q_pre_matrix = q_pre_matrix
                    if notional_matrix is not None and notional_matrix.shape[0] == S:
                        try:
                            notional_matrix = notional_matrix[:, mask]
                        except Exception:
                            notional_matrix = notional_matrix
                    if stocks_list is not None:
                        stocks_list = [sid for sid, m in zip(stocks_list, mask) if m]
                    _, N = W_target_lots.shape
                else:
                    # 掩码长度不匹配时忽略（更稳健）
                    pass
            except Exception:
                pass
        # 构建 映射：样本 s -> 决策全局日 g_dec；以及全局日范围
        g_decisions = (cutoff_indices.astype(int) + 1)
        decision_map = {int(g): int(s) for s, g in enumerate(g_decisions.tolist())}
        g_start = int(np.min(g_decisions))
        g_end = int(np.max(cutoff_indices))

        # 全程以"手数"作为仓位单位，买卖均为整数手；估值时换算为股数
        holdings_lots = np.zeros(N, dtype=np.int64)      # 当前持仓手数
        desired_lots = np.zeros(N, dtype=np.int64)       # 目标手数（非决策日沿用上一日）
        # 预推导所需初始资金（参照 OOS 逻辑：扫描区间内最大名义资金需求）
        def _infer_required_capital_sampling() -> float:
            req_hold = np.zeros(N, dtype=np.int64)
            max_needed = 0.0
            for g in range(g_start, g_end + 1):
                buy_nominal = 0.0
                sell_nominal = 0.0
                if g in decision_map:
                    s = decision_map[g]
                    lots_today = np.nan_to_num(W_target_lots[s], nan=0.0, posinf=0.0, neginf=0.0)
                    lots_today = np.rint(lots_today).astype(np.int64)
                    dec_price = decision_open_t1[s]
                    dec_vol = decision_volume[s]
                    pc_dec = prev_close_decision[s]
                    buy_liq_ok = dec_vol >= (liquidity_alpha * avg_volume_train)
                    buy_block = np.abs(dec_price - pc_dec) / np.clip(pc_dec, 1e-9, None) > price_limit_vec
                    buy_tradable = buy_liq_ok & (~buy_block) & np.isfinite(dec_price)
                    # 先卖（名义规模按当日开盘）
                    delta = lots_today - req_hold
                    sell_lots = np.where(delta < 0, (-delta).astype(np.int64), 0)
                    if np.any(sell_lots > 0):
                        pc_all = prev_close_all[g]
                        op_all = open_all[g]
                        ok_sell = np.isfinite(pc_all) & np.isfinite(op_all) & (pc_all > 0) & (op_all > 0) \
                                  & ((np.abs(op_all - pc_all) / np.clip(pc_all, 1e-9, None)) <= price_limit_vec)
                        idx = np.where((sell_lots > 0) & ok_sell)[0]
                        if idx.size > 0:
                            shares = float(min_lot)
                            sell_val = np.sum(op_all[idx] * (sell_lots[idx].astype(np.float64) * shares))
                            sell_nominal += float(sell_val)
                            req_hold[idx] -= sell_lots[idx]
                    # 再买（名义规模按决策价+冲击）
                    delta = lots_today - req_hold
                    buy_lots = np.where(delta > 0, delta.astype(np.int64), 0)
                    idxb = np.where((buy_lots > 0) & buy_tradable)[0]
                    for j in idxb:
                        lots_j = int(buy_lots[j])
                        if lots_j <= 0 or not np.isfinite(dec_price[j]) or dec_price[j] <= 0:
                            continue
                        qty = float(lots_j * min_lot)
                        impact_pct = calculate_market_impact(qty, float(avg_volume_train[j]), impact_linear, impact_sqrt)
                        impact_pct = float(min(max(impact_pct, 0.0), 0.20))
                        price_in = float(dec_price[j]) * (1.0 + impact_pct)
                        buy_nominal += qty * price_in
                        req_hold[j] += lots_j
                max_needed = max(max_needed, buy_nominal + sell_nominal)
            return float(max_needed)

        inferred_init_cap = _infer_required_capital_sampling()
        cash = float(inferred_init_cap)
        prev_value = float(inferred_init_cap)
        daily_returns: list[float] = []
        values_series: list[float] = []
        cash_series: list[float] = []            # 每日现金
        holding_value_series: list[float] = []   # 每日持仓名义价值
        # 费用累计
        accum_commission = 0.0
        accum_stamp_duty = 0.0
        # 逐日交易统计
        daily_trade_report: List[Dict[str, object]] = []
        # 调试与逐日快照
        import os as _os
        try:
            _DEBUG_EVENTS = bool(int(_os.environ.get("GNNMAM_DEBUG_TRADE_EVENTS", "0")))
        except Exception:
            _DEBUG_EVENTS = False
        debug_records: List[Dict[str, object]] = []
        debug_stock_daily: List[Dict[str, object]] = []
        debug_idx = -1
        if isinstance(debug_stockid, str) and debug_stockid and stocks_list:
            try:
                debug_idx = stocks_list.index(debug_stockid)
            except ValueError:
                cands = [s for s in stocks_list if debug_stockid in s or s in debug_stockid]
                if cands:
                    debug_idx = stocks_list.index(cands[0])

        for g in range(g_start, g_end + 1):
            # 更新今日目标仓位（若今日为决策日）
            s_here = decision_map.get(g, None)
            if g in decision_map:
                s = decision_map[g]
                lots_today = np.nan_to_num(W_target_lots[s], nan=0.0, posinf=0.0, neginf=0.0)
                lots_today = np.rint(lots_today).astype(np.int64)  # [N] 目标手数（取整）
                desired_lots = lots_today
                dec_price = decision_open_t1[s]
                dec_vol = decision_volume[s]
                pc_dec = prev_close_decision[s]
                # 买入可交易性（用于后续 buy 措施）
                buy_liq_ok = dec_vol >= (liquidity_alpha * avg_volume_train)
                buy_block = np.abs(dec_price - pc_dec) / np.clip(pc_dec, 1e-9, None) > price_limit_vec
                buy_tradable = buy_liq_ok & (~buy_block) & np.isfinite(dec_price)
            else:
                # 非决策日，沿用上一日目标；买入不可执行
                buy_tradable = np.zeros(N, dtype=bool)
                dec_price = np.full(N, np.nan)

            # 当日可卖判定（涨跌停限制）
            pc_all = prev_close_all[g]
            op_all = open_all[g]
            ok_sell = np.isfinite(pc_all) & np.isfinite(op_all) & (pc_all > 0) & (op_all > 0) \
                      & ((np.abs(op_all - pc_all) / np.clip(pc_all, 1e-9, None)) < price_limit_vec)

            # 当日买卖计数（用于逐日交易统计）
            buys_today = 0
            sells_today = 0
            buys_debug_today = 0
            sells_debug_today = 0
            # 调试标的：记录当日买入的数量与成本（用于计算次日开盘的持仓收益）
            debug_buy_qty_today = 0.0
            debug_buy_cost_today = 0.0

            # 先卖：多余仓位
            delta_lots = desired_lots - holdings_lots
            sell_lots = np.where(delta_lots < 0, (-delta_lots).astype(np.int64), 0)  # 需卖出手数
            if np.any(sell_lots > 0):
                idx = np.where((sell_lots > 0) & ok_sell)[0]
                for j in idx:
                    lots_j = int(sell_lots[j])
                    if lots_j <= 0:
                        continue
                    qty = float(lots_j * min_lot)  # 股数
                    # 冲击/滑点（按卖出股数）
                    impact_pct = calculate_market_impact(qty, float(avg_volume_train[j]), impact_linear, impact_sqrt)
                    impact_pct = float(min(max(impact_pct, 0.0), 0.20))
                    price_out = float(op_all[j]) * (1.0 - impact_pct)
                    val_out = qty * price_out
                    comm_sell = val_out * commission_rate
                    stamp_sell = val_out * stamp_duty_sell
                    fee_sell = comm_sell + stamp_sell
                    accum_commission += float(comm_sell)
                    accum_stamp_duty += float(stamp_sell)
                    cash += (val_out - fee_sell)
                    holdings_lots[j] -= lots_j
                    sells_today += int(lots_j)
                    if debug_idx == j:
                        sells_debug_today += int(lots_j)
                    if _DEBUG_EVENTS and debug_idx == j:
                        day_str = str(dates_all[g]) if isinstance(dates_all, (list, tuple)) and g < len(dates_all) else str(g)
                        debug_records.append({"date": day_str, "event": "SELL", "stock": stocks_list[j] if stocks_list else j, "lots": lots_j, "qty": qty, "price": float(price_out), "value": float(val_out), "commission": float(comm_sell), "stamp": float(stamp_sell), "cash_after": float(cash)})

            # 再买：不足仓位
            delta_lots = desired_lots - holdings_lots
            buy_lots = np.where(delta_lots > 0, delta_lots.astype(np.int64), 0)
            if np.any(buy_lots > 0):
                idx = np.where((buy_lots > 0) & buy_tradable)[0]
                for j in idx:
                    lots_j = int(buy_lots[j])
                    if lots_j <= 0 or not np.isfinite(dec_price[j]) or dec_price[j] <= 0:
                        continue
                    qty = float(lots_j * min_lot)
                    impact_pct = calculate_market_impact(qty, float(avg_volume_train[j]), impact_linear, impact_sqrt)
                    impact_pct = float(min(max(impact_pct, 0.0), 0.20))
                    price_in = float(dec_price[j]) * (1.0 + impact_pct)
                    cost_in = qty * price_in
                    comm_buy = cost_in * commission_rate
                    fee_buy = comm_buy
                    accum_commission += float(comm_buy)
                    cash -= (cost_in + fee_buy)
                    holdings_lots[j] += lots_j
                    buys_today += int(lots_j)
                    if debug_idx == j:
                        buys_debug_today += int(lots_j)
                        debug_buy_qty_today += float(qty)
                        debug_buy_cost_today += float(cost_in + fee_buy)
                    if _DEBUG_EVENTS and debug_idx == j:
                        day_str = str(dates_all[g]) if isinstance(dates_all, (list, tuple)) and g < len(dates_all) else str(g)
                        debug_records.append({"date": day_str, "event": "BUY", "stock": stocks_list[j] if stocks_list else j, "lots": lots_j, "qty": qty, "price": float(price_in), "cost": float(cost_in), "commission": float(comm_buy), "cash_after": float(cash)})

            # 估值与日收益（按当日开盘对持仓估值）
            hold_val = 0.0
            for j in np.where(holdings_lots > 0)[0]:
                if np.isfinite(op_all[j]) and op_all[j] > 0:
                    hold_val += float(holdings_lots[j] * min_lot) * float(op_all[j])
            total_value = cash + hold_val
            day_ret = (total_value - prev_value) / max(prev_value, 1e-9)
            daily_returns.append(float(day_ret))
            values_series.append(float(total_value))
            cash_series.append(float(cash))
            holding_value_series.append(float(hold_val))
            prev_value = total_value
            # 记录逐日交易统计
            day_str = str(dates_all[g]) if isinstance(dates_all, (list, tuple)) and g < len(dates_all) else str(g)
            daily_trade_report.append({"date": day_str, "buys": int(buys_today), "sells": int(sells_today)})
            # 若指定了 debug_stockid，则打印逐日概要日志（不依赖环境变量）
            if debug_idx >= 0:
                sid = (stocks_list[debug_idx] if stocks_list else str(debug_idx))
                # 计算"今天开盘买入→次日开盘"的持仓收益（若有买入，否则若有持仓则用持仓收益率）
                stock_ret = np.nan
                try:
                    g_next = g + 1
                    if (g_next < open_all.shape[0]) and np.isfinite(open_all[g_next, debug_idx]) and np.isfinite(op_all[debug_idx]) and (op_all[debug_idx] > 0):
                        next_open = float(open_all[g_next, debug_idx])
                        today_open = float(op_all[debug_idx])
                        if debug_buy_qty_today > 0.0 and debug_buy_cost_today > 0.0:
                            avg_entry = debug_buy_cost_today / max(1e-9, debug_buy_qty_today)
                            stock_ret = (next_open - avg_entry) / max(1e-9, avg_entry)
                        elif holdings_lots[debug_idx] > 0:
                            stock_ret = (next_open - today_open) / today_open
                except Exception:
                    stock_ret = np.nan
                # 期望收益与映射前 w（仅在决策日存在索引时输出）
                er_here = np.nan
                q_pre_here = np.nan
                notional_here = np.nan
                try:
                    if (s_here is not None) and (er_matrix is not None) and (debug_idx < er_matrix.shape[1]):
                        er_val = er_matrix[int(s_here), int(debug_idx)]
                        er_here = float(er_val) if np.isfinite(er_val) else np.nan
                except Exception:
                    er_here = np.nan
                try:
                    if (s_here is not None) and (q_pre_matrix is not None) and (debug_idx < q_pre_matrix.shape[1]):
                        q_val = q_pre_matrix[int(s_here), int(debug_idx)]
                        q_pre_here = float(q_val) if np.isfinite(q_val) else np.nan
                    if (s_here is not None) and (notional_matrix is not None) and (debug_idx < notional_matrix.shape[1]):
                        notional_here = float(notional_matrix[int(s_here), int(debug_idx)])
                    # CVaR 和 entropy
                    cvar_here = np.nan
                    entropy_here = np.nan
                    if (s_here is not None) and (cvar_matrix is not None) and (debug_idx < cvar_matrix.shape[1]):
                        cvar_here = float(cvar_matrix[int(s_here), int(debug_idx)])
                    if (s_here is not None) and (entropy_matrix is not None) and (debug_idx < entropy_matrix.shape[1]):
                        entropy_here = float(entropy_matrix[int(s_here), int(debug_idx)])
                except Exception:
                    notional_here = np.nan
                    cvar_here = np.nan
                    entropy_here = np.nan
                # 若目标>持仓但买入未执行，明确给出阻断原因
                buy_block_reason = ""
                try:
                    if (s_here is not None) and (desired_lots[debug_idx] > holdings_lots[debug_idx]):
                        need_buy = int(desired_lots[debug_idx] - holdings_lots[debug_idx])
                        liq_ok = bool(buy_liq_ok[debug_idx]) if debug_idx < buy_liq_ok.shape[0] else False
                        blocked = bool(buy_block[debug_idx]) if debug_idx < buy_block.shape[0] else False
                        price_ok = bool(np.isfinite(dec_price[debug_idx]) and (dec_price[debug_idx] > 0))
                        if need_buy > 0 and not (liq_ok and (not blocked) and price_ok):
                            parts = []
                            if not liq_ok:
                                th = float(liquidity_alpha * avg_volume_train[debug_idx]) if debug_idx < avg_volume_train.shape[0] else float('nan')
                                parts.append(f"liquidity {float(dec_vol[debug_idx]):.0f} < {th:.0f}")
                            if blocked:
                                try:
                                    ratio = abs(float(dec_price[debug_idx]) - float(pc_dec[debug_idx])) / max(1e-9, float(pc_dec[debug_idx]))
                                except Exception:
                                    ratio = float('nan')
                                parts.append(f"limit |Δp|/pc={ratio:.2%} > {float(price_limit_vec[debug_idx]):.2%}")
                            if not price_ok:
                                parts.append("invalid_dec_price")
                            buy_block_reason = "; ".join(parts)
                except Exception:
                    buy_block_reason = ""
                print(
                    f"[debug-daily] {day_str} stock={sid} hold={int(holdings_lots[debug_idx])} target={int(desired_lots[debug_idx])} "
                    f"buys_stock={int(buys_debug_today)} sells_stock={int(sells_debug_today)} "
                    f"buys_all={int(buys_today)} sells_all={int(sells_today)} "
                    f"day_ret={day_ret:.4%} value={total_value:.2f} "
                    f"ER={('nan' if not np.isfinite(er_here) else f'{er_here:.6f}')} "
                    f"CVaR={('nan' if not np.isfinite(cvar_here) else f'{cvar_here:.6f}')} "
                    f"H={('nan' if not np.isfinite(entropy_here) else f'{entropy_here:.4f}')} "
                    f"notional={('nan' if not np.isfinite(notional_here) else f'{notional_here:.2f}')} "
                    f"q_pre={('nan' if not np.isfinite(q_pre_here) else f'{q_pre_here:.6f}')} "
                    f"stock_ret={('nan' if not np.isfinite(stock_ret) else f'{stock_ret:.4%}')}"
                    f"{(' buy_blocked: ' + buy_block_reason) if buy_block_reason else ''}",
                    flush=True,
                )
            # 逐日快照（仅调试标的）
            if debug_idx >= 0:
                snap = {
                    "date": day_str,
                    "g": int(g),
                    "holdings_lots": int(holdings_lots[debug_idx]),
                    "desired_lots": int(desired_lots[debug_idx]) if g in decision_map else int(desired_lots[debug_idx]),
                    "portfolio_value": float(total_value),
                    "day_ret": float(day_ret),
                    "er": (float(er_here) if np.isfinite(er_here) else float('nan')),
                    "notional": (float(notional_here) if np.isfinite(notional_here) else float('nan')),
                    "q_pre": (float(q_pre_here) if np.isfinite(q_pre_here) else float('nan')),
                    "stock_ret": (float(stock_ret) if np.isfinite(stock_ret) else float('nan')),
                }
                debug_stock_daily.append(snap)

        daily_returns_np = np.asarray(daily_returns, dtype=np.float64)
        mean = float(np.mean(daily_returns_np))
        std = float(np.std(daily_returns_np) + 1e-9)
        sharpe = float(mean / std)
        # 下行波动与 Sortino
        neg = daily_returns_np[daily_returns_np < 0]
        downside = float(np.std(neg) + 1e-9) if neg.size > 0 else 1e-9
        sortino_daily = float(mean / downside)
        sharpe_annual = float(sharpe * np.sqrt(252.0))
        sortino_annual = float(sortino_daily * np.sqrt(252.0))
        # 累计收益与回撤
        cum = np.cumprod(1.0 + daily_returns_np) - 1.0
        total_ret = float(cum[-1]) if cum.size > 0 else 0.0
        runmax = np.maximum.accumulate(1.0 + cum) if cum.size > 0 else np.array([1.0])
        dd = (runmax - (1.0 + cum)) / runmax if cum.size > 0 else np.array([0.0])
        maxdd = float(np.max(dd)) if dd.size > 0 else 0.0
        # 年化收益（log 累计换算更稳健）
        n_days = int(daily_returns_np.size)
        if n_days > 0:
            logret = np.log1p(daily_returns_np)
            annual_return = float(np.expm1(np.sum(logret) * (252.0 / max(1, n_days))))
        else:
            annual_return = 0.0
        calmar = float(annual_return / (maxdd + 1e-9))
        # 胜负日统计
        pos_days = int(np.sum(daily_returns_np > 0))
        neg_days = int(np.sum(daily_returns_np < 0))
        win_loss_ratio_daily = float((pos_days / max(1, neg_days))) if neg_days > 0 else float(pos_days)
        # 基准（等资金+整手+成本/流动性/涨跌停约束）
        # 1) 按决策日用等资金名义计算目标手数 W_bench[s, j]
        S_b, N_b = S, N
        W_bench = np.zeros((S_b, N_b), dtype=np.int32)
        try:
            max_notional_b = float(getattr(args, 'max_notional_per_stock', 5000.0))
        except Exception:
            max_notional_b = 5000.0
        lot_sz_b = float(int(min_lot))
        disc_flag = int(getattr(args, 'benchmark_discrete', 1))
        for s in range(S_b):
            dp = decision_open_t1[s]  # [N]
            if disc_flag == 1:
                denom = np.clip(dp * lot_sz_b, 1e-9, None)
                lots = np.floor(max_notional_b / denom)
                lots = np.where(np.isfinite(lots) & (lots > 0), lots, 0.0).astype(np.int64)
                W_bench[s] = lots
            else:
                # 非离散：按股数，再取最近似手数（保持口径统一，仍为整数手）
                shares = max_notional_b / np.clip(dp, 1e-9, None)
                lots = np.rint(shares / lot_sz_b)
                lots = np.where(np.isfinite(lots) & (lots > 0), lots, 0.0).astype(np.int64)
                W_bench[s] = lots

        # 2) 预估基准所需初始资金（与策略相同口径）
        def _infer_required_capital_benchmark() -> float:
            req_hold = np.zeros(N_b, dtype=np.int64)
            max_needed = 0.0
            for g in range(g_start, g_end + 1):
                buy_nominal = 0.0
                sell_nominal = 0.0
                if g in decision_map:
                    s = decision_map[g]
                    lots_today = W_bench[s]
                    # 卖出部分（按当日可卖开盘）
                    delta = lots_today - req_hold
                    sell_lots = np.where(delta < 0, (-delta).astype(np.int64), 0)
                    if np.any(sell_lots > 0):
                        pc_all = prev_close_all[g]
                        op_all = open_all[g]
                        ok_sell_b = np.isfinite(pc_all) & np.isfinite(op_all) & (pc_all > 0) & (op_all > 0) \
                                   & ((np.abs(op_all - pc_all) / np.clip(pc_all, 1e-9, None)) <= price_limit_vec)
                        idx = np.where((sell_lots > 0) & ok_sell_b)[0]
                        if idx.size > 0:
                            sell_val = np.sum(op_all[idx] * (sell_lots[idx].astype(np.float64) * lot_sz_b))
                            sell_nominal += float(sell_val)
                            req_hold[idx] -= sell_lots[idx]
                    # 买入部分（按决策开盘+冲击）
                    dec_price = decision_open_t1[s]
                    dec_vol = decision_volume[s]
                    pc_dec = prev_close_decision[s]
                    buy_liq_ok = dec_vol >= (liquidity_alpha * avg_volume_train)
                    buy_block = np.abs(dec_price - pc_dec) / np.clip(pc_dec, 1e-9, None) > price_limit_vec
                    buy_tradable = buy_liq_ok & (~buy_block) & np.isfinite(dec_price)
                    delta = lots_today - req_hold
                    buy_lots = np.where(delta > 0, delta.astype(np.int64), 0)
                    idxb = np.where((buy_lots > 0) & buy_tradable)[0]
                    for j in idxb:
                        lots_j = int(buy_lots[j])
                        if lots_j <= 0 or not np.isfinite(dec_price[j]) or dec_price[j] <= 0:
                            continue
                        qty = float(lots_j * lot_sz_b)
                        impact_pct = calculate_market_impact(qty, float(avg_volume_train[j]), impact_linear, impact_sqrt)
                        impact_pct = float(min(max(impact_pct, 0.0), 0.20))
                        price_in = float(dec_price[j]) * (1.0 + impact_pct)
                        buy_nominal += qty * price_in
                        req_hold[j] += lots_j
                max_needed = max(max_needed, buy_nominal + sell_nominal)
            return float(max_needed)

        inferred_init_cap_bench = _infer_required_capital_benchmark()

        # 3) 基准动态调仓模拟（先卖后买，含成本/冲击/约束）
        holdings_b = np.zeros(N_b, dtype=np.int64)
        desired_b = np.zeros(N_b, dtype=np.int64)
        cash_b = float(inferred_init_cap_bench)
        prev_value_b = float(inferred_init_cap_bench)
        benchmark_returns_list: list[float] = []
        for g in range(g_start, g_end + 1):
            if g in decision_map:
                s = decision_map[g]
                desired_b = W_bench[s]
                dec_price = decision_open_t1[s]
                dec_vol = decision_volume[s]
                pc_dec = prev_close_decision[s]
                buy_liq_ok = dec_vol >= (liquidity_alpha * avg_volume_train)
                buy_block = np.abs(dec_price - pc_dec) / np.clip(pc_dec, 1e-9, None) > price_limit_vec
                buy_tradable_b = buy_liq_ok & (~buy_block) & np.isfinite(dec_price)
            else:
                buy_tradable_b = np.zeros(N_b, dtype=bool)
                dec_price = np.full(N_b, np.nan)

            pc_all = prev_close_all[g]
            op_all = open_all[g]
            ok_sell_b = np.isfinite(pc_all) & np.isfinite(op_all) & (pc_all > 0) & (op_all > 0) \
                        & ((np.abs(op_all - pc_all) / np.clip(pc_all, 1e-9, None)) < price_limit_vec)

            # 先卖
            delta_lots_b = desired_b - holdings_b
            sell_lots_b = np.where(delta_lots_b < 0, (-delta_lots_b).astype(np.int64), 0)
            if np.any(sell_lots_b > 0):
                idx = np.where((sell_lots_b > 0) & ok_sell_b)[0]
                for j in idx:
                    lots_j = int(sell_lots_b[j])
                    if lots_j <= 0:
                        continue
                    qty = float(lots_j * lot_sz_b)
                    impact_pct = calculate_market_impact(qty, float(avg_volume_train[j]), impact_linear, impact_sqrt)
                    impact_pct = float(min(max(impact_pct, 0.0), 0.20))
                    price_out = float(op_all[j]) * (1.0 - impact_pct)
                    val_out = qty * price_out
                    comm_sell = val_out * commission_rate
                    stamp_sell = val_out * stamp_duty_sell
                    fee_sell = comm_sell + stamp_sell
                    cash_b += (val_out - fee_sell)
                    holdings_b[j] -= lots_j

            # 再买
            delta_lots_b = desired_b - holdings_b
            buy_lots_b = np.where(delta_lots_b > 0, delta_lots_b.astype(np.int64), 0)
            if np.any(buy_lots_b > 0):
                idx = np.where((buy_lots_b > 0) & buy_tradable_b)[0]
                for j in idx:
                    lots_j = int(buy_lots_b[j])
                    if lots_j <= 0 or not np.isfinite(dec_price[j]) or dec_price[j] <= 0:
                        continue
                    qty = float(lots_j * lot_sz_b)
                    impact_pct = calculate_market_impact(qty, float(avg_volume_train[j]), impact_linear, impact_sqrt)
                    impact_pct = float(min(max(impact_pct, 0.0), 0.20))
                    price_in = float(dec_price[j]) * (1.0 + impact_pct)
                    cost_in = qty * price_in
                    comm_buy = cost_in * commission_rate
                    fee_buy = comm_buy
                    cash_b -= (cost_in + fee_buy)
                    holdings_b[j] += lots_j

            # 估值与日收益
            hold_val_b = 0.0
            for j in np.where(holdings_b > 0)[0]:
                if np.isfinite(op_all[j]) and op_all[j] > 0:
                    hold_val_b += float(holdings_b[j] * lot_sz_b) * float(op_all[j])
            total_val_b = cash_b + hold_val_b
            if g == g_start:
                benchmark_returns_list.append(0.0)
            else:
                benchmark_returns_list.append((total_val_b - prev_value_b) / max(prev_value_b, 1e-9))
            prev_value_b = total_val_b

        benchmark_returns = np.asarray(benchmark_returns_list, dtype=np.float32)

        # 等手数基准（一次性成本，买入持有；不做再平衡与流动性判定）
        try:
            lot_sz_eq = float(int(min_lot))
            lots_per_stock_eq = 1  # 固定每标的一手
            g0_prices = open_all[g_start]
            valid0 = np.isfinite(g0_prices) & (g0_prices > 0)
            if valid0.any():
                shares_eq = np.zeros_like(g0_prices, dtype=np.float64)
                shares_eq[valid0] = float(lots_per_stock_eq) * lot_sz_eq
                # 一次性买入价格含冲击；费用只计佣金（无卖出）
                cost_in = 0.0
                for j in np.where(valid0)[0]:
                    qty = float(shares_eq[j])
                    impact_pct = calculate_market_impact(qty, float(avg_volume_train[j]), impact_linear, impact_sqrt)
                    impact_pct = float(min(max(impact_pct, 0.0), 0.20))
                    price_in = float(g0_prices[j]) * (1.0 + impact_pct)
                    cost_in += qty * price_in
                comm_in = cost_in * commission_rate
                prev_val_eq = float(cost_in + comm_in)
                # 逐日估值并形成日收益序列
                benchmark_eq_lots_returns: list[float] = []
                for g in range(g_start, g_end + 1):
                    if g == g_start:
                        benchmark_eq_lots_returns.append(0.0)
                        continue
                    px = open_all[g]
                    hold_val = 0.0
                    idx = np.where(shares_eq > 0)[0]
                    if idx.size > 0:
                        hold_val = float(np.sum(shares_eq[idx] * px[idx]))
                    total_val = hold_val  # 现金视为0，基准只记录持仓价值
                    ret = (total_val - prev_val_eq) / max(prev_val_eq, 1e-9)
                    benchmark_eq_lots_returns.append(float(ret))
                    prev_val_eq = total_val
                benchmark_equal_lots_returns = np.asarray(benchmark_eq_lots_returns, dtype=np.float32)
            else:
                benchmark_equal_lots_returns = np.zeros(int(g_end - g_start + 1), dtype=np.float32)
        except Exception:
            benchmark_equal_lots_returns = np.zeros(int(g_end - g_start + 1), dtype=np.float32)

        return {
            "daily_mean": mean,
            "daily_std": std,
            "sharpe": sharpe,
            "sharpe_annual": sharpe_annual,
            "total_return": total_ret,
            "max_drawdown": maxdd,
            "sortino_daily": sortino_daily,
            "sortino_annual": sortino_annual,
            "calmar": calmar,
            "daily_returns": daily_returns_np.tolist(),
            "values": values_series,
            "cash_series": cash_series,
            "holding_value_series": holding_value_series,
            "final_portfolio_value": float(prev_value),
            "initial_capital": float(inferred_init_cap),
            "total_commission": float(accum_commission),
            "total_stamp_duty": float(accum_stamp_duty),
            "total_fees": float(accum_commission + accum_stamp_duty),
            "avg_daily_return": mean,
            "annual_return": annual_return,
            "daily_trades": daily_trade_report,
            "debug_stock_log": debug_records,
            "debug_stock_daily": debug_stock_daily,
            "benchmark_returns": benchmark_returns.tolist(),
            "benchmark_cumulative": (np.cumprod(1 + benchmark_returns) - 1).tolist(),
            "benchmark_equal_lots_returns": benchmark_equal_lots_returns.tolist(),
            "benchmark_equal_lots_cumulative": (np.cumprod(1 + benchmark_equal_lots_returns) - 1).tolist(),
            "win_days": int(pos_days),
            "loss_days": int(neg_days),
            "win_loss_ratio_daily": win_loss_ratio_daily,
        }

    all_mask_to_use = None
    if int(args.all_exclude_oos) == 1 and (train_mask is not None) and train_mask.any():
        all_mask_to_use = train_mask
    elif int(args.all_exclude_oos) == 1 and (train_mask is not None) and (not train_mask.any()):
        print("[warn] 训练池为空（排除OOS后无股票）；ALL 回测将退化为包含全部股票")
        all_mask_to_use = None

    # 采样驱动策略：为每个"决策日"、每只股票生成价格采样分布（标准化→反标准化），再构造收益分布并决策仓位
    debug_hist_series = None  # 将在策略为采样驱动时填充：List[Tuple[str, np.ndarray]]
    print("[info] 使用采样驱动策略：CVaR-夏普阈值与tanh仓位映射")
    # 准备：仅对决策日窗口进行采样，跳过非决策日以加速
    ds_loader = torch.utils.data.DataLoader(ds_test, batch_size=1, shuffle=False)
    # 绝对时间 -> loader 序索引映射
    g_list = ds_test.time_indices
    t_to_j = {int(g): j for j, g in enumerate(g_list)}
    decisions_j = [t_to_j[int(g)] for g in cutoff_indices.tolist() if int(g) in t_to_j]
    decisions_j_set = set(decisions_j)
    y0_samples_map: Dict[int, np.ndarray] = {}
    step_var_recorder: Optional[StepVarianceRecorder] = None
    sampler_type_cfg = str(getattr(args, 'sampler', 'auto')).lower()
    use_random_sigma_flag = bool(int(getattr(args, 'use_random_sigma', 1)))
    edm_steps_cfg = int(getattr(args, 'edm_steps', 50))
    num_samples_cfg = int(getattr(args, 'num_samples', 32))
    if (sampler_type_cfg in ('ve_edm', 'auto')) and (not use_random_sigma_flag) and edm_steps_cfg > 0:
        step_var_recorder = StepVarianceRecorder(edm_steps_cfg, num_samples_cfg, N_train)
    with torch.no_grad():
        it = 0
        t0_sampling = time.time()
        total_batches = len(decisions_j)
        for batch_ds in ds_loader:  # StreamingPanelDataset 返回 (X, Y, t_index) 或 (X, Y, t_index, mask)
            if isinstance(batch_ds, (list, tuple)) and len(batch_ds) == 4:
                bx, _, t_abs, mask_ds = batch_ds  # [mask机制]
            else:
                bx, _, t_abs = batch_ds
                mask_ds = None
            j_here = t_to_j.get(int(t_abs), None)
            if (j_here is None) or (j_here not in decisions_j_set):
                continue  # 非决策日：跳过采样
            bx = bx.to(device)  # [1, Np, T, F]
            # 重排到训练池顺序，与模型实例化的 N_train 一致
            bx_train = bx[:, order_train_to_panel_arr, :, :].contiguous()  # [1, N_train, T, F]
            # 构造该窗口的波动率条件 vol_cond: [1,N_train,1]
            vol_cond_t = None
            try:
                # 从预处理生成的 yz_vol.csv 读取并缓存到全局
                if 'YZ_TABLE' not in globals():
                    yz_path = os.path.join(args.data_dir, 'yz_vol.csv')
                    if not os.path.exists(yz_path):
                        yz_path = os.path.join('data', 'processed', 'yz_vol.csv')
                    if os.path.exists(yz_path):
                        _df = pd.read_csv(yz_path)
                        _df['date'] = pd.to_datetime(_df['date']).dt.strftime('%Y-%m-%d')
                        # 优先使用预处理生成的标准化缩放列，以与训练一致
                        if 'yz_vol_scale' in _df.columns:
                            col_nm = 'yz_vol_scale'
                        elif 'yz_vol_logz' in _df.columns:
                            col_nm = 'yz_vol_logz'
                        elif 'yz_vol_daily' in _df.columns:
                            col_nm = 'yz_vol_daily'
                        else:
                            col_nm = _df.columns[-1]
                        _pv = _df.pivot(index='date', columns='order_book_id', values=col_nm)
                        globals()['YZ_TABLE'] = _pv
                _pv = globals().get('YZ_TABLE', None)
                if _pv is not None:
                    # 当前窗口末日对应的决策日是 t+1；若越界则用 t
                    dt_idx = int(t_abs.item()) if hasattr(t_abs, 'item') else int(t_abs)
                    date_list = ds_test.dates
                    key = None
                    g_t1 = int(cutoff_indices[dt_idx]) + 1 if (0 <= dt_idx < len(cutoff_indices)) else None
                    if (g_t1 is not None) and (0 <= g_t1 < len(date_list)):
                        key = str(pd.to_datetime(date_list[g_t1]).strftime('%Y-%m-%d'))
                    if (key is None) and (0 <= dt_idx < len(date_list)):
                        key = str(pd.to_datetime(date_list[dt_idx]).strftime('%Y-%m-%d'))
                    if (key is not None) and (key in _pv.index):
                        row = _pv.loc[key]
                        vals = [float(row.get(str(s), np.nan)) for s in train_stocks]
                        vec = np.array(vals, dtype=np.float32)
                        vec = np.nan_to_num(vec, nan=1.0, posinf=1.0, neginf=1.0)
                        vol_cond_t = torch.from_numpy(vec).view(1, -1, 1).to(device)
            except Exception:
                vol_cond_t = None

            # 若模型训练未启用 yz_vol，则不构造 vol_cond，保持 constant 行为
            # 选择采样器：优先使用 ve_edm（高保真多步），否则回退到 direct_score/ddim
            sampler_type = str(getattr(args, 'sampler', 'auto')).lower()
            objective = str(getattr(args, 'objective', 'score')).lower()  # 从训练配置读取
            
            if sampler_type == 've_edm' or sampler_type == 'auto':
                # VE-EDM ODE Heun 采样器（推荐）
                y0_samp = ve_edm_samples(
                    model,
                    bx_train,
                    num_samples=int(args.num_samples),
                    device=device,
                    sigma_min=float(getattr(args, 'score_sigma_min', 0.01)),
                    sigma_max=float(getattr(args, 'score_sigma_max', 1.0)),
                    steps=int(getattr(args, 'edm_steps', 50)),
                    use_random_sigma=bool(int(getattr(args, 'use_random_sigma', 1))),
                    s_churn=float(getattr(args, 's_churn', 0.0)),
                    s_churn_topk_ratio=float(getattr(args, 's_churn_topk_ratio', 0.2)),
                    chunk_size=int(getattr(args, 'chunk_size', 0)) if int(getattr(args, 'chunk_size', 0)) > 0 else int(max(16, min(64, int(args.num_samples)//4))),
                    diff_steps=int(getattr(args, 'diff_steps', 1000)),
                    mask=mask_train,  # 传递mask
                    objective=objective,  # 传递训练目标
                    sigma_data=float(getattr(args, 'sigma_data', 0.025)),  # EDM 预条件化参数
                    vol_cond=(vol_cond_t if use_yz_cond else None),
                    vol_cond_as_input=bool(getattr(args, 'vol_cond_as_input', 1)),
                    vol_cond_scale_output=bool(getattr(args, 'vol_cond_scale_output', 0)),
                    step_var_recorder=step_var_recorder,
                )  # [M,N,1]
            elif int(getattr(args, 'direct_score', 0)) == 1:
                # 以模型直推预测作为 μ（y0 的近似）
                base_mu = py_train  # [1,N,1]
                y0_samp = diffusion_direct_score_samples(
                    model,
                    bx_train,
                    base_mu,
                    num_samples=int(args.num_samples),
                    device=device,
                    chunk_size=int(getattr(args, 'chunk_size', 0)) if int(getattr(args, 'chunk_size', 0)) > 0 else int(max(16, min(64, int(args.num_samples)//4))),
                    sigma_min=float(getattr(args, 'score_sigma_min', 0.01)),
                    sigma_max=float(getattr(args, 'score_sigma_max', 1.0)),
                    diff_steps=int(getattr(args, 'diff_steps', 1000)),
                    vol_cond=(vol_cond_t if use_yz_cond else None),
                    sigma_schedule=str(getattr(args, 'sigma_schedule', 'karras')),
                    time_warp_gamma=float(getattr(args, 'time_warp_gamma', 0.0)),
                    direct_anchor=str(getattr(args, 'direct_anchor', 'random')),
                    direct_lambda=float(getattr(args, 'direct_lambda', 1.0)),
                )  # [M,N,1]
            else:
                y0_samp = diffusion_ddim_samples(
                    model,
                    bx_train,
                    num_samples=int(args.num_samples),
                    device=device,
                    chunk_size=int(getattr(args, 'chunk_size', 0)) if int(getattr(args, 'chunk_size', 0)) > 0 else int(max(16, min(64, int(args.num_samples)//4))),
                    steps=int(getattr(args, 'ddim_steps', 1)),
                    eta=float(getattr(args, 'ddim_eta', 0.0)),
                    sigma_min=float(getattr(args, 'score_sigma_min', 0.01)),
                    sigma_max=float(getattr(args, 'score_sigma_max', 1.0)),
                    diff_steps=int(getattr(args, 'diff_steps', 1000)),
                    vol_cond=(vol_cond_t if use_yz_cond else None),
                    sigma_schedule=str(getattr(args, 'sigma_schedule', 'karras')),
                    time_warp_gamma=float(getattr(args, 'time_warp_gamma', 0.0)),
                )  # [M, N_train, 1]
            # 反标准化改到CPU，降低GPU显存峰值
            y0_np = (y0_samp.squeeze(-1).detach().cpu().numpy())  # [M, N]，此处为 log-return 样本
            y0_samples_map[int(j_here)] = y0_np  # [M, N_train]
            it += 1
            if int(getattr(args, 'progress', 1)) == 1 and (it % max(1, int(getattr(args, 'log_interval', 20))) == 0 or it == total_batches):
                elapsed = time.time() - t0_sampling
                rate = it / max(elapsed, 1e-6)
                remaining = (total_batches - it) / max(rate, 1e-6)
                print(f"[sampling] decisions {it}/{total_batches} ({it/total_batches:.1%}) rate={rate:.2f} it/s eta={remaining:.1f}s", flush=True)
    # 对齐到样本序列 cutoff_indices（S天）
    y0_samples_aligned = []  # [S, M, N]
    for g in cutoff_indices.tolist():
        j = t_to_j.get(int(g))
        if (j is None) or (int(j) not in y0_samples_map):
            raise KeyError(f"missing sampled window for cutoff index {g}")
        y0_samples_aligned.append(y0_samples_map[int(j)])
    y0_samples = np.stack(y0_samples_aligned, axis=0)  # [S, M, N]
    multistep_std_stats = None
    if step_var_recorder is not None:
        multistep_std_stats = step_var_recorder.export()
    # 基于采样计算"净收益分布"（仅模型口径：不施加涨跌停/流动性），用于评估纯模型表现
    decision_price = decision_np_train  # [S,N_train]
    # 确保为数值类型，避免下游乘法/除法报 dtype 错误
    try:
        decision_price = decision_price.astype(np.float64, copy=False)
    except Exception:
        decision_price = decision_price.astype(np.float64)
    S, N = decision_price.shape
    M = int(args.num_samples)

    # 计算每只股票的一手（min_lot）滑点/冲击百分比（买卖对称使用）
    try:
        impact_pct_vec = np.array([
            calculate_market_impact(
                our_volume=float(int(args.min_lot)),
                avg_volume=float(avg_volume_train_train[j]) if j < len(avg_volume_train_train) else 0.0,
                linear_coef=float(args.impact_linear),
                sqrt_coef=float(args.impact_sqrt)
            ) for j in range(N)
        ], dtype=np.float64)
    except Exception:
        impact_pct_vec = np.zeros(N, dtype=np.float64)
    impact_pct_vec = np.clip(impact_pct_vec, 0.0, 0.20)  # 护栏：不超过20%
    # 张量化
    dp_3d = decision_price[:, None, :]  # [S,1,N]
    # 将 log-return 样本还原到价格：price = dp * exp(r)
    y0_samples = np.asarray(y0_samples, dtype=np.float64)
    clip_bound = float(getattr(args, 'exp_clip_bound', 0.0))
    if clip_bound > 0.0:
        over_mask = np.abs(y0_samples) > clip_bound
        if np.any(over_mask):
            max_abs = float(np.nanmax(np.abs(y0_samples)))
            print(f"[warn] log-return overflow risk: |y0_samples|max={max_abs:.3f} > clip_bound={clip_bound:.1f}, clipping before exp", flush=True)
        y0_samples = np.clip(y0_samples, -clip_bound, clip_bound)
    y0_3d = dp_3d * np.exp(y0_samples)  # [S,M,N]

    # 回测版"val_stats"：按标的跨时间的预测/真实标准差
    try:
        S_bt, M_bt, N_bt = y0_samples.shape  # [S,M,N]
        
        # 真实：用开盘 t+1→t+2 的对数收益（与目标口径一致）
        g_t1 = (cutoff_indices.astype(int) + 1).tolist()  # 决策日 t+1
        g_t2 = [g + 1 for g in g_t1]
        D_tot = int(open_all_train.shape[0])
        r_true_arr = np.full((S_bt, N_bt), np.nan, dtype=np.float64)
        for s_idx in range(S_bt):
            gt1 = g_t1[s_idx]
            gt2 = g_t2[s_idx]
            if (0 <= gt1 < D_tot) and (0 <= gt2 < D_tot):
                o1 = open_all_train[gt1, :].astype(np.float64)  # [N]
                o2 = open_all_train[gt2, :].astype(np.float64)
                with np.errstate(divide='ignore', invalid='ignore', over='ignore', under='ignore'):
                    r_true_arr[s_idx, :] = np.log(np.clip(o2, 1e-9, None) / np.clip(o1, 1e-9, None))
        
        std_true_per_stock = np.nanstd(r_true_arr, axis=0)  # [N] 每标的跨时间 std
        valid_n = np.isfinite(std_true_per_stock) & (std_true_per_stock > 0)
        std_true_avg = float(np.nanmean(std_true_per_stock[valid_n])) if np.any(valid_n) else float('nan')
        
        # 预测方式1：M个样本均值的跨时间std（用于交易决策，但会压缩方差）
        r_mean = np.mean(y0_samples, axis=1)  # [S,N]
        std_pred_mean_per_stock = np.nanstd(r_mean, axis=0)  # [N]
        std_pred_mean_avg = float(np.nanmean(std_pred_mean_per_stock[valid_n])) if np.any(valid_n) else float('nan')
        ratio_mean = float(std_pred_mean_avg / std_true_avg) if (np.isfinite(std_pred_mean_avg) and std_true_avg > 0) else float('nan')
        
        # 预测方式2：单次采样的跨时间std（与std_true口径一致，用于训练对齐评估）
        # 对每个样本维度分别计算跨时间std，然后平均
        std_list_per_sample = []
        for m in range(M_bt):
            r_m = y0_samples[:, m, :]  # [S,N] 第m个样本的时间序列
            std_per_stock_m = np.nanstd(r_m, axis=0)  # [N]
            std_list_per_sample.append(std_per_stock_m)
        std_per_stock_all_samples = np.stack(std_list_per_sample, axis=0)  # [M,N]
        std_pred_sample_per_stock = np.mean(std_per_stock_all_samples, axis=0)  # [N] 对M个样本的std取平均
        std_pred_sample_avg = float(np.nanmean(std_pred_sample_per_stock[valid_n])) if np.any(valid_n) else float('nan')
        ratio_sample = float(std_pred_sample_avg / std_true_avg) if (np.isfinite(std_pred_sample_avg) and std_true_avg > 0) else float('nan')
        
        val_like_stats = {
            "std_true": std_true_avg,
            "std_pred_mean": std_pred_mean_avg,  # 均值序列的std（交易用）
            "ratio_mean": ratio_mean,
            "std_pred_sample": std_pred_sample_avg,  # 单次采样的std（训练对齐用）
            "ratio_sample": ratio_sample,
            "n_valid": int(valid_n.sum()),
            "N": int(N_bt),
            "S": int(S_bt),
            "M": int(M_bt),
        }
        print(f"[val-like] std_true={std_true_avg:.7f} | mean: std={std_pred_mean_avg:.7f} ratio={ratio_mean:.5f} | sample: std={std_pred_sample_avg:.7f} ratio={ratio_sample:.5f} | n_valid={int(valid_n.sum())}/{int(N_bt)}", flush=True)
    except Exception as _e_valstd:
        val_like_stats = {"error": str(_e_valstd)}
    # 断言：采样窗口与决策日严格一致
    try:
        assert y0_3d.shape[0] == dp_3d.shape[0], f"S mismatch: y0_S={y0_3d.shape[0]} dp_S={dp_3d.shape[0]}"
        assert y0_3d.shape[2] == dp_3d.shape[2], f"N mismatch: y0_N={y0_3d.shape[2]} dp_N={dp_3d.shape[2]}"
    except AssertionError as _e:
        print(f"[assert-shape] {str(_e)}", flush=True)
    
    imp_1d = impact_pct_vec[None, None, :]  # [1,1,N]
    # 入场与离场有效价格（含对称滑点）
    entry_eff = dp_3d * (1.0 + imp_1d)          # [S,1,N]
    exit_eff = y0_3d * (1.0 - imp_1d)           # [S,M,N]
    # 费用参数
    comm = float(args.commission_rate)
    stamp = float(args.stamp_duty_sell)
    lot = float(int(args.min_lot))
    # 成本与基数
    fee_buy = lot * entry_eff * comm            # [S,1,N]
    fee_sell = lot * exit_eff * (comm + stamp)  # [S,M,N]
    base = lot * entry_eff + fee_buy            # [S,1,N]
    # 净收益分布： (卖出所得 - 买入总成本) / 基数
    numer = (lot * exit_eff - fee_sell) - base  # [S,M,N]
    R = numer / np.clip(base, 1e-9, None)       # [S,M,N]
    # 度量：E(R) 与 CVaR_alpha(R)（默认用于决策映射）
    alpha = float(args.cvar_alpha)
    q = int(max(1, np.floor(M * alpha)))
    use_simple = int(getattr(args, 'er_positive_buy', 0)) == 1
    # 始终计算 ER（简单路径与映射路径都需要）
    ER = np.mean(R, axis=1)  # [S,N]（净收益率：已包含手续费/印花/滑点）
    
    # 统计每只股票ER>0的比例（M次采样平均后的ER）
    er_positive_ratio = np.mean(ER > 0, axis=0) if ER.size > 0 else np.zeros(N, dtype=np.float64)  # [N]
    er_positive_ratio_mean = float(np.mean(er_positive_ratio))  # 全市场平均
    er_positive_ratio_std = float(np.std(er_positive_ratio))   # 全市场标准差
    print(f"[ER>0统计] 全市场平均: {er_positive_ratio_mean:.2%} ± {er_positive_ratio_std:.2%} | 范围: [{np.min(er_positive_ratio):.2%}, {np.max(er_positive_ratio):.2%}]", flush=True)
    
    # 每标的 ER 的统计（回测周期内）：mean/max/min/var/positive_ratio
    try:
        er_mean_vec = np.mean(ER, axis=0) if ER.size > 0 else np.zeros(N, dtype=np.float64)
        er_max_vec = np.max(ER, axis=0) if ER.size > 0 else np.zeros(N, dtype=np.float64)
        er_min_vec = np.min(ER, axis=0) if ER.size > 0 else np.zeros(N, dtype=np.float64)
        er_var_vec = np.var(ER, axis=0) if ER.size > 0 else np.zeros(N, dtype=np.float64)
        def _sf(x: float):
            try:
                v = float(x)
                return (v if np.isfinite(v) else None)
            except Exception:
                return None
        er_stats_dict = {}
        try:
            names = train_stocks if ('train_stocks' in locals() or 'train_stocks' in globals()) else [str(i) for i in range(N)]
        except Exception:
            names = [str(i) for i in range(N)]
        for j in range(N):
            key = str(names[j]) if j < len(names) else str(j)
            er_stats_dict[key] = {
                "mean": _sf(er_mean_vec[j]),
                "max": _sf(er_max_vec[j]),
                "min": _sf(er_min_vec[j]),
                "var": _sf(er_var_vec[j]),
                "positive_ratio": _sf(er_positive_ratio[j]),  # 新增：ER>0的交易日比例
            }
    except Exception:
        er_stats_dict = {}
    if use_simple:
        # 简单路径：仅用 ER，避免计算 CVaR/Entropy 与 S_score，规避数值溢出
        CVaR = np.zeros_like(ER)
        ent = np.zeros_like(ER)
        S_score = np.zeros_like(ER)
    else:
        R_sorted = np.sort(R, axis=1)  # 升序，尾部为低收益
        VaR = R_sorted[:, q - 1, :]  # [S,N]
        CVaR = np.mean(R_sorted[:, :q, :], axis=1)  # [S,N]
        # 信息熵（离散）：对每只股票的 R 分布按 bins 分箱，计算离散熵（自然底）；shape [S,N]
        ent = np.zeros_like(ER)
        for s in range(S):
            for n in range(N):
                r_sn = R[s, :, n]
                bins_sn = _fd_bins(r_sn, min_bins=10, max_bins=200)
                try:
                    hist, _ = np.histogram(r_sn, bins=bins_sn, density=False)
                    p = hist.astype(np.float64)
                    total = float(np.sum(p))
                    if total <= 0:
                        ent[s, n] = 0.0
                    else:
                        p = p / total
                        p = p[p > 0]
                        ent[s, n] = float(-np.sum(p * np.log(p + 1e-12)))
                except Exception:
                    ent[s, n] = 0.0
        # 分母：(|CVaR|+eps)^p * (H+eps)
        cvar_eps = float(getattr(args, "cvar_eps", 1e-6))
        ent_eps = float(getattr(args, "entropy_eps", 1e-6))
        cvar_power = float(getattr(args, "cvar_power", 1.0))
        denom = np.power((np.abs(CVaR) + cvar_eps), cvar_power) * (ent + ent_eps)
        S_score = ER / denom  # [S,N]
    # 仓位映射（默认按名义资金映射）
    k = float(args.risk_k)
    er_positive_buy = int(getattr(args, 'er_positive_buy', 0))
    q_pre_matrix = None  # [S,N]
    if er_positive_buy == 1:
        # 简单规则：ER>0 则按 max_notional_per_stock 买入（整手），否则 0；忽略 tanh 映射
        max_notional = float(getattr(args, 'max_notional_per_stock', 5000.0))
        dp = decision_price  # [S,N]
        lot_sz = float(int(args.min_lot))
        denom = np.clip(dp * lot_sz, 1e-9, None)
        pos_flag = (ER > 0.0).astype(np.float64)  # [S,N]
        notional = pos_flag * max_notional
        q = np.nan_to_num(notional / denom, nan=0.0, posinf=0.0, neginf=0.0)
        q_pre_matrix = q.copy()
        W = np.rint(q).astype(np.int32)
        notional_matrix = notional  # 简单路径
    else:
        if int(getattr(args, 'value_based_position', 1)) == 1:
            max_notional = float(getattr(args, 'max_notional_per_stock', 5000.0))
            # 确保为浮点
            dp = np.asarray(decision_price, dtype=np.float64)  # [S,N]
            lot_sz = float(int(args.min_lot))
            notional = np.where(S_score > 0.0, np.tanh(k * np.abs(S_score)) * max_notional, 0.0)  # [S,N]
            denom = np.clip(dp * lot_sz, 1e-9, None)
            q = np.nan_to_num(notional / denom, nan=0.0, posinf=0.0, neginf=0.0)
            q_pre_matrix = q.copy()
            W = np.rint(q).astype(np.int32)
            notional_matrix = notional  # 映射路径（基于价值）
        else:
            max_lots = int(args.max_lots)
            W_float = np.where(S_score > 0.0, np.tanh(k * np.abs(S_score)) * max_lots, 0.0)
            W_float = np.nan_to_num(W_float, nan=0.0, posinf=0.0, neginf=0.0)
            q_pre_matrix = W_float.copy()
            W = np.rint(W_float).astype(np.int32)
            notional_matrix = None  # 映射路径（基于手数），无 notional
    # 若指定了调试个股，收集最近20天的采样收益分布（用于可视化多模态性）
    dbg_id = str(getattr(args, "debug_stockid", ""))
    # 采样路径下的 R 维度为 [S, M, N_train]，因此 debug 索引需基于训练池顺序
    if isinstance(dbg_id, str) and len(dbg_id) > 0 and train_stocks:
        try:
            dbg_idx = train_stocks.index(dbg_id)
        except ValueError:
            # 模糊匹配：支持不带交易所后缀或子串匹配
            dbg_idx = -1
            try:
                for i, sid in enumerate(train_stocks):
                    base = sid.split('.')[0]
                    if (dbg_id == base) or (dbg_id == sid) or (dbg_id in sid) or (dbg_id in base):
                        dbg_idx = i
                        break
            except Exception:
                dbg_idx = -1
        if dbg_idx >= 0:
            last_k = 20
            s_start = max(0, R.shape[0] - last_k)
            series = []
            # g_to_j 可用于映射到日期
            g_list = ds_test.time_indices
            g_to_j = {int(g): j for j, g in enumerate(g_list)}
            for s in range(s_start, R.shape[0]):
                samples = R[s, :, dbg_idx].astype(np.float64)
                # 使用全局日索引 g 映射真实日期（优先 t+1 决策日；失败则回退到 t 的 cutoff）
                g_t1 = int(cutoff_indices[s]) + 1  # 决策日（t+1）
                if 0 <= g_t1 < len(ds_test.dates):
                    date_str = str(ds_test.dates[g_t1])
                else:
                    g_t = int(cutoff_indices[s])
                    date_str = str(ds_test.dates[g_t]) if 0 <= g_t < len(ds_test.dates) else f"s{s}"
                series.append((date_str, samples))
            debug_hist_series = series

    # 删除 S 统计（按需求不再输出）

    # 打印每只标的的"映射后未乘上限"的统计：m = tanh(k*|S|)
    # 按需求移除 m 统计输出
    # 动态调仓：将 W 映射为目标仓位并进行真实撮合模拟
    # 将涨跌停阈值向量对齐到训练池顺序（若来源为面板顺序）
    try:
        # 若阈值基于面板（76），重排到训练池（55）；若已是训练池长度（55），直接使用
        if price_limit_vec.shape[0] == len(stocks_list):
            price_limit_vec_train = price_limit_vec[order_train_to_panel_arr]
        elif price_limit_vec.shape[0] == N_train:
            price_limit_vec_train = price_limit_vec
        else:
            price_limit_vec_train = np.full(N_train, float(args.price_limit_pct), dtype=np.float32)
    except Exception:
        price_limit_vec_train = np.full(N_train, float(args.price_limit_pct), dtype=np.float32)

    t0_sim = time.time()
    bt_all = simulate_sampling_rebalance(
        W_target_lots=W,
        decision_open_t1=decision_np_train,
        decision_volume=volume_np_train,
        prev_close_decision=pc_dec_np_train,
        cutoff_indices=cutoff_indices,
        open_all=open_all_train,
        prev_close_all=prev_close_all_train,
        avg_volume_train=avg_volume_train_train,
        price_limit_vec=price_limit_vec_train,
        initial_capital=float(args.initial_capital),
        min_lot=int(args.min_lot),
        commission_rate=float(args.commission_rate),
        stamp_duty_sell=float(args.stamp_duty_sell),
        impact_linear=float(args.impact_linear),
        impact_sqrt=float(args.impact_sqrt),
        liquidity_alpha=float(args.liquidity_alpha),
        dates_all=ds_test.dates,
        debug_stockid=str(args.debug_stockid),
        stocks_list=train_stocks,
        er_matrix=ER,
        s_score_matrix=(None if use_simple else S_score),
        q_pre_matrix=q_pre_matrix,
        notional_matrix=notional_matrix,
        cvar_matrix=(None if use_simple else CVaR),
        entropy_matrix=(None if use_simple else ent),
    )
    if multistep_std_stats is not None:
        bt_all["multistep_std_trace"] = multistep_std_stats
    t1_sim = time.time()
    if int(getattr(args, 'progress', 1)) == 1:
        print(f"[simulate] ALL done elapsed={t1_sim - t0_sim:.2f}s", flush=True)
    # 指数回归与超额收益（沪深300）
    try:
        idx_info = None
        idx_name = None
        if index_data is not None and isinstance(index_data, pd.DataFrame) and (len(index_data) > 0):
            # 取日期序列（来自逐日交易报告）
            date_series = []
            try:
                date_series = [pd.to_datetime(row.get("date")) for row in bt_all.get("daily_trades", [])]
            except Exception:
                date_series = []
            # 猜测沪深300列名
            cols = list(index_data.columns)
            base_cols = [c for c in cols if not str(c).endswith("_return")]
            cand_keys = ["HS300", "沪深300", "000300", "000300.SH", "CSI300"]
            hit = None
            for k in cand_keys:
                for c in base_cols:
                    if k.lower() in str(c).lower():
                        hit = c
                        break
                if hit is not None:
                    break
            if hit is None and len(base_cols) > 0:
                hit = base_cols[0]
            if hit is not None:
                idx_name = str(hit)
                # 以原始价格计算日收益，再对齐回测日期
                px = index_data[idx_name].copy()
                idx_ret = px.pct_change().rename("idx_ret")  # 按交易日 pct_change
                # 对齐到回测日期（缺失补0）
                if date_series:
                    idx_on_bt = idx_ret.reindex(date_series).fillna(0.0).to_numpy(dtype=np.float64)
                else:
                    # 若无日期列表，则按长度截断/填充
                    L = len(bt_all.get("daily_returns", []))
                    arr = idx_ret.to_numpy(dtype=np.float64)
                    if arr.size < L:
                        pad = np.zeros(L - arr.size, dtype=np.float64)
                        idx_on_bt = np.concatenate([arr, pad], axis=0)
                    else:
                        idx_on_bt = arr[:L]
                strat_ret = np.asarray(bt_all.get("daily_returns", []), dtype=np.float64)
                Lm = min(len(strat_ret), len(idx_on_bt))
                if Lm > 5:
                    y = strat_ret[:Lm]
                    x = idx_on_bt[:Lm]
                    mask = np.isfinite(y) & np.isfinite(x)
                    y = y[mask]; x = x[mask]
                    if y.size > 5 and np.isfinite(np.var(x)) and (np.var(x) > 1e-12):
                        X = np.stack([np.ones_like(x), x], axis=1)
                        beta = np.linalg.lstsq(X, y, rcond=None)[0]
                        y_hat = X @ beta
                        ss_res = float(np.sum((y - y_hat) ** 2))
                        ss_tot = float(np.sum((y - float(np.mean(y))) ** 2) + 1e-12)
                        r2 = 1.0 - ss_res / ss_tot
                        alpha_daily = float(beta[0]); beta_slope = float(beta[1])
                        excess = (y - x).tolist()
                        bt_all["index_name"] = idx_name
                        bt_all["index_daily_returns"] = idx_on_bt[:Lm].tolist()
                        bt_all["excess_daily_returns"] = excess
                        bt_all["index_regression"] = {
                            "alpha_daily": alpha_daily,
                            "beta": beta_slope,
                            "r2": float(r2),
                            "n": int(y.size),
                        }
                        print(f"[index] {idx_name} 回归: alpha(daily)={alpha_daily:.6e} beta={beta_slope:.3f} R^2={r2:.3f} n={int(y.size)}", flush=True)
                        
                        # 分段回归：上涨日 vs 下跌日
                        try:
                            up_mask = x > 0  # 指数上涨日
                            down_mask = x < 0  # 指数下跌日
                            
                            # 上涨日回归
                            if np.sum(up_mask) > 5:
                                y_up = y[up_mask]
                                x_up = x[up_mask]
                                X_up = np.stack([np.ones_like(x_up), x_up], axis=1)
                                beta_up = np.linalg.lstsq(X_up, y_up, rcond=None)[0]
                                y_hat_up = X_up @ beta_up
                                ss_res_up = float(np.sum((y_up - y_hat_up) ** 2))
                                ss_tot_up = float(np.sum((y_up - float(np.mean(y_up))) ** 2) + 1e-12)
                                r2_up = 1.0 - ss_res_up / ss_tot_up
                                alpha_up = float(beta_up[0])
                                beta_slope_up = float(beta_up[1])
                                n_up = int(np.sum(up_mask))
                            else:
                                alpha_up = beta_slope_up = r2_up = float('nan')
                                n_up = 0
                            
                            # 下跌日回归
                            if np.sum(down_mask) > 5:
                                y_down = y[down_mask]
                                x_down = x[down_mask]
                                X_down = np.stack([np.ones_like(x_down), x_down], axis=1)
                                beta_down = np.linalg.lstsq(X_down, y_down, rcond=None)[0]
                                y_hat_down = X_down @ beta_down
                                ss_res_down = float(np.sum((y_down - y_hat_down) ** 2))
                                ss_tot_down = float(np.sum((y_down - float(np.mean(y_down))) ** 2) + 1e-12)
                                r2_down = 1.0 - ss_res_down / ss_tot_down
                                alpha_down = float(beta_down[0])
                                beta_slope_down = float(beta_down[1])
                                n_down = int(np.sum(down_mask))
                            else:
                                alpha_down = beta_slope_down = r2_down = float('nan')
                                n_down = 0
                            
                            # 保存到结果
                            bt_all["index_regression_up"] = {
                                "alpha_daily": alpha_up,
                                "beta": beta_slope_up,
                                "r2": float(r2_up),
                                "n": n_up,
                            }
                            bt_all["index_regression_down"] = {
                                "alpha_daily": alpha_down,
                                "beta": beta_slope_down,
                                "r2": float(r2_down),
                                "n": n_down,
                            }
                            
                            # 打印分段结果
                            print(f"[index-up] {idx_name} 上涨日(n={n_up}): alpha={alpha_up:.6e} beta={beta_slope_up:.3f} R^2={r2_up:.3f}", flush=True)
                            print(f"[index-down] {idx_name} 下跌日(n={n_down}): alpha={alpha_down:.6e} beta={beta_slope_down:.3f} R^2={r2_down:.3f}", flush=True)
                            
                            # 分位数分析（更细粒度）
                            try:
                                if x.size > 20:  # 确保有足够样本
                                    # 按指数收益率分5个分位数
                                    quantiles = [0, 0.2, 0.4, 0.6, 0.8, 1.0]
                                    q_values = np.quantile(x, quantiles)
                                    q_labels = ["大跌(0-20%)", "小跌(20-40%)", "横盘(40-60%)", "小涨(60-80%)", "大涨(80-100%)"]
                                    q_results = []
                                    
                                    for i in range(len(quantiles) - 1):
                                        q_mask = (x >= q_values[i]) & (x < q_values[i+1])
                                        if i == len(quantiles) - 2:  # 最后一个区间包含右端点
                                            q_mask = (x >= q_values[i]) & (x <= q_values[i+1])
                                        
                                        if np.sum(q_mask) > 3:  # 至少3个样本
                                            y_q = y[q_mask]
                                            x_q = x[q_mask]
                                            # 简单统计（不做回归，因为区间内x变化小）
                                            mean_strat = float(np.mean(y_q))
                                            mean_index = float(np.mean(x_q))
                                            mean_excess = mean_strat - mean_index
                                            n_q = int(np.sum(q_mask))
                                            
                                            q_results.append({
                                                "quantile": q_labels[i],
                                                "mean_strategy_return": mean_strat,
                                                "mean_index_return": mean_index,
                                                "mean_excess_return": mean_excess,
                                                "n": n_q,
                                            })
                                            
                                            print(f"[index-quantile] {q_labels[i]} (n={n_q}): 策略={mean_strat:.4%} 指数={mean_index:.4%} 超额={mean_excess:.4%}", flush=True)
                                    
                                    bt_all["index_quantile_analysis"] = q_results
                            except Exception as _e_q:
                                print(f"[index-quantile] 分位数分析失败: {_e_q}", flush=True)
                        
                        except Exception as _e_seg:
                            print(f"[index] 分段回归失败: {_e_seg}", flush=True)
                        
                        # 新增：每日超额收益 vs 指数收益率的相关性分析（市场中性检验）
                        try:
                            # 计算每日超额：策略日收益 - 等资金基准日收益
                            benchmark_ret_arr = np.asarray(bt_all.get("benchmark_returns", []), dtype=np.float64)
                            if benchmark_ret_arr.size > 0:
                                Lm_excess = min(len(y), len(benchmark_ret_arr))
                                daily_excess = y[:Lm_excess] - benchmark_ret_arr[:Lm_excess]  # 每日超额
                                idx_ret_aligned = x[:Lm_excess]  # 对齐的指数收益
                                
                                # 去除非有限值
                                mask_excess = np.isfinite(daily_excess) & np.isfinite(idx_ret_aligned)
                                daily_excess_clean = daily_excess[mask_excess]
                                idx_ret_clean = idx_ret_aligned[mask_excess]
                                
                                if daily_excess_clean.size > 5 and np.var(idx_ret_clean) > 1e-12:
                                    # 回归：daily_excess = alpha_excess + beta_excess * index_return
                                    X_excess = np.stack([np.ones_like(idx_ret_clean), idx_ret_clean], axis=1)
                                    beta_excess = np.linalg.lstsq(X_excess, daily_excess_clean, rcond=None)[0]
                                    y_hat_excess = X_excess @ beta_excess
                                    ss_res_excess = float(np.sum((daily_excess_clean - y_hat_excess) ** 2))
                                    ss_tot_excess = float(np.sum((daily_excess_clean - float(np.mean(daily_excess_clean))) ** 2) + 1e-12)
                                    r2_excess = 1.0 - ss_res_excess / ss_tot_excess
                                    alpha_excess = float(beta_excess[0])
                                    beta_slope_excess = float(beta_excess[1])
                                    
                                    # 相关系数
                                    if np.std(daily_excess_clean) > 1e-12 and np.std(idx_ret_clean) > 1e-12:
                                        corr_excess = float(np.corrcoef(daily_excess_clean, idx_ret_clean)[0, 1])
                                    else:
                                        corr_excess = 0.0
                                    
                                    # 保存到结果
                                    bt_all["excess_vs_index_regression"] = {
                                        "alpha_daily": alpha_excess,
                                        "beta": beta_slope_excess,
                                        "r2": r2_excess,
                                        "corr": corr_excess,
                                        "n": int(daily_excess_clean.size),
                                    }
                                    
                                    print(f"[excess-vs-index] 每日超额 vs {idx_name}: alpha={alpha_excess:.6e} beta={beta_slope_excess:.3f} R^2={r2_excess:.3f} corr={corr_excess:.3f} n={int(daily_excess_clean.size)}", flush=True)
                                    
                                    # 分段分析：指数上涨日 vs 下跌日的超额表现
                                    up_mask_excess = idx_ret_clean > 0
                                    down_mask_excess = idx_ret_clean < 0
                                    
                                    if np.sum(up_mask_excess) > 5:
                                        excess_up = daily_excess_clean[up_mask_excess]
                                        idx_up = idx_ret_clean[up_mask_excess]
                                        X_up_excess = np.stack([np.ones_like(idx_up), idx_up], axis=1)
                                        beta_up_excess = np.linalg.lstsq(X_up_excess, excess_up, rcond=None)[0]
                                        y_hat_up_excess = X_up_excess @ beta_up_excess
                                        ss_res_up_excess = float(np.sum((excess_up - y_hat_up_excess) ** 2))
                                        ss_tot_up_excess = float(np.sum((excess_up - float(np.mean(excess_up))) ** 2) + 1e-12)
                                        r2_up_excess = 1.0 - ss_res_up_excess / ss_tot_up_excess
                                        alpha_up_excess = float(beta_up_excess[0])
                                        beta_slope_up_excess = float(beta_up_excess[1])
                                        mean_excess_up = float(np.mean(excess_up))
                                        n_up_excess = int(np.sum(up_mask_excess))
                                    else:
                                        alpha_up_excess = beta_slope_up_excess = r2_up_excess = mean_excess_up = float('nan')
                                        n_up_excess = 0
                                    
                                    if np.sum(down_mask_excess) > 5:
                                        excess_down = daily_excess_clean[down_mask_excess]
                                        idx_down = idx_ret_clean[down_mask_excess]
                                        X_down_excess = np.stack([np.ones_like(idx_down), idx_down], axis=1)
                                        beta_down_excess = np.linalg.lstsq(X_down_excess, excess_down, rcond=None)[0]
                                        y_hat_down_excess = X_down_excess @ beta_down_excess
                                        ss_res_down_excess = float(np.sum((excess_down - y_hat_down_excess) ** 2))
                                        ss_tot_down_excess = float(np.sum((excess_down - float(np.mean(excess_down))) ** 2) + 1e-12)
                                        r2_down_excess = 1.0 - ss_res_down_excess / ss_tot_down_excess
                                        alpha_down_excess = float(beta_down_excess[0])
                                        beta_slope_down_excess = float(beta_down_excess[1])
                                        mean_excess_down = float(np.mean(excess_down))
                                        n_down_excess = int(np.sum(down_mask_excess))
                                    else:
                                        alpha_down_excess = beta_slope_down_excess = r2_down_excess = mean_excess_down = float('nan')
                                        n_down_excess = 0
                                    
                                    bt_all["excess_vs_index_up"] = {
                                        "alpha_daily": alpha_up_excess,
                                        "beta": beta_slope_up_excess,
                                        "r2": r2_up_excess,
                                        "mean_excess": mean_excess_up,
                                        "n": n_up_excess,
                                    }
                                    bt_all["excess_vs_index_down"] = {
                                        "alpha_daily": alpha_down_excess,
                                        "beta": beta_slope_down_excess,
                                        "r2": r2_down_excess,
                                        "mean_excess": mean_excess_down,
                                        "n": n_down_excess,
                                    }
                                    
                                    print(f"[excess-up] 指数上涨日(n={n_up_excess}): 平均超额={mean_excess_up:.4%} alpha={alpha_up_excess:.6e} beta={beta_slope_up_excess:.3f} R^2={r2_up_excess:.3f}", flush=True)
                                    print(f"[excess-down] 指数下跌日(n={n_down_excess}): 平均超额={mean_excess_down:.4%} alpha={alpha_down_excess:.6e} beta={beta_slope_down_excess:.3f} R^2={r2_down_excess:.3f}", flush=True)
                                    
                                    # 市场中性评估
                                    if np.isfinite(mean_excess_up) and np.isfinite(mean_excess_down):
                                        if abs(beta_slope_excess) < 0.1 and abs(corr_excess) < 0.2:
                                            neutrality = "强市场中性"
                                        elif abs(beta_slope_excess) < 0.3 and abs(corr_excess) < 0.4:
                                            neutrality = "中等市场中性"
                                        else:
                                            if beta_slope_excess > 0:
                                                neutrality = "正向市场暴露（涨时超额大、跌时超额小）"
                                            else:
                                                neutrality = "负向市场暴露（涨时超额小、跌时超额大/对冲特征）"
                                        print(f"[market-neutrality] {neutrality} | beta={beta_slope_excess:.3f} corr={corr_excess:.3f}", flush=True)
                                        bt_all["market_neutrality_assessment"] = neutrality
                        except Exception as _e_excess:
                            print(f"[excess-vs-index] 超额 vs 指数分析失败: {_e_excess}", flush=True)
                        
    except Exception as _e_idx:
        print(f"[index] 指数回归计算失败: {_e_idx}")
    # 打印指标（仅交易回测指标）

    print("回测(ALL)指标:")
    print(f"  inferred_initial_capital={bt_all.get('initial_capital', 0.0):.2f}")
    print(f"  mean={bt_all['daily_mean']:.6f}  std={bt_all['daily_std']:.6f}  Sharpe={bt_all['sharpe']:.3f}")
    print(f"  total_return={bt_all['total_return']:.4f}  max_drawdown={bt_all['max_drawdown']:.4f}  final_value={bt_all['final_portfolio_value']:.2f}")
    print(f"  avg_daily_return={bt_all.get('avg_daily_return', 0.0):.6f}  annual_return={bt_all.get('annual_return', 0.0):.4f}")
    print(f"  Sharpe_annual={bt_all.get('sharpe_annual', 0.0):.3f}  Sortino_daily={bt_all.get('sortino_daily', 0.0):.3f}  Sortino_annual={bt_all.get('sortino_annual', 0.0):.3f}  Calmar={bt_all.get('calmar', 0.0):.3f}")
    print(f"  Win/Loss(days)={bt_all.get('win_days', 0)}/{bt_all.get('loss_days', 0)}  Win/Loss Ratio(daily)={bt_all.get('win_loss_ratio_daily', 0.0):.3f}")
    print(f"ALL费用 -> 佣金: {bt_all.get('total_commission', 0.0):.2f} 元  印花税: {bt_all.get('total_stamp_duty', 0.0):.2f} 元  合计: {bt_all.get('total_fees', 0.0):.2f} 元")

    results_payload = {
        "config_used": cfg,
        "meta": meta,
        "model_params_total": int(params_total) if params_total is not None else None,
        "model_params_trainable": int(params_trainable) if params_trainable is not None else None,
        "param_sources": locals().get('param_sources', {}),
        "args": {
            "oos_stock_ratio": args.oos_stock_ratio,
            "oos_stock_list": args.oos_stock_list,
            "initial_capital": args.initial_capital,
            "num_samples": args.num_samples,
            "ddim_steps": getattr(args, 'ddim_steps', 1),
            "ddim_eta": getattr(args, 'ddim_eta', 0.0),
            "chunk_size": getattr(args, 'chunk_size', 0),
            "direct_score": getattr(args, 'direct_score', 1),
            "score_sigma_min": getattr(args, 'score_sigma_min', 0.01),
            "score_sigma_max": getattr(args, 'score_sigma_max', 1.0),
            "diff_steps": getattr(args, 'diff_steps', 1000),
            "enable_oos_backtest": getattr(args, 'enable_oos_backtest', 1),
            "impact_linear": args.impact_linear,
            "impact_sqrt": args.impact_sqrt,
            "liquidity_alpha": args.liquidity_alpha,
            "min_lot": args.min_lot,
            "commission_rate": args.commission_rate,
            "stamp_duty_sell": args.stamp_duty_sell,
            "price_limit_pct": args.price_limit_pct,
            "progress": getattr(args, 'progress', 1),
            "log_interval": getattr(args, 'log_interval', 20),
        },
        "backtest_all": bt_all,
        "er_stats": er_stats_dict,
        "val_like_stats": val_like_stats,
    }

    # 始终计算"手数映射策略"作为对比（与主路径共享相同的 R/ER 计算）
    try:
        # 独立计算 alt 分位，避免复用上文 q 变量被覆盖为数组或其他类型
        _alpha_alt = float(getattr(args, "cvar_alpha", 0.05))
        _M_alt = int(args.num_samples)
        q_alt = int(max(1, np.floor(_M_alt * _alpha_alt)))
        # 保证数值 dtype
        R_sorted_alt = np.sort(np.asarray(R, dtype=np.float64), axis=1)
        CVaR_alt = np.mean(R_sorted_alt[:, :q_alt, :], axis=1)
        CVaR_alt = np.asarray(CVaR_alt, dtype=np.float64)
        ent_alt = np.zeros_like(np.asarray(ER, dtype=np.float64))
        for s in range(S):
            for n in range(N):
                r_sn = R_sorted_alt[s, :, n]
                bins_sn = _fd_bins(r_sn, min_bins=10, max_bins=200)
                try:
                    hist, _ = np.histogram(r_sn, bins=bins_sn, density=False)
                    p = np.asarray(hist, dtype=np.float64)
                    total = float(np.sum(p))
                    if total > 0:
                        p = p / total
                        p = p[p > 0]
                        ent_alt[s, n] = float(-np.sum(p * np.log(p + 1e-12)))
                except Exception:
                    ent_alt[s, n] = 0.0
        cvar_eps_alt = float(getattr(args, "cvar_eps", 1e-6))
        ent_eps_alt = float(getattr(args, "entropy_eps", 1e-6))
        cvar_power_alt = float(getattr(args, "cvar_power", 1.0))
        denom_alt = np.power((np.abs(CVaR_alt) + cvar_eps_alt), cvar_power_alt) * (ent_alt + ent_eps_alt)
        denom_alt = np.asarray(denom_alt, dtype=np.float64)
        with np.errstate(divide='ignore', invalid='ignore', over='ignore', under='ignore'):
            S_alt = np.divide(np.asarray(ER, dtype=np.float64), denom_alt, out=np.zeros_like(np.asarray(ER, dtype=np.float64)), where=(denom_alt > 1e-12))
        S_alt = np.asarray(S_alt, dtype=np.float64)
        max_notional_alt = float(getattr(args, 'max_notional_per_stock', 5000.0))
        # 彻底强制 decision_price 转 float64（即使源是字符串）
        dp_alt = np.array(decision_price, dtype=np.float64, copy=True)
        lot_sz_alt = float(int(args.min_lot))
        k_alt = float(getattr(args, 'risk_k', 3.0))
        notional_alt = np.where(S_alt > 0.0, np.tanh(k_alt * np.abs(S_alt)) * max_notional_alt, 0.0)
        denom_shares = np.clip(dp_alt * lot_sz_alt, 1e-9, None)
        q_alt = np.nan_to_num(notional_alt / denom_shares, nan=0.0, posinf=0.0, neginf=0.0)
        W_alt = np.rint(q_alt).astype(np.int32)
        bt_alt = simulate_sampling_rebalance(
            W_target_lots=W_alt,
            decision_open_t1=decision_np_train,
            decision_volume=volume_np_train,
            prev_close_decision=pc_dec_np_train,
            cutoff_indices=cutoff_indices,
            open_all=open_all_train,
            prev_close_all=prev_close_all_train,
            avg_volume_train=avg_volume_train_train,
            price_limit_vec=price_limit_vec_train,
            initial_capital=float(args.initial_capital),
            min_lot=int(args.min_lot),
            commission_rate=float(args.commission_rate),
            stamp_duty_sell=float(args.stamp_duty_sell),
            impact_linear=float(args.impact_linear),
            impact_sqrt=float(args.impact_sqrt),
            liquidity_alpha=float(args.liquidity_alpha),
            dates_all=ds_test.dates,
            debug_stockid="",
            stocks_list=train_stocks,
            er_matrix=ER,
            s_score_matrix=S_alt,
            cvar_matrix=(None if use_simple else CVaR),
            entropy_matrix=(None if use_simple else ent),
        )
        if isinstance(bt_alt, dict):
            bt_all["alt_values"] = bt_alt.get("values", [])
            bt_all["alt_initial_capital"] = bt_alt.get("initial_capital", bt_alt.get("values", [1.0])[0] if bt_alt.get("values", []) else 1.0)
            bt_all["alt_label"] = "手数映射策略"
    except Exception as _e_alt:
        try:
            import traceback
            print(f"[warn] 手数映射策略对比失败: {_e_alt}", flush=True)
            # 详尽的 dtype/shape 诊断
            try:
                print(f"[alt-dtype] dp_alt={dp_alt.dtype} lot_sz_alt(type)={type(lot_sz_alt)} notional_alt={np.asarray(notional_alt).dtype}")
            except Exception:
                pass
            try:
                print(f"[alt-dtype] decision_np_train={getattr(decision_np_train,'dtype',None)} volume_np_train={getattr(volume_np_train,'dtype',None)} pc_dec_np_train={getattr(pc_dec_np_train,'dtype',None)}")
                print(f"[alt-dtype] open_all_train={getattr(open_all_train,'dtype',None)} prev_close_all_train={getattr(prev_close_all_train,'dtype',None)} avg_volume_train_train={getattr(avg_volume_train_train,'dtype',None)} price_limit_vec_train={getattr(price_limit_vec_train,'dtype',None)}")
            except Exception:
                pass
            traceback.print_exc()
        except Exception:
            pass

    bt_oos = None
    # OOS 分支：可控开关 enable_oos_backtest；若存在 OOS，统一使用采样策略（与 ALL 保持一致）。当 K_oos > N_train 时按切片分批，每批尺寸= N_train，最后一批不足位置以 0 填充但不计入统计。
    if int(getattr(args, 'enable_oos_backtest', 1)) == 1 and (pred_panel_oos is not None) and (K_oos > 0):
        if int(args.num_samples) > 0:
            S, M, N = y0_samples.shape  # N = N_train
            assert N == N_train, f"y0_samples shape mismatch: {N} vs {N_train}"
            
            cvar_eps = float(getattr(args, "cvar_eps", 1e-6))
            ent_eps = float(getattr(args, "entropy_eps", 1e-6))
            k = float(args.risk_k)
            max_lots = int(args.max_lots)
            alpha = float(args.cvar_alpha)
            q = int(max(1, np.floor(M * alpha)))

            # 分批处理，批大小固定为 N_train
            start_idx = 0
            chunk_daily_returns: list[np.ndarray] = []
            chunk_weights: list[int] = []  # 按真实 OOS 数量加权
            chunk_fees: list[tuple[float, float]] = []  # (commission, stamp)
            t0_oos = time.time()
            chunks_total = int(np.ceil(K_oos / max(1, N_train)))
            chunk_id = 0
            while start_idx < K_oos:
                end_idx = min(start_idx + N_train, K_oos)
                B = end_idx - start_idx
                # 用 R 的前 B 列作为本批的近似分布（保持尺寸与推理接口一致）
                R_chunk = R[:, :, :B]  # [S, M, B]
                # ER/CVaR/Entropy（仅 B 列）
                R_sorted = np.sort(R_chunk, axis=1)
                CVaR = np.mean(R_sorted[:, :q, :], axis=1)  # [S,B]
                ER = np.mean(R_chunk, axis=1)               # [S,B]
                ent = np.zeros_like(ER)
                for s in range(S):
                    for n_idx in range(B):
                        r_sn = R_chunk[s, :, n_idx]
                        try:
                            bins_sn = _fd_bins(r_sn, min_bins=10, max_bins=200)
                            hist, _ = np.histogram(r_sn, bins=bins_sn, density=False)
                            p = hist.astype(np.float64)
                            total = float(np.sum(p))
                            if total <= 0:
                                ent[s, n_idx] = 0.0
                            else:
                                p = p / total
                                p = p[p > 0]
                                ent[s, n_idx] = float(-np.sum(p * np.log(p + 1e-12)))
                        except Exception:
                            ent[s, n_idx] = 0.0
                cvar_power = float(getattr(args, "cvar_power", 1.0))
                denom = np.power((np.abs(CVaR) + cvar_eps), cvar_power) * (ent + ent_eps)
                S_score = ER / denom
                W_chunk = np.where(S_score > 0.0, np.tanh(k * np.abs(S_score)) * max_lots, 0.0)
                W_chunk = np.nan_to_num(W_chunk, nan=0.0, posinf=0.0, neginf=0.0)
                W_chunk = np.rint(W_chunk).astype(np.int32)  # [S,B]
                # 扩展为 [S, N_train]，仅前 B 位有效
                W_full = np.zeros((S, N_train), dtype=np.int32)
                W_full[:, :B] = W_chunk
                # 掩码：仅前 B 位纳入统计
                mask = np.zeros(N_train, dtype=bool)
                mask[:B] = True
                # 分批模拟（输入尺寸严格为 N_train）
                bt_part = simulate_sampling_rebalance(
                    W_target_lots=W_full,
                decision_open_t1=decision_np_train,
                decision_volume=volume_np_train,
                prev_close_decision=pc_dec_np_train,
                cutoff_indices=cutoff_indices,
                open_all=open_all_train,
                prev_close_all=prev_close_all_train,
                avg_volume_train=avg_volume_train_train,
                price_limit_vec=price_limit_vec_train,
                initial_capital=float(args.initial_capital),
                min_lot=int(args.min_lot),
                commission_rate=float(args.commission_rate),
                stamp_duty_sell=float(args.stamp_duty_sell),
                impact_linear=float(args.impact_linear),
                impact_sqrt=float(args.impact_sqrt),
                liquidity_alpha=float(args.liquidity_alpha),
                dates_all=ds_test.dates,
                debug_stockid="",
                stocks_list=train_stocks,
                    stock_mask=mask,
                    cvar_matrix=None,
                    entropy_matrix=None,
                )
                chunk_daily_returns.append(np.asarray(bt_part.get("daily_returns", []), dtype=np.float64))
                chunk_weights.append(int(B))
                chunk_fees.append((float(bt_part.get("total_commission", 0.0)), float(bt_part.get("total_stamp_duty", 0.0))))
                start_idx = end_idx
                chunk_id += 1
                if int(getattr(args, 'progress', 1)) == 1 and (chunk_id % max(1, int(getattr(args, 'log_interval', 20))) == 0 or start_idx >= K_oos):
                    elapsed = time.time() - t0_oos
                    rate = chunk_id / max(elapsed, 1e-6)
                    remain = (chunks_total - chunk_id) / max(rate, 1e-6)
                    print(f"[oos] chunk {chunk_id}/{chunks_total} (stocks {start_idx}/{K_oos}) rate={rate:.2f} ch/s eta={remain:.1f}s", flush=True)

            # 权重合成（按真实 OOS 数量加权平均日收益）
            Wsum = max(1, int(np.sum(chunk_weights)))
            max_len = max((len(dr) for dr in chunk_daily_returns), default=0)
            combined = np.zeros(max_len, dtype=np.float64)
            for w, dr in zip(chunk_weights, chunk_daily_returns):
                if dr.size == 0:
                    continue
                combined[:dr.size] += (w / Wsum) * dr

            # 从合成日收益重新计算 OOS 指标
            daily_returns_np = combined
            mean = float(np.mean(daily_returns_np)) if daily_returns_np.size > 0 else 0.0
            std = float(np.std(daily_returns_np) + 1e-9) if daily_returns_np.size > 0 else 1e-9
            sharpe = float(mean / std) if std > 0 else 0.0
            neg = daily_returns_np[daily_returns_np < 0]
            downside = float(np.std(neg) + 1e-9) if neg.size > 0 else 1e-9
            sortino_daily = float(mean / downside) if downside > 0 else 0.0
            sharpe_annual = float(sharpe * np.sqrt(252.0))
            sortino_annual = float(sortino_daily * np.sqrt(252.0))
            cum = np.cumprod(1.0 + daily_returns_np) - 1.0 if daily_returns_np.size > 0 else np.array([0.0])
            total_ret = float(cum[-1]) if cum.size > 0 else 0.0
            runmax = np.maximum.accumulate(1.0 + cum) if cum.size > 0 else np.array([1.0])
            dd = (runmax - (1.0 + cum)) / runmax if cum.size > 0 else np.array([0.0])
            maxdd = float(np.max(dd)) if dd.size > 0 else 0.0
            n_days = int(daily_returns_np.size)
            if n_days > 0:
                logret = np.log1p(daily_returns_np)
                annual_return = float(np.expm1(np.sum(logret) * (252.0 / max(1, n_days))))
            else:
                annual_return = 0.0
            calmar = float(annual_return / (maxdd + 1e-9))
            pos_days = int(np.sum(daily_returns_np > 0))
            neg_days = int(np.sum(daily_returns_np < 0))
            win_loss_ratio_daily = float((pos_days / max(1, neg_days))) if neg_days > 0 else float(pos_days)
            # 费用按权重合成（近似）
            total_commission = float(np.sum([w / Wsum * c for (c, s), w in zip(chunk_fees, chunk_weights)]))
            total_stamp_duty = float(np.sum([w / Wsum * s for (c, s), w in zip(chunk_fees, chunk_weights)]))
            bt_oos = {
                "daily_mean": mean,
                "daily_std": std,
                "sharpe": sharpe,
                "sharpe_annual": sharpe_annual,
                "total_return": total_ret,
                "max_drawdown": maxdd,
                "sortino_daily": sortino_daily,
                "sortino_annual": sortino_annual,
                "calmar": calmar,
                "daily_returns": daily_returns_np.tolist(),
                "values": (np.cumprod(1.0 + daily_returns_np)).tolist(),
                "final_portfolio_value": float((1.0 + total_ret)),
                "initial_capital": float(args.initial_capital),
                "total_commission": total_commission,
                "total_stamp_duty": total_stamp_duty,
                "total_fees": float(total_commission + total_stamp_duty),
                "avg_daily_return": mean,
                "annual_return": annual_return,
                "win_days": int(pos_days),
                "loss_days": int(neg_days),
                "win_loss_ratio_daily": win_loss_ratio_daily,
            }
            if int(getattr(args, 'progress', 1)) == 1:
                print(f"[simulate] OOS done chunks={chunks_total} elapsed={time.time() - t0_oos:.2f}s", flush=True)
    if bt_oos is not None:
        results_payload["backtest_oos"] = bt_oos
        print("回测(OOS)指标:")
        print(f"  inferred_initial_capital={bt_oos.get('initial_capital', 0.0):.2f}")
        print(f"  mean={bt_oos['daily_mean']:.6f}  std={bt_oos['daily_std']:.6f}  Sharpe={bt_oos['sharpe']:.3f}")
        print(f"  total_return={bt_oos['total_return']:.4f}  max_drawdown={bt_oos['max_drawdown']:.4f}  final_value={bt_oos['final_portfolio_value']:.2f}")
        print(f"  avg_daily_return={bt_oos.get('avg_daily_return', 0.0):.6f}  annual_return={bt_oos.get('annual_return', 0.0):.4f}")
        print(f"  Sharpe_annual={bt_oos.get('sharpe_annual', 0.0):.3f}  Sortino_daily={bt_oos.get('sortino_daily', 0.0):.3f}  Sortino_annual={bt_oos.get('sortino_annual', 0.0):.3f}  Calmar={bt_oos.get('calmar', 0.0):.3f}")
        print(f"  Win/Loss(days)={bt_oos.get('win_days', 0)}/{bt_oos.get('loss_days', 0)}  Win/Loss Ratio(daily)={bt_oos.get('win_loss_ratio_daily', 0.0):.3f}")
        print(f"OOS费用 -> 佣金: {bt_oos.get('total_commission', 0.0):.2f} 元  印花税: {bt_oos.get('total_stamp_duty', 0.0):.2f} 元  合计: {bt_oos.get('total_fees', 0.0):.2f} 元")
    # OOS不进行调试（debug股票仅在训练股票池内）

    name = save_results(args.results_dir, args.results_name, results_payload)
    # 生成图片（按日期/实验名分目录）
    ts = name.split("_")[-1] if name and "_" in name else time.strftime("%Y%m%d_%H%M%S")
    date_part = ts.split("_")[0] if "_" in ts else ts[:8]
    run_plot_dir = os.path.join("plots", "backtest", date_part, name if name else ts)
    os.makedirs(run_plot_dir, exist_ok=True)
    # 若开启 RL 对比，则在 ALL 回测上额外生成 RL 策略的权益曲线
    if int(getattr(args, 'rl_compare', 0)) == 1:
        try:
            if (ActorCritic is None) or (StockSelectionEnv is None) or (prepare_env_arrays is None) or (make_env_from_data is None):
                raise RuntimeError("rl modules not importable")
            # 使用与 RL 训练完全一致的特征与样本：调用 RL 侧的预处理与环境构造
            rl_args = SimpleNamespace(
                data_dir=str(getattr(args, 'data_dir', os.path.join('data', 'processed'))),
                # 环境/交易参数
                initial_capital=float(args.initial_capital),
                liquidity_alpha=float(args.liquidity_alpha),
                max_volume_pct=0.10,
                min_lot=int(args.min_lot),
                commission_rate=float(args.commission_rate),
                stamp_duty_sell=float(args.stamp_duty_sell),
                impact_linear=float(args.impact_linear),
                impact_sqrt=float(args.impact_sqrt),
                price_limit_pct=float(args.price_limit_pct),
                max_notional_per_stock=float(getattr(args, 'max_notional_per_stock', 20000.0)),
                # 采样参数（与当前回测统一）
                samples=int(getattr(args, 'num_samples', 32)),
                ddim_steps=int(getattr(args, 'ddim_steps', 1)),
                ddim_eta=float(getattr(args, 'ddim_eta', 0.0)),
                sigma_min=float(getattr(args, 'sigma_min', 0.02)),
                sigma_max=float(getattr(args, 'sigma_max', 0.8)),
                diff_steps=int(getattr(args, 'diff_steps', 1000)),
                # 日志/杂项
                ledger_mode=1,
                oos_list_path=os.path.join('data', 'processed', 'oos_stocks.txt'),
            )
            arrays = prepare_env_arrays(rl_args)
            env_rl = make_env_from_data(rl_args, arrays=arrays)

            device_rl = torch.device("cuda" if torch.cuda.is_available() else "cpu")
            _shape = getattr(env_rl.observation_space, "shape", None)
            if not _shape or len(_shape) != 2:
                raise RuntimeError("invalid observation space shape for RL env")
            num_stocks, num_features = int(_shape[0]), int(_shape[1])

            rl_ckpt_path = str(getattr(args, 'rl_checkpoint', os.path.join('checkpoints', 'rl', 'policy.pt')))
            rl_ckpt = torch.load(rl_ckpt_path, map_location=device_rl, weights_only=False)
            cfg_rl = rl_ckpt.get('config', {})
            state_rl = rl_ckpt.get('model', rl_ckpt)
            # 推断是否使用样本编码器
            uses_samples = any(k.startswith('sample_proj') or k.startswith('sample_encoder') for k in state_rl.keys())
            policy = ActorCritic(
                num_features,
                num_stocks,
                model_type=str(cfg_rl.get('rl_model_type', 'transformer')),
                hidden=int(cfg_rl.get('hidden', 256)),
                trm_d_model=int(cfg_rl.get('rl_trm_d_model', 256)),
                trm_nhead=int(cfg_rl.get('rl_trm_nhead', 4)),
                trm_layers=int(cfg_rl.get('rl_trm_layers', 2)),
                trm_d_ff=int(cfg_rl.get('rl_trm_d_ff', 512)),
                trm_dropout=float(cfg_rl.get('rl_trm_dropout', 0.1)),
                use_cls=int(cfg_rl.get('rl_use_cls', 1)),
                use_shared_backbone=int(cfg_rl.get('rl_use_shared_backbone', 1)),
                d_samp=int(cfg_rl.get('rl_d_samp', 32)),
                samp_enc_layers=int(cfg_rl.get('rl_samp_enc_layers', 1)),
                samp_enc_heads=int(cfg_rl.get('rl_samp_enc_heads', 2)),
                samp_enc_dff=int(cfg_rl.get('rl_samp_enc_dff', 64)),
                samp_enc_dropout=float(cfg_rl.get('rl_samp_enc_dropout', 0.1)),
                d_shared=int(cfg_rl.get('rl_d_shared', 0)),
                use_samples=int(1 if uses_samples else 0),
            ).to(device_rl)
            policy.load_state_dict(state_rl, strict=True)
            policy.eval()

            # rollout 一次，得到日收益与权益（与 RL 评估一致）
            obs, info = env_rl.reset(seed=42)
            daily_rets_rl = []
            values_series_rl = [float(env_rl.prev_value)]
            portfolio_value = float(env_rl.prev_value)
            for _ in range(env_rl.S):
                obs_t = torch.from_numpy(obs).to(device_rl)
                mask_t = torch.from_numpy(info["action_mask"].astype(np.float32)).to(device_rl)
                # 样本与共享特征
                samples_np = info.get("samples")
                shared_np = info.get("shared")
                samples_t = torch.from_numpy(samples_np).to(device_rl).unsqueeze(0).permute(0, 2, 1, 3) if (samples_np is not None and uses_samples) else None
                shared_t = torch.from_numpy(shared_np).to(device_rl).unsqueeze(0) if (shared_np is not None) else None
                with torch.no_grad():
                    actions, _, _, _ = policy.get_action_and_value(
                        obs_t.unsqueeze(0), mask_t.unsqueeze(0), samples_t, shared_t
                    )
                obs, reward, terminated, truncated, info = env_rl.step(actions.squeeze(0).detach().cpu().numpy())
                daily_rets_rl.append(float(info.get("daily_ret", 0.0)))
                portfolio_value = float(info.get("portfolio_value", portfolio_value))
                values_series_rl.append(portfolio_value)
                if terminated:
                    break
            # 将 RL 权益曲线附加到 bt_all，用绘图函数统一输出
            bt_all["rl_values"] = values_series_rl
            bt_all["rl_initial_capital"] = float(values_series_rl[0] if len(values_series_rl) > 0 else args.initial_capital)
            bt_all["rl_label"] = "RL策略"
            print("[rl] 覆盘对比: RL 策略曲线已生成")
        except Exception as e:
            print(f"[rl] 覆盘对比失败，跳过RL曲线: {e}")

    # 将当前运行配置(config.json 或 --config 指定文件)中的自定义日收益传递给绘图层，避免因回退到训练配置而丢失
    try:
        cfg_path_rt = getattr(args, 'config', '')
        cfg_json_rt = None
        if isinstance(cfg_path_rt, str) and len(cfg_path_rt) > 0 and os.path.exists(cfg_path_rt):
            with open(cfg_path_rt, 'r', encoding='utf-8') as f:
                cfg_json_rt = json.load(f)
        elif os.path.exists('config.json'):
            with open('config.json', 'r', encoding='utf-8') as f:
                cfg_json_rt = json.load(f)
        if isinstance(cfg_json_rt, dict):
            bcfg_rt = cfg_json_rt.get('backtest', {}) if isinstance(cfg_json_rt.get('backtest', {}), dict) else {}
            series_rt = bcfg_rt.get('custom_daily_returns', None)
            if isinstance(series_rt, list):
                bt_all['custom_daily_returns'] = series_rt
                if bt_oos is not None:
                    bt_oos['custom_daily_returns'] = series_rt
    except Exception:
        pass

    save_backtest_plots(bt_all, run_plot_dir, "all", index_data)
    if bt_oos is not None:
        save_backtest_plots(bt_oos, run_plot_dir, "oos", index_data)
    
    # 生成多步推理方差演化图表（如果有数据）
    if multistep_std_stats is not None:
        try:
            from pathlib import Path as _PathLib
            import matplotlib as _mpl_std
            _mpl_std.rcParams['axes.unicode_minus'] = False
            _mpl_std.rcParams['font.family'] = 'sans-serif'
            _mpl_std.rcParams['font.sans-serif'] = ['Arial', 'DejaVu Sans', 'Liberation Sans', 'sans-serif']
            import matplotlib.pyplot as _plt_std
            
            trace = multistep_std_stats
            sigmas = np.array(trace['sigmas'])
            mean_std_x = np.array(trace['mean_std_x'])
            mean_std_y0 = np.array(trace['mean_std_y0'])
            count_windows = trace['count_windows']
            
            num_steps = len(sigmas)
            steps = np.arange(num_steps)
            
            # 如果有多个资产，计算跨资产的平均std
            if mean_std_x.ndim == 2:
                std_x_mean = mean_std_x.mean(axis=1)
                std_x_std = mean_std_x.std(axis=1)
                std_y0_mean = mean_std_y0.mean(axis=1)
                std_y0_std = mean_std_y0.std(axis=1)
            else:
                std_x_mean = mean_std_x
                std_x_std = np.zeros_like(std_x_mean)
                std_y0_mean = mean_std_y0
                std_y0_std = np.zeros_like(std_y0_mean)
            
            # 尝试获取真实std作为参考（从外层作用域）
            true_std = None
            try:
                # val_like_stats是外层变量，直接引用而非用locals()查找
                if isinstance(val_like_stats, dict) and 'std_true' in val_like_stats:
                    true_std = float(val_like_stats.get('std_true', float('nan')))
                    if not np.isfinite(true_std) or true_std <= 0:
                        true_std = None
            except Exception:
                pass
            
            # 创建图表
            fig_std, axes_std = _plt_std.subplots(2, 2, figsize=(14, 10))
            
            # 子图1: x_i 的std随step变化
            ax = axes_std[0, 0]
            ax.plot(steps, std_x_mean, marker='o', label='std(x_i)', linewidth=2)
            ax.fill_between(steps, std_x_mean - std_x_std, std_x_mean + std_x_std, alpha=0.2)
            if true_std is not None:
                ax.axhline(y=true_std, color='red', linestyle='--', linewidth=1.5, label=f'True std={true_std:.4f}')
            ax.set_xlabel('Step (sigma_max -> sigma_min)', fontsize=11)
            ax.set_ylabel('Std', fontsize=11)
            ax.set_title(f'x_i Variance Evolution (Linear) | Windows={count_windows}', fontsize=12, fontweight='bold')
            ax.legend()
            ax.grid(True, alpha=0.3)
            
            # 子图2: y0_hat_i 的std随step变化
            ax = axes_std[0, 1]
            ax.plot(steps, std_y0_mean, marker='s', color='orange', label='std(y0_hat_i)', linewidth=2)
            ax.fill_between(steps, std_y0_mean - std_y0_std, std_y0_mean + std_y0_std, alpha=0.2, color='orange')
            if true_std is not None:
                ax.axhline(y=true_std, color='red', linestyle='--', linewidth=1.5, label=f'True std={true_std:.4f}')
            ax.set_xlabel('Step (sigma_max -> sigma_min)', fontsize=11)
            ax.set_ylabel('Std', fontsize=11)
            ax.set_title(f'y0_hat_i Variance Evolution (Linear) | Windows={count_windows}', fontsize=12, fontweight='bold')
            ax.legend()
            ax.grid(True, alpha=0.3)
            
            # 子图3: 对比x vs y0_hat
            ax = axes_std[1, 0]
            ax.plot(steps, std_x_mean, marker='o', label='std(x_i)', linewidth=2)
            ax.plot(steps, std_y0_mean, marker='s', label='std(y0_hat_i)', linewidth=2)
            if true_std is not None:
                ax.axhline(y=true_std, color='red', linestyle='--', linewidth=1.5, label=f'True std={true_std:.4f}')
            ax.set_xlabel('Step (sigma_max -> sigma_min)', fontsize=11)
            ax.set_ylabel('Std', fontsize=11)
            ax.set_title('x vs y0_hat Variance Comparison', fontsize=12, fontweight='bold')
            ax.legend()
            ax.grid(True, alpha=0.3)
            
            # 子图4: sigma随step变化
            ax = axes_std[1, 1]
            ax.plot(steps, sigmas, marker='d', color='green', linewidth=2, label='sigma schedule')
            ax.set_xlabel('Step', fontsize=11)
            ax.set_ylabel('Sigma (log scale)', fontsize=11)
            ax.set_yscale('log')
            ax.set_title('Noise Schedule sigma(step)', fontsize=12, fontweight='bold')
            ax.legend()
            ax.grid(True, alpha=0.3, which='both')
            
            fig_std.tight_layout()
            multistep_std_path = os.path.join(run_plot_dir, "multistep_std_evolution.png")
            fig_std.savefig(multistep_std_path, dpi=150)
            _plt_std.close(fig_std)
            print(f"[multistep] Variance evolution chart saved: {multistep_std_path}")
        except Exception as e_std:
            print(f"[multistep] WARNING: Failed to generate variance evolution chart: {e_std}")
    # 保存 debug_stock 最近20天的采样分布直方图
    try:
        dbg_id = str(getattr(args, "debug_stockid", ""))
        if isinstance(dbg_id, str) and len(dbg_id) > 0 and (debug_hist_series is not None) and len(debug_hist_series) > 0:
            hist_dir = os.path.join(run_plot_dir, "debug_hist")
            os.makedirs(hist_dir, exist_ok=True)
            print(f"[debug] Generating {len(debug_hist_series)} histogram(s) for {dbg_id}...")
            for date_str, samples in debug_hist_series:
                try:
                    fig, ax = plt.subplots(figsize=(6, 3.2))
                    x = np.asarray(samples, dtype=np.float64)
                    bins_sn = _fd_bins(x, min_bins=10, max_bins=200)
                    ax.hist(x, bins=bins_sn, color="#1f77b4", alpha=0.8)
                    ax.set_title(f"{dbg_id} Return Samples {date_str}")
                    ax.set_xlabel("Return")
                    ax.set_ylabel("Frequency")
                    fig.tight_layout()
                    safe_date = re.sub(r"[^0-9A-Za-z_-]", "-", str(date_str))
                    fig.savefig(os.path.join(hist_dir, f"debug_hist_{dbg_id}_{safe_date}.png"), dpi=120)
                    plt.close(fig)
                except Exception as e_hist:
                    print(f"[debug] WARNING: Failed to generate histogram for {date_str}: {e_hist}")
                    try:
                        plt.close(fig)
                    except Exception:
                        pass
            print(f"[debug] Histograms saved to {hist_dir}")
    except Exception as e_outer:
        print(f"[debug] WARNING: Failed to generate debug histograms: {e_outer}")


    # 可视化：调试个股的最近20天采样收益分布直方图
    try:
        if debug_hist_series is not None and isinstance(debug_hist_series, list) and len(debug_hist_series) > 0:
            from pathlib import Path as _P
            import matplotlib.pyplot as _plt
            debug_dir = os.path.join(run_plot_dir, "debug")
            os.makedirs(debug_dir, exist_ok=True)
            bins = int(getattr(args, "entropy_bins", 20))
            sid = str(getattr(args, "debug_stockid", ""))
            for date_str, samples in debug_hist_series:
                try:
                    _plt.figure(figsize=(5, 3.5))
                    _plt.hist(samples, bins=bins, color="#1f77b4", alpha=0.85)
                    _plt.title(f"{sid} | {date_str}")
                    _plt.xlabel("Net Return (sampled)")
                    _plt.ylabel("Count")
                    _plt.tight_layout()
                    fn = os.path.join(debug_dir, f"hist_{sid}_{str(date_str).replace(':','-').replace('/','-')}.png")
                    _plt.savefig(fn, dpi=120)
                    _plt.close()
                except Exception as e_hist2:
                    print(f"[debug] WARNING: Failed to save histogram for {date_str}: {e_hist2}")
                    try:
                        _plt.close()
                    except Exception:
                        pass
            print(f"[debug] Saved {len(debug_hist_series)} return histograms for {sid} -> {debug_dir}")
    except Exception as _e2:
        print(f"[debug] WARNING: Failed to generate histograms: {_e2}")


if __name__ == "__main__":
    main()