377 lines
115 KiB
Plaintext
377 lines
115 KiB
Plaintext
{
|
||
"cells": [
|
||
{
|
||
"cell_type": "code",
|
||
"id": "b93c7ca1",
|
||
"metadata": {
|
||
"ExecuteTime": {
|
||
"end_time": "2025-10-03T06:58:45.372926Z",
|
||
"start_time": "2025-10-03T06:58:45.083976Z"
|
||
}
|
||
},
|
||
"source": [
|
||
"import pandas as pd\n",
|
||
"import numpy as np\n",
|
||
"import matplotlib.pyplot as plt\n",
|
||
"import seaborn as sns\n",
|
||
"import talib as ta # Make sure TA-Lib is installed: pip install TA-Lib\n",
|
||
"import statsmodels.api as sm\n",
|
||
"\n",
|
||
"import warnings\n",
|
||
"\n",
|
||
"# 忽略所有警告\n",
|
||
"warnings.filterwarnings(\"ignore\")\n",
|
||
"\n",
|
||
"# --- 0. Configure your file path ---\n",
|
||
"# Please replace 'your_futures_data.csv' with the actual path to your CSV file\n",
|
||
"file_path = '/mnt/d/PyProject/NewQuant/data/data/KQ_m@CZCE_SA/KQ_m@CZCE_SA_min15.csv'\n",
|
||
"\n",
|
||
"sns.set(style='whitegrid')\n",
|
||
"plt.rcParams['font.sans-serif'] = ['SimHei'] # 用来正常显示中文标签\n",
|
||
"plt.rcParams['axes.unicode_minus'] = False # 用来正常显示负号"
|
||
],
|
||
"outputs": [],
|
||
"execution_count": 1
|
||
},
|
||
{
|
||
"metadata": {
|
||
"ExecuteTime": {
|
||
"end_time": "2025-10-03T06:58:45.441191Z",
|
||
"start_time": "2025-10-03T06:58:45.381967Z"
|
||
}
|
||
},
|
||
"cell_type": "code",
|
||
"source": [
|
||
"\n",
|
||
"# --- 1. Data Loading and Preprocessing ---\n",
|
||
"def load_and_preprocess_data(file_path):\n",
|
||
" \"\"\"\n",
|
||
" Loads historical futures data and performs basic preprocessing.\n",
|
||
" Assumes data contains 'datetime', 'open', 'high', 'low', 'close', 'volume' columns.\n",
|
||
" \"\"\"\n",
|
||
" try:\n",
|
||
" df = pd.read_csv(file_path, parse_dates=['datetime'], index_col='datetime')\n",
|
||
" # Ensure data is sorted by time\n",
|
||
" df = df.sort_index()\n",
|
||
" # Check and handle missing values\n",
|
||
" initial_rows = len(df)\n",
|
||
" df.dropna(inplace=True)\n",
|
||
" if len(df) < initial_rows:\n",
|
||
" print(f\"Warning: Missing values found in data, deleted {initial_rows - len(df)} rows.\")\n",
|
||
"\n",
|
||
" # Check if necessary columns exist\n",
|
||
" required_columns = ['open', 'high', 'low', 'close', 'volume']\n",
|
||
" if not all(col in df.columns for col in required_columns):\n",
|
||
" raise ValueError(f\"CSV file is missing required columns. Please ensure it contains: {required_columns}\")\n",
|
||
"\n",
|
||
" print(f\"Successfully loaded {len(df)} rows of data.\")\n",
|
||
" print(\"First 5 rows of data:\")\n",
|
||
" print(df.head())\n",
|
||
" return df\n",
|
||
" except FileNotFoundError:\n",
|
||
" print(f\"Error: File '{file_path}' not found. Please check the path.\")\n",
|
||
" return None\n",
|
||
" except Exception as e:\n",
|
||
" print(f\"Error during data loading or preprocessing: {e}\")\n",
|
||
" return None\n",
|
||
"\n",
|
||
"\n",
|
||
"df_raw = load_and_preprocess_data(file_path)\n",
|
||
"# df_raw = df_raw[df_raw.index <= '2024-01-01']"
|
||
],
|
||
"id": "3dcf270c1da82220",
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Successfully loaded 25662 rows of data.\n",
|
||
"First 5 rows of data:\n",
|
||
" open high low close volume open_oi \\\n",
|
||
"datetime \n",
|
||
"2020-12-31 14:45:00 1607.0 1611.0 1603.0 1611.0 19480.0 148833.0 \n",
|
||
"2021-01-04 09:00:00 1610.0 1636.0 1601.0 1620.0 55486.0 146448.0 \n",
|
||
"2021-01-04 09:15:00 1620.0 1620.0 1601.0 1604.0 30314.0 153373.0 \n",
|
||
"2021-01-04 09:30:00 1604.0 1606.0 1590.0 1595.0 30803.0 157091.0 \n",
|
||
"2021-01-04 09:45:00 1595.0 1601.0 1594.0 1600.0 10031.0 158730.0 \n",
|
||
"\n",
|
||
" close_oi underlying_symbol \n",
|
||
"datetime \n",
|
||
"2020-12-31 14:45:00 146448.0 CZCE.SA105 \n",
|
||
"2021-01-04 09:00:00 153373.0 CZCE.SA105 \n",
|
||
"2021-01-04 09:15:00 157091.0 CZCE.SA105 \n",
|
||
"2021-01-04 09:30:00 158730.0 CZCE.SA105 \n",
|
||
"2021-01-04 09:45:00 160031.0 CZCE.SA105 \n"
|
||
]
|
||
}
|
||
],
|
||
"execution_count": 2
|
||
},
|
||
{
|
||
"metadata": {
|
||
"ExecuteTime": {
|
||
"end_time": "2025-10-03T07:02:35.779448Z",
|
||
"start_time": "2025-10-03T06:58:45.453734Z"
|
||
}
|
||
},
|
||
"cell_type": "code",
|
||
"source": [
|
||
"import pandas as pd\n",
|
||
"import numpy as np\n",
|
||
"from scipy.signal import find_peaks\n",
|
||
"from scipy.stats import gaussian_kde\n",
|
||
"import matplotlib.pyplot as plt\n",
|
||
"from tqdm import tqdm\n",
|
||
"# 引入numba来JIT编译我们的核心计算，获得接近C的速度\n",
|
||
"\n",
|
||
"def find_hvn_kde_numba(prices: np.ndarray, volumes: np.ndarray) -> np.ndarray:\n",
|
||
" if len(prices) < 2 or np.sum(volumes) < 1e-6:\n",
|
||
" return np.array([np.nan])\n",
|
||
"\n",
|
||
" min_price, max_price = np.min(prices), np.max(prices)\n",
|
||
" if min_price == max_price:\n",
|
||
" return np.array([min_price])\n",
|
||
"\n",
|
||
" # Scott's rule for bandwidth\n",
|
||
" n = len(prices)\n",
|
||
" bw = (n * 3/4)**(-1/5) * np.std(prices)\n",
|
||
" if bw < 1e-6:\n",
|
||
" return np.array([np.mean(prices)])\n",
|
||
"\n",
|
||
" eval_points = np.linspace(min_price, max_price, 100) # 减少评估点以提高速度\n",
|
||
" density = np.zeros_like(eval_points)\n",
|
||
"\n",
|
||
" # 手动实现KDE\n",
|
||
" for i in range(len(eval_points)):\n",
|
||
" x = eval_points[i]\n",
|
||
" kernel_vals = (1 / (bw * np.sqrt(2 * np.pi))) * np.exp(-0.5 * ((x - prices) / bw)**2)\n",
|
||
" density[i] = np.sum(volumes * kernel_vals)\n",
|
||
"\n",
|
||
" # 手动实现峰值寻找\n",
|
||
" peaks_indices = []\n",
|
||
" max_density = np.max(density)\n",
|
||
" prominence_threshold = max_density * 0.2 # 提高显著性阈值\n",
|
||
" for i in range(1, len(density) - 1):\n",
|
||
" if density[i] > density[i-1] and density[i] > density[i+1]:\n",
|
||
" if density[i] > prominence_threshold:\n",
|
||
" peaks_indices.append(i)\n",
|
||
"\n",
|
||
" if len(peaks_indices) > 0:\n",
|
||
" return eval_points[np.array(peaks_indices)]\n",
|
||
"\n",
|
||
" return np.array([np.nan])\n",
|
||
"\n",
|
||
"# ==============================================================================\n",
|
||
"# 模块二：主分析流程（已彻底重构为向量化版本）\n",
|
||
"# ==============================================================================\n",
|
||
"\n",
|
||
"def analyze_hvn_crossing_event_vectorized(\n",
|
||
" df_raw: pd.DataFrame,\n",
|
||
" profile_window: int = 250,\n",
|
||
" forward_window: int = 50,\n",
|
||
" tick_size: float = 0.01):\n",
|
||
"\n",
|
||
" print(\"Step 1: 准备数据...\")\n",
|
||
" df = df_raw.copy().reset_index(drop=True) # 确保索引是连续的整数\n",
|
||
" df['forward_returns'] = np.log(df['close'].shift(-forward_window) / df['close'])\n",
|
||
"\n",
|
||
" print(\"Step 2: 一次性向量化展开所有K线...\")\n",
|
||
" # 计算每根K线需要展开的tick数\n",
|
||
" num_ticks = ((df['high'] - df['low']) / tick_size).round().astype(int) + 1\n",
|
||
" # 创建一个索引，用于将展开后的数据映射回原始的K线\n",
|
||
" expanded_idx = np.repeat(df.index, num_ticks)\n",
|
||
"\n",
|
||
" # 计算每个tick的价格和成交量\n",
|
||
" # 使用Numba JIT加速这个循环\n",
|
||
" def expand_bars(lows, highs, volumes, num_ticks, expanded_size):\n",
|
||
" all_prices = np.empty(expanded_size, dtype=np.float64)\n",
|
||
" all_volumes = np.empty(expanded_size, dtype=np.float64)\n",
|
||
" current_pos = 0\n",
|
||
" for i in range(len(lows)):\n",
|
||
" n = num_ticks[i]\n",
|
||
" if n > 0 and volumes[i] > 0:\n",
|
||
" prices = np.linspace(lows[i], highs[i], n)\n",
|
||
" vols = np.full(n, volumes[i] / n)\n",
|
||
" all_prices[current_pos:current_pos+n] = prices\n",
|
||
" all_volumes[current_pos:current_pos+n] = vols\n",
|
||
" current_pos += n\n",
|
||
" return all_prices, all_volumes\n",
|
||
"\n",
|
||
" all_prices, all_volumes = expand_bars(df['low'].values, df['high'].values,\n",
|
||
" df['volume'].values, num_ticks.values,\n",
|
||
" len(expanded_idx))\n",
|
||
"\n",
|
||
" # 创建一个包含展开后数据的DataFrame\n",
|
||
" df_expanded = pd.DataFrame({\n",
|
||
" 'original_index': expanded_idx,\n",
|
||
" 'price': all_prices,\n",
|
||
" 'volume': all_volumes\n",
|
||
" })\n",
|
||
" print(f\"K线展开完成，共 {len(df_expanded)} 个价格点。\")\n",
|
||
"\n",
|
||
"\n",
|
||
" print(f\"Step 3: 使用滚动窗口和Numba JIT批量计算HVN...\")\n",
|
||
" # --- 这是性能提升的核心 ---\n",
|
||
" # 我们将使用一个for循环，但循环内部的计算是高度优化的\n",
|
||
" hvn_list = [np.array([np.nan])] * len(df)\n",
|
||
"\n",
|
||
" # Groupby一次，后续查询会非常快\n",
|
||
" grouped_expanded = df_expanded.groupby('original_index')\n",
|
||
"\n",
|
||
" for i in tqdm(range(profile_window, len(df)), desc=\"Calculating HVNs\"):\n",
|
||
" window_indices = df.index[i - profile_window : i]\n",
|
||
"\n",
|
||
" # 快速收集窗口数据\n",
|
||
" window_data = df_expanded[df_expanded['original_index'].isin(window_indices)]\n",
|
||
"\n",
|
||
" # 调用JIT编译的函数\n",
|
||
" hvns = find_hvn_kde_numba(\n",
|
||
" window_data['price'].values,\n",
|
||
" window_data['volume'].values\n",
|
||
" )\n",
|
||
" hvn_list[i] = hvns\n",
|
||
"\n",
|
||
" df['hvns'] = hvn_list\n",
|
||
" df = df.dropna(subset=['hvns'])\n",
|
||
" print(\"HVN批量计算完成.\")\n",
|
||
"\n",
|
||
" # --- 后续的事件识别、分析和可视化流程与之前版本完全相同 ---\n",
|
||
" print(\"Step 4: 识别HVN穿越事件...\")\n",
|
||
" # ... (与之前版本相同的事件识别、路径分析和绘图代码) ...\n",
|
||
" events = []\n",
|
||
" for i, row in df.iterrows():\n",
|
||
" idx = df.index.get_loc(i)\n",
|
||
" if idx == 0: continue\n",
|
||
" prev_close = df['close'].iloc[idx-1]\n",
|
||
" current_close = row['close']\n",
|
||
" hvns = row['hvns']\n",
|
||
" if isinstance(hvns, np.ndarray) and not np.isnan(hvns).all():\n",
|
||
" for hvn in hvns:\n",
|
||
" if prev_close < hvn and current_close > hvn: events.append({'event_index': i, 'event_type': 'bullish_cross'})\n",
|
||
" if prev_close > hvn and current_close < hvn: events.append({'event_index': i, 'event_type': 'bearish_cross'})\n",
|
||
" if not events: print(\"未找到任何HVN穿越事件。\"); return\n",
|
||
" df_events = pd.DataFrame(events); print(f\"共识别出 {len(df_events)} 个事件.\")\n",
|
||
" print(\"Step 5: 分析事件后的平均走势...\")\n",
|
||
" bullish_cross_indices = df_events[df_events['event_type'] == 'bullish_cross']['event_index']\n",
|
||
" bearish_cross_indices = df_events[df_events['event_type'] == 'bearish_cross']['event_index']\n",
|
||
" bullish_paths, bearish_paths = [], []\n",
|
||
" for index in bullish_cross_indices:\n",
|
||
" loc = df.index.get_loc(index)\n",
|
||
" if loc + forward_window < len(df):\n",
|
||
" start_price = df.loc[index, 'close']\n",
|
||
" path = df['close'].iloc[loc : loc + forward_window].values / start_price\n",
|
||
" bullish_paths.append(path)\n",
|
||
" for index in bearish_cross_indices:\n",
|
||
" loc = df.index.get_loc(index)\n",
|
||
" if loc + forward_window < len(df):\n",
|
||
" start_price = df.loc[index, 'close']\n",
|
||
" path = df['close'].iloc[loc : loc + forward_window].values / start_price\n",
|
||
" bearish_paths.append(path)\n",
|
||
" if not bullish_paths or not bearish_paths: print(\"事件数量不足，无法进行路径分析。\"); return\n",
|
||
" avg_bullish_path, avg_bearish_path = np.mean(bullish_paths, axis=0), np.mean(bearish_paths, axis=0)\n",
|
||
" print(\"Step 6: 结果可视化...\")\n",
|
||
" plt.style.use('seaborn-v0_8-darkgrid'); fig, ax = plt.subplots(figsize=(12, 7))\n",
|
||
" ax.plot(avg_bullish_path, label=f'Avg Path after Bullish Cross (N={len(bullish_paths)})', color='green', linewidth=2)\n",
|
||
" ax.plot(avg_bearish_path, label=f'Avg Path after Bearish Cross (N={len(bearish_paths)})', color='red', linewidth=2)\n",
|
||
" ax.axhline(1.0, color='black', linestyle='--', linewidth=1, label='Event Price Level')\n",
|
||
" ax.set_title(f'Average Price Path after HVN Crossing Event (Forward Window = {forward_window} bars)', fontsize=16)\n",
|
||
" ax.set_xlabel('Bars after Event', fontsize=12); ax.set_ylabel('Normalized Price (Event Price = 1.0)', fontsize=12)\n",
|
||
" ax.legend(fontsize=10); ax.grid(True); plt.show()\n",
|
||
"\n",
|
||
"\n",
|
||
"# ==============================================================================\n",
|
||
"# 使用示例\n",
|
||
"# ==============================================================================\n",
|
||
"print(\"正在生成模拟数据...\")\n",
|
||
"np.random.seed(42)\n",
|
||
"n_points = 26000\n",
|
||
"prices = 100 + np.random.randn(n_points).cumsum() * 0.1\n",
|
||
"df_raw = pd.DataFrame({\n",
|
||
" 'open': prices, 'high': prices + np.random.uniform(0, 0.5, n_points),\n",
|
||
" 'low': prices - np.random.uniform(0, 0.5, n_points),\n",
|
||
" 'close': prices + np.random.uniform(-0.25, 0.25, n_points),\n",
|
||
" 'volume': np.random.randint(100, 1000, n_points) * 10\n",
|
||
"}, index=pd.to_datetime(pd.date_range('2023-01-01', periods=n_points, freq='min')))\n",
|
||
"df_raw['open'] = df_raw['close'].shift(1)\n",
|
||
"df_raw = df_raw.dropna()\n",
|
||
"print(f\"模拟数据生成完毕，共 {len(df_raw)} 行。\")\n",
|
||
"\n",
|
||
"# --- 运行全新的、高性能的分析函数 ---\n",
|
||
"analyze_hvn_crossing_event_vectorized(\n",
|
||
" df_raw,\n",
|
||
" profile_window=250,\n",
|
||
" forward_window=50\n",
|
||
")"
|
||
],
|
||
"id": "30958840dbc186d7",
|
||
"outputs": [
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"正在生成模拟数据...\n",
|
||
"模拟数据生成完毕，共 25999 行。\n",
|
||
"Step 1: 准备数据...\n",
|
||
"Step 2: 一次性向量化展开所有K线...\n",
|
||
"K线展开完成，共 1327133 个价格点。\n",
|
||
"Step 3: 使用滚动窗口和Numba JIT批量计算HVN...\n"
|
||
]
|
||
},
|
||
{
|
||
"name": "stderr",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"Calculating HVNs: 100%|██████████| 25749/25749 [03:49<00:00, 112.18it/s]\n"
|
||
]
|
||
},
|
||
{
|
||
"name": "stdout",
|
||
"output_type": "stream",
|
||
"text": [
|
||
"HVN批量计算完成.\n",
|
||
"Step 4: 识别HVN穿越事件...\n",
|
||
"共识别出 4748 个事件.\n",
|
||
"Step 5: 分析事件后的平均走势...\n",
|
||
"Step 6: 结果可视化...\n"
|
||
]
|
||
},
|
||
{
|
||
"data": {
|
||
"text/plain": [
|
||
"<Figure size 1200x700 with 1 Axes>"
|
||
],
|
||
"image/png": "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"
|
||
},
|
||
"metadata": {},
|
||
"output_type": "display_data",
|
||
"jetTransient": {
|
||
"display_id": null
|
||
}
|
||
}
|
||
],
|
||
"execution_count": 3
|
||
}
|
||
],
|
||
"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
|
||
}
|