参数优化

"""贝叶斯优化示例 - 使用scikit-optimize"""
import numpy as np
from skopt import gp_minimize
from skopt.space import Integer, Real

# 假设这是我们的策略收益函数（实际中这里是回测函数）
def strategy_sharpe(params):
    """
    模拟策略夏普比率
    params = [short_window, long_window, stop_loss]
    """
    short, long, stop = params
    if short >= long:
        return -1  # 无效参数
    
    # 模拟收益（实际中这里运行回测）
    np.random.seed(short + long)
    returns = np.random.normal(0.0003, 0.012, 252*2)
    # 添加一些与参数相关的信号
    signal_quality = 1 - abs(short/60 - 0.5) - abs(long/180 - 1)
    returns += signal_quality * 0.001
    
    sharpe = returns.mean() / returns.std() * np.sqrt(252)
    return -sharpe  # skopt最小化，所以取负

# 定义参数空间
space = [
    Integer(5, 60, name='short_window'),
    Integer(60, 250, name='long_window'),
    Real(0.01, 0.10, name='stop_loss')
]

# 运行贝叶斯优化
result = gp_minimize(
    strategy_sharpe,
    space,
    n_calls=50,      # 总评估次数
    n_random_starts=10,  # 随机初始化次数
    random_state=42
)

print(f"最优参数: 短期={result.x[0]}, 长期={result.x[1]}, 止损={result.x[2]:.2%}")
print(f"最优夏普: {-result.fun:.2f}")
print(f"总共评估了 {len(result.func_vals)} 组参数")

我有一个双均线策略，需要优化短期均线（5-60日）和长期均线（60-250日）。
请帮我：
1. 分别用网格搜索、随机搜索、贝叶斯优化三种方法寻找最优参数
2. 比较三种方法的计算效率和找到的最优解质量
3. 画出参数敏感性热力图（短期x长期 -> 夏普比率）

我通过网格搜索找到了一个最优参数组合（短期20日，长期120日，夏普1.8）。
请帮我：
1. 设计一个参数邻域稳健性测试：在最优参数±20%范围内随机采样100组参数
2. 计算这100组参数的夏普分布，评估最优参数是高原还是孤峰
3. 如果稳健性不足，提出参数简化或约束方案

有些交易员认为参数优化本身就是过拟合的根源，主张完全不做优化、只用固定参数（如20日/60日均线）。
请讨论：
1. 这种观点的合理性和局限性
2. 在"完全不做优化"和"过度优化"之间，有没有中间道路？
3. 提出一个"有约束的优化"框架，平衡收益和稳健性

"""参数优化 + 稳健性评估框架"""
import numpy as np
import pandas as pd
from itertools import product

class ParameterOptimizer:
    def __init__(self, strategy_func, param_grid):
        self.strategy = strategy_func
        self.grid = param_grid
    
    def grid_search(self, data):
        """网格搜索 + 稳健性评估"""
        results = []
        keys = list(self.grid.keys())
        values = [self.grid[k] for k in keys]
        
        for combo in product(*values):
            params = dict(zip(keys, combo))
            sharpe = self.strategy(data, params)
            results.append({**params, 'sharpe': sharpe})
        
        df = pd.DataFrame(results)
        best = df.loc[df['sharpe'].idxmax()]
        
        # 稳健性评估：最优参数邻域的表现
        neighbor_scores = self._check_robustness(df, best, keys)
        
        return {
            'best_params': best.to_dict(),
            'robustness': neighbor_scores,
            'all_results': df
        }
    
    def _check_robustness(self, df, best, keys, tolerance=0.2):
        """检查最优参数邻域的稳健性"""
        mask = True
        for k in keys:
            if not isinstance(best[k], (int, float)):
                continue
            val_range = df[k].max() - df[k].min()
            margin = val_range * tolerance
            mask &= df[k].between(best[k] - margin, best[k] + margin)
        
        neighbors = df[mask]
        return {
            'neighbor_count': len(neighbors),
            'neighbor_mean_sharpe': neighbors['sharpe'].mean(),
            'neighbor_std_sharpe': neighbors['sharpe'].std(),
            'robustness_ratio': (neighbors['sharpe'].mean() 
                                / (neighbors['sharpe'].std() + 1e-6))
        }

# 使用示例
def dummy_strategy(data, params):
    np.random.seed(int(params.get('short', 10)))
    returns = np.random.normal(0.0003, 0.012, 500)
    quality = 1 - abs(params.get('short', 10)/30 - 1)
    returns += quality * 0.0005
    return returns.mean() / returns.std() * np.sqrt(252)

param_grid = {
    'short': list(range(5, 31, 5)),
    'long': list(range(60, 121, 20))
}

optimizer = ParameterOptimizer(dummy_strategy, param_grid)
result = optimizer.grid_search(None)

print("=== 最优参数 ===")
print(result['best_params'])
print("
=== 稳健性评估 ===")
print(result['robustness'])