NewQuant/futures_trading_strategies/MA/Spectral/search_SpectralTrendStrategy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "id": "522f09ca7b3fe929",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-26T11:24:28.437374Z",
     "start_time": "2025-11-26T11:24:28.405444Z"
    }
   },
   "source": [
    "import sys\n",
    "\n",
    "if '/mnt/d/PyProject/NewQuant/' not in sys.path:\n",
    "    sys.path.append('/mnt/d/PyProject/NewQuant/')\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n"
   ],
   "outputs": [],
   "execution_count": 1
  },
  {
   "cell_type": "code",
   "id": "4f7e4b438cea750e",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-26T11:24:29.366534Z",
     "start_time": "2025-11-26T11:24:28.437374Z"
    }
   },
   "source": [
    "import pandas as pd\n",
    "from datetime import datetime\n",
    "import itertools\n",
    "from typing import Dict, Any, List, Tuple, Optional\n",
    "import multiprocessing  # 导入 multiprocessing 模块\n",
    "import math  # 保留 math 导入，因为您的策略内部可能需要用到数学函数\n",
    "\n",
    "# 导入所有必要的模块\n",
    "# 请确保这些导入路径与您的项目结构相符\n",
    "from src.analysis.grid_search_analyzer import GridSearchAnalyzer\n",
    "from src.analysis.result_analyzer import ResultAnalyzer\n",
    "from src.common_utils import generate_parameter_range\n",
    "from src.data_manager import DataManager\n",
    "from src.backtest_engine import BacktestEngine\n",
    "# 导入策略类\n",
    "\n",
    "import builtins\n",
    "\n",
    "\n",
    "origin_print = print\n",
    "\n"
   ],
   "outputs": [],
   "execution_count": 2
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-26T11:24:29.384793Z",
     "start_time": "2025-11-26T11:24:29.368538Z"
    }
   },
   "cell_type": "code",
   "source": [
    "\n",
    "def slient_print(*args):\n",
    "    pass\n"
   ],
   "id": "f903fd2761d446cd",
   "outputs": [],
   "execution_count": 3
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-26T11:27:01.326922Z",
     "start_time": "2025-11-26T11:24:29.388796Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from src.strategies.Spectral.utils import run_single_backtest\n",
    "# --- 主执行块 ---\n",
    "# 这是多进程代码的入口点，必须在 'if __name__ == \"__main__\":' 保护块中\n",
    "# 确保 autoreload 启用 (在Jupyter Notebook中使用，纯Python脚本运行时可移除)\n",
    "# %load_ext autoreload\n",
    "# %autoreload 2\n",
    "\n",
    "from src.strategies.Spectral.SpectralTrendStrategy2 import SpectralTrendStrategy\n",
    "\n",
    "# --- 全局配置 ---\n",
    "data_file_path = \"D:/PyProject/NewQuant/data/data/KQ_m@CZCE_MA/KQ_m@CZCE_MA_min15.csv\"\n",
    "\n",
    "\n",
    "initial_capital = 100000.0\n",
    "slippage_rate = 0.0000\n",
    "commission_rate = 0.0000\n",
    "global_config = {\n",
    "    'symbol': 'MA',\n",
    "}\n",
    "# 确保每个合约的tick_size在这里定义或获取\n",
    "RB_TICK_SIZE = 1.0  # 螺纹钢的最小变动单位\n",
    "\n",
    "# --- 定义参数网格 ---\n",
    "param1_name = \"spectral_window_days\"\n",
    "param1_values = generate_parameter_range(start=2, end=12, step=1)\n",
    "# param1_name = \"exit_threshold\"\n",
    "# param1_values = generate_parameter_range(start=0.1, end=0.9, step=0.1)\n",
    "param2_name = \"trend_strength_threshold\"\n",
    "param2_values = generate_parameter_range(start=0.1, end=0.9, step=0.1)\n",
    "# param2_name = \"dominance_multiplier\"\n",
    "# param2_values = generate_parameter_range(start=0, end=5, step=0.5)\n",
    "optimization_metric = 'total_return'\n",
    "\n",
    "# 生成所有参数组合\n",
    "param_combinations = list(itertools.product(param1_values, param2_values))\n",
    "total_combinations = len(param_combinations)\n",
    "print(f\"总计 {total_combinations} 种参数组合需要回测。\")\n",
    "\n",
    "all_results: List[Dict[str, Any]] = []\n",
    "grid_results: List[Dict[str, Any]] = []\n",
    "\n",
    "# 准备传递给每个子进程的公共配置字典\n",
    "common_config_for_processes = {\n",
    "    'main_symbol': global_config['symbol'],\n",
    "    'symbol': global_config['symbol'],\n",
    "    'data_path': data_file_path,\n",
    "    'initial_capital': initial_capital,\n",
    "    'slippage_rate': slippage_rate,\n",
    "    'commission_rate': commission_rate,\n",
    "    'start_time': datetime(2022, 1, 1),  # 回测起始时间\n",
    "    'end_time': datetime(2024, 6, 1),  # 回测结束时间\n",
    "    'roll_over_mode': True,  # 保持换月模式\n",
    "    'param1_name': param1_name,\n",
    "    'param2_name': param2_name,\n",
    "    'optimization_metric': optimization_metric,\n",
    "    'strategy': SpectralTrendStrategy,\n",
    "    'order_direction': ['BUY', 'SELL'],\n",
    "    # 'hawkes_entry_percent': 0.9,\n",
    "    'stop_loss_tick': 5\n",
    "}\n",
    "\n",
    "# 确定要使用的进程数量 (通常是CPU核心数)\n",
    "num_processes = int(multiprocessing.cpu_count() * 0.6)\n",
    "if num_processes < 1:\n",
    "    num_processes = 1\n",
    "\n",
    "print(f\"--- 启动多进程网格搜索，使用 {num_processes} 个进程 ---\")\n",
    "\n",
    "builtins.print = slient_print\n",
    "\n",
    "# 创建一个进程池\n",
    "with multiprocessing.Pool(processes=num_processes) as pool:\n",
    "    # 准备 run_single_backtest 函数的参数列表\n",
    "    # starmap 需要一个可迭代对象，其中每个元素是传递给目标函数的参数元组\n",
    "    args_for_starmap = [\n",
    "        (combo, common_config_for_processes) for combo in param_combinations\n",
    "    ]\n",
    "\n",
    "    run_single_backtest(*args_for_starmap[0])\n",
    "\n",
    "    # 使用 starmap() 来并行执行 run_single_backtest 函数\n",
    "    # starmap 是阻塞的，会等待所有任务完成并返回结果列表\n",
    "    for i, result_entry in enumerate(pool.starmap(run_single_backtest, args_for_starmap)):\n",
    "        if result_entry:  # 确保结果不为空\n",
    "            all_results.append(result_entry)\n",
    "            # 仅将成功的（无错误的）结果添加到用于网格分析的列表中\n",
    "            if 'error' not in result_entry:\n",
    "                grid_results.append(\n",
    "                    {\n",
    "                        param1_name: result_entry.get(param1_name),\n",
    "                        param2_name: result_entry.get(param2_name),\n",
    "                        optimization_metric: result_entry.get(optimization_metric, 0.0),\n",
    "                    }\n",
    "                )\n",
    "            else:\n",
    "                # 对于失败的组合，将其优化指标设置为一个特殊值，便于识别\n",
    "                grid_results.append(\n",
    "                    {\n",
    "                        param1_name: result_entry.get(param1_name),\n",
    "                        param2_name: result_entry.get(param2_name),\n",
    "                        optimization_metric: float('-inf'),  # 用负无穷表示失败\n",
    "                        'error_message': result_entry['error']\n",
    "                    }\n",
    "                )\n",
    "\n",
    "builtins.print = origin_print\n",
    "print(\"\\n--- 网格搜索回测完毕 ---\")"
   ],
   "id": "aed5938660e42b20",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "总计 99 种参数组合需要回测。\n",
      "--- 启动多进程网格搜索，使用 12 个进程 ---\n",
      "\n",
      "--- 网格搜索回测完毕 ---\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-26T11:27:01.556370Z",
     "start_time": "2025-11-26T11:27:01.340011Z"
    }
   },
   "cell_type": "code",
   "source": [
    "\n",
    "# --- 5. 后处理和最佳结果选择 ---\n",
    "if all_results:\n",
    "    results_df = pd.DataFrame(all_results)\n",
    "    # print(\"\\n--- 所有回测结果汇总 ---\")\n",
    "    # # 确保打印时浮点数格式化\n",
    "    # pd.set_option('display.float_format', lambda x: '%.4f' % x)\n",
    "    # print(results_df.to_string())\n",
    "\n",
    "    # 找到最佳组合 (排除有错误的)\n",
    "    # 过滤掉包含 'error' 键的行，或者 'error' 键的值不为空的行\n",
    "    # 同时确保优化指标是数值，并且不为无穷大\n",
    "    print(results_df.info())\n",
    "    successful_results_df = results_df[(pd.to_numeric(results_df[optimization_metric], errors='coerce').notna()) &\n",
    "                                       (pd.to_numeric(results_df[optimization_metric], errors='coerce') != float(\n",
    "                                           '-inf'))\n",
    "                                       ].copy()  # 使用 .copy() 避免 SettingWithCopyWarning\n",
    "\n",
    "    if not successful_results_df.empty and optimization_metric in successful_results_df.columns:\n",
    "        # 确保优化指标列是数值类型\n",
    "        successful_results_df[optimization_metric] = pd.to_numeric(successful_results_df[optimization_metric],\n",
    "                                                                   errors='coerce')\n",
    "\n",
    "        if not successful_results_df.empty and optimization_metric in successful_results_df.columns:\n",
    "            # 过滤掉NaN值，如果所有夏普比率都是NaN，则可能没有有效结果\n",
    "            normal_results = successful_results_df[\n",
    "                (results_df['total_trades'] > 100)\n",
    "                # &\n",
    "                # (results_df['profit_factor'] < 3.)\n",
    "            ]\n",
    "            if len(normal_results) > 0:\n",
    "                best_result = normal_results.loc[(normal_results[optimization_metric].idxmax())]\n",
    "                print(f\"\\n--- 最优参数组合 (按{optimization_metric}) ---\")\n",
    "                print(best_result)\n",
    "            else:\n",
    "                print('ERROR!!!!!!!!!!!!!!!!!!!!')\n",
    "\n",
    "        # 找到最大值的索引\n",
    "        # best_result = successful_results_df.loc[successful_results_df[optimization_metric].idxmax()]\n",
    "        # print(f\"\\n--- 最优参数组合 (按 {optimization_metric}) ---\")\n",
    "        # print(best_result)\n",
    "\n",
    "        # 导出到CSV\n",
    "        output_filename = f\"grid_search_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv\"\n",
    "        # results_df.to_csv(output_filename, index=False, encoding='utf-8')\n",
    "        # print(f\"\\n所有结果已导出到: {output_filename}\")\n",
    "\n",
    "        # 打印枢轴表\n",
    "        grid_df = pd.DataFrame(grid_results)\n",
    "        # 确保优化指标列是数值类型，非数值的（如 -inf）在pandas中可能被正确处理\n",
    "        grid_df[optimization_metric] = pd.to_numeric(grid_df[optimization_metric], errors='coerce')\n",
    "\n",
    "        pivot_table = grid_df.pivot_table(\n",
    "            index=param1_name, columns=param2_name, values=optimization_metric\n",
    "        )\n",
    "        # print(f\"\\n{optimization_metric} 网格结果 (Pivoted):\")\n",
    "        # print(pivot_table.to_string())\n",
    "    else:\n",
    "        print(f\"\\n没有成功的组合结果可供分析，或优化指标 '{optimization_metric}' 不在结果中，或所有组合均失败。\")\n",
    "else:\n",
    "    print(\"没有可用的回测结果。\")\n",
    "print(\"\\n--- 动态网格搜索完成 ---\")\n",
    "\n",
    "# --- 6. 可视化 (依赖 GridSearchAnalyzer) ---\n",
    "if grid_results:\n",
    "    grid_analyzer = GridSearchAnalyzer(grid_results, optimization_metric)\n",
    "    grid_analyzer.find_best_parameters()  # 这会找到并打印最佳参数\n",
    "    grid_analyzer.plot_heatmap()  # 这会绘制热力图\n",
    "else:\n",
    "    print(\"\\n没有生成任何网格搜索结果，无法进行分析。\")"
   ],
   "id": "a1c18a2776fcaba2",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 99 entries, 0 to 98\n",
      "Data columns (total 42 columns):\n",
      " #   Column                    Non-Null Count  Dtype  \n",
      "---  ------                    --------------  -----  \n",
      " 0   main_symbol               99 non-null     object \n",
      " 1   trade_volume              99 non-null     int64  \n",
      " 2   spectral_window_days      99 non-null     int64  \n",
      " 3   trend_strength_threshold  99 non-null     float64\n",
      " 4   order_direction           99 non-null     object \n",
      " 5   enable_log                99 non-null     bool   \n",
      " 6   low_freq_days             99 non-null     int64  \n",
      " 7   high_freq_days            99 non-null     int64  \n",
      " 8   exit_threshold            99 non-null     float64\n",
      " 9   初始资金                      99 non-null     float64\n",
      " 10  最终资金                      99 non-null     float64\n",
      " 11  总收益率                      99 non-null     float64\n",
      " 12  年化收益率                     99 non-null     float64\n",
      " 13  最大回撤                      99 non-null     float64\n",
      " 14  夏普比率                      99 non-null     float64\n",
      " 15  卡玛比率                      99 non-null     float64\n",
      " 16  总交易次数                     99 non-null     int64  \n",
      " 17  交易成本                      99 non-null     float64\n",
      " 18  总实现盈亏                     99 non-null     float64\n",
      " 19  胜率                        99 non-null     float64\n",
      " 20  盈亏比                       99 non-null     float64\n",
      " 21  盈利交易次数                    99 non-null     int64  \n",
      " 22  亏损交易次数                    99 non-null     int64  \n",
      " 23  平均每次盈利                    99 non-null     float64\n",
      " 24  平均每次亏损                    99 non-null     float64\n",
      " 25  initial_capital           99 non-null     float64\n",
      " 26  final_capital             99 non-null     float64\n",
      " 27  total_return              99 non-null     float64\n",
      " 28  annualized_return         99 non-null     float64\n",
      " 29  max_drawdown              99 non-null     float64\n",
      " 30  sharpe_ratio              99 non-null     float64\n",
      " 31  calmar_ratio              99 non-null     float64\n",
      " 32  sortino_ratio             99 non-null     float64\n",
      " 33  total_trades              99 non-null     int64  \n",
      " 34  transaction_costs         99 non-null     float64\n",
      " 35  total_realized_pnl        99 non-null     float64\n",
      " 36  win_rate                  99 non-null     float64\n",
      " 37  profit_loss_ratio         99 non-null     float64\n",
      " 38  winning_trades_count      99 non-null     int64  \n",
      " 39  losing_trades_count       99 non-null     int64  \n",
      " 40  avg_profit_per_trade      99 non-null     float64\n",
      " 41  avg_loss_per_trade        99 non-null     float64\n",
      "dtypes: bool(1), float64(29), int64(10), object(2)\n",
      "memory usage: 31.9+ KB\n",
      "None\n",
      "\n",
      "--- 最优参数组合 (按total_return) ---\n",
      "main_symbol                          MA\n",
      "trade_volume                          1\n",
      "spectral_window_days                  2\n",
      "trend_strength_threshold            0.2\n",
      "order_direction             [BUY, SELL]\n",
      "enable_log                        False\n",
      "low_freq_days                         2\n",
      "high_freq_days                        1\n",
      "exit_threshold                      0.0\n",
      "初始资金                           100000.0\n",
      "最终资金                           101726.0\n",
      "总收益率                            0.01726\n",
      "年化收益率                          0.004924\n",
      "最大回撤                           0.006538\n",
      "夏普比率                           0.241619\n",
      "卡玛比率                           0.753058\n",
      "总交易次数                               174\n",
      "交易成本                                0.0\n",
      "总实现盈亏                            1725.0\n",
      "胜率                             0.586207\n",
      "盈亏比                            1.226912\n",
      "盈利交易次数                               51\n",
      "亏损交易次数                               36\n",
      "平均每次盈利                        79.647059\n",
      "平均每次亏损                       -64.916667\n",
      "initial_capital                100000.0\n",
      "final_capital                  101726.0\n",
      "total_return                    0.01726\n",
      "annualized_return              0.004924\n",
      "max_drawdown                   0.006538\n",
      "sharpe_ratio                   0.241619\n",
      "calmar_ratio                   0.753058\n",
      "sortino_ratio                  0.329565\n",
      "total_trades                        174\n",
      "transaction_costs                   0.0\n",
      "total_realized_pnl               1725.0\n",
      "win_rate                       0.586207\n",
      "profit_loss_ratio              1.226912\n",
      "winning_trades_count                 51\n",
      "losing_trades_count                  36\n",
      "avg_profit_per_trade          79.647059\n",
      "avg_loss_per_trade           -64.916667\n",
      "Name: 1, dtype: object\n",
      "\n",
      "--- 动态网格搜索完成 ---\n",
      "\n",
      "--- 最佳参数组合 ---\n",
      "  spectral_window_days: 2\n",
      "  trend_strength_threshold: 0.2\n",
      "  total_return: 0.0173\n",
      "[2, 12, 0.1, 0.9]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x800 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    }
   ],
   "execution_count": 5
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "quant",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}