{
 "cells": [
  {
   "cell_type": "code",
   "id": "782ec73f",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-07T07:55:54.364036Z",
     "start_time": "2025-11-07T07:55:54.346679Z"
    }
   },
   "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-07T07:55:54.385222Z",
     "start_time": "2025-11-07T07:55:54.370043Z"
    }
   },
   "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-07T07:55:54.401394Z",
     "start_time": "2025-11-07T07:55:54.388328Z"
    }
   },
   "source": [
    "\n",
    "# --- 单个回测任务函数 ---\n",
    "# 这个函数将在每个独立的进程中运行，因此它必须是自包含的\n"
   ],
   "outputs": [],
   "execution_count": 9
  },
  {
   "cell_type": "code",
   "id": "c0984689",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-07T07:55:54.417453Z",
     "start_time": "2025-11-07T07:55:54.404008Z"
    }
   },
   "source": [
    "\n",
    "def slient_print(*args):\n",
    "    pass\n"
   ],
   "outputs": [],
   "execution_count": 10
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-11-07T07:59:14.620530Z",
     "start_time": "2025-11-07T07:55:54.421507Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from src.strategies.KalmanStrategy.utils import run_single_backtest\n",
    "from src.strategies.KalmanStrategy.KalmanStrategy2 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_MA/KQ_m@CZCE_MA_min15.csv\"\n",
    "\n",
    "\n",
    "initial_capital = 100000.0\n",
    "slippage_rate = 0.0000\n",
    "commission_rate = 0.0001\n",
    "global_config = {\n",
    "    'symbol': 'MA',\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(2022, 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': 'REVERSION'\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-07T07:59:14.871144Z",
     "start_time": "2025-11-07T07:59:14.632051Z"
    }
   },
   "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                          MA\n",
      "trade_volume                          1\n",
      "kalman_measurement_noise           0.51\n",
      "entry_threshold_atr                 0.7\n",
      "order_direction             [BUY, SELL]\n",
      "enable_log                        False\n",
      "strategy_mode                 REVERSION\n",
      "初始资金                           100000.0\n",
      "最终资金                        101025.8533\n",
      "总收益率                           0.010259\n",
      "年化收益率                          0.003559\n",
      "最大回撤                            0.00583\n",
      "夏普比率                           0.169574\n",
      "卡玛比率                           0.610437\n",
      "总交易次数                               542\n",
      "交易成本                           140.3901\n",
      "总实现盈亏                            1165.0\n",
      "胜率                             0.299242\n",
      "盈亏比                            3.075544\n",
      "盈利交易次数                               79\n",
      "亏损交易次数                              185\n",
      "平均每次盈利                        61.810127\n",
      "平均每次亏损                       -20.097297\n",
      "initial_capital                100000.0\n",
      "final_capital               101025.8533\n",
      "total_return                   0.010259\n",
      "annualized_return              0.003559\n",
      "max_drawdown                    0.00583\n",
      "sharpe_ratio                   0.169574\n",
      "calmar_ratio                   0.610437\n",
      "sortino_ratio                  0.211033\n",
      "total_trades                        542\n",
      "transaction_costs              140.3901\n",
      "total_realized_pnl               1165.0\n",
      "win_rate                       0.299242\n",
      "profit_loss_ratio              3.075544\n",
      "winning_trades_count                 79\n",
      "losing_trades_count                 185\n",
      "avg_profit_per_trade          61.810127\n",
      "avg_loss_per_trade           -20.097297\n",
      "Name: 13, dtype: object\n",
      "\n",
      "--- 动态网格搜索完成 ---\n",
      "\n",
      "--- 最佳参数组合 ---\n",
      "  kalman_measurement_noise: 0.51\n",
      "  entry_threshold_atr: 0.7\n",
      "  total_return: 0.0103\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
}