NewQuant/src/strategies/KalmanStrategy/grid_search_multi_process.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "id": "782ec73f",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-09T15:22:17.269305Z",
     "start_time": "2025-11-09T15:22:17.246198Z"
    }
   },
   "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": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "cell_type": "code",
   "id": "298b8b26",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-09T15:22:17.288543Z",
     "start_time": "2025-11-09T15:22:17.273214Z"
    }
   },
   "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",
    "\n",
    "import builtins\n",
    "\n",
    "\n",
    "origin_print = print\n",
    "\n"
   ],
   "outputs": [],
   "execution_count": 8
  },
  {
   "cell_type": "code",
   "id": "76f9a2e9",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-09T15:22:17.305734Z",
     "start_time": "2025-11-09T15:22:17.291525Z"
    }
   },
   "source": [
    "\n",
    "# --- 单个回测任务函数 ---\n",
    "# 这个函数将在每个独立的进程中运行，因此它必须是自包含的\n"
   ],
   "outputs": [],
   "execution_count": 9
  },
  {
   "cell_type": "code",
   "id": "c0984689",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-09T15:22:17.322796Z",
     "start_time": "2025-11-09T15:22:17.308739Z"
    }
   },
   "source": [
    "\n",
    "def slient_print(*args):\n",
    "    pass\n"
   ],
   "outputs": [],
   "execution_count": 10
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-09T15:29:57.347468Z",
     "start_time": "2025-11-09T15:22:17.327802Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from src.strategies.KalmanStrategy.utils import run_single_backtest\n",
    "from src.strategies.KalmanStrategy.KalmanStrategy3 import DualModeKalmanStrategy\n",
    "# --- 主执行块 ---\n",
    "# 这是多进程代码的入口点，必须在 'if __name__ == \"__main__\":' 保护块中\n",
    "# 确保 autoreload 启用 (在Jupyter Notebook中使用，纯Python脚本运行时可移除)\n",
    "# %load_ext autoreload\n",
    "# %autoreload 2\n",
    "\n",
    "from src.strategies.ValueMigrationStrategy.ValueMigrationStrategy import ValueMigrationStrategy\n",
    "\n",
    "# --- 全局配置 ---\n",
    "data_file_path = \"D:/PyProject/NewQuant/data/data/KQ_m@CZCE_SA/KQ_m@CZCE_SA_min15.csv\"\n",
    "\n",
    "\n",
    "initial_capital = 100000.0\n",
    "slippage_rate = 0.0000\n",
    "commission_rate = 0.0001\n",
    "global_config = {\n",
    "    'symbol': 'SA',\n",
    "}\n",
    "# 确保每个合约的tick_size在这里定义或获取\n",
    "RB_TICK_SIZE = 1.0  # 螺纹钢的最小变动单位\n",
    "\n",
    "# --- 定义参数网格 ---\n",
    "param1_name = \"kalman_measurement_noise\"\n",
    "param1_values = generate_parameter_range(start=0.01, end=5.01, step=0.5)\n",
    "param2_name = \"entry_threshold_atr\"\n",
    "param2_values = generate_parameter_range(start=0.1, end=3.1, step=0.3)\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(2021, 1, 1),  # 回测起始时间\n",
    "    'end_time': datetime(2024, 1, 1),  # 回测结束时间\n",
    "    'roll_over_mode': True,  # 保持换月模式\n",
    "    'param1_name': param1_name,\n",
    "    'param2_name': param2_name,\n",
    "    'optimization_metric': optimization_metric,\n",
    "    'strategy': DualModeKalmanStrategy,\n",
    "    'order_direction': ['BUY', 'SELL'],\n",
    "    'stop_loss_tick': 5,\n",
    "    'strategy_mode': 'TREND'\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",
    "    # 使用 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_mesMAge': result_entry['error']\n",
    "                    }\n",
    "                )\n",
    "\n",
    "builtins.print = origin_print\n",
    "print(\"\\n--- 网格搜索回测完毕 ---\")"
   ],
   "id": "a5f8ff3d084c2349",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "总计 121 种参数组合需要回测。\n",
      "--- 启动多进程网格搜索，使用 12 个进程 ---\n",
      "\n",
      "--- 网格搜索回测完毕 ---\n"
     ]
    }
   ],
   "execution_count": 11
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-09T15:29:57.681195Z",
     "start_time": "2025-11-09T15:29:57.378952Z"
    }
   },
   "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": "b6838275ff519227",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 121 entries, 0 to 120\n",
      "Data columns (total 40 columns):\n",
      " #   Column                    Non-Null Count  Dtype  \n",
      "---  ------                    --------------  -----  \n",
      " 0   main_symbol               121 non-null    object \n",
      " 1   trade_volume              121 non-null    int64  \n",
      " 2   kalman_measurement_noise  121 non-null    float64\n",
      " 3   entry_threshold_atr       121 non-null    float64\n",
      " 4   order_direction           121 non-null    object \n",
      " 5   enable_log                121 non-null    bool   \n",
      " 6   strategy_mode             121 non-null    object \n",
      " 7   初始资金                      121 non-null    float64\n",
      " 8   最终资金                      121 non-null    float64\n",
      " 9   总收益率                      121 non-null    float64\n",
      " 10  年化收益率                     121 non-null    float64\n",
      " 11  最大回撤                      121 non-null    float64\n",
      " 12  夏普比率                      121 non-null    float64\n",
      " 13  卡玛比率                      121 non-null    float64\n",
      " 14  总交易次数                     121 non-null    int64  \n",
      " 15  交易成本                      121 non-null    float64\n",
      " 16  总实现盈亏                     121 non-null    float64\n",
      " 17  胜率                        121 non-null    float64\n",
      " 18  盈亏比                       121 non-null    float64\n",
      " 19  盈利交易次数                    121 non-null    int64  \n",
      " 20  亏损交易次数                    121 non-null    int64  \n",
      " 21  平均每次盈利                    121 non-null    float64\n",
      " 22  平均每次亏损                    121 non-null    float64\n",
      " 23  initial_capital           121 non-null    float64\n",
      " 24  final_capital             121 non-null    float64\n",
      " 25  total_return              121 non-null    float64\n",
      " 26  annualized_return         121 non-null    float64\n",
      " 27  max_drawdown              121 non-null    float64\n",
      " 28  sharpe_ratio              121 non-null    float64\n",
      " 29  calmar_ratio              121 non-null    float64\n",
      " 30  sortino_ratio             121 non-null    float64\n",
      " 31  total_trades              121 non-null    int64  \n",
      " 32  transaction_costs         121 non-null    float64\n",
      " 33  total_realized_pnl        121 non-null    float64\n",
      " 34  win_rate                  121 non-null    float64\n",
      " 35  profit_loss_ratio         121 non-null    float64\n",
      " 36  winning_trades_count      121 non-null    int64  \n",
      " 37  losing_trades_count       121 non-null    int64  \n",
      " 38  avg_profit_per_trade      121 non-null    float64\n",
      " 39  avg_loss_per_trade        121 non-null    float64\n",
      "dtypes: bool(1), float64(29), int64(7), object(3)\n",
      "memory usage: 37.1+ KB\n",
      "None\n",
      "\n",
      "--- 最优参数组合 (按total_return) ---\n",
      "main_symbol                          SA\n",
      "trade_volume                          1\n",
      "kalman_measurement_noise           0.01\n",
      "entry_threshold_atr                 0.7\n",
      "order_direction             [BUY, SELL]\n",
      "enable_log                        False\n",
      "strategy_mode                     TREND\n",
      "初始资金                           100000.0\n",
      "最终资金                        102764.3367\n",
      "总收益率                           0.027643\n",
      "年化收益率                           0.00633\n",
      "最大回撤                           0.007762\n",
      "夏普比率                           0.261089\n",
      "卡玛比率                           0.815491\n",
      "总交易次数                               124\n",
      "交易成本                            28.6633\n",
      "总实现盈亏                            2793.0\n",
      "胜率                             0.193548\n",
      "盈亏比                           11.262703\n",
      "盈利交易次数                               12\n",
      "亏损交易次数                               50\n",
      "平均每次盈利                       369.416667\n",
      "平均每次亏损                            -32.8\n",
      "initial_capital                100000.0\n",
      "final_capital               102764.3367\n",
      "total_return                   0.027643\n",
      "annualized_return               0.00633\n",
      "max_drawdown                   0.007762\n",
      "sharpe_ratio                   0.261089\n",
      "calmar_ratio                   0.815491\n",
      "sortino_ratio                  0.299849\n",
      "total_trades                        124\n",
      "transaction_costs               28.6633\n",
      "total_realized_pnl               2793.0\n",
      "win_rate                       0.193548\n",
      "profit_loss_ratio             11.262703\n",
      "winning_trades_count                 12\n",
      "losing_trades_count                  50\n",
      "avg_profit_per_trade         369.416667\n",
      "avg_loss_per_trade                -32.8\n",
      "Name: 2, dtype: object\n",
      "\n",
      "--- 动态网格搜索完成 ---\n",
      "\n",
      "--- 最佳参数组合 ---\n",
      "  kalman_measurement_noise: 0.01\n",
      "  entry_threshold_atr: 0.7\n",
      "  total_return: 0.0276\n",
      "[0.01, 5.01, 0.1, 3.1]\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": 12
  }
 ],
 "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
}