diff --git a/src/experiment/regression.ipynb b/src/experiment/regression.ipynb index b0680a3..84506b4 100644 --- a/src/experiment/regression.ipynb +++ b/src/experiment/regression.ipynb @@ -22,8 +22,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2026-03-07T16:27:36.008131Z", - "start_time": "2026-03-07T16:27:36.005668Z" + "end_time": "2026-03-07T17:05:52.792500Z", + "start_time": "2026-03-07T17:05:52.789046Z" } }, "source": [ @@ -48,7 +48,7 @@ "from src.training.config import TrainingConfig" ], "outputs": [], - "execution_count": 6 + "execution_count": 19 }, { "cell_type": "markdown", @@ -60,8 +60,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-03-07T16:27:36.020762Z", - "start_time": "2026-03-07T16:27:36.011650Z" + "end_time": "2026-03-07T17:05:52.800138Z", + "start_time": "2026-03-07T17:05:52.795957Z" } }, "cell_type": "code", @@ -121,7 +121,7 @@ " return data" ], "outputs": [], - "execution_count": 7 + "execution_count": 20 }, { "cell_type": "markdown", @@ -135,8 +135,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-03-07T16:27:36.027366Z", - "start_time": "2026-03-07T16:27:36.024465Z" + "end_time": "2026-03-07T17:05:52.808283Z", + "start_time": "2026-03-07T17:05:52.803432Z" } }, "cell_type": "code", @@ -174,7 +174,7 @@ "}" ], "outputs": [], - "execution_count": 8 + "execution_count": 21 }, { "cell_type": "markdown", @@ -187,14 +187,19 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2026-03-07T16:27:36.035196Z", - "start_time": "2026-03-07T16:27:36.031430Z" + "end_time": "2026-03-07T17:05:52.816594Z", + "start_time": "2026-03-07T17:05:52.811772Z" } }, "source": [ - "# 日期范围配置\n", + "# 日期范围配置（正确的 train/val/test 三分法）\n", + "# Train: 用于训练模型参数\n", + "# Val: 用于验证/早停/调参（位于 train 之后，test 之前）\n", + "# Test: 仅用于最终评估，完全独立于训练过程\n", "TRAIN_START = \"20200101\"\n", - "TRAIN_END = \"20241231\"\n", + "TRAIN_END = \"20231231\"\n", + "VAL_START = \"20240101\"\n", + "VAL_END = \"20241231\"\n", "TEST_START = \"20250101\"\n", "TEST_END = \"20251231\"\n", "\n", @@ -242,7 +247,7 @@ "PERSIST_MODEL = False" ], "outputs": [], - "execution_count": 9 + "execution_count": 22 }, { "cell_type": "markdown", @@ -257,8 +262,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2026-03-07T16:27:41.855565Z", - "start_time": "2026-03-07T16:27:36.040416Z" + "end_time": "2026-03-07T17:05:57.952733Z", + "start_time": "2026-03-07T17:05:52.822302Z" } }, "source": [ @@ -287,6 +292,7 @@ "\n", "# 4. 打印配置信息\n", "print(f\"\\n[配置] 训练期: {TRAIN_START} - {TRAIN_END}\")\n", + "print(f\"[配置] 验证期: {VAL_START} - {VAL_END}\")\n", "print(f\"[配置] 测试期: {TEST_START} - {TEST_END}\")\n", "print(f\"[配置] 特征数: {len(feature_cols)}\")\n", "print(f\"[配置] 目标变量: {target_col}\")\n", @@ -301,10 +307,13 @@ " StandardScaler(exclude_cols=[\"ts_code\", \"trade_date\", target_col]),\n", "]\n", "\n", - "# 7. 创建数据划分器\n", + "# 7. 创建数据划分器（正确的 train/val/test 三分法）\n", + "# Train: 训练模型参数 | Val: 验证/早停 | Test: 最终评估\n", "splitter = DateSplitter(\n", " train_start=TRAIN_START,\n", " train_end=TRAIN_END,\n", + " val_start=VAL_START,\n", + " val_end=VAL_END,\n", " test_start=TEST_START,\n", " test_end=TEST_END,\n", ")\n", @@ -396,31 +405,32 @@ "output_type": "stream", "text": [ "数据形状: (7044952, 24)\n", - "数据列: ['ts_code', 'trade_date', 'low', 'close', 'vol', 'high', 'total_mv', 'f_ann_date', 'n_income', 'ma5', 'ma10', 'ma20', 'ma_ratio', 'volatility_5', 'volatility_20', 'vol_ratio', 'return_10', 'return_20', 'return_diff', 'vol_ma5', 'vol_ma20', 'market_cap_rank', 'high_low_ratio', 'return_5']\n", + "数据列: ['ts_code', 'trade_date', 'close', 'vol', 'high', 'low', 'total_mv', 'f_ann_date', 'n_income', 'ma5', 'ma10', 'ma20', 'ma_ratio', 'volatility_5', 'volatility_20', 'vol_ratio', 'return_10', 'return_20', 'return_diff', 'vol_ma5', 'vol_ma20', 'market_cap_rank', 'high_low_ratio', 'return_5']\n", "\n", "前5行预览:\n", "shape: (5, 24)\n", - "┌───────────┬────────────┬─────────┬─────────┬───┬──────────┬─────────────┬────────────┬───────────┐\n", - "│ ts_code ┆ trade_date ┆ low ┆ close ┆ … ┆ vol_ma20 ┆ market_cap_ ┆ high_low_r ┆ return_5 │\n", - "│ --- ┆ --- ┆ --- ┆ --- ┆ ┆ --- ┆ rank ┆ atio ┆ --- │\n", - "│ str ┆ str ┆ f64 ┆ f64 ┆ ┆ f64 ┆ --- ┆ --- ┆ f64 │\n", - "│ ┆ ┆ ┆ ┆ ┆ ┆ f64 ┆ f64 ┆ │\n", - "╞═══════════╪════════════╪═════════╪═════════╪═══╪══════════╪═════════════╪════════════╪═══════════╡\n", - "│ 000001.SZ ┆ 20200102 ┆ 1806.75 ┆ 1841.69 ┆ … ┆ null ┆ 0.993583 ┆ null ┆ -0.004746 │\n", - "│ 000001.SZ ┆ 20200103 ┆ 1847.15 ┆ 1875.53 ┆ … ┆ null ┆ 0.993585 ┆ null ┆ -0.02852 │\n", - "│ 000001.SZ ┆ 20200106 ┆ 1846.05 ┆ 1863.52 ┆ … ┆ null ┆ 0.993588 ┆ null ┆ -0.004685 │\n", - "│ 000001.SZ ┆ 20200107 ┆ 1850.42 ┆ 1872.26 ┆ … ┆ null ┆ 0.993588 ┆ null ┆ -0.022743 │\n", - "│ 000001.SZ ┆ 20200108 ┆ 1815.49 ┆ 1818.76 ┆ … ┆ null ┆ 0.993586 ┆ null ┆ -0.008401 │\n", - "└───────────┴────────────┴─────────┴─────────┴───┴──────────┴─────────────┴────────────┴───────────┘\n", + "┌───────────┬────────────┬─────────┬───────────┬───┬──────────┬────────────┬───────────┬───────────┐\n", + "│ ts_code ┆ trade_date ┆ close ┆ vol ┆ … ┆ vol_ma20 ┆ market_cap ┆ high_low_ ┆ return_5 │\n", + "│ --- ┆ --- ┆ --- ┆ --- ┆ ┆ --- ┆ _rank ┆ ratio ┆ --- │\n", + "│ str ┆ str ┆ f64 ┆ f64 ┆ ┆ f64 ┆ --- ┆ --- ┆ f64 │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ f64 ┆ f64 ┆ │\n", + "╞═══════════╪════════════╪═════════╪═══════════╪═══╪══════════╪════════════╪═══════════╪═══════════╡\n", + "│ 000001.SZ ┆ 20200102 ┆ 1841.69 ┆ 1.5302e6 ┆ … ┆ null ┆ 0.993583 ┆ null ┆ -0.004746 │\n", + "│ 000001.SZ ┆ 20200103 ┆ 1875.53 ┆ 1.1162e6 ┆ … ┆ null ┆ 0.993585 ┆ null ┆ -0.02852 │\n", + "│ 000001.SZ ┆ 20200106 ┆ 1863.52 ┆ 862083.5 ┆ … ┆ null ┆ 0.993588 ┆ null ┆ -0.004685 │\n", + "│ 000001.SZ ┆ 20200107 ┆ 1872.26 ┆ 728607.56 ┆ … ┆ null ┆ 0.993588 ┆ null ┆ -0.022743 │\n", + "│ 000001.SZ ┆ 20200108 ┆ 1818.76 ┆ 847824.12 ┆ … ┆ null ┆ 0.993586 ┆ null ┆ -0.008401 │\n", + "└───────────┴────────────┴─────────┴───────────┴───┴──────────┴────────────┴───────────┴───────────┘\n", "\n", - "[配置] 训练期: 20200101 - 20241231\n", + "[配置] 训练期: 20200101 - 20231231\n", + "[配置] 验证期: 20240101 - 20241231\n", "[配置] 测试期: 20250101 - 20251231\n", "[配置] 特征数: 15\n", "[配置] 目标变量: return_5\n" ] } ], - "execution_count": 10 + "execution_count": 23 }, { "cell_type": "markdown", @@ -433,8 +443,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2026-03-07T16:27:48.155192Z", - "start_time": "2026-03-07T16:27:41.865012Z" + "end_time": "2026-03-07T17:06:05.023337Z", + "start_time": "2026-03-07T17:05:57.962781Z" } }, "source": [ @@ -478,35 +488,43 @@ ] } ], - "execution_count": 11 + "execution_count": 24 }, { "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2026-03-07T16:27:48.744530Z", - "start_time": "2026-03-07T16:27:48.163043Z" + "end_time": "2026-03-07T17:06:05.994624Z", + "start_time": "2026-03-07T17:06:05.030217Z" } }, "source": [ - "# 步骤 2: 划分训练/测试集\n", - "print(\"\\n[步骤 2/6] 划分训练集和测试集\")\n", + "# 步骤 2: 划分训练/验证/测试集（正确的三分法）\n", + "print(\"\\n[步骤 2/6] 划分训练集、验证集和测试集\")\n", "print(\"-\" * 60)\n", "if splitter:\n", - " train_data, test_data = splitter.split(filtered_data)\n", + " # 正确的三分法：train用于训练，val用于验证/早停，test仅用于最终评估\n", + " train_data, val_data, test_data = splitter.split(filtered_data)\n", " print(f\" 训练集数据规模: {train_data.shape}\")\n", + " print(f\" 验证集数据规模: {val_data.shape}\")\n", " print(f\" 测试集数据规模: {test_data.shape}\")\n", " print(f\" 训练集股票数: {train_data['ts_code'].n_unique()}\")\n", + " print(f\" 验证集股票数: {val_data['ts_code'].n_unique()}\")\n", " print(f\" 测试集股票数: {test_data['ts_code'].n_unique()}\")\n", " print(\n", " f\" 训练集日期范围: {train_data['trade_date'].min()} - {train_data['trade_date'].max()}\"\n", " )\n", " print(\n", + " f\" 验证集日期范围: {val_data['trade_date'].min()} - {val_data['trade_date'].max()}\"\n", + " )\n", + " print(\n", " f\" 测试集日期范围: {test_data['trade_date'].min()} - {test_data['trade_date'].max()}\"\n", " )\n", "\n", " print(\"\\n 训练集前5行预览:\")\n", " print(train_data.head())\n", + " print(\"\\n 验证集前5行预览:\")\n", + " print(val_data.head())\n", " print(\"\\n 测试集前5行预览:\")\n", " print(test_data.head())\n", "else:\n", @@ -520,55 +538,80 @@ "output_type": "stream", "text": [ "\n", - "[步骤 2/6] 划分训练集和测试集\n", + "[步骤 2/6] 划分训练集、验证集和测试集\n", "------------------------------------------------------------\n", - " 训练集数据规模: (3760991, 24)\n", + " 训练集数据规模: (2991506, 24)\n", + " 验证集数据规模: (769485, 24)\n", " 测试集数据规模: (771207, 24)\n", - " 训练集股票数: 3321\n", + " 训练集股票数: 3297\n", + " 验证集股票数: 3220\n", " 测试集股票数: 3215\n", - " 训练集日期范围: 20200102 - 20241231\n", + " 训练集日期范围: 20200102 - 20231229\n", + " 验证集日期范围: 20240102 - 20241231\n", " 测试集日期范围: 20250102 - 20251231\n", "\n", " 训练集前5行预览:\n", "shape: (5, 24)\n", - "┌───────────┬────────────┬─────────┬─────────┬───┬──────────┬─────────────┬────────────┬───────────┐\n", - "│ ts_code ┆ trade_date ┆ low ┆ close ┆ … ┆ vol_ma20 ┆ market_cap_ ┆ high_low_r ┆ return_5 │\n", - "│ --- ┆ --- ┆ --- ┆ --- ┆ ┆ --- ┆ rank ┆ atio ┆ --- │\n", - "│ str ┆ str ┆ f64 ┆ f64 ┆ ┆ f64 ┆ --- ┆ --- ┆ f64 │\n", - "│ ┆ ┆ ┆ ┆ ┆ ┆ f64 ┆ f64 ┆ │\n", - "╞═══════════╪════════════╪═════════╪═════════╪═══╪══════════╪═════════════╪════════════╪═══════════╡\n", - "│ 000001.SZ ┆ 20200102 ┆ 1806.75 ┆ 1841.69 ┆ … ┆ null ┆ 0.993583 ┆ null ┆ -0.004746 │\n", - "│ 000002.SZ ┆ 20200102 ┆ 4824.87 ┆ 4832.29 ┆ … ┆ null ┆ 0.99492 ┆ null ┆ -0.011057 │\n", - "│ 000004.SZ ┆ 20200102 ┆ 90.1 ┆ 90.75 ┆ … ┆ null ┆ 0.057219 ┆ null ┆ -0.000441 │\n", - "│ 000005.SZ ┆ 20200102 ┆ 28.82 ┆ 29.1 ┆ … ┆ null ┆ 0.28984 ┆ null ┆ 0.022337 │\n", - "│ 000006.SZ ┆ 20200102 ┆ 190.24 ┆ 191.3 ┆ … ┆ null ┆ 0.631551 ┆ null ┆ 0.012964 │\n", - "└───────────┴────────────┴─────────┴─────────┴───┴──────────┴─────────────┴────────────┴───────────┘\n", + "┌───────────┬────────────┬─────────┬───────────┬───┬──────────┬────────────┬───────────┬───────────┐\n", + "│ ts_code ┆ trade_date ┆ close ┆ vol ┆ … ┆ vol_ma20 ┆ market_cap ┆ high_low_ ┆ return_5 │\n", + "│ --- ┆ --- ┆ --- ┆ --- ┆ ┆ --- ┆ _rank ┆ ratio ┆ --- │\n", + "│ str ┆ str ┆ f64 ┆ f64 ┆ ┆ f64 ┆ --- ┆ --- ┆ f64 │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ f64 ┆ f64 ┆ │\n", + "╞═══════════╪════════════╪═════════╪═══════════╪═══╪══════════╪════════════╪═══════════╪═══════════╡\n", + "│ 000001.SZ ┆ 20200102 ┆ 1841.69 ┆ 1.5302e6 ┆ … ┆ null ┆ 0.993583 ┆ null ┆ -0.004746 │\n", + "│ 000002.SZ ┆ 20200102 ┆ 4832.29 ┆ 1012130.4 ┆ … ┆ null ┆ 0.99492 ┆ null ┆ -0.011057 │\n", + "│ 000004.SZ ┆ 20200102 ┆ 90.75 ┆ 17853.2 ┆ … ┆ null ┆ 0.057219 ┆ null ┆ -0.000441 │\n", + "│ 000005.SZ ┆ 20200102 ┆ 29.1 ┆ 104134.12 ┆ … ┆ null ┆ 0.28984 ┆ null ┆ 0.022337 │\n", + "│ 000006.SZ ┆ 20200102 ┆ 191.3 ┆ 124751.76 ┆ … ┆ null ┆ 0.631551 ┆ null ┆ 0.012964 │\n", + "└───────────┴────────────┴─────────┴───────────┴───┴──────────┴────────────┴───────────┴───────────┘\n", + "\n", + " 验证集前5行预览:\n", + "shape: (5, 24)\n", + "┌───────────┬────────────┬─────────┬───────────┬───┬───────────┬───────────┬───────────┬───────────┐\n", + "│ ts_code ┆ trade_date ┆ close ┆ vol ┆ … ┆ vol_ma20 ┆ market_ca ┆ high_low_ ┆ return_5 │\n", + "│ --- ┆ --- ┆ --- ┆ --- ┆ ┆ --- ┆ p_rank ┆ ratio ┆ --- │\n", + "│ str ┆ str ┆ f64 ┆ f64 ┆ ┆ f64 ┆ --- ┆ --- ┆ f64 │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ f64 ┆ f64 ┆ │\n", + "╞═══════════╪════════════╪═════════╪═══════════╪═══╪═══════════╪═══════════╪═══════════╪═══════════╡\n", + "│ 000001.SZ ┆ 20240102 ┆ 1074.93 ┆ 1.1584e6 ┆ … ┆ 861841.07 ┆ 0.990616 ┆ 0.349245 ┆ -0.003256 │\n", + "│ ┆ ┆ ┆ ┆ ┆ 5 ┆ ┆ ┆ │\n", + "│ 000002.SZ ┆ 20240102 ┆ 1844.3 ┆ 811106.29 ┆ … ┆ 636017.52 ┆ 0.981982 ┆ 0.056113 ┆ -0.026601 │\n", + "│ ┆ ┆ ┆ ┆ ┆ 9 ┆ ┆ ┆ │\n", + "│ 000004.SZ ┆ 20240102 ┆ 65.59 ┆ 28867.0 ┆ … ┆ 45538.156 ┆ 0.07789 ┆ 0.297557 ┆ -0.014789 │\n", + "│ 000005.SZ ┆ 20240102 ┆ 10.38 ┆ 63028.0 ┆ … ┆ 146027.22 ┆ 0.017643 ┆ 0.301508 ┆ -0.05395 │\n", + "│ ┆ ┆ ┆ ┆ ┆ 7 ┆ ┆ ┆ │\n", + "│ 000006.SZ ┆ 20240102 ┆ 177.64 ┆ 261947.19 ┆ … ┆ 313782.29 ┆ 0.54955 ┆ 0.215557 ┆ -0.013454 │\n", + "│ ┆ ┆ ┆ ┆ ┆ 25 ┆ ┆ ┆ │\n", + "└───────────┴────────────┴─────────┴───────────┴───┴───────────┴───────────┴───────────┴───────────┘\n", "\n", " 测试集前5行预览:\n", "shape: (5, 24)\n", - "┌───────────┬────────────┬─────────┬─────────┬───┬────────────┬────────────┬───────────┬───────────┐\n", - "│ ts_code ┆ trade_date ┆ low ┆ close ┆ … ┆ vol_ma20 ┆ market_cap ┆ high_low_ ┆ return_5 │\n", - "│ --- ┆ --- ┆ --- ┆ --- ┆ ┆ --- ┆ _rank ┆ ratio ┆ --- │\n", - "│ str ┆ str ┆ f64 ┆ f64 ┆ ┆ f64 ┆ --- ┆ --- ┆ f64 │\n", - "│ ┆ ┆ ┆ ┆ ┆ ┆ f64 ┆ f64 ┆ │\n", - "╞═══════════╪════════════╪═════════╪═════════╪═══╪════════════╪════════════╪═══════════╪═══════════╡\n", - "│ 000001.SZ ┆ 20250102 ┆ 1455.46 ┆ 1460.57 ┆ … ┆ 1.2151e6 ┆ 0.991617 ┆ 0.063478 ┆ -0.002622 │\n", - "│ 000002.SZ ┆ 20250102 ┆ 1284.65 ┆ 1291.92 ┆ … ┆ 1.2839e6 ┆ 0.970007 ┆ 0.020839 ┆ -0.022509 │\n", - "│ 000004.SZ ┆ 20250102 ┆ 54.17 ┆ 57.63 ┆ … ┆ 159807.918 ┆ 0.099106 ┆ 0.131858 ┆ -0.064897 │\n", - "│ 000006.SZ ┆ 20250102 ┆ 285.33 ┆ 288.12 ┆ … ┆ 404264.211 ┆ 0.72392 ┆ 0.028423 ┆ -0.048278 │\n", - "│ 000007.SZ ┆ 20250102 ┆ 57.49 ┆ 58.15 ┆ … ┆ 88380.2845 ┆ 0.183495 ┆ 0.391829 ┆ 0.015649 │\n", - "└───────────┴────────────┴─────────┴─────────┴───┴────────────┴────────────┴───────────┴───────────┘\n" + "┌───────────┬────────────┬─────────┬───────────┬───┬───────────┬───────────┬───────────┬───────────┐\n", + "│ ts_code ┆ trade_date ┆ close ┆ vol ┆ … ┆ vol_ma20 ┆ market_ca ┆ high_low_ ┆ return_5 │\n", + "│ --- ┆ --- ┆ --- ┆ --- ┆ ┆ --- ┆ p_rank ┆ ratio ┆ --- │\n", + "│ str ┆ str ┆ f64 ┆ f64 ┆ ┆ f64 ┆ --- ┆ --- ┆ f64 │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ f64 ┆ f64 ┆ │\n", + "╞═══════════╪════════════╪═════════╪═══════════╪═══╪═══════════╪═══════════╪═══════════╪═══════════╡\n", + "│ 000001.SZ ┆ 20250102 ┆ 1460.57 ┆ 1.8196e6 ┆ … ┆ 1.2151e6 ┆ 0.991617 ┆ 0.063478 ┆ -0.002622 │\n", + "│ 000002.SZ ┆ 20250102 ┆ 1291.92 ┆ 1.1827e6 ┆ … ┆ 1.2839e6 ┆ 0.970007 ┆ 0.020839 ┆ -0.022509 │\n", + "│ 000004.SZ ┆ 20250102 ┆ 57.63 ┆ 119760.37 ┆ … ┆ 159807.91 ┆ 0.099106 ┆ 0.131858 ┆ -0.064897 │\n", + "│ ┆ ┆ ┆ ┆ ┆ 8 ┆ ┆ ┆ │\n", + "│ 000006.SZ ┆ 20250102 ┆ 288.12 ┆ 307195.1 ┆ … ┆ 404264.21 ┆ 0.72392 ┆ 0.028423 ┆ -0.048278 │\n", + "│ ┆ ┆ ┆ ┆ ┆ 1 ┆ ┆ ┆ │\n", + "│ 000007.SZ ┆ 20250102 ┆ 58.15 ┆ 68219.01 ┆ … ┆ 88380.284 ┆ 0.183495 ┆ 0.391829 ┆ 0.015649 │\n", + "│ ┆ ┆ ┆ ┆ ┆ 5 ┆ ┆ ┆ │\n", + "└───────────┴────────────┴─────────┴───────────┴───┴───────────┴───────────┴───────────┴───────────┘\n" ] } ], - "execution_count": 12 + "execution_count": 25 }, { "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2026-03-07T16:27:49.562499Z", - "start_time": "2026-03-07T16:27:48.753734Z" + "end_time": "2026-03-07T17:06:06.818724Z", + "start_time": "2026-03-07T17:06:06.002551Z" } }, "source": [ @@ -612,50 +655,50 @@ "[步骤 3/6] 训练集数据处理\n", "------------------------------------------------------------\n", " [1/3] 应用处理器: NullFiller\n", - " 处理前记录数: 3760991\n", - " 处理后记录数: 3760991\n", + " 处理前记录数: 2991506\n", + " 处理后记录数: 2991506\n", " [2/3] 应用处理器: Winsorizer\n", - " 处理前记录数: 3760991\n", - " 处理后记录数: 3760991\n", + " 处理前记录数: 2991506\n", + " 处理后记录数: 2991506\n", " [3/3] 应用处理器: StandardScaler\n", - " 处理前记录数: 3760991\n", - " 处理后记录数: 3760991\n", + " 处理前记录数: 2991506\n", + " 处理后记录数: 2991506\n", "\n", " 训练集处理后前5行预览:\n", "shape: (5, 24)\n", - "┌───────────┬────────────┬───────────┬──────────┬───┬──────────┬───────────┬───────────┬───────────┐\n", - "│ ts_code ┆ trade_date ┆ low ┆ close ┆ … ┆ vol_ma20 ┆ market_ca ┆ high_low_ ┆ return_5 │\n", - "│ --- ┆ --- ┆ --- ┆ --- ┆ ┆ --- ┆ p_rank ┆ ratio ┆ --- │\n", - "│ str ┆ str ┆ f64 ┆ f64 ┆ ┆ f64 ┆ --- ┆ --- ┆ f64 │\n", - "│ ┆ ┆ ┆ ┆ ┆ ┆ f64 ┆ f64 ┆ │\n", - "╞═══════════╪════════════╪═══════════╪══════════╪═══╪══════════╪═══════════╪═══════════╪═══════════╡\n", - "│ 000001.SZ ┆ 20200102 ┆ 7.215424 ┆ 7.219817 ┆ … ┆ null ┆ 1.579213 ┆ null ┆ -0.004746 │\n", - "│ 000002.SZ ┆ 20200102 ┆ 7.215424 ┆ 7.219817 ┆ … ┆ null ┆ 1.579213 ┆ null ┆ -0.011057 │\n", - "│ 000004.SZ ┆ 20200102 ┆ 0.118662 ┆ 0.111432 ┆ … ┆ null ┆ -1.671014 ┆ null ┆ -0.000441 │\n", - "│ 000005.SZ ┆ 20200102 ┆ -0.292838 ┆ -0.29447 ┆ … ┆ null ┆ -0.862878 ┆ null ┆ 0.022337 │\n", - "│ 000006.SZ ┆ 20200102 ┆ 0.791109 ┆ 0.77345 ┆ … ┆ null ┆ 0.324248 ┆ null ┆ 0.012964 │\n", - "└───────────┴────────────┴───────────┴──────────┴───┴──────────┴───────────┴───────────┴───────────┘\n", + "┌───────────┬───────────┬───────────┬───────────┬───┬──────────┬───────────┬───────────┬───────────┐\n", + "│ ts_code ┆ trade_dat ┆ close ┆ vol ┆ … ┆ vol_ma20 ┆ market_ca ┆ high_low_ ┆ return_5 │\n", + "│ --- ┆ e ┆ --- ┆ --- ┆ ┆ --- ┆ p_rank ┆ ratio ┆ --- │\n", + "│ str ┆ --- ┆ f64 ┆ f64 ┆ ┆ f64 ┆ --- ┆ --- ┆ f64 │\n", + "│ ┆ str ┆ ┆ ┆ ┆ ┆ f64 ┆ f64 ┆ │\n", + "╞═══════════╪═══════════╪═══════════╪═══════════╪═══╪══════════╪═══════════╪═══════════╪═══════════╡\n", + "│ 000001.SZ ┆ 20200102 ┆ 7.139221 ┆ 4.749919 ┆ … ┆ null ┆ 1.59168 ┆ null ┆ -0.004746 │\n", + "│ 000002.SZ ┆ 20200102 ┆ 7.139221 ┆ 2.92576 ┆ … ┆ null ┆ 1.59168 ┆ null ┆ -0.011057 │\n", + "│ 000004.SZ ┆ 20200102 ┆ 0.095339 ┆ -0.574944 ┆ … ┆ null ┆ -1.639529 ┆ null ┆ -0.000441 │\n", + "│ 000005.SZ ┆ 20200102 ┆ -0.301277 ┆ -0.271162 ┆ … ┆ null ┆ -0.835937 ┆ null ┆ 0.022337 │\n", + "│ 000006.SZ ┆ 20200102 ┆ 0.742213 ┆ -0.19857 ┆ … ┆ null ┆ 0.344511 ┆ null ┆ 0.012964 │\n", + "└───────────┴───────────┴───────────┴───────────┴───┴──────────┴───────────┴───────────┴───────────┘\n", "\n", " 训练集特征统计:\n", " 特征数: 15\n", - " 样本数: 3760991\n", + " 样本数: 2991506\n", " 缺失值统计:\n", - " ma5: 11541 (0.31%)\n", - " ma10: 25950 (0.69%)\n", - " ma20: 54850 (1.46%)\n", - " ma_ratio: 54850 (1.46%)\n", - " volatility_5: 11541 (0.31%)\n" + " ma5: 11541 (0.39%)\n", + " ma10: 25950 (0.87%)\n", + " ma20: 54850 (1.83%)\n", + " ma_ratio: 54850 (1.83%)\n", + " volatility_5: 11541 (0.39%)\n" ] } ], - "execution_count": 13 + "execution_count": 26 }, { "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2026-03-07T16:28:09.621524Z", - "start_time": "2026-03-07T16:27:49.566330Z" + "end_time": "2026-03-07T17:06:20.427156Z", + "start_time": "2026-03-07T17:06:06.824957Z" } }, "source": [ @@ -690,15 +733,15 @@ "[步骤 4/6] 训练模型\n", "------------------------------------------------------------\n", " 模型类型: LightGBM\n", - " 训练样本数: 3760991\n", + " 训练样本数: 2991506\n", " 特征数: 15\n", " 目标变量: return_5\n", "\n", " 目标变量统计:\n", - " 均值: 0.001511\n", - " 标准差: 0.062515\n", - " 最小值: -0.165141\n", - " 最大值: 0.225065\n", + " 均值: 0.001610\n", + " 标准差: 0.059623\n", + " 最小值: -0.155098\n", + " 最大值: 0.212842\n", " 缺失值: 0\n", "\n", " 开始训练...\n", @@ -706,14 +749,14 @@ ] } ], - "execution_count": 14 + "execution_count": 27 }, { "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2026-03-07T16:28:09.687281Z", - "start_time": "2026-03-07T16:28:09.625395Z" + "end_time": "2026-03-07T17:06:20.555487Z", + "start_time": "2026-03-07T17:06:20.431885Z" } }, "source": [ @@ -753,14 +796,14 @@ ] } ], - "execution_count": 15 + "execution_count": 28 }, { "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2026-03-07T16:28:10.718020Z", - "start_time": "2026-03-07T16:28:09.691077Z" + "end_time": "2026-03-07T17:06:21.654690Z", + "start_time": "2026-03-07T17:06:20.570580Z" } }, "source": [ @@ -795,28 +838,214 @@ " 预测完成！\n", "\n", " 预测结果统计:\n", - " 均值: 0.000635\n", - " 标准差: 0.006529\n", - " 最小值: -0.125836\n", - " 最大值: 0.149914\n" + " 均值: 0.000689\n", + " 标准差: 0.006131\n", + " 最小值: -0.114917\n", + " 最大值: 0.122962\n" ] } ], - "execution_count": 16 + "execution_count": 29 }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### 4.3 查看结果" + "### 4.3 训练指标曲线" ] }, { "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2026-03-07T16:28:10.746425Z", - "start_time": "2026-03-07T16:28:10.723160Z" + "end_time": "2026-03-07T17:06:27.993171Z", + "start_time": "2026-03-07T17:06:21.659478Z" + } + }, + "source": [ + "print(\"\\n\" + \"=\" * 80)\n", + "print(\"训练指标曲线\")\n", + "print(\"=\" * 80)\n", + "\n", + "# 重新训练以收集指标（因为之前的训练没有保存评估结果）\n", + "print(\"\\n重新训练模型以收集训练指标...\")\n", + "\n", + "import lightgbm as lgb\n", + "\n", + "# 准备数据（使用 val 做验证，test 不参与训练过程）\n", + "X_train_np = X_train.to_numpy()\n", + "y_train_np = y_train.to_numpy()\n", + "X_val_np = val_data.select(feature_cols).to_numpy()\n", + "y_val_np = val_data.select(target_col).to_series().to_numpy()\n", + "\n", + "# 创建数据集\n", + "train_dataset = lgb.Dataset(X_train_np, label=y_train_np)\n", + "val_dataset = lgb.Dataset(X_val_np, label=y_val_np, reference=train_dataset)\n", + "\n", + "# 用于存储评估结果\n", + "evals_result = {}\n", + "\n", + "# 使用与原模型相同的参数重新训练\n", + "# 正确的三分法：train用于训练，val用于验证，test不参与训练过程\n", + "# 添加早停：如果验证指标连续100轮没有改善则停止训练\n", + "booster_with_eval = lgb.train(\n", + " MODEL_PARAMS,\n", + " train_dataset,\n", + " num_boost_round=MODEL_PARAMS.get(\"n_estimators\", 100),\n", + " valid_sets=[train_dataset, val_dataset],\n", + " valid_names=[\"train\", \"val\"],\n", + " callbacks=[\n", + " lgb.record_evaluation(evals_result),\n", + " lgb.early_stopping(stopping_rounds=100, verbose=True),\n", + " ],\n", + ")\n", + "\n", + "print(\"训练完成，指标已收集\")\n", + "\n", + "# 获取指标名称\n", + "metric_name = list(evals_result[\"train\"].keys())[0]\n", + "print(f\"\\n评估指标: {metric_name}\")\n", + "\n", + "# 提取训练和验证指标\n", + "train_metric = evals_result[\"train\"][metric_name]\n", + "val_metric = evals_result[\"val\"][metric_name]\n", + "\n", + "# 显示早停信息\n", + "actual_rounds = len(train_metric)\n", + "expected_rounds = MODEL_PARAMS.get(\"n_estimators\", 100)\n", + "print(f\"\\n[早停信息]\")\n", + "print(f\" 配置的最大轮数: {expected_rounds}\")\n", + "print(f\" 实际训练轮数: {actual_rounds}\")\n", + "if actual_rounds < expected_rounds:\n", + " print(f\" 早停状态: 已触发（连续100轮验证指标未改善）\")\n", + "else:\n", + " print(f\" 早停状态: 未触发（达到最大轮数）\")\n", + "\n", + "print(f\"\\n最终指标:\")\n", + "print(f\" 训练 {metric_name}: {train_metric[-1]:.6f}\")\n", + "print(f\" 验证 {metric_name}: {val_metric[-1]:.6f}\")" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "================================================================================\n", + "训练指标曲线\n", + "================================================================================\n", + "\n", + "重新训练模型以收集训练指标...\n", + "Training until validation scores don't improve for 100 rounds\n", + "Early stopping, best iteration is:\n", + "[264]\ttrain's l1: 0.0425269\tval's l1: 0.0537147\n", + "训练完成，指标已收集\n", + "\n", + "评估指标: l1\n", + "\n", + "[早停信息]\n", + " 配置的最大轮数: 1000\n", + " 实际训练轮数: 364\n", + " 早停状态: 已触发（连续100轮验证指标未改善）\n", + "\n", + "最终指标:\n", + " 训练 l1: 0.042479\n", + " 验证 l1: 0.053722\n" + ] + } + ], + "execution_count": 30 + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-03-07T17:06:28.093700Z", + "start_time": "2026-03-07T17:06:27.999580Z" + } + }, + "source": [ + "# 绘制训练指标曲线\n", + "import matplotlib.pyplot as plt\n", + "\n", + "fig, ax = plt.subplots(figsize=(12, 6))\n", + "\n", + "# 绘制训练集和验证集的指标曲线（注意：val用于验证，test不参与训练）\n", + "iterations = range(1, len(train_metric) + 1)\n", + "ax.plot(iterations, train_metric, label=f\"Train {metric_name}\", linewidth=2, color=\"blue\")\n", + "ax.plot(iterations, val_metric, label=f\"Validation {metric_name}\", linewidth=2, color=\"red\")\n", + "\n", + "ax.set_xlabel(\"Iteration\", fontsize=12)\n", + "ax.set_ylabel(metric_name.upper(), fontsize=12)\n", + "ax.set_title(f\"Training and Validation {metric_name.upper()} Curve\", fontsize=14, fontweight=\"bold\")\n", + "ax.legend(fontsize=10)\n", + "ax.grid(True, alpha=0.3)\n", + "\n", + "# 标记最佳验证指标点（用于早停决策）\n", + "best_iter = val_metric.index(min(val_metric))\n", + "best_metric = min(val_metric)\n", + "ax.axvline(x=best_iter + 1, color=\"green\", linestyle=\"--\", alpha=0.7, label=f\"Best Iteration ({best_iter + 1})\")\n", + "ax.scatter([best_iter + 1], [best_metric], color=\"green\", s=100, zorder=5)\n", + "ax.annotate(\n", + " f\"Best: {best_metric:.6f}\\nIter: {best_iter + 1}\",\n", + " xy=(best_iter + 1, best_metric),\n", + " xytext=(best_iter + 1 + len(iterations) * 0.1, best_metric),\n", + " fontsize=9,\n", + " arrowprops=dict(arrowstyle=\"->\", color=\"green\", alpha=0.7),\n", + ")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(f\"\\n[指标分析]\")\n", + "print(f\" 最佳验证 {metric_name}: {best_metric:.6f}\")\n", + "print(f\" 最佳迭代轮数: {best_iter + 1}\")\n", + "print(f\" 早停建议: 如果验证指标连续10轮不下降，建议在第 {best_iter + 1} 轮停止训练\")\n", + "print(f\"\\n[重要提醒] 验证集仅用于早停/调参，测试集完全独立于训练过程！\")" + ], + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAJOCAYAAABm7rQwAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAd2RJREFUeJzt3Ql8E2X+x/Ff2vTgKne5b1BOQU7BAxQWUBQ5RMWDQ/4oKCqiqCByiLvIriKoKJ6ouwhYFV0VcRHUVUARQVlQVFwROcshN73zf/0enGySpm3SNNOk/bx9jZlMJpPJ9Omk+fJ7nnG4XC6XAAAAAAAAADaKsfPFAAAAAAAAAEUoBQAAAAAAANsRSgEAAAAAAMB2hFIAAAAAAACwHaEUAAAAAAAAbEcoBQAAAAAAANsRSgEAAAAAAMB2hFIAAAAAAACwHaEUAAAAAAAAbEcoBQBABHr55ZfF4XC4p6LQsGFD9/amT59eJNssqfT4WMdKj1sk8mwf2l5CbTvF8Z7D0c4BAED0IJQCAMBPaBPo9Mknn3D8II888ohXu1i/fn2eR2XkyJHu9eLj4+XAgQMl8giWlMDJM6zTaceOHQU+Z+XKlXLnnXdKt27dpGzZskE/Py8ul0uWL18uN954o5x11lmSlJQkcXFxUqNGDenZs6fMnj1b9u7dW+jtAwBgN6ftrwgAAArUqVMn+dvf/lakR+qBBx6Qo0ePmnn9soyioyGBHt+cnBxz/+9//7t07tw513qnT5+WN998032/X79+Ur169YhvO+ESTfsajPnz58s777xTpNv87bff5LrrrpPPP/8812OpqamyevVqM33//fdelXMAAEQyQikAAPyENur333+Xv/zlL+77f/rTn6R3795ex6tJkyZ5Hr9jx46ZSobCaNWqlZmK0ujRo4t0e/ifOnXqmPbx4YcfmvtLliyROXPmmCoWT8uWLZPjx4+7748YMaLID2M42k64RNO+BkMrourWrSsdO3aU7Oxseffdd0Pa3v79+6V79+7yyy+/uJc1atRI+vfvb6qk9Fz1xRdf+A2sipq+n/T0dFMBBgBAqOi+BwCAR2hzzz33uCffEEerizwfv+qqq6R+/fpeXflefPFFad++vZQpU0Yuuugi8zz9Ijl+/Hi58MILpV69elKuXDlJSEgwQcYVV1zh9wtrfl2fevTo4V6uocZPP/0kQ4cOlWrVqkliYqJ5fX9VGnmNKaX77fla//3vf+Xpp5+Wc845x2wvOTlZ/u///s988fV16tQpmTRpkjkOuq4GDAsWLDDvuTDdHHW9UaNGmfdQq1Ytc5z0y2/Tpk1Nt7f//Oc/uZ6jx8B6HT022n3p5ptvdj+/RYsW8vzzz/t9Pd3e5ZdfbsJDnfr27SsbN26UwtD9sxw8eFA++OCDXOtoBZVFj6tWSimtFhowYIDpklWlShUTZlWqVMlUW/35z3+WkydPFlm3ucK8Zw3TtBpM24SGINrtsHz58tKyZUsZN26cV5c0ndfX9TweynOfrPZX0L5qZdnjjz8u559/vlSuXNm8rr7+ZZddJq+//nqu9UNpy0XptddeM5VNetwGDRoU8vb0/OEZSI0dO1Z+/PFHmTt3rvn9++tf/yr//ve/5YcffjDhaF6/G/kdK8+foe/zdu7caX7+euy1beoxLej3u0uXLu7Hfc+l3377rdx0000m1Ndzpbalc8891/wjQDBtHQBQArgAAIBfv/zyi0s/Kq1p2rRp+T5+4YUXet1v27atWe/dd9/1Wu5vmjFjhte2Fy5c6PW4p+7du7uXn3POOa4KFSrk2p7D4XB99NFHXs9r0KCB3/fy8ccfez33ggsu8LuPF110kdf2MjIycr1na7riiiu87utrBOLuu+/O9zjFx8e7Vq5c6fWc4cOHux9v3Lixq1atWn6f++KLL3o976uvvnKVL18+13qJiYmunj17uu/rcQtEWlqaq1KlSu7nXXXVVV6P79271xUbG+t+/K677nI/VrVq1Xzfd5s2bVzHjx/32p7n49peAmk7hX3PgwcPznf/kpKSXJs3b/b7e+Fvstpffvuqx6tVq1b5bkf3KzMzM+S2nB/dV8/n6vsLhu97DPb5e/bsMb/P1vPbtWvnys7ODui5nr8bet7w5HusPPfL83nNmjVz1axZ02vdZcuWef3u33zzzV7b3r59u9f6a9eudT/29NNPu5xOZ54/05YtW5qfPQCgdKD7HgAAReSzzz6TBg0ayODBg011j47zopxOp7Rr18505dHxg7Q6RasB1qxZIx9//LFZZ+bMmaZCSKungrF582ZTQXLXXXeZqhKtCNLuNZpZaPWNDn4cLO0CpM/TyrC3337bXZ2klRjaRei8884z9+fNm2fes0WrUa688kpTBfHPf/5TCkOryLSbUps2bUzFkFZRHDp0SN5//30zVk5GRobccccd8t133/l9vlbGaEWMVpLoc5955hlzXJRWk2h1htLjo/MnTpww97WaQ8fr0WoyHfNp1apVQe+7VmVde+21plJMaQXckSNHTMWTVT2jPxt/Xfe0q9fFF19s2o/+PHX/tDJm6dKlpq3oz0CrU+69914prFDes74H7bqqVWdWxZJ2KdNKIK2i0a6q9913nxmEW39u2vY2bNhg9t/iOXZUIGOaXX/99bJ161b3fa1M1MosHUR83bp1Zpnut1bXTJ06NaS2HMn0HHEmgzxj+PDhEhNjX2cHrcRUWvHVtm1b+fXXX6VixYqmEs76/X/jjTfkqaeecndXXbx4sfv5zZs3l65du5r5tWvXmso6a+w1Pf5aqaddWl955RVTYai/28OGDZN//etftr1HAEDxIZQCAKCI6Bgv2g3KCiEs+qVLJ+1us2nTJnO1Nf3ypl2QvvzyS9MFLisrywxSrF1kgqHBgoYJ2vVFaSCjXXrUV199Vaj3MXDgQPNlX7et3Ya0y5MVpug2rS/yL7zwgvs5Gmzol3wNgqzARb9kBmvGjBnmC6sGGhpCaaijXYYuvfRSc1/prXaN0q6Q/uh4ThqOKe1WqO9Badcm/fJboUIFc9w9uwLqeGIaDCoNfrRbkX5BDpZ+UbdCKR13R7uYaVdC3657+vPSEM/yzTffmPHM9Eu7hjwaRGkA1KFDBxOgKB2vKpRQKpT3rD/rzMxM8zPWkEJDKA3SNPBZuHChWUfbr66joat2b9WueZ6hlC4LlB4P3Z5F90+vLKc0gNKusFYwpeHolClT/AY1gbblSLZ7926v+xry2E3PKXo1QU/aRjUg1pDz8OHDpn1qt1DfUMqzG+ejjz7qDqS0W6Ceu6yf2zXXXOO+OIAGjxq4e/6OAABKJkIpAACKyG233ZYrkFI6VotWfWjgkJ9du3YF/ZpagWAFUurss892zxd23BytMrLG99GqFx2rSqtiPLepX0Q15LEMGTLEHUhZX0QLE0rpl1Ed80eDmYKOlb9Qqnbt2u5Ayvd4WPuvoZSGXp7052PRUEXH+rLClmDol2qt5rEquTSI0lBqy5YtJmjx90Vdv6Tff//9JlzRSrD83nMoQnnPixYtMqFOfkGdhnD6uI7lFSorcPKsDrLExsbKDTfc4F5HAxFtixriFaYtI39aGafnNn9Vjfp7b7UZDaI0lNIwyWr/+rPyDNq1OtSi41Dp43nR8yWhFACUfAx0DgBAEcmrgkEHsC4okLK+1AdLK5R8u5BZPLv8FNU2rSoHrWDyVLNmzXzvB2LPnj3mWBUUSOV3rPLb9/z2XytoPGl1VmF5Bij6JVy74b366qvuZdr1TbvNWZ544gnTtS2/QKqw7cNTYd+zVv9pd6pAKsdC3UeLBk357Zvv/bwCpkDacqTz7dK7bdu2Qm3H93wQ6M9KK+i0C7I/VndYpRdX0KpP7aZq0QpHz5DS9+eaH60oBQCUfIRSAAAUEa0c8KUVHDrGkkXDCK140S/E+iVRx5gKhTWGi8XfFczCsU0dU8aTNX6WZd++fUG/ro7BpF9qLY899pgJUvQ4eY4tVBTHw7eizXf/rWqawtDKEKsCRPddu7F5flHXapKqVau673t2cdNKL+1mp4GBPnfixIlSVAr7nlNSUtwBjh5PrYjRSjndPx3rKxy0qim/ffO9r9U8dv1+2E3HGvPcbw04Aw3UPLs0WmOr+Y4VVZjzmuWCCy6QZs2aubvzaTCl3Wctvldg9Py56nM1jM1rKsx4eACA6EMoBQBAGOkg3Z50sGatfLAuox6t1QDaBc6za9xbb73lVelTmK5vvsdKv9Ba4ZeOzVSUdNB53+5pFh0vSQOywtLKkD59+niNo+M5LpDvF3XP9637pV0AtZoqLS0tpP0oqvfsuX/687j66qvdQUV+PxffQMgzcCyI70Donl1BdUyof/zjH15Bh283zZJE25Mec4uOS6fjO3kOmu8ZNHn+XD2DSA3IrWo5Hb9s/vz5RbJ/nu1ZxynTgdCVdpXULqF5/Vw1uNaurTrWmOekXQW1ii+QwfABANGPMaUAAAijpk2bmmoFq7JBv0zq2EL6Rb8wwU0kGT16tHvwav0yrONbaRWQVoZpxUSwfIOFfv36me4/OkaNXt2rKHXp0kVatWrlrsD685//bMb+0u5e+lqFGeTckw70rlei8w1jtFujDnrv+76tqpX33ntPbrnlFrOe7kdhu2oV5Xv2/LloqKE/Fw0M9Mp2+V0hzbfbmVYJ6vP090GryfLrIqlXedNKGeuKgHrlRL2you6/vqbnmFP6O2Xn1ej69+9vQkNfGsBMmzbNXf1mXWjAt8pPrxaoY3gpvVqjb1joz+OPP24GmbcCH73S3QcffGBeU4+jdovTCju9Gp52tbTGC+vUqZNX8Kjjz2noqd1KfQdQLyx9vQcffNCEZNpV1aLjfvkGk3fffbc5N2iV3fbt26V169bmqn76HjQo04H4P/30U1N1pdsFAJQCLgAA4Ncvv/yig7C4p2nTpuX7+Mcff+x3O2PGjPFaz5p69uzpqlOnjt/tL1y40GtdT927d3cvHz58uNdj+T2vQYMGfl9L99vzOfq+AnleRkaG68ILL/T73i699FKv+59++mmBrUy316ZNG7/b0/eZ17H2fEyPjaf83tuXX37pKleuXK7XiouLc3Xr1s19X99/sNLS0lxVqlTJte27774717qfffaZy+l05lq3fPnyrkGDBuW5H57r6s89kDZQmPd86NAhV+3atQP6uXgeXz0GtWrV8vu8r776qsB93bt3r6tly5Z+n29NgwcPdmVmZgb0886vLedH18tvH/z9Lvoel7wmz59bQXbs2OHq2rVrUPtx+vRpV7Nmzfyud9lll+V5rPL7nfLH9/ddp82bN/tdd/78+X7bu+8EACgd6L4HAECYPfnkk/LQQw9JgwYNTOVA/fr1zVhB2l0qrwGEo4G+lxUrVsh9990ndevWNdUjWlWjVR1TpkzxWtffVQn9bW/16tWmykjHXNJBqbWS4rnnnpPp06cX+f5bFSNajVW+fHkzaXWOdqv805/+FNK2dd+HDh2aa7m+N186ts6HH35oqoj0edpF7rLLLjOD47dp00aK+z1r9zititKKFq3w0assagWOdtn0934s+l60Wqx3797uyqBgaLWYVhvp2GJahafHRX9fdBw2rTbTsYu0wiuaf4eCoecP/dnpeUMrobQKU7tR6vvX7m69evUyXfK0qsySmJhoqs20+5/+Dup9rZhbtmxZkY5X5tsltUOHDnm23VtvvdV0QdSue2eddZaULVvWvAetlurevbupuvIchw8AULI5NJkq7p0AAADRSQdP1pDCl3br0zBBafCh3RX9dXkCAABA6VU6/mkJAACE7cpgjRs3lgsvvFDq1asnv//+u6me0iu0WXSMJAIpAAAA+KJSCgAAFFq7du3y7Wqjg2K/+eabpisXAAAA4IkxpQAAQKGNGzdO+vTpY660puPVaPik40sNGDDAjPejV5MjkAIAAIA/VEoBAAAAAADAdlRKAQAAAAAAwHaEUgAAAAAAALAdV98rIjk5ObJnzx6pUKGCOByOotosAAAAAABAVHG5XHL8+HGpXbu2xMTkXQ9FKFVENJDSS2EDAAAAAABA5LfffjMXwSGUCjOtkLIOeFJSUtRVeR04cECqV6+eb4KJ0os2AtoJOJeAzxtEikj8uyQtK02GLRtm5l8d+KokOhOLe5dKtUhsI4g8tJPwOnbsmCncsbKSvFApVUSsLnsaSEVjKJWWlmb2m5M2aCPgXAI+b1Bc+JsE0dpO4rPiJa5snJnX/SKUKl6R2EYQeWgn9ihoeCNCKQAAAAAIQUJsgrzY/0X3PAAgMIRSAAAAABBiJUByuWSOIQAEiVpGAAAAAAAA2I5KKQAAAAAIQVZOlrz67atmfljbYeKM4WsWAASCSikAAAAACDGUWrZtmZl0HgAQGEIpAAAAAECJ1KNHD0lISJDy5cubS9O3atVKUlJSimwssW+++Sao52RmZsq4ceOkcuXKUqVKFbn99tslKyur0OuPGDFC4uPjzfuzpnXr1rkf1/Xr1atnrkRYp04dGT9+vGRkZJjHdu7c6fU8nZxOp/Tv39/9/AcffFDatGljlutzfTVs2FDKlCnjfn6lSpWCOh4AoRQAAAAAoMSaPXu2nDhxQo4dOyZ//etf5frrr5dff/21WPbl4Ycfls8//1y+++472bp1q3z22Wfyl7/8JaT1b731VvP+rKlr165ej23bts2892+//dZMegxU/fr1vZ53+PBhEypde+217uc3bdrUrO8ZVPlavHixextHjhwJ8QihtCGUAgAAAACUeFrZ1K9fPxO8/PDDD+7lGzdulIsvvthUImkI8/zzz3s9dt5555lKo2rVqskVV1xhlnfu3NncduvWzVQI5RcseXrppZdkypQpUqtWLTM98MAD8uKLLxbZ+r5atGgh5cqVM/Mul0tiYmLkp59+8rvu22+/LTk5OTJo0CD3suHDh8ull15q3j8QDoRSAAAAAIASTwOXd955R06fPi3t2rUzy/bt2yd/+tOfZOzYsXLgwAETzEybNk1WrVplHteucxpEaQXQ7t27ZeLEiWb5+vXrze3atWtNhdDkyZPN/csvv1weeeQRv6//+++/y65du9yvrXReu9EdPXq00Ou/+uqrJlDTromPPfaYeZ+edH80OEtOTjaVUtqlzx8Nu7SKLDExMYijKnLLLbeYwE4rtJYvXx7UcwFCKQAAAABAiTVp0iRTHaUVQ1oFpJVHGtCov//973LRRRfJ1VdfLbGxsdK6dWsZOXKkvPbaa+bxuLg409Vvz549ZmwqXTc/7733ntx///1+H9PwSnmOu2TNHz9+vFDr33HHHabqSwM1DZXmzZtnJk+6P7ot7QI4ZswYqVmzZq7X0vf40Ucfyf/93/9JMPT4/fLLLyaw07Br8ODB8tVXXwW1DZRuhFIAAAAAgBJr1qxZptJJK6Q0wHnllVfk2WefNY/t2LHDVPdo2GNNTzzxhOzdu9fdfS4tLU06dOggzZs3l6eeeqrQ+6HVSsqzysma10HYC7N++/btpXr16iZQ026GGkAtXbo0z658bdu2NYOj+1q4cKGce+655vFgXHjhhVK2bFkT2F133XWmquzNN98Mahso3ZzFvQMAAAAAEM0SYhNk/mXz3fOIXDpm1GWXXWYqmrTbmV6ZbuDAgbJkyRK/6zdp0sR0j9PxmNasWSO9evUy3dQ0pNIxqoKhV9CrW7euuWKfblfpvO5DxYoVQ15f6ZhR+dGr+fmOKaXd/TSU0oqyUBX0+oAvWgwAAAAAhEDDifoV65sp2KAC9rIqo9q0aWPu33jjjbJ69WpT3aOBjU4a/Fhd0DSQ2r9/v/m5ahWVhi5alaRq1KghP//8c1Cvr10D//znP5uxrHTSAdLz6zJX0Pqvv/66ubKehmYbNmww40dpFzqlXfY0bNIqMX38P//5j7maX58+fbxeY+XKlXLw4EEZOnRortfX46GVYtnZ2WbSeV2mdGyrf//735Kenm6W6b7omF0DBgwI6pigdCOUAgAAAACUWPfdd5/pCqfTBRdcYKqdpk6dah6rU6eOfPjhh6Y7n17dToOm2267zQQ9SsdZ0i5t+twrr7xS/va3v7kHHp85c6YZ00krmqzBzfVKdfldie/BBx80lVbalU6n888/3z1IutIxn3QKdH3tTli/fn3TnU8HKb/11lvl7rvvNo9pkKZjY2mVlT6u+69XH5w7d67XPulYVFdddZXf6qvRo0dLmTJl5B//+Id5LZ3XZVbope+/atWqpgvho48+aoIp7UYIBMrh0sg0wsyfP9/8smsSrCeAJ5980n3JTX9SUlLML6um3s2aNZPZs2ebkkyL9pnVfsOeNB1esWJFrm1pytulSxdzVYJNmzZ5XekgP3rS0l9i7eMbbZfL1HLN1NRUM9gf5ZagjYBzCfi8QXHhbxJEazvJysmS17e+buavbnW1OGMYJaU4RWIbQeShnYRXoBlJxP2G6qBsEyZMMJfh3LhxowmlNEDSk4o/eglOLTMcNWqUCZG0VFCnLVu2eK3Xt29fM1idNS1evNjv9u69916pXbt2WN4bAAAAgJJHQ6nFWxabSecBAIGJuFBqzpw5phxQ+862bNlSFixYYEbz16se+KOXu9TAaeLEiaacUUso9QoEvldF0KsB6KUvrUlLLH198MEH8q9//cuUHQIAAAAAACB8IqquNCMjQ77++muvUf+13FL7/K5bt87vc3S5VlZ50sqqt99+22vZJ598Yso3NYy65JJLzABv2vfVooPXaRimz9MQrCDazU8ni9XnWEsAdYomur/aizPa9hv2oY2AdgLOJeDzBpEiEv8usfbJmo+kfSuNIrGNIPLQTsIr0N+/iAqldMR/HdFfB5fzpPe3bdvm9zk67pS/9XW5RSupBg0aJI0aNTJXR9CB4XQAOg209MoJesLScad0QLmOHTuasakKMmvWLJkxY0au5QcOHDBXJIi2xqL9POM//lhiDx4UV5kyWlomLp0SE82t6O0f89ZyXSb00S4VrDaivyv0ywftBJxLwOcNilMk/l2SlpUmGekZZl6HHUl0Jhb3LpVqkdhGEHloJ+F1/Pjx6AulwuXaa691z+ulP8855xxzBQKtnurZs6cZSF0PmGeFVkF0Xc8KLa2UqlevnrnqQDQOdK5XZqj88ssSs3JlUM91xcefCad00jDLd14DLWve53F3sPVHCJbnNvwt09flcru2txFt33ywg3YCziXg8wbFKRL/LtFQKj4h3sxr7wxCqeIViW0EkYd2El6J+r092kKpatWqmcol7UrnSe/rOFD+6PJg1leNGzc2r7V9+3YTSq1evdpUTem4U560akovq+l75T6l6/qur/SkF40nPj1pOzy6Iwb8vIwM7XepqVzwzw36GZ5PdvwvqPINrgKZrBDM935et/6WOSPq18eWNhKt7Rv2oZ2ANgLOIyiNnze6H7pP1nyk7FdpZrURHbpFL4Q1fvx4U5Sg80eOHAnra+v3R72i/A8//GCGhtErwz/22GNSqVIl9zrfffed3HXXXebCXXFxcTJw4EB58cUXvbajlV4XXnihrFmzRn7//Xev56NknktKkkCPaUR9q46Pj5cOHTrIqlWrzMnCSi/1/rhx4/w+p2vXruZxPclYVq5caZbnZdeuXXLo0CGpVauWuf/EE0+YMaYse/bsMeNS6ZUAu3TpIqWFa8IEcVxzjcjp0yLaBVEna97fsvzmCxFwBbezrjOvp1Nx0V+yQAKt/IIu34owz0nHNvM3X65cqQvEAAAAIpmGBxnZGebKewdPHZQ6Feq4QyqE75ifzjotx9OPy8nMk9KwUkOJcYQ/WMjMzDQhUn5OnTolf/3rX+W8884z8zfccIPceuut8tprr7m/b2pY9uc//9mMaaxf3rdu3ZprO08//bTfQgigJIm4b7baJW748OGmSqlz584yd+5cOXnypLkanxo2bJjUqVPHjOmk7rzzTunevbtJnvv16ydLliyRDRs2yHPPPWceP3HihBn7afDgwaZ6SseUuvfee6Vp06YmeFL169f32ofy5cubW+3iV7duXSk1rrii6MaI0kHNNJgKNswqbAhmBVT6mlk2XYZX3+OpU2cmu2k4VaGCiHYV1VudrMArrymQxzX88jfxYQgAAJDLkbQj8so3r8iT65+Un3//2Syr93g9aVK5idze+XYZ3m64VEqkuqUgGuadyDhhAqZj6cfkeMZxr3lzm378f/MZx836+jzL+C7jpWfjnnm+hhYl6LjCOv6v9X1Pr76ulUgfffSRGXf4xx9/dH/X7N+/v1lHxx7W3jw63MuKFStMkHT77bfn+37Gjh3r1YVJxy72LLJ4/PHHTSg1atQo9zK9gryn3377zVyZ/vXXXzffjYGSKuJCqWuuucYMFj516lQzWHm7du3ML781mPnOnTu9ysC6detmEucpU6aYE0mzZs1M2ty6dWvzuJ5ANm/ebEootUyzdu3a0rt3b5k5cyapczjpz8iq7LGbhlIaTlmBlVW55Xnfc7LCLGudorgNd6WYFcKlpood9DeuhhVe6Xhe1q3nfFEv86wesyrFfIM1/gUSAAAUkw+3fyiDXx8spzJz/wPlf3//r9z14V3ywOoH5M2r35Q+Tc/8Y3hpqF5Kz07PHSJ5zPsLmPwdQ1UurpwkJSRJhfgKUiGhgiSXSzaBn857Ltf5RpUa5btveuV1DaF8u+/pd8UhQ4bIm2++KT169DDd6bTYYf369XL22WebdRYvXizLli0zBRAaaun3z0ceecQ8NxCffvqpGdfY875+zz3//PPNBb1atmwpjz76qFcvHQ22pk+f7nXFeKAkirhQSmmKnFd3Pe0H7EtPIjr5U6ZMGfnwww+Dev2GDRu6L+mKKKRd23TSbm7FRduPjrWVX3jlrzrMd9IqLN/5Eyf0UgZnxvGybm2oDnPYEbYFS0un86v+ym/SkKtaNb1cp/6VciYI03aj28zrNr/HGHwfAIBSFUj1e62f+c6g//mylp3OPG3We/+696MumMrOyT5TveRTtZTn/B8hk2f1ksUZ4zwTIMX/ESYlVJBqZau55z2XW/Pl48tLbExs2N/ns88+a6qhtHJJXXDBBXL55ZebCqUHH3zQLNOiBquXjY4Rdd1115kpEBqEvfDCC/L555+7lx0+fNgEXVp80alTJ9PLR19TK7UqV65sHtPw68YbbwzoyvBANIvIUAqIelrBY4UfdgRgvlVahZk8wy+fyXXqlGQdOyZOvZKJNbi9Pse61ak4gtzMzDOTBnWRwN/YYP6W+QvACgrBAg3Jgt2OTlScAQAQVJc9rZDSQCpHcvJdVx+PccWY9XdN2GWuyvfjoR/lnBr/q5qxQ3pWet6VSnnM6zhN/pRxlvEKkaqWrSqNKjfyqlryndf3HaljbGnooxe+WrhwoXtZVlaW1xXVfYd7CZRuV8eTeuutt8xV4C3afVDHQNZKKaUFGbNnzzYX39JxqO6//37TpRAoDQilgGjneSXCMHHl5Mih1FRziWNHXuOOabWWv8CqMMuskM1f9VigIZtuy25W9dvvv0tUscKpEEMyh9MpFbOyxKFjnFnr5Led2NgzXX2tW9/J33LfZXrf2pY1+d4PZB3f+/p75Tnpa3neBwCUWjqGlHY381chlVcwpetP/2S6HE0/aqqP/j7w7yaoCZYGYfr8AquWfCqYdBB2XzoouDtc+iNEalCpQb7hks5r1VNJuhpYvXr1zDjF2h0vmOcFEkhdddVVpupJr/juqW3btuaCXv5ol0AdCN26cJe1no53rFVduk2gJIneMwqAyAw2dPynSGB1ocwrtNIqsAMHzozLpSGSVlxpsObvNr/HrNu8QjSdIr07sL4HnfQ9hECjmmIYRa54FBRa+VtW0P381rFeM9TbvCZ/+5LX8oK2lc/kcLmkUmamOLSK1PoD33e7/pYV9F6skNJzn32X5TUfzLq+85F+3zdADeV+UW4rv23n5EjMoUNnzp2ebSTS9ztSt13UtzChkA5qHiwNsJ7f+Lzc1+0+ubnjzSaQ0qAo4HGX/pjXQMpfGKbbO9M9rrwJkComJEndCrUlKV7DpPJSIe7M8qQ/5nUq6yxzpnpJ/07xnMwO+97Xciud/FSnB/p3TiDrFdU6Wt1/8OCZtmtV1R84IDXi4syA5anffSfJ1aubbd0yZIj0vfZa6dO5s1zUtaupktq4ebNUqlhRWpx11pnzkVa5798f8H59snatDL7pJvnHU09Jn7ZtRfbt81pn9MCBctmNN8qX778vHdu2lecXLZL006elW+PGUiYhQX5Zt869rV1790rX/v3lszfflIb16uml+4r2WBX1zy87+39/W1p/K+cRwIVFMOernBxxHj4sUqVK8Bf8suO8WLOmSJ06UtI5XAyeVCSOHTsmFStWlKNHj3qVekYDTd9T/6iCKcy/AqDko42EQD+c9QPZM6TSsCyQ4Kswy4pqO/ktAwCUbv7CqvyCrPyWFWLe5XCYcEirt91Li2jbBe3rwTIuqT6i8BeaGb05TjJjRY7HuSQ91uNLvpl1iUMcUiFdpEKGSNIft3rfzJvJ9b/laS5JSnOZ+bjsQu9SiddDRAbo1fn+uH+ziLyl/yYnIu/pGFJa1SQiOnrU939c4KediDz6x+0IEdHrJ8712OYiEfmLiGzN4zUvFpF/+/nHOs9I7xURma5tSkS0Y988EenkZ1s6opQO4a51+FzHsZR54AGRhx+Wkp6RUCkFAOGkf8haVxasWDH6j7Xnv4D5hFY5GRlyaN8+qZqUJDH6L2IFhVu6jm5Lb60pmPs6b026Tc/7+S0PZJnvvxrrpK8ZzP3CPMfffeu4F8Wtv33099oAUNBngeetzTQiKq7arRMhpgI1D2dKs8N+Aqc/5stnFN97K6l8L5P13B+TJx3i/Mww57m97GfZ9X9Mefk4gP0a/sdUkIZWZgmUUIRSAIDgQjarq6bvOGY5OZKtA7knJwdfAo3Ik1dYlVeoVdCkTSQ7Ww4eOCDVqlY9U5mbV3eRQOc9982at0LLol4WyPJIuq/hqu/Ps7D3Q3lukNvWMQzT0tMlMSHhf92KomC/I3Lbdt0G+1gRzOu97MxMiXU6zwQ4Rbjtgh4vn6C/W7uksL5pWk5q7i0n/XdWlIqOWJHEPLpG53e/ONYtSFGsU4Svo5V06RkZkhAf73+AdRv3JeR1om1frL8TPScdr9MOQQbl2k5OnT4tZcv80ZU1TK9TaF26SGlAKAUAAHKzvogUZcCYkyM5+occwSXyoKHU0dRUScjvwhoo9bSdHCzoAixhUtXlkiZPNpP//v7fgAc6V9otTwcRv3rATPn010+lddsb5aIGF4V1X0t7GzlSTG0E0dVOjqemShnaSbHiNxQAAAAAAqDVFLd3vr1Qx+qu8+6SG9reIM/3f55ACgD+QCgFAAAAAAEa3m64lI0rKzEBfpWKccSY9Ye1HcYxBgAfhFIAAAAAEKBKiZXkzavfNFVTBQVT+rh23XvrmrfM8wAA3gilAAAAACAIfZr2kfeve1/KxJUxoZP+58lapo8vv3659G7Sm+MLAH4QSgEAAABAIYKpXRN2ydy+c6VR5UZejzWu3Ngs3z1hN4EUAOSDq+8BAAAAQCFol7w7utwho9uPlgFLB0hWTpa8OuBVqV2hdnCXmAeAUopQCgAAAABCoAFUfGy8maqWrUogBQABovseAAAAAAAAbEcoBQAAAAAAANsRSgEAAAAAAMB2hFIAAAAAAACwHaEUAAAAAAAAbMfV9wAAAAAgBHExcTL1oqnueQBAYAilAAAAACAEsTGx0qlOJ44hAASJ7nsAAAAAAACwHZVSAAAAABCCrJws+XTHp2a+e8Pu4ozhaxYABIKzJQAAAACEGErN/XKumT+//vmEUgAQILrvAQAAAAAAwHaEUgAAAAAAALAdoRQAAAAAAABsRygFAAAAAAAA2xFKAQAAAAAAwHaEUgAAAAAAALCd0/6XBAAAAICSIy4mTu47/z73PAAgMIRSAAAAABCC2JhYuaD+BRxDAAgS3fcAAAAAAABgOyqlAAAAACAE2TnZsm7XOjPftW5XUzkFACgYoRQAAAAAhCAzJ1Nmr5lt5lOGpBBKAUCA6L4HAAAAAAAA2xFKAQAAAAAAwHaEUgAAAAAAALAdoRQAAAAAAABsRygFAAAAAAAA2xFKAQAAAAAAwHZO+18SAAAAAEoOZ4xTxncZ754HAASGMyYAAAAAhECDqJ6Ne3IMASBIdN8DAAAAAACA7aiUAgAAAIAQZOdky8a9G818+1rtJTYmluMJAAEglAIAAACAEGTmZMpD/37IzKcMSSGUAoAA0X0PAAAAAAAAtiOUAgAAAAAAgO0IpQAAAAAAAGA7QikAAAAAAADYjlAKAAAAAAAAtiOUAgAAAAAAgO2c9r8kAAAAAJQczhinjOkwxj0PAAgMZ0wAAAAACIEGUf3O6scxBIAg0X0PAAAAAAAAtqNSCgAAAABCkOPKka2pW818q+RWEuPg3/4BIBCEUgAAAAAQgozsDJm8erKZTxmSIonORI4nAASACB8AAAAAAAC2I5QCAAAAAACA7QilAAAAAAAAYDtCKQAAAAAAANiOUAoAAAAAAAC2I5QCAAAAAACA7ZwccwAAAAAI4UtVjFNGthvpngcABIYzJgAAAACEQIOoQS0GcQwBIEh03wMAAAAAAIDtqJQCAAAAgBDkuHLk58M/m/kmVZpIjIN/+weAQBBKAQAAAEAIMrIzZMK/Jpj5lCEpkuhM5HgCQAAiMsKfP3++NGzYUBITE6VLly6yfv36fNdPSUmR5s2bm/XbtGkjy5cv93p8xIgR4nA4vKa+ffu6H9+xY4eMGjVKGjVqJGXKlJEmTZrItGnTJCMjI2zvEQAAAAAAoDSLuFBq6dKlMmHCBBMKbdy4Udq2bSt9+vSR1NRUv+uvXbtWhg4dakKlTZs2yYABA8y0ZcsWr/U0hNq7d697Wrx4sfuxbdu2SU5Ojjz77LOydetWefzxx2XBggUyefLksL9fAAAAAACA0ijiQqk5c+bI6NGjZeTIkdKyZUsTDpUtW1Zeeuklv+vPmzfPBE4TJ06UFi1ayMyZM6V9+/by1FNPea2XkJAgNWvWdE+VK1d2P6bPX7hwofTu3VsaN24s/fv3l3vuuUfeeuutsL9fAAAAAACA0iiixpTS7nJff/21TJo0yb0sJiZGevXqJevWrfP7HF2ulVWetLLq7bff9lr2ySefSHJysgmjLrnkEnn44YelatWqee7L0aNHpUqVKnk+np6ebibLsWPHzK1WXOkUTXR/XS5X1O037EMbAe0EnEvA5w0iRST+XWLtkzUfSftWGkViG0HkoZ2EV6C/fxEVSh08eFCys7OlRo0aXsv1vnax82ffvn1+19flnpVQgwYNMmNG/fzzz6Zb3qWXXmoCrdjY2Fzb3L59uzz55JPy6KOP5rmvs2bNkhkzZuRafuDAAUlLS5NoaywawumJW0NAgDYCziXg8wbFgb9JEK3tJC0rTTLSz4xHq8OOMNB58YrENoLIQzsJr+PHj0dfKBUu1157rXteB0I/55xzzGDmWj3Vs2dPr3V3795tQqwhQ4aYboR50WouzwotrZSqV6+eVK9eXZKSkiTafhl18Hfdd07aoI2Acwn4vEFx4W8SRGs70VAqPiHezGvvDEKp4hWJbQSRh3YSXnohuqgLpapVq2Yql/bv3++1XO/rOFD+6PJg1lc6bpS+llZEeYZSe/bskYsvvli6desmzz33XL77qmNU6eRLT3rReOLTk3a07jvsQRsB7QScS8DnDSJFpP1dEu+Ml+vaXOeej5T9Ks0irY0gMtFOwifQ372I+g2Nj4+XDh06yKpVq7zSS73ftWtXv8/R5Z7rq5UrV+a5vtq1a5ccOnRIatWq5VUh1aNHD/P6Oug5Jy8AAAAAgXDGOE0opZPOAwACE3FnTO0SN3z4cOnYsaN07txZ5s6dKydPnjRX41PDhg2TOnXqmDGd1J133indu3eXxx57TPr16ydLliyRDRs2uCudTpw4YcZ+Gjx4sKme0jGl7r33XmnatKkZEN0zkGrQoIEZR0rHhbLkV3EFAAAAAACAEhJKXXPNNSYUmjp1qhmsvF27drJixQr3YOY7d+70qmLSrnavvfaaTJkyxQxg3qxZM3PlvdatW5vHtTvg5s2b5ZVXXpEjR45I7dq1pXfv3jJz5kx39zutrNKufDrVrVvXa3+sq2gAAAAAgD/6neG3Y7+Z+XpJ9UyXIABAwRwuUpcioQOdV6xY0VzlIRoHOterhOigjHRbBG0EnEvA5w2KC3+TIFrbiQ50PiRliJlPGZLCQOfFLBLbCCIP7SQyMhJ+QwEAAAAAAGA7QikAAAAAAADYjlAKAAAAAAAAtiOUAgAAAAAAgO0IpQAAAAAAAGA7QikAAAAAAADYzmn/SwIAAABAyeGMccrA5gPd8wCAwHDGBAAAAIAQaBB107k3cQwBIEh03wMAAAAAAIDtqJQCAAAAgBC4XC45cOqAma9etro4HA6OJwAEgFAKAAAAAEKQnp0uo/45ysynDEmRRGcixxMAAkD3PQAAAAAAANiOUAoAAAAAAAC2I5QCAAAAAACA7QilAAAAAAAAYDtCKQAAAAAAANiOUAoAAAAAAAC2c9r/kgAAAABQcsQ6YuWyppe55wEAgSGUAgAAAIAQxMXGydhOYzmGABAkuu8BAAAAAADAdlRKAQAAAEAIXC6XHEs/ZuaTEpLE4XBwPAEgAIRSAAAAABCC9Ox0uWHZDWY+ZUiKJDoTOZ4AEAC67wEAAAAAAMB2hFIAAAAAAACwHaEUAAAAAAAAbEcoBQAAAAAAANsRSgEAAAAAAMB2hFIAAAAAAACwndP+lwQAAACAkiPWESs9G/V0zwMAAkMoBQAAAAAhiIuNk/HnjecYAkCQ6L4HAAAAAAAA21EpBQAAAAAhcLlckp6dbuYTYhPE4XBwPAEgAFRKAQAAAEAINJAakjLETFY4BQAoGKEUAAAAAAAAbEcoBQAAAAAAANsRSgEAAAAAAMB2hFIAAAAAAACwHaEUAAAAAAAAbEcoBQAAAAAAANs57X9JAAAAACg5Yhwxcn69893zAIDAEEoBAAAAQAjiY+Pl/gvu5xgCQJCI8QEAAAAAAGA7QikAAAAAAADYjlAKAAAAAEKQlpUmVyy+wkw6DwAIDKEUAAAAAAAAbEcoBQAAAAAAANsRSgEAAAAAAMB2hFIAAAAAAACwHaEUAAAAAAAAbEcoBQAAAAAAANs57X9JAAAAACg5Yhwx0rFWR/c8ACAwhFIAAAAAEIL42HiZ1mMaxxAAgkSMDwAAAAAAANsRSgEAAAAAAMB2hFIAAAAAEIK0rDS56vWrzKTzAIDAMKYUAAAAAIQoPTudYwgAQaJSCgAAAAAAALYjlAIAAAAAAIDtCKUAAAAAAABgO0IpAAAAAAAA2I5QCgAAAAAAALbj6nsAAAAAEIIYR4y0rt7aPQ8ACAyhFAAAAACEID42Xmb1msUxBIAgEeMDAAAAAADAdoRSAAAAAAAAsB2hFAAAAACEIC0rTa5/63oz6TwAIDCMKQUAAAAAITqWfoxjCABBolIKAAAAAAAAtovIUGr+/PnSsGFDSUxMlC5dusj69evzXT8lJUWaN29u1m/Tpo0sX77c6/ERI0aIw+Hwmvr27eu1zuHDh+X666+XpKQkqVSpkowaNUpOnDgRlvcHAAAAAABQ2kVcKLV06VKZMGGCTJs2TTZu3Cht27aVPn36SGpqqt/1165dK0OHDjUh0qZNm2TAgAFm2rJli9d6GkLt3bvXPS1evNjrcQ2ktm7dKitXrpT33ntP/v3vf8vNN98c1vcKAAAAAABQWkVcKDVnzhwZPXq0jBw5Ulq2bCkLFiyQsmXLyksvveR3/Xnz5pnAaeLEidKiRQuZOXOmtG/fXp566imv9RISEqRmzZruqXLlyu7Hvv/+e1mxYoW88MILpjLrggsukCeffFKWLFkie/bsCft7BgAAAAAAKG0iaqDzjIwM+frrr2XSpEnuZTExMdKrVy9Zt26d3+focq2s8qSVVW+//bbXsk8++USSk5NNGHXJJZfIww8/LFWrVnVvQ7vsdezY0b2+vqa+9pdffikDBw7M9brp6elmshw7dmZgw5ycHDNFE91fl8sVdfsN+9BGQDsB5xLweYNIEYl/l1j7ZM1H0r6VRpHYRhB5aCfhFejvX0SFUgcPHpTs7GypUaOG13K9v23bNr/P2bdvn9/1dblFK6kGDRokjRo1kp9//lkmT54sl156qQmjYmNjzboaWHlyOp1SpUoVr+14mjVrlsyYMSPX8gMHDkhaWlrUNZajR4+aE7cGcQBtBJxLwOcNigN/kyBa20lGdobUSaxj5g8eOCjxsfHFvUulWiS2EUQe2kl4HT9+PPpCqXC59tpr3fM6EPo555wjTZo0MdVTPXv2LNQ2tZrLs0JLK6Xq1asn1atXN4OlR9svow7+rvvOSRu0EXAuAZ83KC78TYJobifPDHimuHcBEd5GEFloJ+GlF6KLulCqWrVqpnJp//79Xsv1vo4D5Y8uD2Z91bhxY/Na27dvN6GUrus7kHpWVpa5Il9e29ExqnTypSe9aDzx6Uk7Wvcd9qCNgHYCziXg8waRgr9LQBsB55LIFmi2EFEJRHx8vHTo0EFWrVrllV7q/a5du/p9ji73XF/pFfTyWl/t2rVLDh06JLVq1XJv48iRI2Y8K8vq1avNa+vA5wAAAAAAAChaERVKKe0S9/zzz8srr7xiroo3duxYOXnypLkanxo2bJjXQOh33nmnuXLeY489Zsadmj59umzYsEHGjRtnHj9x4oS5Mt8XX3whO3bsMAHWlVdeKU2bNjUDoiu9ap+OO6VX/Vu/fr2sWbPGPF+7/dWuXbuYjgQAAACAaJCelS6j3hllJp0HAEj0dd9T11xzjRksfOrUqWaQ8Xbt2pnQyRrMfOfOnV5lYN26dZPXXntNpkyZYgYwb9asmbnyXuvWrc3j2h1w8+bNJuTSaigNmXr37i0zZ8706n63aNEiE0Rpdz7d/uDBg+WJJ54ohiMAAAAAIJq4xCWpp1Ld8wCAKA2llIZDVqWTLx2c3NeQIUPM5E+ZMmXkww8/LPA19Up7Gm4BAAAAAACgFHbfAwAAAAAAQMlHKAUAAAAAAADbEUoBAAAAAADAdoRSAAAAAAAAsF1EDnQOAAAAANHCIQ6pl1TPPQ8ACAyhFAAAAACEIMGZIE/3e5pjCABBovseAAAAAAAAbEcoBQAAAAAAANsRSgEAAABACNKz0uXW9281k84DAALDmFIAAAAAEAKXuOS3Y7+55wEAgaFSCgAAAAAAALYjlAIAAAAAAIDtCKUAAAAAAABgO0IpAAAAAAAA2I5QCgAAAAAAALbj6nsAAAAAEAKHOCS5bLJ7HgAQGEIpAAAAAAhBgjNBXrzyRY4hAASJ7nsAAAAAAACwHaEUAAAAAAAAbEcoBQAAAAAhyMjOkAkfTjCTzgMAAsOYUgAAAAAQghxXjvx0+Cf3PAAgMFRKAQAAAAAAwHaEUgAAAAAAALAdoRQAAAAAAABsRygFAAAAAAAA2xFKAQAAAAAAwHZcfQ8AAAAAQpSUkMQxBIAgEUoBAAAAQAgSnYmyaNAijiEABInuewAAAAAAALAdoRQAAAAAAABsRygFAAAAACHIyM6QSR9NMpPOAwACw5hSAAAAABCCHFeObDmwxT0PAAgMlVIAAAAAAACwHaEUAAAAAAAAbEcoBQAAAAAAANsRSgEAAAAAAMB2hFIAAAAAAACwHVffAwAAAIAQJcQmcAwBIEiEUgAAAAAQgkRnorxx9RscQwAIEt33AAAAAAAAYDsqpQAAAAAAQL6ys7MlMzOzxBylnJwc837S0tIkJoZ6nWDFxcVJbGyshIpQCgAAAABCkJGdIbM+m2XmJ104SeJj4zmeKDFcLpfs27dPjhw5IiXtfWkwdfz4cXE4HMW9O1GpUqVKUrNmzZCOH6EUAAAAAIQgx5UjG/ZucM8DJYkVSCUnJ0vZsmVLTICjoVRWVpY4nc4S857sPHanTp2S1NRUc79WrVqF3hahFAAAAAAA8NtlzwqkqlatWqKOEKFUaMqUKWNuNZjS9lHYrnx0nAQAAAAAALlYY0hphRTgy2oXoYw1RigFAAAAAADyRPc2hKtdEEoBAAAAAADAdoRSAAAAAAAABWjYsKHMnTu32LdRkhBKAQAAAACAEtWtLL9p+vTphdruV199JTfffHOR7utzzz0nPXr0kKSkJLNvOrB8acLV9wAAAAAgBInORHl36LscQyBC7N271z2/dOlSmTp1qvzwww/uZeXLl/e6Cp9eZdDpLDgeqV69epHv66lTp6Rv375mmjRpkpQ2VEoBAAAAAIASo2bNmu6pYsWKpgLJur9t2zapUKGCfPDBB9KlSxdJTEyUzz//XH7++We58sorpUaNGia06tSpk3z00Uf5dr3T7b7wwgsycOBAcyW6Zs2ayT//+c+g9nX8+PFy//33y3nnnSelEaEUAAAAAAAoVbQq6c9//rN89913cs4558iJEyfksssuk1WrVsmmTZtM5dIVV1whO3fuzHc7M2bMkKuvvlo2b95snn/99dfL4cOHbXsf0Y7uewAAAAAQgozsDJmzbo6Zn9B1gsTHxnM8UaJ17Ciyb5+9r1mzpsiGDUW3PQ2TevXqZbrtacVTlSpVpG3btu7HZ86cKcuWLTOVT+PGjctzOyNGjJChQ4ea+b/85S/yxBNPyPr1602ohYIRSgEAAABACHJcObLmtzVmfvx54zmWKPE0kNq9W6JaR03WPGillA6A/v7775sxqbKysuT06dMFVkpplZWlXLlyZsDy1NTUsO13SUMoBQAAAAAAgqpaivbX1ADJ0z333CMrV66URx99VJo2bSplypSRq666SjIyMvLdTlxcnNd9rbrKyckp2p0twQilAAAAAABAwIqyG12kWLNmjemKp4OWW5VTO3bsKO7dKvEIpQAAAAAAQKmmV8576623zODmWu304IMP2lLxtG/fPjNt377d3P/Pf/5jrg5Yv359M85VScfV9wAAAAAAQKk2Z84cqVy5snTr1s0EU3369JH27duH/XUXLFgg5557rowePdrcv+iii8x9HWC9NAhrpdSWLVtk48aNMmzYsHC+DAAAAAAAQC7aJU8nS48ePcTlcplJBzO3NGzYUFavXu313Ntuu83rvm93Pt2GryNHjuT7U/DdxvTp081UWoW1Uuqdd96RkSNHhvMlAAAAAAAAEIUYUwoAAAAAQpAQmyApQ1Lc8wCAMIVSN910U8Drfvvtt8FuHgAAAACiig6KnOhMLO7dAICSH0q9/PLLEhcXJ/Hx8QWum5mZWdj9AgAAAAAAQAkW9JhS9erVk169esnx48cLnKZMmRKevQYAAACACJGZnSlzv5hrJp0HAIQplOrSpYusX78+4DJWAAAAACjJsl3ZsuqXVWbSeQBAmEKpiy++WMqXLy+//fZbgeu2bdtWhg0bFuxLAAAAAAAAoIQLekypsWPHminQAKt9+/aF2S8AAAAAAACUYEFXSgVj7ty5Ur9+/XC+BAAAAAAAAKJQWEMp5XK5glp//vz50rBhQ0lMTAxo/KqUlBRp3ry5Wb9NmzayfPnyPNcdM2aMGedKwzJPP/74o1x55ZVSrVo1SUpKkgsuuEA+/vjjoPYbAAAAAACUHD169JDx48e772tW4Zsn+NLM4e233w75tR1FtJ38TJ8+Xdq1ayclOpQKxtKlS2XChAkybdo02bhxoxmTqk+fPpKamup3/bVr18rQoUNl1KhRsmnTJhkwYICZtmzZkmvdZcuWyRdffCG1a9fO9djll18uWVlZsnr1avn666/N6+qyffv2heV9AgAAAACA8Ljiiiukb9++fh/77LPPTOCzefPmoLf71Vdfyc033yx2BEN79+6VSy+9VOy0detWGTx4sAnf/BX0lPhQas6cOTJ69GgZOXKktGzZUhYsWCBly5aVl156ye/68+bNMw1t4sSJ0qJFC5k5c6YZw+qpp57yWm/37t1y++23y6JFiyQuLs7rsYMHD8pPP/0k999/v5xzzjnSrFkzeeSRR+TUqVN+wy0AAAAAABC5tHBl5cqVsmvXrlyPLVy4UDp27Gi+/werevXqJqOwQ82aNSUhIUHspDlI48aNTSair2+HiAmlMjIyTJVSr1693MtiYmLM/XXr1vl9ji73XF9pZZXn+jk5OXLjjTea4KpVq1a5tlG1alU5++yz5dVXX5WTJ0+aiqlnn31WkpOTpUOHDkX6HgEAAACUPAmxCfKPgf8wk84DKF7a80kDpJdfftlr+YkTJ8wQQBpaHTp0SG644QapW7euCZp0OKDFixfnu13f7nta4HLRRReZ4YS0sEaDMF/33XefnHXWWeY1NPB58MEHJTMz0zz28ssvy4wZM+Tbb781lUk6Wfvs233vP//5j1xyySVSpkwZk2NoxZa+H8uIESNMz7FHH31UatWqZda57bbb3K8ViE6dOsnf/vY3ufbaa20LxIK++p52qwvUnj17Al5XK5ays7OlRo0aXsv1/rZt2/w+R7vX+Vvfs9vd7Nmzxel0yh133OF3G/qD/uijj8wPr0KFCiYI00BqxYoVUrly5Tz3Nz093UyWY8eOuUMwnaKJ7q+O/RVt+w370EZAOwHnEvB5g0gRqX+XVIivYG5134IdVxelo41E87GMtnYdGxtrilM04Jk8ebL53q9ef/11kzto6KKBzrnnnmt6TenY0u+//755jgZHnTt3dm/L971b9/XYDBo0yGQQOlTQ0aNH5a677sr1nPLly5vqLB1KSIMlDZN02b333itXX321Wfbhhx+6A62KFSu6n2ttRwtotACna9euZtxtHeJIe5mNGzfObNuiY2NrhZMOTbR9+3bzPnV4Il3XH8/Xyevx/H7unsfC9/ct0N+/oEMpLXOzfqAF0Z0LdN1w0Mor7eKnQVpe+6H7qOmhBlHat1RTxxdeeMH0QdX+opow+jNr1iyTaPo6cOCApKWlSTTRxqK/QHosNJQDaCPgXAI+b1Ac+JsEtBNwLoksWmWj52btUaSTJfa888Sxf7+t++KqUUOyv/gi4PWHDRtmqoY0oOnevbtZpgHOwIEDpVy5cqZy6c477zQBluYFY8eONeGQjnWtwwJ5hi6e7906HhoiaQHNe++95x67+qGHHjJZggZf1nM09LJoVZYGVxqO6XjacXFxZj90H/TCaxbrudZ2/vGPf5ic4cUXXzT7rhd704otfS8PP/ywCcZ0v7SwRpfr9po2bWrGpNIiHB0iKb/Q0fP9+T6e12PWfuo6WnXmO1TS8ePHwxNKeaZwRUl/AHrg9vs0bL2fV19GXZ7f+hoyaYJYv3599+P6Q7377rvND2rHjh2mgWoj+v333006qp5++mnTwF555RWvBuRp0qRJphF5VkrVq1fPlAha24kW2oj0l1D3nVAKtBFwLgGfNygu/E2CaG0nmdmZ8sKmF8z8/537fxIX6/3lDPaKxDYSrTQI0XBBex/p5LZ/vzh277Z9f7z2oQCtW7eWbt26maF6evbsaSqHPv/8c5MB6HY0G/jLX/4ib775phmHWocU0t5QGvpYr2N1qfN8XW1Tev/HH380GYBn3nDBBReYW802rOdoyPXkk0/Kzz//bKqzNMjRzMB6PCYmJtdrWKzt/PDDD6biSauoLNptUNu6brdOnTpmOzpkkWe3Ow3LdKzsvI5bfq/t+V7zoo/pOtpVULswevK9n+c2JEjDhw+XcIiPjzdjOK1atcp0pVN6gPW+lqT5o6Vr+rjnJRo1TNLlSkvv/I05pcutpFAH8lK+Jyu9n1+5mf6g/fWx1OdF44lPG2K07jvsQRsB7QScS8DnDSJFpP1d4spxyYqfV5j5Ue1HRcx+lWaR1kailRVaWJObTYNge3LoawbZE0vHjtKLns2fP9905WvSpIn06NHDvBcdO0kvkvb444+bQc81jNJsQcMpz/fq+959j4fvY57r6HjXOm6V9rLSLEJDpSVLlshjjz2W6/kOP+8tmNdSWq3kuY6Va+TVcyy/1/b33vN63N/vWqC/e0GHUuGklUcaemkXQe3DqdVM2nfSCpC0/E4TQO06p7TUTsvw9Afar18/88PdsGGDPPfcc+ZxTet08qQ/JK2k0sHNlQZYWuKmrzt16lTTfe/555+XX375xWwTAAAAAAB42LAhKg6HjtmkucFrr71mKqa0i54Vsqxdu9Z0tdPQSJdpeKPVTzpgeSBatGghv/32m+zdu9c97I+OLeVJX6NBgwbywAMPuJf9+uuvuQp0srOzC3wtDdU0H9HwTK1Zs8YEP1a2Ea0iKja+5pprTJ9PDYfatWsn33zzjRlw3BrMfOfOneYHbtFSPG1cGkJpKdsbb7xhRqfXMr1gug3qa2gZnY5kr4GYlvS98847ZpsAAAAAACD66IDimjPo8DuaJegV6iw65pL2vNLg6Pvvv5dbbrkl1/BA+dFeWXpVPS1w0avn6fBBnuGTatasmckxtIBGu9k98cQTsmzZslxX9Pvll19M/qEXgPO8oJrl+uuvN93h9LW0O54OaK4VYNoLzPfib6HQKjHdD510Xrs16rx2fQyXiKqUUtpVL6/uep988kmuZUOGDDFToHQcKV8aROmAZgAAAAAAoOTQLnw6QPhll13mHpBcTZkyxQRFffv2NYON61XxdCghvQhYILRKSQMm3b729NJwSUMn3Z6lf//+ZmBzzTg0bNLeWA8++KBMnz7dvc7gwYPlrbfekosvvliOHDlixvH2DM+U7p9mFlr11alTJ3NfnzdnzhwpSnv27DFXJLRo0ZBO2kPNXx5TFByuaLquYwTTgc61f6g24Ggc6FwHhNcrENLnGrQRcC4BnzcoLvxNgmhtJ2lZaTIk5cw/lKcMSZFEZ2AD/KL0tJFoHuhcq3gaNWoU8MDV0cK66pwO1p3fuEkoXPsINCPhNxQAAAAAAAC2I5QCAAAAAACA7SJuTCkAAAAAiCYJsQnyYv8X3fMAgMAQSgEAAABACHQ8muRyyRxDAAgS3fcAAAAAAECeuD4awtUuCKUAAAAAIARZOVny0qaXzKTzQEkRFxdnbk+dOlXcu4IIZLULq50UBt33AAAAACAEGkQt27bMzF/X5jpxxvA1CyVDbGysVKpUSVJTU839smXLmu6qJaXKJysrS5xOZ4l5T3YeOw2ktF1o+9B2UlicLQEAAAAAgF81a9Y0t1YwVZKClZycHImJiSGUKiQNpKz2UViEUgAAAAAAwC+tIqpVq5YkJydLZmZmiTlKGkgdOnRIqlataoIpBEe77IVSIWUhlAIAAAAAAPnSAKIoQohICqU0WElMTCSUKkbEgQAAAAAAALAdoRQAAAAAAABsRygFAAAAAAAA2zGmFAAAAACEICE2QeZfNt89DwAIDKEUAAAAAIR4dbL6FetzDAEgSHTfAwAAAAAAgO2olAIAAACAEGTlZMnrW18381e3ulqcMXzNAoBAcLYEAAAAgBBDqcVbFpv5QS0GEUoBQIDovgcAAAAAAADbEUoBAAAAAADAdoRSAAAAAAAAsB2hFAAAAAAAAGxHKAUAAAAAAADbEUoBAAAAAADAdk77XxIAAAAASo742HiZ03uOex4AEBhCKQAAAAAIQYwjRppVbcYxBIAg0X0PAAAAAAAAtqNSCgAAAABCkJWTJf/84Z9mvv/Z/cUZw9csAAgEZ0sAAAAACDGUWvjNQjN/WbPLCKUAIEB03wMAAAAAAIDtCKUAAAAAAABgO0IpAAAAAAAA2I5QCgAAAAAAALYjlAIAAAAAAIDtCKUAAAAAAABgO6f9LwkAAAAAJUd8bLz85ZK/uOcBAIEhlAIAAACAEMQ4YqRNjTYcQwAIEt33AAAAAAAAYDsqpQAAAAAgBFk5WfLh9g/NfJ+mfcQZw9csAAgEZ0sAAAAACDGUWvD1AjPfs3FPQikACBDd9wAAAAAAAGA7QikAAAAAAADYjlAKAAAAAAAAtiOUAgAAAAAAgO0IpQAAAAAAAGA7QikAAAAAAADYzmn/SwIAAABAyREXEydTL5rqngcABIZQCgAAAABCEBsTK53qdOIYAkCQ6L4HAAAAAAAA21EpBQAAAAAhyMrJkk93fGrmuzfsLs4YvmYBQCA4WwIAAABAiKHU3C/nmvnz659PKAUAAaL7HgAAAAAAAGxHKAUAAAAAAADbEUoBAAAAAADAdoRSAAAAAAAAsB2hFAAAAAAAAGxHKAUAAAAAAADbOe1/SQAAAAAoOeJi4uS+8+9zzwMAAkMoBQAAAAAhiI2JlQvqX8AxBIAg0X0PAAAAAAAAtqNSCgAAAABCkJ2TLet2rTPzXet2NZVTAICCEUoBAAAAQAgyczJl9prZZj5lSAqhFAAEiO57AAAAAAAAsB2hFAAAAAAAAGxHKAUAAAAAAADbEUoBAAAAAADAdoRSAAAAAAAAsF3EhVLz58+Xhg0bSmJionTp0kXWr1+f7/opKSnSvHlzs36bNm1k+fLlea47ZswYcTgcMnfu3FyPvf/+++b1ypQpI5UrV5YBAwYUyfsBAAAAAABAhIdSS5culQkTJsi0adNk48aN0rZtW+nTp4+kpqb6XX/t2rUydOhQGTVqlGzatMkESTpt2bIl17rLli2TL774QmrXrp3rsTfffFNuvPFGGTlypHz77beyZs0aue6668LyHgEAAACULM4Yp4zvMt5MOg8AiMJQas6cOTJ69GgTDrVs2VIWLFggZcuWlZdeesnv+vPmzZO+ffvKxIkTpUWLFjJz5kxp3769PPXUU17r7d69W26//XZZtGiRxMXFeT2WlZUld955p/ztb38zlVRnnXWWee2rr746rO8VAAAAQMmgQVTPxj3NRCgFAFEYSmVkZMjXX38tvXr1ci+LiYkx99etW+f3Obrcc32llVWe6+fk5JgqKA2uWrVqlWsbWpGloZW+1rnnniu1atWSSy+91G+1FQAAAAAAAIpGxNSWHjx4ULKzs6VGjRpey/X+tm3b/D5n3759ftfX5ZbZs2eL0+mUO+64w+82/vvf/5rb6dOnm0otHc/qsccekx49esiPP/4oVapU8fu89PR0M1mOHTvmDsF0iia6vy6XK+r2G/ahjYB2As4l4PMGkSIS/y7JzsmWjfs2mvn2NdtLbExsce9SqRaJbQSRh3YSXoH+/kVMKBUOWnmlXfy0GkoHOM/vQD3wwAMyePBgM79w4UKpW7euGUT9lltu8fu8WbNmyYwZM3ItP3DggKSlpUk00WNw9OhRc+LWijGANgLOJeDzBsWBv0kQre0kLStNHlz5oJl/7k/PSaIzsbh3qVSLxDaCyEM7Ca/jx49HVyhVrVo1iY2Nlf3793st1/s1a9b0+xxdnt/6n332mRkkvX79+u7HtRrr7rvvNlfg27Fjh+mup3QcKUtCQoI0btxYdu7cmef+Tpo0yQzK7lkpVa9ePalevbokJSVJtP0yamin+85JG7QRcC4BnzcoLvxNgmhtJxpKxSfEm/nk5GRCqWIWiW0EkYd2El6JiYnRFUrFx8dLhw4dZNWqVeYKelYj0fvjxo3z+5yuXbuax8ePH+9etnLlSrNc6VhS/sacsq60p/Q1NYT64Ycf5IILLjDLMjMzTWDVoEGDPPdXn6OTLz3pReOJT0/a0brvsAdtBLQTcC4BnzeIFJH2d4nuh9UzI5L2qzSLtDaCyEQ7CZ9Af/ciJpRSWnk0fPhw6dixo3Tu3NlUM508edIdIA0bNkzq1Kljus4pvWpe9+7dzRhQ/fr1kyVLlsiGDRvkueeeM49XrVrVTJ706ntaSXX22Web+1rVpFfdmzZtmql00iBKr8SnhgwZYvMRAAAAAAAAKB0iKpS65pprzJhMU6dONYOVt2vXTlasWOEezFy703mmbd26dZPXXntNpkyZIpMnT5ZmzZrJ22+/La1btw7qdTWE0sHQtYLq9OnT0qVLF1m9erVUrly5yN8jAAAAAAAARBwuHf0NIdMxpSpWrGgG1IvGMaV07C3t/055K2gj4FwCPm9QXPibBNHaTnRMqSEpZ3pZpAxJYUypYhaJbQSRh3YSGRkJv6EAAAAAAAAo3d33AAAAACDaOGOcMqbDGPc8ACAwnDEBAAAAIAQaRPU7qx/HEACCRPc9AAAAAAAA2I5KKQAAAAAIQY4rR7ambjXzrZJbSYyDf/sHgEAQSgEAAABACDKyM2Ty6slmnqvvAUDgiPABAAAAAABgO0IpAAAAAAAA2I5QCgAAAAAAALYjlAIAAAAAAIDtCKUAAAAAAABgO0IpAAAAAAAA2M5p/0sCAAAAQMnhjHHKyHYj3fMAgMBwxgQAAACAEGgQNajFII4hAASJ7nsAAAAAAACwHZVSAAAAABCCHFeO/Hz4ZzPfpEoTiXHwb/8AEAhCKQAAAAAIQUZ2hkz41wQznzIkRRKdiRxPAAgAET4AAAAAAABsRygFAAAAAAAA2xFKAQAAAAAAwHaEUgAAAAAAALAdoRQAAAAAAABsRygFAAAAAAAA2zntf0kAAAAAKDmcMU4Z2nqoex4AEBjOmAAAAAAQAg2irmtzHccQAIJE9z0AAAAAAADYjkopAAAAAAiBy+WS3479ZubrJdUTh8PB8QSAABBKAQAAAEAI0rPT5bblt5n5lCEpkuhM5HgCQADovgcAAAAAAADbEUoBAAAAAADAdoRSAAAAAAAAsB2hFAAAAAAAAGxHKAUAAAAAAADbEUoBAAAAAADAdk77XxIAAAAASg5njFMGNh/ongcABIYzJgAAAACEQIOom869iWMIAEGi+x4AAAAAAABsR6UUAAAAAITA5XLJgVMHzHz1stXF4XBwPAEgAIRSAAAAABCC9Ox0GfXPUWY+ZUiKJDoTOZ4AEAC67wEAAAAAAMB2hFIAAAAAAACwHaEUAAAAAAAAbEcoBQAAAAAAANsRSgEAAAAAAMB2hFIAAAAAAACwndP+lwQAAACAkiPWESuXNb3MPQ8ACAyhFAAAAACEIC42TsZ2GssxBIAg0X0PAAAAAAAAtqNSCgAAAABC4HK55Fj6MTOflJAkDoeD4wkAASCUAgAAAIAQpGenyw3LbjDzKUNSJNGZyPEEgADQfQ8AAAAAAAC2I5QCAAAAAACA7QilAAAAAAAAYDtCKQAAAAAAANiOUAoAAAAAAAC2I5QCAAAAAACA7Zz2vyQAAAAAlByxjljp2ainex4AEBhCKQAAAAAIQVxsnIw/bzzHEACCRPc9AAAAAAAA2I5KKQAAAAAIgcvlkvTsdDOfEJsgDoeD4wkAAaBSCgAAAABCoIHUkJQhZrLCKQBAwQilAAAAAAAAYDtCKQAAAAAAANiOUAoAAAAAAAC2I5QCAAAAAACA7QilAAAAAAAAYDtCKQAAAAAAANjOaf9LAgAAAEDJEeOIkfPrne+eBwAEJiLPmPPnz5eGDRtKYmKidOnSRdavX5/v+ikpKdK8eXOzfps2bWT58uV5rjtmzBhxOBwyd+5cv4+np6dLu3btzDrffPNNyO8FAAAAQMkWHxsv919wv5l0HgAQpaHU0qVLZcKECTJt2jTZuHGjtG3bVvr06SOpqal+11+7dq0MHTpURo0aJZs2bZIBAwaYacuWLbnWXbZsmXzxxRdSu3btPF//3nvvzfdxAAAAAAAAlMBQas6cOTJ69GgZOXKktGzZUhYsWCBly5aVl156ye/68+bNk759+8rEiROlRYsWMnPmTGnfvr089dRTXuvt3r1bbr/9dlm0aJHExcX53dYHH3wg//rXv+TRRx8Ny3sDAAAAAABABIZSGRkZ8vXXX0uvXr3cy2JiYsz9devW+X2OLvdcX2lllef6OTk5cuONN5rgqlWrVn63s3//fhOG/f3vfzchGAAAAAAEIi0rTa5YfIWZdB4AEIUDnR88eFCys7OlRo0aXsv1/rZt2/w+Z9++fX7X1+WW2bNni9PplDvuuMPvNlwul4wYMcKMN9WxY0fZsWNHgfuqY0/pZDl27Jg7ANMpmuj+6jGItv2GfWgjoJ2Acwn4vEGkiMS/S6x9suYjad9Ko0hsI4g8tJPwCvT3L6JCqXDQyivt4qfjU+ng5f48+eSTcvz4cZk0aVLA2501a5bMmDEj1/IDBw5IWlpa1DWWo0ePmhO3VqYBtBFwLgGfNygO/E2CaG0nWh2VkZ5h5nUs3ERnYnHvUqkWiW0EkYd2El6asURdKFWtWjWJjY01Xek86f2aNWv6fY4uz2/9zz77zHww1K9f3/24VmPdfffd5gp8WhW1evVq090vISHBaztaNXX99dfLK6+8kut1NcDSAdk9K6Xq1asn1atXl6SkJIm2X0YN7HTfOWmDNgLOJeDzBsWFv0kQre1EQ6n4hDNX3UtOTiaUKmaR2EYQeWgn4ZWYmBh9oVR8fLx06NBBVq1aZa6gZzUUvT9u3Di/z+natat5fPz48e5lK1euNMuVjiXlb8wpXa6DqasnnnhCHn74Yffje/bsMevolQC7dOni93U1wPINsZSe9KLxxKcn7Wjdd9iDNgLaCTiXgM8bRIpI+7tE98PqlRFJ+1WaRVobQWSinYRPoL97ERVKKa0+Gj58uKlS6ty5s6lmOnnypDtAGjZsmNSpU8d0n1N33nmndO/eXR577DHp16+fLFmyRDZs2CDPPfecebxq1apm8qRX39NKqrPPPtvc96yiUuXLlze3TZo0kbp169ryvgEAAAAAAEqTiAulrrnmGjMu09SpU81g5e3atZMVK1a4BzPfuXOnV+LWrVs3ee2112TKlCkyefJkadasmbz99tvSunXrYnwXAAAAAAAAiKpQSmlXvby6633yySe5lg0ZMsRMgSro6noNGzZ0Xz0DAAAAAPIT44iRjrU6uucBAFEcSgEAAABAtIiPjZdpPaYV924AQNQhxgcAAAAAAIDtCKUAAAAAAABgO0IpAAAAAAhBWlaaXPX6VWbSeQBAYBhTCgAAAABClJ6dzjEEgCBRKQUAAAAAAADbEUoBAAAAAADAdoRSAAAAAAAAsB2hFAAAAAAAAGxHKAUAAAAAAADbcfU9AAAAAAhBjCNGWldv7Z4HAASGUAoAAAAAQhAfGy+zes3iGAJAkIjxAQAAAAAAYDtCKQAAAAAAANiOUAoAAAAAQpCWlSbXv3W9mXQeABAYxpQCAAAAgBAdSz/GMQSAIFEpBQAAAAAAANsRSgEAAAAAAMB2hFIAAAAAAACwHaEUAAAAAAAAbEcoBQAAAAAAANtx9T0AAAAACEGMI0aaVWnmngcABIZQCgAAAABCEB8bL3P6zOEYAkCQiPEBAAAAAABgO0IpAAAAAAAA2I5QCgAAAABCkJ6VLqPeGWUmnQcABIYxpQAAAAAgBC5xSeqpVPc8ACAwVEoBAAAAAADAdoRSAAAAAAAAsB3d9+C2aJHIr7+KJCfnnipUEHE4OFgAAAAAAKBoEErBbfFih3zwgf8DEh/vHVJVr35m8pyvWvV/U+XKIrGxHFwAAAAAAOAfoRTcDhzI+2BkZIjs2nVmCoRWVVWq5B1UVavmfd/fVKYMPxAAAAAAAEoDQim4LVjgkj17HJKaKnlOGlxlZxd80Fwukd9/PzNt3x74QdZQKq/Aygq19Naa9D5dCwEAAFCcHOKQekn13PMAgMAQSsHt3HNFOnTI/4Dk5JwJmjScskIqazp0yHs6ePDM7dGjgR/k06eDq8hScXG5Ayt/4RVBFgAAAMIhwZkgT/d7moMLAEEilEJQYmL+V7nUvHlgz8nKEjl8OHdolVeIZU36vEBkZors3XtmCjXIqlLlzHhYeU1JSQz4DgAAAABAUSCUQtg5nf8bID1Q2v3v+PG8Qyudt+5b8zqlp4cvyLJCOR0rK7/gqmLFM+GVTr7z2tVQjwcAAAAAAKUdX48RkXSgdCvMadQo8CDr1KncYZW/ec9laWmB75d2X9SqL50Kq2xZ75DKep/WvL9l/ubLlaNqCwAAIBKkZ6XLXR/eZeYf7/O46c4HACgYoRRKVJClQY1ODRoE/jwryNJJwyZrgPaCpiNHzgRhwdLX02nfPgmJVm1ZQVV+1VkFzWtIpscOAAAAheMSl/x27Df3PAAgMIRSKPU0lKlf/8wUDK2aOnYsd1il3Q51cHd9TCfPec/7eqvrFibYsl5ft6HTb2f+BiqU2NjcYZWGXeXL/++2XDlNrcpJzZpnHtdlnpO1nk6EXAAAAACAQBBKAYVkjS+lU6BdDPPqcmgFVhpS5Tfvucx30u0URnb2/wK1vGkoVSGg7WnVlW9o5RtcnQm6/nfrO+/vfpkyVHQBAAAAQElCKAVESJfDWrVC25YO3u4ZWuVVrVXQfDBjbOU3SL1ORX2stArLOl6e875TQY9pwOV7qxOD0AMAAACAfQilgBIiLk6kSpUzUygyMkROnPjfdCboypHdu49KbGxFOXUqxizzXcfzvucyvc3KCv39adh18uSZKZzH0F9gVdBtQY/plJjofT8hgcovAAAAAKUboRQAL/HxucMtHb8qNTVdkpPPdFssbNDlGV5puGTd+s77u+9vKmyXxfyqzXTSijE7+AZV/sKrUJbpfWuy7usYYgAAAAAQCQilABRL0FUUtHrq9Om8Ayt/y3V9fSyYWw3lwkG7SuqU/3heRUu7KHoGVr7hlU5axeXvNr/H9FZ/zqdPx5sB8bVSLK916SYJAChpHOKQ5LLJ7nkAQGAIpQBELWucKZ2qVw/Pa2jwpZVehQmz9FZDJ533nApaVtgrMgZCu1KGY8yvM7SMruDkUavtfMOq/CYNu8K9TmEqAAEAsCQ4E+TFK1/kgABAkAilAKCA4MsKLvRKi+HmGYIVJtDyXOY7+S73vR/OMMyTVp5pYFfU3S9DodVbBQVX+piOO+bvNr/HCrrN6zFr8ndfu2Fq2wQAAACiGaEUAERoCGYnKwxLTz8zaUhl3XrO53d7+nSOHDp0SpzOcpKe7gjoOZ7btya7wjHfCjKdwjmQflELNMCy677vY9akgZ91qxVpJ044pEKFM+vrMsI1AACA0otQCgBQJGHYmQHxT0hyclmJiSl8GY+GQ54hVX6TZ5BWlOv6rh+uccWKYmD+6KL9JGt4LdGqLw2nPMMr3/n8HvNdL9Imz/fnu5xADig5MrIz5P6P7jfzj/R6ROJj44t7lwAgKhBKAQAiivWlvVw5iRgalGlIpSFQMLeFeY6/W2sqzP3iqDwLRnb2mUnDv9LGX2Cly6J5CvU9aFB35EisuQKrBo7BPA8oTjmuHPnp8E/ueQBAYAilAAAo6MPyj8AgGmngE0qoFeh9f49Z3SJ1OrPcJadOZUhsbLxkZjq8HvM3n9djJUVpDuTyr6YL/soVGkqV5jAvHBNBHwDADlH6JzYAAAiE9QVTr3RY3HJyXJKa+rskJycXuounVn5pd0p/gZUGPJ6BVjRNVnhoBVWBTJHYrbS4aLuwjiWKhr+gT8eFs259p6JYHui6DodDMjIqSrlyjoC3E+791qa3d6+IntnefVck0Rme917Y5YSMACIVoRQAAIjKL8p2XxAg0lgBXTBBVlFMVogWnm275OTJNImLS5ScHIft742gL1qCPo1+ykjEfasacmb26vu037dEnLwCq2CnSNuOb/hmBZenT5eXChXOBJfW8vyeY/fyQJ7j+bi/+VAft+YJLVGcCKUAAACiPKArKc5U0x2V5OSEkC6YEKlBXzgDPbtCO39TXo/5W074V3ysn2PpoOeP8sW9E1El3AFYoAGZvWGcQ9LSktxVl+HcF8/bvOZjfJa1aSNy7rlS4hFKAQAAACU06ItUVgBYmGArKytHUlMPSeXKVc04ZIXZRkGhWbDL07NFXjmtb0xk6EMiMSHuR7j3uzBToNuK9AtswD/9uZWu4NIKL8tKpJo8mVAKAAAAACIqANTgo1y5bElOPlNNEAnSskQ2/zPJzE/sf2ZMqdIcbviGjuEIynQ7eb1OdnaOHD58RJKSKnkFl3mtH+7lwTzHel/Wcs/H/c0X9Hgw64b78YLWJdD0Finnt3ArxadLAAAAAAhdojNRFg1axKEU7+5HxUUDjtTUjIgKLhEYO8M4DS8PHjwslStXcYeX4QzrPG/zms/xWNa+feloNYRSAAAAAAAgYqoo7Qsvswgvixm5MQAAAAAAAGxHKAUAAAAAIcjIzpBJH00yk84DAAJD9z0AAAAACEGOK0e2HNjingcABIZKKQAAAAAAANiOUAoAAAAAAAC2I5QCAAAAAACA7QilAAAAAAAAYDtCKQAAAAAAANiOq+8BAAAAQIgSYhM4hgAQJEIpAAAAAAhBojNR3rj6DY4hAASJ7nsAAAAAAACwXUSGUvPnz5eGDRtKYmKidOnSRdavX5/v+ikpKdK8eXOzfps2bWT58uV5rjtmzBhxOBwyd+5c97IdO3bIqFGjpFGjRlKmTBlp0qSJTJs2TTIyMor0fQEAAAAAACBCQ6mlS5fKhAkTTCi0ceNGadu2rfTp00dSU1P9rr927VoZOnSoCZU2bdokAwYMMNOWLVtyrbts2TL54osvpHbt2l7Lt23bJjk5OfLss8/K1q1b5fHHH5cFCxbI5MmTw/Y+AQAAAJQMGdkZMuOTGWbSeQBAlIZSc+bMkdGjR8vIkSOlZcuWJhwqW7asvPTSS37XnzdvnvTt21cmTpwoLVq0kJkzZ0r79u3lqaee8lpv9+7dcvvtt8uiRYskLi7O6zF9/sKFC6V3797SuHFj6d+/v9xzzz3y1ltvhfW9AgAAAIh+Oa4c2bB3g5l0HgAQhaGUdpf7+uuvpVevXu5lMTEx5v66dev8PkeXe66vtLLKc32tgrrxxhtNcNWqVauA9uXo0aNSpUqVQr8XAAAAAAAARMnV9w4ePCjZ2dlSo0YNr+V6X7vY+bNv3z6/6+tyy+zZs8XpdModd9wR0H5s375dnnzySXn00UfzXCc9Pd1MlmPHjrkDMJ2iie6vy+WKuv2GfWgjoJ2Acwn4vEGkiMS/S6x9suYjad9Ko0hsI4g8tJPwCvT3L6JCqXDQyivt4qfjU+kA5wXRbn7anW/IkCGmG2FeZs2aJTNmzMi1/MCBA5KWlibR1li0MkxP3FqZBtBGwLkEfN6gOPA3CaK1naRlpUlG+pmxpHQs3ERnYnHvUqkWiW0EkYd2El7Hjx+PvlCqWrVqEhsbK/v37/darvdr1qzp9zm6PL/1P/vsM/PBUL9+fffjWo119913myvw6ZX3LHv27JGLL75YunXrJs8991y++zpp0iQzILtnpVS9evWkevXqkpSUJNH2y6iBne47J23QRsC5BHzeoLjwNwmitZ1oKBWfEG/mk5OTCaWKWSS2EUQe2kl4JSYmRl8oFR8fLx06dJBVq1aZK+hZDUXvjxs3zu9zunbtah4fP368e9nKlSvNcqVjSfkbc0qX62DqnhVSGkjp6+ug5wWdvBISEszkS58XjSc+PWlH677DHrQR0E7AuQR83iBSRNrfJbofVq+MSNqv0izS2ggiE+0kfAL93YuoUEpp9dHw4cOlY8eO0rlzZ1PNdPLkSXeANGzYMKlTp47pPqfuvPNO6d69uzz22GPSr18/WbJkiWzYsMFd6VS1alUzedKr72kl1dlnn+0OpHr06CENGjQw40hpFzxLXhVavqw+5NbYUtFEgz8trdMkk5M2aCPgXAI+b1Bc+JsE0dpOtFIq81Sm+/tAhvNMVz4Uj0hsI4g8tJPwsrIRKyuJmlDqmmuuMaHQ1KlTzWDl7dq1kxUrVrgHM9+5c6fXiUW72r322msyZcoUmTx5sjRr1kzefvttad26dcCvqZVVOri5TnXr1vV6rKAD6NtfUrvwAQAAACidavyf90WYAKA0O378uFSsWDHPxx2uQFMXFJiy6phUFSpUCGhA9UhijYf122+/Rd14WLAHbQS0E3AuAZ83iBT8XQLaCDiXRD6NmjSQql27dr4VixFXKRWt9CD7VllFGw2kCKVAGwHnEvB5g+LG3ySgnYBzCfjMiX75VUhZ6GALAAAAAAAA2xFKAQAAAAAAwHaEUpCEhASZNm2auQX8oY0gELQT0EYQKs4joJ2gKHAuAe0kejDQOQAAAAAAAGxHpRQAAAAAAABsRygFAAAAAAAA2xFKAQAAAAAAwHaEUqXc/PnzpWHDhpKYmChdunSR9evXF/cuoRhNnz5dHA6H19S8eXP342lpaXLbbbdJ1apVpXz58jJ48GDZv38/P7MS7N///rdcccUVUrt2bdMe3n77ba/HXS6XTJ06VWrVqiVlypSRXr16yU8//eS1zuHDh+X666+XpKQkqVSpkowaNUpOnDhh8ztBcbWRESNG5Dqv9O3b12sd2kjJNmvWLOnUqZNUqFBBkpOTZcCAAfLDDz94rRPI58vOnTulX79+UrZsWbOdiRMnSlZWls3vBsXZTnr06JHrfDJmzBivdWgnJdczzzwj55xzjvl7QqeuXbvKBx984H6c8wgCaSecRyIPoVQptnTpUpkwYYK58t7GjRulbdu20qdPH0lNTS3uXUMxatWqlezdu9c9ff755+7H7rrrLnn33XclJSVFPv30U9mzZ48MGjSIn1cJdvLkSXNu0ADbn7/+9a/yxBNPyIIFC+TLL7+UcuXKmfOI/mFo0UBq69atsnLlSnnvvfdMiHHzzTfb+C5QnG1EaQjleV5ZvHix1+O0kZJNPy80cPriiy/MeSAzM1N69+5t2k6gny/Z2dkmkMrIyJC1a9fKK6+8Ii+//LIJxVF62okaPXq01/lEP4cstJOSrW7duvLII4/I119/LRs2bJBLLrlErrzySvM3huI8gkDaieI8EmFcKLU6d+7suu2229z3s7OzXbVr13bNmjWrWPcLxWfatGmutm3b+n3syJEjrri4OFdKSop72ffff+/S08i6dets3EsUF/1ZL1u2zH0/JyfHVbNmTdff/vY3r3aSkJDgWrx4sbn/3Xffmed99dVX7nU++OADl8PhcO3evdvmdwC724gaPny468orr8zzObSR0ic1NdW0lU8//TTgz5fly5e7YmJiXPv27XOv88wzz7iSkpJc6enpxfAuYHc7Ud27d3fdeeedeT6HdlL6VK5c2fXCCy9wHkFA7URxHok8VEqVUvovjZoea1cbS0xMjLm/bt26Yt03FC/teqXdcBo3bmyqF7QMXml70X+19Gwz2rWvfv36tJlS6pdffpF9+/Z5tYmKFSuarsDWeURvtctex44d3evo+nq+0coqlA6ffPKJ6Y5z9tlny9ixY+XQoUPux2gjpc/Ro0fNbZUqVQL+fNHbNm3aSI0aNdzraFXmsWPHvP71GyW3nVgWLVok1apVk9atW8ukSZPk1KlT7sdoJ6WHVsUtWbLEVNJp9yzOIwiknVg4j0QWZ3HvAIrHwYMHzS+p5x93Su9v27aNH0sppWGCdofQL45aEj9jxgy58MILZcuWLSZ8iI+PNwGDb5vRx1D6WD93f+cR6zG91TDCk9PpNF8yaDelg3bd025YjRo1kp9//lkmT54sl156qfnyGBsbSxspZXJycmT8+PFy/vnnm1BBBfL5orf+zjXWYyj57URdd9110qBBA/OPZ5s3b5b77rvPjDv11ltvmcdpJyXff/7zHxMu6DABOv7csmXLpGXLlvLNN99wHkGB7URxHok8hFIA3PSLokUHCNSQSv/4e/31180g1gAQrGuvvdY9r5Uuem5p0qSJqZ7q2bMnB7SU0TGD9B86PMcrBAJtJ57jEer5RC+yoecRDbz1vIKST//hVAMoraR74403ZPjw4WY8MiCQdqLBFOeRyEP3vVJKy571X6h9r2yj92vWrFls+4XIov9qfdZZZ8n27dtNu9Bun0eOHPFahzZTelnnivzOI3rre/EEvVqWXm2Nc03ppF2D9TNIzyuKNlJ6jBs3zlzs4OOPPzYD0VoC+XzRW3/nGusxlPx24o/+45nyPJ/QTko2raps2rSpdOjQwVyxUS+0MW/ePM4jCKid+MN5pPgRSpXiX1T9JV21apVXqbTe9+xvi9LtxIkT5l8f9V8itb3ExcV5tRktmdcxp2gzpZN2x9IvAJ5tQsd30bGirDaht/pFU8d6sKxevdqcb6w/AlC67Nq1y4wppecVRRsp+XQMfA0atPuE/v7rucNTIJ8veqvdMTxDbr1Cm17u2+qSgZLdTvzRSgjleT6hnZQu+vdEeno65xEE1E784TwSAYp7pHUUnyVLlpirZL388svm6kc333yzq1KlSl5XtkHpcvfdd7s++eQT1y+//OJas2aNq1evXq5q1aqZK+CoMWPGuOrXr+9avXq1a8OGDa6uXbuaCSXX8ePHXZs2bTKTfmTMmTPHzP/666/m8UceecScN9555x3X5s2bzVXWGjVq5Dp9+rR7G3379nWde+65ri+//NL1+eefu5o1a+YaOnRoMb4r2NVG9LF77rnHXEFNzysfffSRq3379qYNpKWlubdBGynZxo4d66pYsaL5fNm7d697OnXqlHudgj5fsrKyXK1bt3b17t3b9c0337hWrFjhql69umvSpEnF9K5gdzvZvn2766GHHjLtQ88n+rnTuHFj10UXXeTeBu2kZLv//vvN1Rj1569/c+h9vZrvv/71L/M45xEU1E44j0QmQqlS7sknnzR/BMbHx7s6d+7s+uKLL4p7l1CMrrnmGletWrVMe6hTp465rydviwYNt956q7msatmyZV0DBw40fzCi5Pr4449N0OA7DR8+3Dyek5PjevDBB101atQwIXfPnj1dP/zwg9c2Dh06ZEKo8uXLm8u3jxw50oQVKPltRL9Maoig4UFcXJyrQYMGrtGjR+f6xw/aSMnmr33otHDhwqA+X3bs2OG69NJLXWXKlDH/YKL/kJKZmVkM7wjF0U527txpAqgqVaqYz5umTZu6Jk6c6Dp69KjXdmgnJddNN91kPkf071T9XNG/OaxASnEeQUHthPNIZHLo/4q7WgsAAAAAAAClC2NKAQAAAAAAwHaEUgAAAAAAALAdoRQAAAAAAABsRygFAAAAAAAA2xFKAQAAAAAAwHaEUgAAAAAAALAdoRQAAAAAAABsRygFAAAAAAAA2xFKAQAAlFKffPKJOBwOcwsAAGA3QikAAIAi8vLLL5uQZ8OGDeb+8uXLZfr06cV+fJ9++mmzbwAAAJGEUAoAACBMNJSaMWNGxIZSF110kZw+fdrcAgAA2I1QCgAAIIq4XC4TJBWFmJgYSUxMNLcAAAB24y8QAACAMBgxYoTMnz/fzGuXPmuy5OTkyNy5c6VVq1YmGKpRo4bccsst8vvvv3ttp2HDhnL55ZfLhx9+KB07dpQyZcrIs88+ax5buHChXHLJJZKcnCwJCQnSsmVLeeaZZ3I9f+vWrfLpp5+696FHjx75jimVkpIiHTp0MK9VrVo1ueGGG2T37t253l/58uXN8gEDBpj56tWryz333CPZ2dlFfDQBAEBJ5CzuHQAAACiJNGDas2ePrFy5Uv7+97/7fVy71I0cOVLuuOMO+eWXX+Spp56STZs2yZo1ayQuLs697g8//CBDhw41zxk9erScffbZZrkGUBpq9e/fX5xOp7z77rty6623msDrtttuM+to8HX77beb0OiBBx4wyzQAy4u1T506dZJZs2bJ/v37Zd68eWafdN8qVarkXlfDpz59+kiXLl3k0UcflY8++kgee+wxadKkiYwdO7ZIjycAACh5HC6tAQcAAEDIrEDnq6++MlVN48aNM9VSvn9uff7553LhhRfKokWL5LrrrnMv12qovn37ei3XSqdff/1VVqxYYQIgT9qNT6uZPOnzf/rpJ/n555/dy1q3bm0qnnwrovT+xRdfLB9//LGpnsrMzJS6deuayit9D1rBpd5//31TrTV16lT3GFlaKfXKK6/IQw89JA8++KB7m+3btzfdAa3B3gEAAPJC9z0AAACbafe4ihUryp/+9Cc5ePCge9Iuc1rRpCGRp0aNGuUKpJRnIHX06FGzje7du8t///tfcz9YGiSlpqaaaisrkFL9+vWT5s2bm3DK15gxY7zua9imrw8AAFAQuu8BAADYTCuZNDTSiiR/NBjyDaX80S5106ZNk3Xr1smpU6e8HtPta/AVDK3IUlb3QE8aSmmFlycNrnQcKU+VK1fONS4WAACAP4RSAAAANtMxnzSQ0m56/vgGPb5d9JR2z+vZs6cJi+bMmSP16tWT+Ph4Wb58uTz++OPmNcItNjY27K8BAABKLkIpAACAMPG82p4nHQhcBwU///zz/QZOgdBBzdPT0+Wf//yn1K9f373ct+tffvvhq0GDBu6B1fWqfp50mfU4AABAUWBMKQAAgDApV66cuT1y5IjX8quvvtpcuW7mzJm5npOVlZVr/fyqlDwHUdcuewsXLvS7H4FsUwdn1wquBQsWmMDL8sEHH8j3339vxpYCAAAoKlRKAQAAhIkOXK7uuOMOM1C5BknXXnutGYz8lltukVmzZsk333wjvXv3lri4ODPWlA6CPm/ePLnqqqvy3bY+R7vrXXHFFWZbJ06ckOeff96ESnv37s21H88884w8/PDD0rRpU7OObyWU0n2YPXu2uYKg7uPQoUNl//79Zn/0KoB33XVXER8hAABQmhFKAQAAhMmgQYPk9ttvlyVLlsg//vEPU9WkoZTSaiQNi5599lmZPHmyOJ1OE/zccMMNpltfQXQw8jfeeEOmTJki99xzj9SsWVPGjh1rxqO66aabvNadOnWqGcT8r3/9qxw/ftwETv5CKTVixAgpW7asPPLII3LfffeZKquBAweasKpSpUpFdGQAAABEHC7Pmm8AAAAAAADABowpBQAAAAAAANsRSgEAAAAAAMB2hFIAAAAAAACwHaEUAAAAAAAAbEcoBQAAAAAAANsRSgEAAAAAAMB2hFIAAAAAAACwHaEUAAAAAAAAbEcoBQAAAAAAANsRSgEAAAAAAMB2hFIAAAAAAACwHaEUAAAAAAAAbEcoBQAAAAAAALHb/wM+rnZWS4+q3QAAAABJRU5ErkJggg==" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "[指标分析]\n", + " 最佳验证 l1: 0.053715\n", + " 最佳迭代轮数: 264\n", + " 早停建议: 如果验证指标连续10轮不下降，建议在第 264 轮停止训练\n", + "\n", + "[重要提醒] 验证集仅用于早停/调参，测试集完全独立于训练过程！\n" + ] + } + ], + "execution_count": 31 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4.4 查看结果" + ] + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-03-07T17:06:28.129848Z", + "start_time": "2026-03-07T17:06:28.109731Z" } }, "source": [ @@ -856,48 +1085,44 @@ "================================================================================\n", "\n", "结果数据形状: (771207, 25)\n", - "结果列: ['ts_code', 'trade_date', 'low', 'close', 'vol', 'high', 'total_mv', 'f_ann_date', 'n_income', 'ma5', 'ma10', 'ma20', 'ma_ratio', 'volatility_5', 'volatility_20', 'vol_ratio', 'return_10', 'return_20', 'return_diff', 'vol_ma5', 'vol_ma20', 'market_cap_rank', 'high_low_ratio', 'return_5', 'prediction']\n", + "结果列: ['ts_code', 'trade_date', 'close', 'vol', 'high', 'low', 'total_mv', 'f_ann_date', 'n_income', 'ma5', 'ma10', 'ma20', 'ma_ratio', 'volatility_5', 'volatility_20', 'vol_ratio', 'return_10', 'return_20', 'return_diff', 'vol_ma5', 'vol_ma20', 'market_cap_rank', 'high_low_ratio', 'return_5', 'prediction']\n", "\n", "结果前10行预览:\n", "shape: (10, 25)\n", "┌───────────┬───────────┬───────────┬───────────┬───┬───────────┬───────────┬───────────┬──────────┐\n", - "│ ts_code ┆ trade_dat ┆ low ┆ close ┆ … ┆ market_ca ┆ high_low_ ┆ return_5 ┆ predicti │\n", + "│ ts_code ┆ trade_dat ┆ close ┆ vol ┆ … ┆ market_ca ┆ high_low_ ┆ return_5 ┆ predicti │\n", "│ --- ┆ e ┆ --- ┆ --- ┆ ┆ p_rank ┆ ratio ┆ --- ┆ on │\n", "│ str ┆ --- ┆ f64 ┆ f64 ┆ ┆ --- ┆ --- ┆ f64 ┆ --- │\n", "│ ┆ str ┆ ┆ ┆ ┆ f64 ┆ f64 ┆ ┆ f64 │\n", "╞═══════════╪═══════════╪═══════════╪═══════════╪═══╪═══════════╪═══════════╪═══════════╪══════════╡\n", - "│ 000001.SZ ┆ 20250102 ┆ 7.215424 ┆ 7.219817 ┆ … ┆ 1.575139 ┆ -1.347097 ┆ -0.002622 ┆ -0.00414 │\n", - "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 1 │\n", - "│ 000002.SZ ┆ 20250102 ┆ 7.215424 ┆ 7.219817 ┆ … ┆ 1.500066 ┆ -1.494802 ┆ -0.022509 ┆ -0.00644 │\n", - "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 3 │\n", - "│ 000004.SZ ┆ 20250102 ┆ -0.122611 ┆ -0.106629 ┆ … ┆ -1.525498 ┆ -1.110228 ┆ -0.064897 ┆ 0.018069 │\n", - "│ 000006.SZ ┆ 20250102 ┆ 1.429646 ┆ 1.41091 ┆ … ┆ 0.645142 ┆ -1.46853 ┆ -0.048278 ┆ -0.00495 │\n", - "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 8 │\n", - "│ 000007.SZ ┆ 20250102 ┆ -0.100317 ┆ -0.103205 ┆ … ┆ -1.232326 ┆ -0.209675 ┆ 0.015649 ┆ -0.00123 │\n", - "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 1 │\n", - "│ 000008.SZ ┆ 20250102 ┆ -0.063519 ┆ -0.067059 ┆ … ┆ 0.410216 ┆ -1.48541 ┆ -0.066939 ┆ -0.01023 │\n", - "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 3 │\n", - "│ 000009.SZ ┆ 20250102 ┆ 0.045333 ┆ 0.039996 ┆ … ┆ 1.197186 ┆ -1.358101 ┆ -0.036045 ┆ 0.002236 │\n", - "│ 000010.SZ ┆ 20250102 ┆ -0.293174 ┆ -0.293811 ┆ … ┆ -0.872494 ┆ -1.382331 ┆ 0.092123 ┆ -0.00730 │\n", - "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 3 │\n", - "│ 000011.SZ ┆ 20250102 ┆ -0.233141 ┆ -0.235741 ┆ … ┆ -0.098467 ┆ -1.409992 ┆ -0.022094 ┆ -0.00176 │\n", - "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 3 │\n", - "│ 000012.SZ ┆ 20250102 ┆ 0.54057 ┆ 0.526749 ┆ … ┆ 1.006268 ┆ -1.411495 ┆ -0.029188 ┆ 0.000613 │\n", + "│ 000001.SZ ┆ 20250102 ┆ 7.139221 ┆ 5.587779 ┆ … ┆ 1.588367 ┆ -1.34697 ┆ -0.002622 ┆ -0.00449 │\n", + "│ 000002.SZ ┆ 20250102 ┆ 7.139221 ┆ 3.526191 ┆ … ┆ 1.513717 ┆ -1.494739 ┆ -0.022509 ┆ 0.00046 │\n", + "│ 000004.SZ ┆ 20250102 ┆ -0.117733 ┆ -0.216144 ┆ … ┆ -1.494831 ┆ -1.109999 ┆ -0.064897 ┆ 0.01386 │\n", + "│ 000006.SZ ┆ 20250102 ┆ 1.365091 ┆ 0.443786 ┆ … ┆ 0.663601 ┆ -1.468456 ┆ -0.048278 ┆ 0.007108 │\n", + "│ 000007.SZ ┆ 20250102 ┆ -0.114388 ┆ -0.397614 ┆ … ┆ -1.203308 ┆ -0.209058 ┆ 0.015649 ┆ -0.00067 │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 4 │\n", + "│ 000008.SZ ┆ 20250102 ┆ -0.079069 ┆ 3.219998 ┆ … ┆ 0.429996 ┆ -1.485343 ┆ -0.066939 ┆ -0.00880 │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 4 │\n", + "│ 000009.SZ ┆ 20250102 ┆ 0.025538 ┆ 0.204049 ┆ … ┆ 1.21254 ┆ -1.357979 ┆ -0.036045 ┆ 0.001033 │\n", + "│ 000010.SZ ┆ 20250102 ┆ -0.300634 ┆ 0.584268 ┆ … ┆ -0.8455 ┆ -1.382219 ┆ 0.092123 ┆ -0.00428 │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ 5 │\n", + "│ 000011.SZ ┆ 20250102 ┆ -0.243891 ┆ -0.488782 ┆ … ┆ -0.075826 ┆ -1.409893 ┆ -0.022094 ┆ 0.002294 │\n", + "│ 000012.SZ ┆ 20250102 ┆ 0.501156 ┆ -0.060654 ┆ … ┆ 1.022696 ┆ -1.411396 ┆ -0.029188 ┆ 0.000017 │\n", "└───────────┴───────────┴───────────┴───────────┴───┴───────────┴───────────┴───────────┴──────────┘\n", "\n", "结果后5行预览:\n", "shape: (5, 25)\n", "┌───────────┬───────────┬───────────┬───────────┬───┬───────────┬───────────┬──────────┬───────────┐\n", - "│ ts_code ┆ trade_dat ┆ low ┆ close ┆ … ┆ market_ca ┆ high_low_ ┆ return_5 ┆ predictio │\n", + "│ ts_code ┆ trade_dat ┆ close ┆ vol ┆ … ┆ market_ca ┆ high_low_ ┆ return_5 ┆ predictio │\n", "│ --- ┆ e ┆ --- ┆ --- ┆ ┆ p_rank ┆ ratio ┆ --- ┆ n │\n", "│ str ┆ --- ┆ f64 ┆ f64 ┆ ┆ --- ┆ --- ┆ f64 ┆ --- │\n", "│ ┆ str ┆ ┆ ┆ ┆ f64 ┆ f64 ┆ ┆ f64 │\n", "╞═══════════╪═══════════╪═══════════╪═══════════╪═══╪═══════════╪═══════════╪══════════╪═══════════╡\n", - "│ 605588.SH ┆ 20251231 ┆ -0.150009 ┆ -0.151005 ┆ … ┆ -1.041064 ┆ 0.083361 ┆ null ┆ 0.002801 │\n", - "│ 605589.SH ┆ 20251231 ┆ -0.282833 ┆ -0.286372 ┆ … ┆ 1.082326 ┆ 0.586743 ┆ null ┆ 0.003757 │\n", - "│ 605598.SH ┆ 20251231 ┆ 0.163451 ┆ 0.166474 ┆ … ┆ 0.865913 ┆ 1.46704 ┆ null ┆ -0.003742 │\n", - "│ 605599.SH ┆ 20251231 ┆ -0.360996 ┆ -0.359651 ┆ … ┆ 0.623404 ┆ 1.560273 ┆ null ┆ 0.004761 │\n", - "│ 689009.SH ┆ 20251231 ┆ -0.101257 ┆ -0.108012 ┆ … ┆ 1.304467 ┆ -1.339619 ┆ null ┆ -0.000987 │\n", + "│ 605588.SH ┆ 20251231 ┆ -0.161094 ┆ -0.601605 ┆ … ┆ -1.013122 ┆ 0.084104 ┆ null ┆ 0.003068 │\n", + "│ 605589.SH ┆ 20251231 ┆ -0.293364 ┆ -0.152478 ┆ … ┆ 1.098326 ┆ 0.587703 ┆ null ┆ 0.002339 │\n", + "│ 605598.SH ┆ 20251231 ┆ 0.149122 ┆ -0.248806 ┆ … ┆ 0.88313 ┆ 1.46838 ┆ null ┆ -0.002429 │\n", + "│ 605599.SH ┆ 20251231 ┆ -0.364967 ┆ -0.482522 ┆ … ┆ 0.641985 ┆ 1.561653 ┆ null ┆ 0.004799 │\n", + "│ 689009.SH ┆ 20251231 ┆ -0.119084 ┆ -0.481066 ┆ … ┆ 1.319218 ┆ -1.339489 ┆ null ┆ -0.000833 │\n", "└───────────┴───────────┴───────────┴───────────┴───┴───────────┴───────────┴──────────┴───────────┘\n", "\n", "每日预测样本数统计:\n", @@ -912,21 +1137,21 @@ "│ --- ┆ --- ┆ --- ┆ --- │\n", "│ str ┆ str ┆ f64 ┆ f64 │\n", "╞═══════════╪════════════╪═══════════╪════════════╡\n", - "│ 000001.SZ ┆ 20250102 ┆ -0.002622 ┆ -0.004141 │\n", - "│ 000002.SZ ┆ 20250102 ┆ -0.022509 ┆ -0.006443 │\n", - "│ 000004.SZ ┆ 20250102 ┆ -0.064897 ┆ 0.018069 │\n", - "│ 000006.SZ ┆ 20250102 ┆ -0.048278 ┆ -0.004958 │\n", - "│ 000007.SZ ┆ 20250102 ┆ 0.015649 ┆ -0.001231 │\n", - "│ 000008.SZ ┆ 20250102 ┆ -0.066939 ┆ -0.010233 │\n", - "│ 000009.SZ ┆ 20250102 ┆ -0.036045 ┆ 0.002236 │\n", - "│ 000010.SZ ┆ 20250102 ┆ 0.092123 ┆ -0.007303 │\n", - "│ 000011.SZ ┆ 20250102 ┆ -0.022094 ┆ -0.001763 │\n", - "│ 000012.SZ ┆ 20250102 ┆ -0.029188 ┆ 0.000613 │\n", + "│ 000001.SZ ┆ 20250102 ┆ -0.002622 ┆ -0.00449 │\n", + "│ 000002.SZ ┆ 20250102 ┆ -0.022509 ┆ 0.00046 │\n", + "│ 000004.SZ ┆ 20250102 ┆ -0.064897 ┆ 0.01386 │\n", + "│ 000006.SZ ┆ 20250102 ┆ -0.048278 ┆ 0.007108 │\n", + "│ 000007.SZ ┆ 20250102 ┆ 0.015649 ┆ -0.000674 │\n", + "│ 000008.SZ ┆ 20250102 ┆ -0.066939 ┆ -0.008804 │\n", + "│ 000009.SZ ┆ 20250102 ┆ -0.036045 ┆ 0.001033 │\n", + "│ 000010.SZ ┆ 20250102 ┆ 0.092123 ┆ -0.004285 │\n", + "│ 000011.SZ ┆ 20250102 ┆ -0.022094 ┆ 0.002294 │\n", + "│ 000012.SZ ┆ 20250102 ┆ -0.029188 ┆ 0.000017 │\n", "└───────────┴────────────┴───────────┴────────────┘\n" ] } ], - "execution_count": 17 + "execution_count": 32 }, { "cell_type": "markdown", @@ -938,8 +1163,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-03-07T16:28:11.060067Z", - "start_time": "2026-03-07T16:28:10.751743Z" + "end_time": "2026-03-07T17:06:28.442742Z", + "start_time": "2026-03-07T17:06:28.133253Z" } }, "cell_type": "code", @@ -1011,22 +1236,22 @@ "│ --- ┆ --- ┆ --- │\n", "│ str ┆ f64 ┆ str │\n", "╞════════════╪══════════╪═══════════╡\n", - "│ 2025-01-02 ┆ 0.129296 ┆ 603007.SH │\n", - "│ 2025-01-02 ┆ 0.087661 ┆ 603559.SH │\n", - "│ 2025-01-02 ┆ 0.056859 ┆ 000595.SZ │\n", - "│ 2025-01-02 ┆ 0.052261 ┆ 600811.SH │\n", - "│ 2025-01-02 ┆ 0.046187 ┆ 603366.SH │\n", + "│ 2025-01-02 ┆ 0.112045 ┆ 603007.SH │\n", + "│ 2025-01-02 ┆ 0.085536 ┆ 603559.SH │\n", + "│ 2025-01-02 ┆ 0.02923 ┆ 603959.SH │\n", + "│ 2025-01-02 ┆ 0.027056 ┆ 002356.SZ │\n", + "│ 2025-01-02 ┆ 0.025893 ┆ 002693.SZ │\n", "│ … ┆ … ┆ … │\n", - "│ 2025-01-06 ┆ 0.145456 ┆ 603007.SH │\n", - "│ 2025-01-06 ┆ 0.066654 ┆ 603959.SH │\n", - "│ 2025-01-06 ┆ 0.06255 ┆ 002691.SZ │\n", - "│ 2025-01-06 ┆ 0.054795 ┆ 000638.SZ │\n", - "│ 2025-01-06 ┆ 0.047319 ┆ 002713.SZ │\n", + "│ 2025-01-06 ┆ 0.122962 ┆ 603007.SH │\n", + "│ 2025-01-06 ┆ 0.05708 ┆ 603959.SH │\n", + "│ 2025-01-06 ┆ 0.031928 ┆ 603106.SH │\n", + "│ 2025-01-06 ┆ 0.029876 ┆ 603536.SH │\n", + "│ 2025-01-06 ┆ 0.02902 ┆ 000856.SZ │\n", "└────────────┴──────────┴───────────┘\n" ] } ], - "execution_count": 18 + "execution_count": 33 }, { "cell_type": "markdown", @@ -1039,8 +1264,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2026-03-07T16:28:11.069209Z", - "start_time": "2026-03-07T16:28:11.065068Z" + "end_time": "2026-03-07T17:06:28.449645Z", + "start_time": "2026-03-07T17:06:28.446303Z" } }, "source": [ @@ -1060,21 +1285,21 @@ "text": [ "\n", "特征重要性:\n", - "return_10 3245.995642\n", - "ma_ratio 2818.976538\n", - "vol_ratio 2701.151667\n", - "return_20 2681.762756\n", - "high_low_ratio 2469.737874\n", - "return_diff 1463.681328\n", - "volatility_5 1357.026476\n", - "market_cap_rank 722.088673\n", - "vol_ma5 653.087969\n", - "vol_ma20 631.252641\n", - "ma20 548.830554\n", - "n_income 495.525785\n", - "ma5 469.811824\n", - "ma10 305.156890\n", - "volatility_20 203.306830\n", + "return_10 2508.074001\n", + "return_20 1599.133273\n", + "vol_ratio 1443.186734\n", + "ma_ratio 1258.536915\n", + "volatility_5 1168.921020\n", + "high_low_ratio 1021.852749\n", + "return_diff 726.928342\n", + "vol_ma20 595.716762\n", + "vol_ma5 551.588497\n", + "market_cap_rank 542.557658\n", + "ma20 432.252425\n", + "n_income 346.770895\n", + "ma5 342.071273\n", + "ma10 328.521408\n", + "volatility_20 136.785447\n", "dtype: float64\n", "\n", "================================================================================\n", @@ -1083,7 +1308,7 @@ ] } ], - "execution_count": 19 + "execution_count": 34 }, { "cell_type": "markdown", @@ -1100,8 +1325,8 @@ "cell_type": "code", "metadata": { "ExecuteTime": { - "end_time": "2026-03-07T16:28:11.377695Z", - "start_time": "2026-03-07T16:28:11.076235Z" + "end_time": "2026-03-07T17:06:28.464210Z", + "start_time": "2026-03-07T17:06:28.457241Z" } }, "source": [ @@ -1125,7 +1350,7 @@ ] } ], - "execution_count": 20 + "execution_count": 35 }, { "cell_type": "markdown", @@ -1142,8 +1367,8 @@ { "metadata": { "ExecuteTime": { - "end_time": "2026-03-07T16:28:11.542731Z", - "start_time": "2026-03-07T16:28:11.384139Z" + "end_time": "2026-03-07T17:06:28.553758Z", + "start_time": "2026-03-07T17:06:28.467408Z" } }, "cell_type": "code", @@ -1193,7 +1418,7 @@ "text/plain": [ "
" ], - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data", @@ -1207,28 +1432,28 @@ "text": [ "\n", "[特征重要性排名 - Gain]\n", - "return_10 3245.995642\n", - "ma_ratio 2818.976538\n", - "vol_ratio 2701.151667\n", - "return_20 2681.762756\n", - "high_low_ratio 2469.737874\n", - "return_diff 1463.681328\n", - "volatility_5 1357.026476\n", - "market_cap_rank 722.088673\n", - "vol_ma5 653.087969\n", - "vol_ma20 631.252641\n", - "ma20 548.830554\n", - "n_income 495.525785\n", - "ma5 469.811824\n", - "ma10 305.156890\n", - "volatility_20 203.306830\n", + "return_10 2508.074001\n", + "return_20 1599.133273\n", + "vol_ratio 1443.186734\n", + "ma_ratio 1258.536915\n", + "volatility_5 1168.921020\n", + "high_low_ratio 1021.852749\n", + "return_diff 726.928342\n", + "vol_ma20 595.716762\n", + "vol_ma5 551.588497\n", + "market_cap_rank 542.557658\n", + "ma20 432.252425\n", + "n_income 346.770895\n", + "ma5 342.071273\n", + "ma10 328.521408\n", + "volatility_20 136.785447\n", "dtype: float64\n", "\n", "所有特征都有一定重要性\n" ] } ], - "execution_count": 21 + "execution_count": 36 } ], "metadata": { diff --git a/src/training/components/splitters.py b/src/training/components/splitters.py index 5d29969..7b17204 100644 --- a/src/training/components/splitters.py +++ b/src/training/components/splitters.py @@ -1,30 +1,39 @@ """数据划分器 -提供基于日期范围的数据划分功能，支持一次性训练/测试划分。 +提供基于日期范围的数据划分功能，支持 train/val/test 三分法。 """ -from typing import Tuple +from typing import Tuple, Optional import polars as pl class DateSplitter: - """基于日期范围的一次性划分 + """基于日期范围的一次性划分（支持 train/val/test 三分法） - 将数据按日期划分为训练集和测试集，不滚动。 + 将数据按日期划分为训练集、验证集和测试集，不滚动。 + + 正确的三分法： + - Train: 用于训练模型参数 + - Val: 用于验证/早停/调参（从训练时间后切出） + - Test: 仅用于最终评估，完全独立于训练过程 示例: - train_start: "20200101", train_end: "20221231" (训练集：3年) + train_start: "20200101", train_end: "20211231" (训练集：2年) + val_start: "20220101", val_end: "20221231" (验证集：1年) test_start: "20230101", test_end: "20231231" (测试集：1年) 特点: - 一次性划分，不滚动 - - 训练集和测试集互不重叠 + - 训练集、验证集、测试集三者互不重叠 + - 验证集和测试集按时间顺序位于训练集之后 - 基于实际日期范围，而非行数 Attributes: train_start: 训练期开始日期，格式 "YYYYMMDD" train_end: 训练期结束日期，格式 "YYYYMMDD" + val_start: 验证期开始日期，格式 "YYYYMMDD"（可选） + val_end: 验证期结束日期，格式 "YYYYMMDD"（可选） test_start: 测试期开始日期，格式 "YYYYMMDD" test_end: 测试期结束日期，格式 "YYYYMMDD" """ @@ -35,6 +44,8 @@ class DateSplitter: train_end: str, test_start: str, test_end: str, + val_start: Optional[str] = None, + val_end: Optional[str] = None, ): """初始化日期划分器 @@ -43,17 +54,31 @@ class DateSplitter: train_end: 训练期结束日期 "YYYYMMDD" test_start: 测试期开始日期 "YYYYMMDD" test_end: 测试期结束日期 "YYYYMMDD" + val_start: 验证期开始日期 "YYYYMMDD"（可选，如果不提供则从 train 中划分） + val_end: 验证期结束日期 "YYYYMMDD"（可选，如果不提供则从 train 中划分） Raises: ValueError: 日期格式错误或日期范围无效 + + Note: + 正确的三分法： + - Train: 用于训练模型参数 + - Val: 用于验证/早停/调参（必须位于 train 之后、test 之前） + - Test: 仅用于最终评估，完全独立于训练过程 """ # 验证日期格式（简单的长度检查） - for name, value in [ + dates_to_check = [ ("train_start", train_start), ("train_end", train_end), ("test_start", test_start), ("test_end", test_end), - ]: + ] + if val_start is not None: + dates_to_check.append(("val_start", val_start)) + if val_end is not None: + dates_to_check.append(("val_end", val_end)) + + for name, value in dates_to_check: if not isinstance(value, str) or len(value) != 8: raise ValueError( f"{name} 必须是格式为 'YYYYMMDD' 的8位字符串，得到: {value}" @@ -68,31 +93,83 @@ class DateSplitter: raise ValueError( f"test_start ({test_start}) 必须早于或等于 test_end ({test_end})" ) - if test_start <= train_end: - raise ValueError( - f"测试集开始日期 ({test_start}) 必须晚于训练集结束日期 ({train_end})，" - "以确保训练集和测试集不重叠" + + # 验证 val 日期（如果提供了） + if val_start is not None and val_end is not None: + if val_start > val_end: + raise ValueError( + f"val_start ({val_start}) 必须早于或等于 val_end ({val_end})" + ) + if val_start <= train_end: + raise ValueError( + f"验证集开始日期 ({val_start}) 必须晚于训练集结束日期 ({train_end})，" + "以确保验证集在训练集之后" + ) + if test_start <= val_end: + raise ValueError( + f"测试集开始日期 ({test_start}) 必须晚于验证集结束日期 ({val_end})，" + "以确保测试集在验证集之后" + ) + elif val_start is not None or val_end is not None: + raise ValueError("val_start 和 val_end 必须同时提供或同时省略") + + # 如果没有提供 val 日期，自动从 train 后划分一段作为 val + # 默认取 train 结束后的 20% 时间作为 val，但必须确保在 test 之前 + if val_start is None: + # 计算 train 时间跨度（天数近似） + from datetime import datetime + + train_start_dt = datetime.strptime(train_start, "%Y%m%d") + train_end_dt = datetime.strptime(train_end, "%Y%m%d") + test_start_dt = datetime.strptime(test_start, "%Y%m%d") + + train_days = (train_end_dt - train_start_dt).days + val_duration = max(int(train_days * 0.2), 30) # 至少30天 + + val_start_dt = train_end_dt + __import__("datetime").timedelta(days=1) + val_end_dt = val_start_dt + __import__("datetime").timedelta( + days=val_duration ) + # 确保 val 在 test 之前 + if val_end_dt >= test_start_dt: + # 取 train 和 test 之间的中点 + gap_days = (test_start_dt - train_end_dt).days + val_end_dt = train_end_dt + __import__("datetime").timedelta( + days=gap_days // 2 + ) + val_start_dt = train_end_dt + __import__("datetime").timedelta(days=1) + + val_start = val_start_dt.strftime("%Y%m%d") + val_end = min(val_end_dt.strftime("%Y%m%d"), test_start) + self.train_start = train_start self.train_end = train_end + self.val_start = val_start + self.val_end = val_end self.test_start = test_start self.test_end = test_end def split( self, data: pl.DataFrame, date_col: str = "trade_date" - ) -> Tuple[pl.DataFrame, pl.DataFrame]: - """划分数据为训练集和测试集 + ) -> Tuple[pl.DataFrame, pl.DataFrame, pl.DataFrame]: + """划分数据为训练集、验证集和测试集 Args: data: 输入数据，必须包含日期列 date_col: 日期列名，默认为 "trade_date" Returns: - (train_data, test_data) 元组 + (train_data, val_data, test_data) 元组 Raises: ValueError: 数据中不包含指定的日期列 + + Note: + 正确的三分法： + - train_data: 用于训练模型参数 + - val_data: 用于验证/早停/调参 + - test_data: 仅用于最终评估，完全独立于训练过程 """ if date_col not in data.columns: raise ValueError(f"数据中不包含列 '{date_col}'，可用列: {data.columns}") @@ -103,20 +180,43 @@ class DateSplitter: & (pl.col(date_col) <= self.train_end) ) + # 筛选验证集数据 + val_data = data.filter( + (pl.col(date_col) >= self.val_start) & (pl.col(date_col) <= self.val_end) + ) + # 筛选测试集数据 test_data = data.filter( (pl.col(date_col) >= self.test_start) & (pl.col(date_col) <= self.test_end) ) - return train_data, test_data + return train_data, val_data, test_data + + def split_train_test( + self, data: pl.DataFrame, date_col: str = "trade_date" + ) -> Tuple[pl.DataFrame, pl.DataFrame]: + """划分数据为训练集和测试集（验证集合并到训练集） + + 适用于不需要验证集的场景，或者使用交叉验证的场景。 + + Args: + data: 输入数据，必须包含日期列 + date_col: 日期列名，默认为 "trade_date" + + Returns: + (train_val_data, test_data) 元组，其中 train_val_data 包含 train + val + """ + train_data, val_data, test_data = self.split(data, date_col) + # 合并 train 和 val + train_val_data = pl.concat([train_data, val_data]) + return train_val_data, test_data def __repr__(self) -> str: """返回划分器的字符串表示""" return ( f"DateSplitter(" - f"train_start='{self.train_start}', " - f"train_end='{self.train_end}', " - f"test_start='{self.test_start}', " - f"test_end='{self.test_end}'" + f"train='{self.train_start}-{self.train_end}', " + f"val='{self.val_start}-{self.val_end}', " + f"test='{self.test_start}-{self.test_end}'" f")" )