Upload folder using huggingface_hub

.gitattributes

@@ -58,3 +58,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/data/_libs/expanding.cpython-313-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+Kronos/qlib/build/lib.linux-x86_64-cpython-313/qlib/data/_libs/rolling.cpython-313-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

Kronos/.claude/settings.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(python build_test_data.py)"
+    ]
+  }
+}

Kronos/.gitignore

@@ -0,0 +1,76 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# PyCharm
+.idea/
+
+# VS Code
+.vscode/
+
+# macOS
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Windows
+Thumbs.db
+ehthumbs.db
+Desktop.ini
+
+# Linux
+*~
+
+# Data files (large files)
+*.feather
+*.parquet
+*.h5
+*.hdf5
+
+# Model files (large files)
+*.pth
+*.pt
+*.ckpt
+*.bin
+
+# Logs
+*.log
+logs/
+
+# Environment
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Temporary files
+*.tmp
+*.temp
+temp/
+tmp/
+.python-version

Kronos/.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+    "python-envs.defaultEnvManager": "ms-python.python:conda",
+    "python-envs.defaultPackageManager": "ms-python.python:conda"
+}

Kronos/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ShiYu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Kronos/examples/get_akshare_date_2024-2025_x.py

@@ -0,0 +1,629 @@
+import pandas as pd
+import requests
+import json
+from datetime import datetime, timedelta
+import os
+import time
+import random
+
+
+def get_stock_market(stock_code):
+    """
+    根据股票代码判断市场类型
+    返回: 市场前缀 '0'-深交所, '1'-上交所
+    """
+    if stock_code.startswith(('0', '2', '3')):
+        return '0'  # 深交所
+    elif stock_code.startswith(('6', '9')):
+        return '1'  # 上交所
+    else:
+        return '1'  # 默认上交所
+
+
+def get_stock_data_eastmoney(stock_code="002354", start_year=2024, end_year=2025):
+    """
+    使用东方财富网API获取指定年份范围的股票数据 - 修复版
+    """
+    try:
+        print(f"正在从东方财富网获取股票 {stock_code} 的 {start_year}-{end_year} 年数据...")
+
+        # 计算日期范围
+        start_date = f"{start_year}0101"
+        current_date = datetime.now()
+
+        if current_date.year > end_year:
+            end_date = f"{end_year}1231"
+        else:
+            end_date = current_date.strftime('%Y%m%d')
+
+        print(f"时间范围: {start_date} 到 {end_date}")
+
+        # 获取市场类型
+        market = get_stock_market(stock_code)
+        secid = f"{market}.{stock_code}"
+
+        # 使用更简单的东方财富API
+        url = "http://push2his.eastmoney.com/api/qt/stock/kline/get"
+
+        params = {
+            'secid': secid,
+            'fields1': 'f1,f2,f3,f4,f5,f6',
+            'fields2': 'f51,f52,f53,f54,f55,f56,f57,f58,f59,f60,f61',
+            'klt': '101',  # 日线
+            'fqt': '1',    # 前复权
+            'beg': start_date,
+            'end': end_date,
+            'lmt': '10000',
+            'ut': 'fa5fd1943c7b386f172d6893dbfba10b',
+            'cb': f'jQuery{random.randint(1000000, 9999999)}_{int(time.time()*1000)}'
+        }
+
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36',
+            'Referer': 'https://quote.eastmoney.com/',
+            'Accept': '*/*',
+        }
+
+        time.sleep(random.uniform(1, 2))
+
+        response = requests.get(url, params=params, headers=headers, timeout=10)
+
+        print(f"API响应状态码: {response.status_code}")
+
+        if response.status_code == 200:
+            # 处理JSONP响应
+            response_text = response.text
+
+            # 提取JSON数据（处理JSONP格式）
+            if response_text.startswith('/**/'):
+                response_text = response_text[4:]
+
+            # 查找JSON数据的开始和结束位置
+            start_idx = response_text.find('(')
+            end_idx = response_text.rfind(')')
+
+            if start_idx != -1 and end_idx != -1:
+                json_str = response_text[start_idx + 1:end_idx]
+                try:
+                    data = json.loads(json_str)
+                except json.JSONDecodeError:
+                    print("❌ JSON解析失败，尝试直接解析...")
+                    # 如果JSON解析失败，尝试直接提取数据
+                    return parse_kline_data_directly(response_text, stock_code, start_year, end_year)
+            else:
+                print("❌ 无法找到JSON数据边界")
+                return None
+
+            print(f"API返回数据状态: {data.get('rc', 'N/A')}")
+
+            if data and data.get('data') is not None:
+                klines = data['data'].get('klines', [])
+                print(f"获取到 {len(klines)} 条K线数据")
+
+                if not klines:
+                    print("⚠️ K线数据为空")
+                    return None
+
+                # 解析数据
+                stock_data = []
+                for kline in klines:
+                    try:
+                        items = kline.split(',')
+                        if len(items) >= 6:
+                            stock_data.append({
+                                '日期': items[0],
+                                '股票代码': stock_code,
+                                '开盘价': float(items[1]),
+                                '收盘价': float(items[2]),
+                                '最高价': float(items[3]),
+                                '最低价': float(items[4]),
+                                '成交量': float(items[5]),
+                                '成交额': float(items[6]) if len(items) > 6 else 0,
+                                '振幅': float(items[7]) if len(items) > 7 else 0,
+                                '涨跌幅': float(items[8]) if len(items) > 8 else 0,
+                                '涨跌额': float(items[9]) if len(items) > 9 else 0,
+                                '换手率': float(items[10]) if len(items) > 10 else 0
+                            })
+                    except (ValueError, IndexError) as e:
+                        continue
+
+                if not stock_data:
+                    print("❌ 解析后无有效数据")
+                    return None
+
+                df = pd.DataFrame(stock_data)
+                df['日期'] = pd.to_datetime(df['日期'])
+                df.set_index('日期', inplace=True)
+                df = df.sort_index()
+
+                # 筛选指定年份的数据
+                df = df[(df.index.year >= start_year) & (df.index.year <= end_year)]
+
+                print(f"✅ 成功获取 {len(df)} 条有效数据")
+                print(f"实际时间范围: {df.index.min().strftime('%Y-%m-%d')} 到 {df.index.max().strftime('%Y-%m-%d')}")
+                return df
+            else:
+                print("❌ API返回数据为空")
+                return None
+        else:
+            print(f"❌ 请求失败，状态码: {response.status_code}")
+            return None
+
+    except Exception as e:
+        print(f"❌ 获取数据时出错: {str(e)}")
+        return None
+
+
+def parse_kline_data_directly(response_text, stock_code, start_year, end_year):
+    """
+    直接解析K线数据（当JSON解析失败时使用）
+    """
+    try:
+        # 尝试直接从响应文本中提取K线数据
+        if '"klines":[' in response_text:
+            start_idx = response_text.find('"klines":[') + 10
+            end_idx = response_text.find(']', start_idx)
+            klines_str = response_text[start_idx:end_idx]
+
+            # 清理字符串并分割
+            klines = klines_str.replace('"', '').split(',')
+
+            stock_data = []
+            for kline in klines:
+                if kline.strip():
+                    items = kline.split(',')
+                    if len(items) >= 6:
+                        stock_data.append({
+                            '日期': items[0],
+                            '股票代码': stock_code,
+                            '开盘价': float(items[1]),
+                            '收盘价': float(items[2]),
+                            '最高价': float(items[3]),
+                            '最低价': float(items[4]),
+                            '成交量': float(items[5]),
+                            '成交额': float(items[6]) if len(items) > 6 else 0,
+                        })
+
+            if stock_data:
+                df = pd.DataFrame(stock_data)
+                df['日期'] = pd.to_datetime(df['日期'])
+                df.set_index('日期', inplace=True)
+                df = df.sort_index()
+                df = df[(df.index.year >= start_year) & (df.index.year <= end_year)]
+                print(f"✅ 直接解析获取 {len(df)} 条数据")
+                return df
+    except Exception as e:
+        print(f"❌ 直接解析也失败: {e}")
+
+    return None
+
+
+def get_stock_data_akshare(stock_code="002354", start_year=2024, end_year=2025):
+    """
+    使用AKShare作为备用数据源 - 修复版
+    """
+    try:
+        print(f"尝试使用AKShare获取股票 {stock_code} 数据...")
+        import akshare as ak
+
+        # 计算日期范围
+        start_date = f"{start_year}0101"
+        end_date = datetime.now().strftime('%Y%m%d')
+
+        # 获取数据
+        df = ak.stock_zh_a_hist(symbol=stock_code, period="daily",
+                               start_date=start_date, end_date=end_date,
+                               adjust="qfq")
+
+        if df is not None and not df.empty:
+            # 重命名列以匹配我们的格式
+            column_mapping = {
+                '日期': '日期',
+                '开盘': '开盘价',
+                '收盘': '收盘价',
+                '最高': '最高价',
+                '最低': '最低价',
+                '成交量': '成交量',
+                '成交额': '成交额',
+                '振幅': '振幅',
+                '涨跌幅': '涨跌幅',
+                '涨跌额': '涨跌额',
+                '换手率': '换手率'
+            }
+
+            # 只映射存在的列
+            actual_mapping = {k: v for k, v in column_mapping.items() if k in df.columns}
+            df = df.rename(columns=actual_mapping)
+
+            # 添加股票代码列
+            df['股票代码'] = stock_code
+            df['日期'] = pd.to_datetime(df['日期'])
+            df.set_index('日期', inplace=True)
+            df = df.sort_index()
+
+            # 筛选指定年份
+            df = df[(df.index.year >= start_year) & (df.index.year <= end_year)]
+
+            print(f"✅ AKShare成功获取 {len(df)} 条数据")
+            return df
+        else:
+            print("❌ AKShare未返回数据")
+            return None
+
+    except ImportError:
+        print("⚠️ AKShare未安装，使用 pip install akshare 安装")
+        return None
+    except Exception as e:
+        print(f"❌ AKShare获取数据失败: {e}")
+        return None
+
+
+def get_stock_data_baostock(stock_code="002354", start_year=2024, end_year=2025):
+    """
+    使用Baostock作为第三个数据源
+    """
+    try:
+        print(f"尝试使用Baostock获取股票 {stock_code} 数据...")
+        import baostock as bs
+        import pandas as pd
+
+        # 登录系统
+        lg = bs.login()
+
+        # 计算日期范围
+        start_date = f"{start_year}-01-01"
+        end_date = datetime.now().strftime('%Y-%m-%d')
+
+        # 根据市场添加前缀
+        market = get_stock_market(stock_code)
+        if market == '0':
+            full_code = f"sz.{stock_code}"
+        else:
+            full_code = f"sh.{stock_code}"
+
+        # 获取数据
+        rs = bs.query_history_k_data_plus(
+            full_code,
+            "date,open,high,low,close,volume,amount,turn,pctChg",
+            start_date=start_date,
+            end_date=end_date,
+            frequency="d",
+            adjustflag="2"  # 前复权
+        )
+
+        data_list = []
+        while (rs.error_code == '0') & rs.next():
+            data_list.append(rs.get_row_data())
+
+        # 退出系统
+        bs.logout()
+
+        if data_list:
+            df = pd.DataFrame(data_list, columns=rs.fields)
+
+            # 数据类型转换
+            df['date'] = pd.to_datetime(df['date'])
+            df['open'] = pd.to_numeric(df['open'])
+            df['high'] = pd.to_numeric(df['high'])
+            df['low'] = pd.to_numeric(df['low'])
+            df['close'] = pd.to_numeric(df['close'])
+            df['volume'] = pd.to_numeric(df['volume'])
+            df['amount'] = pd.to_numeric(df['amount'])
+            df['turn'] = pd.to_numeric(df['turn'])
+            df['pctChg'] = pd.to_numeric(df['pctChg'])
+
+            # 重命名列
+            df = df.rename(columns={
+                'date': '日期',
+                'open': '开盘价',
+                'high': '最高价',
+                'low': '最低价',
+                'close': '收盘价',
+                'volume': '成交量',
+                'amount': '成交额',
+                'turn': '换手率',
+                'pctChg': '涨跌幅'
+            })
+
+            # 添加股票代码列
+            df['股票代码'] = stock_code
+            df.set_index('日期', inplace=True)
+            df = df.sort_index()
+
+            # 筛选指定年份
+            df = df[(df.index.year >= start_year) & (df.index.year <= end_year)]
+
+            # 计算涨跌额
+            df['涨跌额'] = df['收盘价'].diff()
+
+            print(f"✅ Baostock成功获取 {len(df)} 条数据")
+            return df
+        else:
+            print("❌ Baostock未返回数据")
+            return None
+
+    except ImportError:
+        print("⚠️ Baostock未安装，使用 pip install baostock 安装")
+        return None
+    except Exception as e:
+        print(f"❌ Baostock获取数据失败: {e}")
+        return None
+
+
+def get_stock_data_with_retry(stock_code="002354", start_year=2024, end_year=2025, retry_count=2):
+    """
+    带重试机制的数据获取 - 多数据源版本
+    """
+    data_sources = [
+        ("AKShare", get_stock_data_akshare),
+        ("Baostock", get_stock_data_baostock),
+        ("东方财富", get_stock_data_eastmoney)
+    ]
+
+    for source_name, data_func in data_sources:
+        print(f"\n🔍 尝试从 {source_name} 获取数据...")
+        data = data_func(stock_code, start_year, end_year)
+
+        if data is not None and not data.empty:
+            # 检查数据是否包含目标年份
+            available_years = data.index.year.unique()
+            print(f"获取到的数据年份: {sorted(available_years)}")
+
+            if any(year in available_years for year in range(start_year, end_year + 1)):
+                print(f"✅ {source_name} 数据获取成功！")
+                # 标记数据来源
+                data.attrs['data_source'] = source_name
+                return data
+            else:
+                print(f"⚠️ 数据未包含目标年份数据")
+
+    print("❌ 所有真实数据源都失败，使用示例数据...")
+    return create_sample_data(stock_code, start_year, end_year)
+
+
+def create_sample_data(stock_code="002354", start_year=2024, end_year=2025):
+    """
+    创建更真实的示例数据
+    """
+    print(f"📊 创建 {start_year}-{end_year} 年的示例数据...")
+
+    # 生成交易日（排除周末）
+    start_date = datetime(start_year, 1, 1)
+    end_date = datetime.now()
+    all_dates = pd.bdate_range(start=start_date, end=end_date, freq='B')
+
+    # 只保留目标年份的数据
+    trading_dates = [date for date in all_dates if start_year <= date.year <= end_year]
+
+    # 生成更真实的股价数据
+    import numpy as np
+    np.random.seed(42)
+
+    # 设置合理的基准价格
+    base_prices = {
+        '600580': 12.0,  # 卧龙电驱 - 更合理的价格
+        '002354': 5.0,   # 天娱数科
+        '300207': 15.0,  # 欣旺达
+    }
+    base_price = base_prices.get(stock_code, 10.0)
+
+    stock_data = []
+    current_price = base_price
+
+    for i, date in enumerate(trading_dates):
+        # 更真实的股价波动
+        volatility = 0.015  # 1.5%的日波动率
+
+        if i > 0:
+            # 使用更真实的随���游走
+            daily_return = np.random.normal(0, volatility)
+            # 添加一些趋势
+            if i < len(trading_dates) * 0.3:  # 前30%的时间
+                trend_bias = 0.0005  # 轻微上涨趋势
+            elif i < len(trading_dates) * 0.7:  # 中间40%的时间
+                trend_bias = -0.0003  # 轻微下跌趋势
+            else:  # 后30%的时间
+                trend_bias = 0.0002  # 轻微上涨趋势
+
+            daily_return += trend_bias
+            current_price = current_price * (1 + daily_return)
+
+            # 价格边界限制 - 更合理
+            current_price = max(base_price * 0.5, min(base_price * 2.0, current_price))
+        else:
+            current_price = base_price
+
+        # 生成OHLC数据
+        open_variation = np.random.normal(0, volatility * 0.2)
+        open_price = current_price * (1 + open_variation)
+
+        daily_range = abs(np.random.normal(volatility * 0.8, volatility * 0.3))
+        high_price = max(open_price, current_price) * (1 + daily_range)
+        low_price = min(open_price, current_price) * (1 - daily_range)
+        close_price = current_price
+
+        # 确保价格合理性
+        high_price = max(open_price, close_price, low_price, high_price)
+        low_price = min(open_price, close_price, high_price, low_price)
+
+        # 生成成交量（更合理）
+        base_volume = 500000  # 基础成交量
+        volume_variation = abs(daily_return) * 3000000 if i > 0 else 0
+        volume = int(base_volume + volume_variation + np.random.randint(-100000, 200000))
+        volume = max(100000, volume)
+
+        # 计算成交额（万元）
+        amount = volume * close_price / 10000
+
+        # 计算涨跌幅和涨跌额
+        if i > 0:
+            prev_close = stock_data[-1]['收盘价']
+            price_change = close_price - prev_close
+            pct_change = (price_change / prev_close) * 100
+        else:
+            price_change = 0
+            pct_change = 0
+
+        # 计算振幅
+        amplitude = ((high_price - low_price) / open_price) * 100
+
+        # 生成换手率（0.5%-8%之间）
+        turnover_rate = np.random.uniform(0.5, 8.0)
+
+        stock_data.append({
+            '日期': date,
+            '股票代码': stock_code,
+            '开盘价': round(open_price, 2),
+            '收盘价': round(close_price, 2),
+            '最高价': round(high_price, 2),
+            '最低价': round(low_price, 2),
+            '成交量': volume,
+            '成交额': round(amount, 2),
+            '振幅': round(amplitude, 2),
+            '涨跌幅': round(pct_change, 2),
+            '涨跌额': round(price_change, 2),
+            '换手率': round(turnover_rate, 2)
+        })
+
+    df = pd.DataFrame(stock_data)
+    df.set_index('日期', inplace=True)
+
+    print(f"✅ 已创建 {len(df)} 条 {start_year}-{end_year} 年的模拟数据")
+    print(f"时间范围: {df.index.min().strftime('%Y-%m-%d')} 到 {df.index.max().strftime('%Y-%m-%d')}")
+
+    # 标记为模拟数据
+    df.attrs['data_source'] = '模拟数据'
+
+    return df
+
+
+def display_data_info(df, stock_code, start_year, end_year):
+    """显示数据信息"""
+    if df is None or df.empty:
+        print("没有数据可显示")
+        return
+
+    # 获取数据来源
+    data_source = df.attrs.get('data_source', '未知来源')
+
+    print(f"\n{'=' * 60}")
+    print(f"股票 {stock_code} {start_year}-{end_year} 年数据摘要")
+    print(f"{'=' * 60}")
+
+    print(f"数据时间范围: {df.index.min().strftime('%Y-%m-%d')} 到 {df.index.max().strftime('%Y-%m-%d')}")
+    print(f"总交易天数: {len(df)}")
+    print(f"数据来源: {data_source}")
+
+    # 按年份显示统计
+    for year in sorted(df.index.year.unique()):
+        year_data = df[df.index.year == year]
+        print(f"\n{year}年统计:")
+        print(f"  交易天数: {len(year_data)}")
+        print(f"  平均收盘价: {year_data['收盘价'].mean():.2f} 元")
+        print(f"  最高价: {year_data['最高价'].max():.2f} 元")
+        print(f"  最低价: {year_data['最低价'].min():.2f} 元")
+        if len(year_data) > 1:
+            year_return = (year_data['收盘价'].iloc[-1] / year_data['收盘价'].iloc[0] - 1) * 100
+            print(f"  年度涨跌幅: {year_return:+.2f}%")
+
+    # 显示最新交易日数据
+    latest_date = df.index.max()
+    print(f"\n最新交易日 ({latest_date.strftime('%Y-%m-%d')}) 数据:")
+    latest_data = df.loc[latest_date]
+    for col, value in latest_data.items():
+        if col != '股票代码':
+            if col in ['成交量']:
+                print(f"  {col}: {value:,.0f}")
+            elif col in ['成交额']:
+                print(f"  {col}: {value:,.2f} 万元")
+            else:
+                print(f"  {col}: {value}")
+
+
+def save_stock_data(df, stock_code, save_dir="D:/lianghuajiaoyi/Kronos/examples/data"):
+    """
+    保存股票数据到指定目录
+    """
+    if df is not None and not df.empty:
+        # 确保保存目录存在
+        os.makedirs(save_dir, exist_ok=True)
+
+        # 保存CSV文件
+        csv_file = os.path.join(save_dir, f"{stock_code}_stock_data.csv")
+
+        # 重置索引以便保存日期列
+        df_reset = df.reset_index()
+        df_reset.to_csv(csv_file, encoding='utf-8-sig', index=False)
+
+        print(f"\n📁 股票数据已保存: {csv_file}")
+        return True
+    return False
+
+
+def main(stock_code="002354", start_year=2024, end_year=2025):
+    """
+    主函数：获取并保存股票数据 - 最终版
+    """
+    # 设置保存目录
+    save_directory = "D:/lianghuajiaoyi/Kronos/examples/data"
+
+    print("=" * 60)
+    print(f"开始获取股票 {stock_code} 的 {start_year}-{end_year} 年数据")
+    print("=" * 60)
+    print(f"数据将保存到: {save_directory}")
+
+    # 检查必要库
+    try:
+        import requests
+        import numpy as np
+    except ImportError:
+        print("正在安装必要库...")
+        import subprocess
+        subprocess.check_call(["pip", "install", "requests", "numpy", "pandas"])
+        import requests
+        import numpy as np
+
+    # 获取数据（多数据源）
+    stock_data = get_stock_data_with_retry(stock_code, start_year, end_year)
+
+    if stock_data is not None:
+        # 显示数据信息
+        display_data_info(stock_data, stock_code, start_year, end_year)
+
+        # 保存数据到指定目录
+        save_stock_data(stock_data, stock_code, save_directory)
+
+        print(f"\n🎉 股票 {stock_code} 数据处理完成!")
+        print(f"最新数据日期: {stock_data.index.max().strftime('%Y-%m-%d')}")
+
+        # 显示保存的文件
+        csv_file = os.path.join(save_directory, f"{stock_code}_stock_data.csv")
+        if os.path.exists(csv_file):
+            file_size = os.path.getsize(csv_file) / 1024  # KB
+            print(f"📄 生成的文件: {csv_file} ({file_size:.1f} KB)")
+    else:
+        print("❌ 未能获取股票数据")
+
+
+# 使用方法说明
+if __name__ == "__main__":
+    """
+    使用方法：
+    修改下面的参数来获取不同股票的数据
+    """
+
+    # ==================== 在这里修改参数 ====================
+    TARGET_STOCK_CODE = "300418"  # 股票代码
+    START_YEAR = 2024  # 开始年份
+    END_YEAR = 2025  # 结束年份
+    # =====================================================
+
+    print("股票数据获取工具 - 终极优化版")
+    print("说明：修改代码中的 TARGET_STOCK_CODE 来获取不同股票的数据")
+    print(f"当前设置: 股票代码={TARGET_STOCK_CODE}, 年份范围={START_YEAR}-{END_YEAR}")
+    print()
+
+    # 运行主程序
+    main(stock_code=TARGET_STOCK_CODE, start_year=START_YEAR, end_year=END_YEAR)
+
+    print(f"\n💡 提示：要获取其他股票数据，请修改代码中的 TARGET_STOCK_CODE 变量")

Kronos/examples/get_date_new.py

@@ -0,0 +1,661 @@
+import pandas as pd
+import requests
+import json
+from datetime import datetime, timedelta
+import os
+import time
+import random
+
+
+def get_stock_market(stock_code):
+    """
+    根据股票代码判断市场类型
+    返回: 市场前缀 '0'-深交所, '1'-上交所
+    """
+    if stock_code.startswith(('0', '2', '3')):
+        return '0'  # 深交所
+    elif stock_code.startswith(('6', '9')):
+        return '1'  # 上交所
+    else:
+        return '1'  # 默认上交所
+
+
+def get_stock_data_eastmoney_all_history(stock_code="002354"):
+    """
+    使用东方财富网API获取股票所有历史数据
+    """
+    try:
+        print(f"正在从东方财富网获取股票 {stock_code} 的全部历史数据...")
+
+        # 获取市场类型
+        market = get_stock_market(stock_code)
+        secid = f"{market}.{stock_code}"
+
+        # 使用东方财富API获取所有历史数据
+        url = "http://push2his.eastmoney.com/api/qt/stock/kline/get"
+
+        # 设置足够早的起始日期（中国股市从1990年开始）
+        start_date = "19900101"
+        end_date = datetime.now().strftime('%Y%m%d')
+
+        params = {
+            'secid': secid,
+            'fields1': 'f1,f2,f3,f4,f5,f6',
+            'fields2': 'f51,f52,f53,f54,f55,f56,f57,f58,f59,f60,f61',
+            'klt': '101',  # 日线
+            'fqt': '1',  # 前复权
+            'beg': start_date,
+            'end': end_date,
+            'lmt': '50000',  # 增加限制数量以获取更多历史数据
+            'ut': 'fa5fd1943c7b386f172d6893dbfba10b',
+            'cb': f'jQuery{random.randint(1000000, 9999999)}_{int(time.time() * 1000)}'
+        }
+
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36',
+            'Referer': 'https://quote.eastmoney.com/',
+            'Accept': '*/*',
+        }
+
+        time.sleep(random.uniform(1, 2))
+
+        response = requests.get(url, params=params, headers=headers, timeout=15)
+
+        print(f"API响应状态码: {response.status_code}")
+
+        if response.status_code == 200:
+            # 处理JSONP响应
+            response_text = response.text
+
+            # 提取JSON数据（处理JSONP格式）
+            if response_text.startswith('/**/'):
+                response_text = response_text[4:]
+
+            # 查找JSON数据的开始和结束位置
+            start_idx = response_text.find('(')
+            end_idx = response_text.rfind(')')
+
+            if start_idx != -1 and end_idx != -1:
+                json_str = response_text[start_idx + 1:end_idx]
+                try:
+                    data = json.loads(json_str)
+                except json.JSONDecodeError:
+                    print("❌ JSON解析失败，尝试直接解析...")
+                    return parse_kline_data_directly_all_history(response_text, stock_code)
+            else:
+                print("❌ 无法找到JSON数据边界")
+                return None
+
+            print(f"API返回数据状态: {data.get('rc', 'N/A')}")
+
+            if data and data.get('data') is not None:
+                klines = data['data'].get('klines', [])
+                print(f"获取到 {len(klines)} 条历史K线数据")
+
+                if not klines:
+                    print("⚠️ K线数据为空")
+                    return None
+
+                # 解析数据
+                stock_data = []
+                for kline in klines:
+                    try:
+                        items = kline.split(',')
+                        if len(items) >= 6:
+                            stock_data.append({
+                                '日期': items[0],
+                                '股票代码': stock_code,
+                                '开盘价': float(items[1]),
+                                '收盘价': float(items[2]),
+                                '最高价': float(items[3]),
+                                '最低价': float(items[4]),
+                                '成交量': float(items[5]),
+                                '成交额': float(items[6]) if len(items) > 6 else 0,
+                                '振幅': float(items[7]) if len(items) > 7 else 0,
+                                '涨跌幅': float(items[8]) if len(items) > 8 else 0,
+                                '涨跌额': float(items[9]) if len(items) > 9 else 0,
+                                '换手率': float(items[10]) if len(items) > 10 else 0
+                            })
+                    except (ValueError, IndexError) as e:
+                        continue
+
+                if not stock_data:
+                    print("❌ 解析后无有效数据")
+                    return None
+
+                df = pd.DataFrame(stock_data)
+                df['日期'] = pd.to_datetime(df['日期'])
+                df.set_index('日期', inplace=True)
+                df = df.sort_index()
+
+                print(f"✅ ���功获取 {len(df)} 条历史数据")
+                print(
+                    f"历史数据时间范围: {df.index.min().strftime('%Y-%m-%d')} 到 {df.index.max().strftime('%Y-%m-%d')}")
+                return df
+            else:
+                print("❌ API返回数据为空")
+                return None
+        else:
+            print(f"❌ 请求失败，状态码: {response.status_code}")
+            return None
+
+    except Exception as e:
+        print(f"❌ 获取历史数据时出错: {str(e)}")
+        return None
+
+
+def parse_kline_data_directly_all_history(response_text, stock_code):
+    """
+    直接解析K线数据（当JSON解析失败时使用）- 全历史版本
+    """
+    try:
+        # 尝试直接从响应文本中提取K线数据
+        if '"klines":[' in response_text:
+            start_idx = response_text.find('"klines":[') + 10
+            end_idx = response_text.find(']', start_idx)
+            klines_str = response_text[start_idx:end_idx]
+
+            # 清理字符串并分割
+            klines = [k.strip().strip('"') for k in klines_str.split('","') if k.strip()]
+
+            stock_data = []
+            for kline in klines:
+                if kline.strip():
+                    items = kline.split(',')
+                    if len(items) >= 6:
+                        stock_data.append({
+                            '日期': items[0],
+                            '股票代码': stock_code,
+                            '开盘价': float(items[1]),
+                            '收盘价': float(items[2]),
+                            '最高价': float(items[3]),
+                            '最低价': float(items[4]),
+                            '成交量': float(items[5]),
+                            '成交额': float(items[6]) if len(items) > 6 else 0,
+                        })
+
+            if stock_data:
+                df = pd.DataFrame(stock_data)
+                df['日期'] = pd.to_datetime(df['日期'])
+                df.set_index('日期', inplace=True)
+                df = df.sort_index()
+                print(f"✅ 直接解析获取 {len(df)} 条历史数据")
+                return df
+    except Exception as e:
+        print(f"❌ 直接解析也失败: {e}")
+
+    return None
+
+
+def get_stock_data_akshare_all_history(stock_code="002354"):
+    """
+    使用AKShare作为备用数据源 - 全历史版本
+    """
+    try:
+        print(f"尝试使用AKShare获取股票 {stock_code} 全部历史数据...")
+        import akshare as ak
+
+        # 获取所有历史数据
+        df = ak.stock_zh_a_hist(symbol=stock_code, period="daily",
+                                adjust="qfq")
+
+        if df is not None and not df.empty:
+            # 重命名列以匹配我们的格式
+            column_mapping = {
+                '日期': '日期',
+                '开盘': '开盘价',
+                '收盘': '收盘价',
+                '最高': '最高价',
+                '最低': '最低价',
+                '成交量': '成交量',
+                '成交额': '成交额',
+                '振幅': '振幅',
+                '涨跌幅': '涨跌幅',
+                '涨跌额': '涨跌额',
+                '换手率': '换手率'
+            }
+
+            # 只映射存在的列
+            actual_mapping = {k: v for k, v in column_mapping.items() if k in df.columns}
+            df = df.rename(columns=actual_mapping)
+
+            # 添加股票代码列
+            df['股票代码'] = stock_code
+            df['日期'] = pd.to_datetime(df['日期'])
+            df.set_index('日期', inplace=True)
+            df = df.sort_index()
+
+            print(f"✅ AKShare成功获取 {len(df)} 条历史数据")
+            print(f"时间范围: {df.index.min().strftime('%Y-%m-%d')} 到 {df.index.max().strftime('%Y-%m-%d')}")
+            return df
+        else:
+            print("❌ AKShare未返回数据")
+            return None
+
+    except ImportError:
+        print("⚠️ AKShare未安装，使用 pip install akshare 安装")
+        return None
+    except Exception as e:
+        print(f"❌ AKShare获取历史数据失败: {e}")
+        return None
+
+
+def get_stock_data_baostock_all_history(stock_code="002354"):
+    """
+    使用Baostock作为第三个数据源 - 全历史版本
+    """
+    try:
+        print(f"尝试使用Baostock获取股票 {stock_code} 全部历史数据...")
+        import baostock as bs
+        import pandas as pd
+
+        # 登录系统
+        lg = bs.login()
+
+        # 根据市场添加前缀
+        market = get_stock_market(stock_code)
+        if market == '0':
+            full_code = f"sz.{stock_code}"
+        else:
+            full_code = f"sh.{stock_code}"
+
+        # 获取上市日期
+        rs = bs.query_stock_basic(code=full_code)
+        if rs.error_code != '0':
+            print(f"❌ 获取股票基本信息失败: {rs.error_msg}")
+            bs.logout()
+            return None
+
+        # 获取上市��期
+        list_date = None
+        while (rs.error_code == '0') & rs.next():
+            list_date = rs.get_row_data()[2]  # 上市日期在第三个字段
+
+        if not list_date:
+            print("❌ 无法获取上市日期")
+            bs.logout()
+            return None
+
+        print(f"股票上市日期: {list_date}")
+
+        # 获取从上市日期到现在的所有数据
+        end_date = datetime.now().strftime('%Y-%m-%d')
+
+        # 获取数据
+        rs = bs.query_history_k_data_plus(
+            full_code,
+            "date,open,high,low,close,volume,amount,turn,pctChg",
+            start_date=list_date,
+            end_date=end_date,
+            frequency="d",
+            adjustflag="2"  # 前复权
+        )
+
+        data_list = []
+        while (rs.error_code == '0') & rs.next():
+            data_list.append(rs.get_row_data())
+
+        # 退出系统
+        bs.logout()
+
+        if data_list:
+            df = pd.DataFrame(data_list, columns=rs.fields)
+
+            # 数据类型转换
+            df['date'] = pd.to_datetime(df['date'])
+            df['open'] = pd.to_numeric(df['open'], errors='coerce')
+            df['high'] = pd.to_numeric(df['high'], errors='coerce')
+            df['low'] = pd.to_numeric(df['low'], errors='coerce')
+            df['close'] = pd.to_numeric(df['close'], errors='coerce')
+            df['volume'] = pd.to_numeric(df['volume'], errors='coerce')
+            df['amount'] = pd.to_numeric(df['amount'], errors='coerce')
+            df['turn'] = pd.to_numeric(df['turn'], errors='coerce')
+            df['pctChg'] = pd.to_numeric(df['pctChg'], errors='coerce')
+
+            # 重命名列
+            df = df.rename(columns={
+                'date': '日期',
+                'open': '开盘价',
+                'high': '最高价',
+                'low': '最低价',
+                'close': '收盘价',
+                'volume': '成交量',
+                'amount': '成交额',
+                'turn': '换手率',
+                'pctChg': '涨跌幅'
+            })
+
+            # 添加股票代码列
+            df['股票代码'] = stock_code
+            df.set_index('日期', inplace=True)
+            df = df.sort_index()
+
+            # 计算涨跌额
+            df['涨跌额'] = df['收盘价'].diff()
+
+            # 清理无效数据
+            df = df.dropna()
+
+            print(f"✅ Baostock成功获取 {len(df)} 条历史数据")
+            print(f"时间范围: {df.index.min().strftime('%Y-%m-%d')} 到 {df.index.max().strftime('%Y-%m-%d')}")
+            return df
+        else:
+            print("❌ Baostock未返回数据")
+            return None
+
+    except ImportError:
+        print("⚠️ Baostock未安装，使用 pip install baostock 安装")
+        return None
+    except Exception as e:
+        print(f"❌ Baostock获取历史数据失败: {e}")
+        return None
+
+
+def get_stock_data_with_retry_all_history(stock_code="002354", retry_count=2):
+    """
+    带重试机制的数据获取 - 多数据源全历史版本
+    """
+    data_sources = [
+        ("AKShare", get_stock_data_akshare_all_history),
+        ("Baostock", get_stock_data_baostock_all_history),
+        ("东方财富", get_stock_data_eastmoney_all_history)
+    ]
+
+    for source_name, data_func in data_sources:
+        print(f"\n🔍 尝试从 {source_name} 获取全部历史数据...")
+        data = data_func(stock_code)
+
+        if data is not None and not data.empty:
+            print(f"✅ {source_name} 历史数据获取成功！")
+            # 标记数据来源
+            data.attrs['data_source'] = source_name
+            return data
+
+    print("❌ 所有真实数据源都失败，使用示例数据...")
+    return create_sample_data_all_history(stock_code)
+
+
+def create_sample_data_all_history(stock_code="002354"):
+    """
+    创建更真实的历史示例数据 - 从上市年份开始
+    """
+    # 模拟不同股票的上市年份
+    list_years = {
+        '600580': 2002,  # 卧龙电驱
+        '002354': 2010,  # 天娱数科
+        '300418': 2015,  # 昆仑万维
+        '300207': 2011,  # 欣旺达
+    }
+
+    list_year = list_years.get(stock_code, 2010)
+    current_year = datetime.now().year
+
+    print(f"📊 创建 {stock_code} 从 {list_year} 年上市至今的示例数据...")
+
+    # 生成从上市年份到现在的交易日（排除周末）
+    start_date = datetime(list_year, 1, 1)
+    end_date = datetime.now()
+    all_dates = pd.bdate_range(start=start_date, end=end_date, freq='B')
+
+    # 生成更真实的股价数据
+    import numpy as np
+    np.random.seed(42)
+
+    # 设置合理的基准价格（根据股票类型）
+    base_prices = {
+        '600580': 8.0,  # 卧龙电驱
+        '002354': 15.0,  # 天娱数科 - 上市时价格较高
+        '300418': 20.0,  # 昆仑万维
+        '300207': 12.0,  # 欣旺达
+    }
+    base_price = base_prices.get(stock_code, 10.0)
+
+    stock_data = []
+    current_price = base_price
+
+    for i, date in enumerate(all_dates):
+        # 模拟真实的市场波动
+        volatility = 0.02  # 2%的日波动率
+
+        if i > 0:
+            # 使用随机游走模拟价格变化
+            daily_return = np.random.normal(0, volatility)
+
+            # 模拟不同年份的市场趋势
+            year = date.year
+            if year <= list_year + 2:  # 上市初期波动较大
+                daily_return += np.random.normal(0.001, 0.01)
+            elif year <= list_year + 5:  # 成长期
+                daily_return += np.random.normal(0.0005, 0.005)
+            else:  # 成熟期
+                daily_return += np.random.normal(0.0002, 0.003)
+
+            current_price = current_price * (1 + daily_return)
+
+            # 价格边界限制
+            current_price = max(base_price * 0.3, min(base_price * 10.0, current_price))
+        else:
+            current_price = base_price
+
+        # 生成OHLC数据
+        open_variation = np.random.normal(0, volatility * 0.2)
+        open_price = current_price * (1 + open_variation)
+
+        daily_range = abs(np.random.normal(volatility * 0.8, volatility * 0.3))
+        high_price = max(open_price, current_price) * (1 + daily_range)
+        low_price = min(open_price, current_price) * (1 - daily_range)
+        close_price = current_price
+
+        # 确保价格合理性
+        high_price = max(open_price, close_price, low_price, high_price)
+        low_price = min(open_price, close_price, high_price, low_price)
+
+        # 生成成交量（随年份增长）
+        base_volume = 100000 + (year - list_year) * 50000  # 成交量逐年增长
+        volume_variation = abs(daily_return) * 5000000 if i > 0 else 0
+        volume = int(base_volume + volume_variation + np.random.randint(-200000, 400000))
+        volume = max(50000, volume)
+
+        # 计算成交额（万元）
+        amount = volume * close_price / 10000
+
+        # 计算涨跌幅和涨跌额
+        if i > 0:
+            prev_close = stock_data[-1]['收盘价']
+            price_change = close_price - prev_close
+            pct_change = (price_change / prev_close) * 100
+        else:
+            price_change = 0
+            pct_change = 0
+
+        # 计算振幅
+        amplitude = ((high_price - low_price) / open_price) * 100
+
+        # 生成换手率（1%-15%之间）
+        turnover_rate = np.random.uniform(1.0, 15.0)
+
+        stock_data.append({
+            '日期': date,
+            '股票代码': stock_code,
+            '开盘价': round(open_price, 2),
+            '收盘价': round(close_price, 2),
+            '最高价': round(high_price, 2),
+            '最低价': round(low_price, 2),
+            '成交量': volume,
+            '成交额': round(amount, 2),
+            '振幅': round(amplitude, 2),
+            '涨跌幅': round(pct_change, 2),
+            '涨跌额': round(price_change, 2),
+            '换手率': round(turnover_rate, 2)
+        })
+
+    df = pd.DataFrame(stock_data)
+    df.set_index('日期', inplace=True)
+
+    print(f"✅ 已创建 {len(df)} 条从 {list_year} 年至今的模拟历史数据")
+    print(f"时间范围: {df.index.min().strftime('%Y-%m-%d')} 到 {df.index.max().strftime('%Y-%m-%d')}")
+
+    # 标记为模拟数据
+    df.attrs['data_source'] = '模拟历史数据'
+
+    return df
+
+
+def display_all_history_data_info(df, stock_code):
+    """显示全历史数据信息"""
+    if df is None or df.empty:
+        print("没有数据可显示")
+        return
+
+    # 获取数据来源
+    data_source = df.attrs.get('data_source', '未知来源')
+
+    print(f"\n{'=' * 60}")
+    print(f"股票 {stock_code} 全部历史数据摘要")
+    print(f"{'=' * 60}")
+
+    print(f"数据时间范围: {df.index.min().strftime('%Y-%m-%d')} 到 {df.index.max().strftime('%Y-%m-%d')}")
+    print(f"总交易天数: {len(df):,}")
+    print(f"数据来源: {data_source}")
+
+    # 按年份显示统计
+    years = sorted(df.index.year.unique())
+    print(f"\n历史年份: {years}")
+
+    # 显示关键年份统计
+    key_years = [years[0]]  # 上市年份
+    if len(years) > 1:
+        key_years.append(years[-1])  # 最新年份
+    if len(years) > 5:
+        key_years.extend([years[len(years) // 2], years[len(years) // 4], years[3 * len(years) // 4]])
+
+    for year in sorted(set(key_years)):
+        year_data = df[df.index.year == year]
+        if len(year_data) > 0:
+            print(f"\n{year}年统计:")
+            print(f"  交易天数: {len(year_data)}")
+            print(f"  平均收盘价: {year_data['收盘价'].mean():.2f} 元")
+            print(f"  最高价: {year_data['最高价'].max():.2f} 元")
+            print(f"  最低价: {year_data['最低价'].min():.2f} 元")
+            if len(year_data) > 1:
+                year_return = (year_data['收盘价'].iloc[-1] / year_data['收盘价'].iloc[0] - 1) * 100
+                print(f"  年度涨跌幅: {year_return:+.2f}%")
+
+    # 显示整体统计
+    print(f"\n整体统计:")
+    total_return = (df['收盘价'].iloc[-1] / df['收盘价'].iloc[0] - 1) * 100
+    print(f"  总涨跌幅: {total_return:+.2f}%")
+    print(f"  历史最高价: {df['最高价'].max():.2f} 元")
+    print(f"  历史最低价: {df['最低价'].min():.2f} 元")
+    print(f"  平均日成交量: {df['成交量'].mean():,.0f} 股")
+
+    # 显示最新交易日数据
+    latest_date = df.index.max()
+    print(f"\n最新交易日 ({latest_date.strftime('%Y-%m-%d')}) 数据:")
+    latest_data = df.loc[latest_date]
+    for col, value in latest_data.items():
+        if col != '股票代码':
+            if col in ['成交量']:
+                print(f"  {col}: {value:,.0f}")
+            elif col in ['成交额']:
+                print(f"  {col}: {value:,.2f} 万元")
+            else:
+                print(f"  {col}: {value}")
+
+
+def save_all_history_stock_data(df, stock_code, save_dir="D:/lianghuajiaoyi/Kronos/examples/data"):
+    """
+    保存全历史股票数据到指定目录
+    """
+    if df is not None and not df.empty:
+        # 确保保存目录存在
+        os.makedirs(save_dir, exist_ok=True)
+
+        # 保存CSV文件 - 使用全历史命名
+        csv_file = os.path.join(save_dir, f"{stock_code}_all_history.csv")
+
+        # 重置索引以便保存日期列
+        df_reset = df.reset_index()
+        df_reset.to_csv(csv_file, encoding='utf-8-sig', index=False)
+
+        print(f"\n📁 全历史股票数据已保存: {csv_file}")
+
+        # 同时保存一个按年份分割的版本
+        years = df_reset['日期'].dt.year.unique()
+        for year in years:
+            year_data = df_reset[df_reset['日期'].dt.year == year]
+            year_file = os.path.join(save_dir, f"{stock_code}_{year}.csv")
+            year_data.to_csv(year_file, encoding='utf-8-sig', index=False)
+
+        print(f"📁 同时保存了 {len(years)} 个年份的单独数据文件")
+        return True
+    return False
+
+
+def main_all_history(stock_code="002354"):
+    """
+    主函数：获取并保存股票全历史数据
+    """
+    # 设置保存目录
+    save_directory = "D:/lianghuajiaoyi/Kronos/examples/data"
+
+    print("=" * 60)
+    print(f"开始获取股票 {stock_code} 的全部历史数据")
+    print("=" * 60)
+    print(f"数据将保存到: {save_directory}")
+
+    # 检查必要库
+    try:
+        import requests
+        import numpy as np
+    except ImportError:
+        print("正在安装必要库...")
+        import subprocess
+        subprocess.check_call(["pip", "install", "requests", "numpy", "pandas"])
+        import requests
+        import numpy as np
+
+    # 获取全历史数据（多数据源）
+    stock_data = get_stock_data_with_retry_all_history(stock_code)
+
+    if stock_data is not None:
+        # 显示数据信息
+        display_all_history_data_info(stock_data, stock_code)
+
+        # 保存全历史数据到指定目录
+        save_all_history_stock_data(stock_data, stock_code, save_directory)
+
+        print(f"\n🎉 股票 {stock_code} 全历史数据处理完成!")
+        print(
+            f"数据时间跨度: {stock_data.index.min().strftime('%Y-%m-%d')} 到 {stock_data.index.max().strftime('%Y-%m-%d')}")
+        print(f"总交易天数: {len(stock_data):,}")
+
+        # 显示保存的文件
+        csv_file = os.path.join(save_directory, f"{stock_code}_all_history.csv")
+        if os.path.exists(csv_file):
+            file_size = os.path.getsize(csv_file) / 1024  # KB
+            print(f"📄 生成的文件: {csv_file} ({file_size:.1f} KB)")
+    else:
+        print("❌ 未能获取股票全历史数据")
+
+
+# 使用方法说明
+if __name__ == "__main__":
+    """
+    使用方法：
+    修改下面的参数来获取不同股票的全历史数据
+    """
+
+    # ==================== 在这里修改参数 ====================
+    TARGET_STOCK_CODE = "300418"  # 股票代码
+    # =====================================================
+
+    print("股票全历史数据获取工具")
+    print("说明：修改代码中的 TARGET_STOCK_CODE 来获取不同股票的全部历史数据")
+    print(f"当前设置: 股票代码={TARGET_STOCK_CODE}")
+    print()
+
+    # 运行主程序
+    main_all_history(stock_code=TARGET_STOCK_CODE)
+
+    print(f"\n💡 提示：要获取其他股票的全历史数据，请修改代码中的 TARGET_STOCK_CODE 变量")

Kronos/examples/prediction_akshare_2024-2025.py

@@ -0,0 +1,545 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+import numpy as np
+import sys
+import os
+from datetime import datetime, timedelta
+import warnings
+
+warnings.filterwarnings('ignore')
+
+# 添加项目路径以便导入自定义模块
+sys.path.append("../")
+from model import Kronos, KronosTokenizer, KronosPredictor
+
+# 设置中文字体
+plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
+plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
+
+
+def ensure_output_directory(output_dir):
+    """确保输出目录存在，如果不存在则创建"""
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+        print(f"✅ 创建输出目录: {output_dir}")
+    return output_dir
+
+
+def prepare_stock_data(csv_file_path, stock_code):
+    """
+    准备股票数据，转换为Kronos模型需要的格式
+
+    参数:
+    csv_file_path: CSV文件路径
+    stock_code: 股票代码，用于显示信息
+
+    返回:
+    df: 处理后的DataFrame
+    """
+    print(f"正在加载和预处理股票 {stock_code} 数据...")
+
+    # 读取CSV文件
+    df = pd.read_csv(csv_file_path, encoding='utf-8-sig')
+
+    # 检查数据列名并重命名为标准格式
+    column_mapping = {
+        '日期': 'timestamps',
+        '开盘价': 'open',
+        '最高价': 'high',
+        '最低价': 'low',
+        '收盘价': 'close',
+        '成交量': 'volume',
+        '成交额': 'amount'
+    }
+
+    # 只重命名存在的列
+    actual_mapping = {k: v for k, v in column_mapping.items() if k in df.columns}
+    df = df.rename(columns=actual_mapping)
+
+    # 确保时间戳列存在并转换为datetime格式
+    if 'timestamps' not in df.columns:
+        # 如果数据有日期索引，重置索引
+        if df.index.name == '日期':
+            df = df.reset_index()
+            df = df.rename(columns={'日期': 'timestamps'})
+
+    df['timestamps'] = pd.to_datetime(df['timestamps'])
+
+    # 按时间排序
+    df = df.sort_values('timestamps').reset_index(drop=True)
+
+    print(f"✅ 数据加载完成，共 {len(df)} 条记录")
+    print(f"时间范围: {df['timestamps'].min()} 到 {df['timestamps'].max()}")
+    print(f"数据列: {df.columns.tolist()}")
+
+    return df
+
+
+def calculate_prediction_parameters(df, target_days=100):
+    """
+    根据目标预测天数计算合适的参数
+
+    参数:
+    df: 股票数据DataFrame
+    target_days: 目标预测天数（自然日）
+
+    返回:
+    lookback: 回看期数
+    pred_len: 预测期数
+    """
+    # 计算平均交易日数量（考虑节假日）
+    total_days = (df['timestamps'].max() - df['timestamps'].min()).days
+    trading_days = len(df)
+    trading_ratio = trading_days / total_days if total_days > 0 else 0.7  # 交易日比例
+
+    # 计算目标预测的交易日数量
+    pred_trading_days = int(target_days * trading_ratio)
+
+    # 设置回看期数为预测期数的2-3倍，但不超过数据总量的70%
+    max_lookback = int(len(df) * 0.7)
+    lookback = min(pred_trading_days * 2, max_lookback, len(df) - pred_trading_days)
+    pred_len = min(pred_trading_days, len(df) - lookback)
+
+    print(f"📊 参数计算:")
+    print(f"  目标预测天数: {target_days} 天（自然日）")
+    print(f"  预计交易日数量: {pred_trading_days} 天")
+    print(f"  回看期数 (lookback): {lookback}")
+    print(f"  预测期数 (pred_len): {pred_len}")
+
+    return lookback, pred_len
+
+
+def generate_future_dates_with_holidays(last_date, pred_len):
+    """
+    生成未来的交易日日期，考虑中国节假日
+
+    参数:
+    last_date: 最后一个历史数据的日期
+    pred_len: 预测期数
+
+    返回:
+    future_dates: 未来的交易日日期列表
+    """
+    # 中国主要节假日（需要根据实际情况调整）
+    holidays_2025 = [
+        # 2025年国庆节假期（通常为10月1日-10月8日）
+        datetime(2025, 10, 1), datetime(2025, 10, 2), datetime(2025, 10, 3),
+        datetime(2025, 10, 4), datetime(2025, 10, 5), datetime(2025, 10, 6),
+        datetime(2025, 10, 7), datetime(2025, 10, 8),  # 添加10月8日
+        # 周末调休等可以根据需要添加
+    ]
+
+    future_dates = []
+    current_date = last_date + timedelta(days=1)
+
+    while len(future_dates) < pred_len:
+        # 如果是工作日（周一到周五）且不是节假日
+        if current_date.weekday() < 5 and current_date not in holidays_2025:
+            future_dates.append(current_date)
+        current_date += timedelta(days=1)
+
+    print(f"📅 生成的未来交易日: 共 {len(future_dates)} 天")
+    print(f"   起始日期: {future_dates[0].strftime('%Y-%m-%d')}")
+    print(f"   结束日期: {future_dates[-1].strftime('%Y-%m-%d')}")
+
+    # 显示节假日信息
+    holiday_count = sum(1 for date in holidays_2025 if date > last_date)
+    print(f"   包含节假日: {holiday_count} 天")
+
+    return future_dates[:pred_len]
+
+
+def plot_prediction_with_details(kline_df, pred_df, future_dates, stock_code="002354", stock_name="股票", pred_len=100,
+                                 output_dir="."):
+    """
+    绘制详细的预测结果图表 - 优化版，图表更大更清晰
+
+    参数:
+    kline_df: 历史K线数据
+    pred_df: 预测数据
+    future_dates: 未来日期列表
+    stock_code: 股票代码
+    stock_name: 股票名称
+    pred_len: 预测期数
+    output_dir: 输出目录
+    """
+    # 确保输出目录存在
+    ensure_output_directory(output_dir)
+
+    # 确保数据长度一致
+    min_len = min(len(pred_df), len(future_dates))
+    pred_df = pred_df.iloc[:min_len]
+    future_dates = future_dates[:min_len]
+
+    # 设置预测数据的索引为未来日期
+    pred_df.index = future_dates
+
+    # 准备价格数据
+    sr_close = kline_df.set_index('timestamps')['close']
+    sr_pred_close = pred_df['close']
+    sr_close.name = '历史数据'
+    sr_pred_close.name = "预测数据"
+
+    # 准备成交量数据
+    sr_volume = kline_df.set_index('timestamps')['volume']
+    sr_pred_volume = pred_df['volume']
+    sr_volume.name = '历史数据'
+    sr_pred_volume.name = "预测数据"
+
+    # 合并数据
+    close_df = pd.concat([sr_close, sr_pred_close], axis=1)
+    volume_df = pd.concat([sr_volume, sr_pred_volume], axis=1)
+
+    # 创建更大的图表
+    fig = plt.figure(figsize=(18, 14))
+
+    # 使用GridSpec创建更灵活的布局
+    gs = plt.GridSpec(3, 1, figure=fig, height_ratios=[3, 1, 1])
+
+    ax1 = fig.add_subplot(gs[0])  # 价格图表
+    ax2 = fig.add_subplot(gs[1])  # 成交量图表
+    ax3 = fig.add_subplot(gs[2])  # 价格变动图表
+
+    # 1. 价格图表 - 更大更清晰
+    # 只显示最近200个交易日的历史数据，避免图表过于拥挤
+    recent_history = close_df['历史数据'].iloc[-min(200, len(close_df['历史数据'])):]
+    ax1.plot(recent_history.index, recent_history.values, label='历史价格', color='#1f77b4', linewidth=2.5, alpha=0.9)
+    ax1.plot(close_df['预测数据'].index, close_df['预测数据'].values, label='预测价格',
+             color='#ff7f0e', linewidth=2.5, linestyle='-', marker='o', markersize=3)
+
+    # 添加预测起始点的标记
+    prediction_start_date = close_df['预测数据'].index[0] if len(close_df['预测数据']) > 0 else close_df.index[-1]
+    prediction_start_price = close_df['历史数据'].iloc[-1]
+    ax1.axvline(x=prediction_start_date, color='red', linestyle='--', alpha=0.7, linewidth=1.5)
+    ax1.annotate('预测起点', xy=(prediction_start_date, prediction_start_price),
+                 xytext=(10, 10), textcoords='offset points',
+                 bbox=dict(boxstyle='round,pad=0.3', facecolor='yellow', alpha=0.7),
+                 arrowprops=dict(arrowstyle='->', connectionstyle='arc3,rad=0'))
+
+    ax1.set_ylabel('收盘价 (元)', fontsize=14, fontweight='bold')
+    ax1.legend(loc='upper left', fontsize=12)
+    ax1.grid(True, alpha=0.3)
+    ax1.set_title(f'{stock_name}({stock_code}) 股票价格预测 - 未来{pred_len}个交易日',
+                  fontsize=16, fontweight='bold', pad=20)
+
+    # 设置x轴日期格式
+    ax1.xaxis.set_major_formatter(plt.matplotlib.dates.DateFormatter('%Y-%m-%d'))
+    plt.setp(ax1.xaxis.get_majorticklabels(), rotation=45)
+
+    # 设置y轴格式
+    ax1.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'{x:.2f}'))
+
+    # 2. 成交量图表 - 优化显示
+    # 只显示预测期的成交量
+    pred_volumes = volume_df['预测数据'].dropna()
+    if len(pred_volumes) > 0:
+        ax2.bar(pred_volumes.index, pred_volumes.values,
+                alpha=0.7, color='#ff7f0e', label='预测成交量', width=0.8)
+
+    ax2.set_ylabel('成交量 (手)', fontsize=14, fontweight='bold')
+    ax2.legend(loc='upper left', fontsize=12)
+    ax2.grid(True, alpha=0.3)
+
+    # 设置x轴标签
+    if len(pred_volumes) > 0:
+        ax2.xaxis.set_major_formatter(plt.matplotlib.dates.DateFormatter('%m-%d'))
+        plt.setp(ax2.xaxis.get_majorticklabels(), rotation=45)
+
+    # 3. 价格变动图表 - 优化显示
+    if len(close_df['预测数据']) > 0:
+        price_change = close_df['预测数据'] - close_df['历史数据'].iloc[-1]
+        colors = ['green' if x >= 0 else 'red' for x in price_change]
+
+        # 每5个交易日显示一个标签，避免过于拥挤
+        bars = ax3.bar(range(len(price_change)), price_change, alpha=0.8, color=colors)
+
+        # 在关键点添加数值标签
+        for i, bar in enumerate(bars):
+            height = bar.get_height()
+            if i % 10 == 0 or i == len(bars) - 1 or abs(height) > price_change.std():  # 每10天或最后一天或显著波动
+                ax3.text(bar.get_x() + bar.get_width() / 2., height,
+                         f'{height:+.2f}', ha='center', va='bottom' if height >= 0 else 'top',
+                         fontsize=8, fontweight='bold')
+
+        ax3.axhline(y=0, color='black', linestyle='-', alpha=0.5, linewidth=1)
+
+    ax3.set_ylabel('价格变动 (��)', fontsize=14, fontweight='bold')
+    ax3.set_xlabel('交易日', fontsize=14, fontweight='bold')
+    ax3.grid(True, alpha=0.3)
+
+    # 设置x轴标签
+    if len(price_change) > 0:
+        # 每10个交易日显示一个标签
+        xticks_positions = list(range(0, len(price_change), max(1, len(price_change) // 10)))
+        if len(price_change) - 1 not in xticks_positions:
+            xticks_positions.append(len(price_change) - 1)
+        ax3.set_xticks(xticks_positions)
+        ax3.set_xticklabels([f'D{i + 1}' for i in xticks_positions])
+
+    # 添加详细的统计信息框
+    if len(close_df['预测数据']) > 0 and not np.isnan(close_df['历史数据'].iloc[-1]):
+        pred_stats = {
+            '股票代码': stock_code,
+            '股票名称': stock_name,
+            '当前价格': f"{close_df['历史数据'].iloc[-1]:.2f} 元",
+            '预测结束价格': f"{close_df['预测数据'].iloc[-1]:.2f} 元",
+            '预测涨跌幅': f"{(close_df['预测数据'].iloc[-1] / close_df['历史数据'].iloc[-1] - 1) * 100:+.2f}%",
+            '预测期间最高价': f"{close_df['预测数据'].max():.2f} 元",
+            '预测期间最低价': f"{close_df['预测数据'].min():.2f} 元",
+            '预测波动率': f"{close_df['预测数据'].std():.2f} 元",
+            '预测起始日期': f"{close_df['预测数据'].index[0].strftime('%Y-%m-%d')}",
+            '预测结束日期': f"{close_df['预测数据'].index[-1].strftime('%Y-%m-%d')}",
+            '预测交易日数': f"{len(close_df['预测数据'])} 天"
+        }
+
+        stats_text = "\n".join([f"{k}: {v}" for k, v in pred_stats.items()])
+        fig.text(0.02, 0.02, stats_text, fontsize=10,
+                 bbox=dict(boxstyle="round,pad=0.5", facecolor="lightblue", alpha=0.8),
+                 verticalalignment='bottom')
+
+    plt.tight_layout()
+
+    # 保存高分辨率图片到指定目录
+    chart_filename = os.path.join(output_dir, f'{stock_code}_prediction_chart.png')
+    plt.savefig(chart_filename, dpi=300, bbox_inches='tight', facecolor='white')
+    print(f"📊 预测图表已保存: {chart_filename}")
+
+    plt.show()
+
+    return close_df, volume_df
+
+
+def generate_prediction_report(close_df, volume_df, pred_df, future_dates, stock_code="002354", stock_name="股票",
+                               output_dir="."):
+    """
+    生成预测报告
+    """
+    # 确保输出目录存在
+    ensure_output_directory(output_dir)
+
+    print(f"\n{'=' * 70}")
+    print(f"📊 {stock_name}({stock_code}) 股票预测报告")
+    print(f"{'=' * 70}")
+
+    if len(close_df['预测数据']) == 0 or np.isnan(close_df['历史数据'].iloc[-1]):
+        print("❌ 没有有效的预测数据可生成报告")
+        return
+
+    # 确保所有数组长度一致
+    min_len = min(len(close_df['预测数据']), len(volume_df['预测数据']), len(future_dates))
+
+    # 基本统计
+    historical_close = close_df['历史数据'].iloc[-1]
+    predicted_close = close_df['预测数据'].iloc[-1]
+    price_change_pct = (predicted_close / historical_close - 1) * 100
+
+    print(f"🔮 预测概览:")
+    print(f"   当前价格: {historical_close:.2f} 元")
+    print(f"   预测结束价格: {predicted_close:.2f} 元")
+    print(f"   预测涨跌幅: {price_change_pct:+.2f}%")
+    print(f"   预测期间: {min_len} 个交易日")
+    print(
+        f"   预测时间范围: {future_dates[0].strftime('%Y-%m-%d')} 到 {future_dates[min_len - 1].strftime('%Y-%m-%d')}")
+
+    print(f"\n📈 价格预测统计:")
+    print(f"   预测最高价: {close_df['预测数据'].max():.2f} 元")
+    print(f"   预测最低价: {close_df['预测数据'].min():.2f} 元")
+    print(f"   预测平均价: {close_df['预测数据'].mean():.2f} 元")
+    print(f"   价格波动率: {close_df['预测数据'].std():.2f} 元")
+
+    print(f"\n📊 成交量预测统计:")
+    print(f"   预测平均成交量: {volume_df['预测数据'].mean():,.0f} 手")
+    print(f"   预测最大成交量: {volume_df['预测数据'].max():,.0f} 手")
+    print(f"   预测最小成交量: {volume_df['预测数据'].min():,.0f} 手")
+
+    # 保存详细预测数据到指定目录 - 确保所有数组长度一致
+    prediction_details = pd.DataFrame({
+        '日期': future_dates[:min_len],
+        '预测收盘价': close_df['预测数据'].values[:min_len],
+        '预测成交量': volume_df['预测数据'].values[:min_len],
+        '价格变动(元)': (close_df['预测数据'].values[:min_len] - historical_close),
+        '价格变动(%)': ((close_df['预测数据'].values[:min_len] / historical_close - 1) * 100)
+    })
+
+    prediction_file = os.path.join(output_dir, f'{stock_code}_detailed_predictions.csv')
+    prediction_details.to_csv(prediction_file, index=False, encoding='utf-8-sig')
+    print(f"\n💾 详细预测数据已保存: {prediction_file}")
+
+
+def main(stock_code="002354", stock_name="天娱数科", data_dir="./data", pred_days=100, output_dir="./output"):
+    """
+    主函数：执行股票价格预测
+
+    参数:
+    stock_code: 股票代码
+    stock_name: 股票名称
+    data_dir: 数据文件目录
+    pred_days: 预测天数（自然日）
+    output_dir: 输出文件目录
+    """
+    # 构建数据文件路径
+    csv_file_path = os.path.join(data_dir, f"{stock_code}_stock_data.csv")
+
+    print(f"🎯 开始 {stock_name}({stock_code}) 股票价格预测")
+    print("=" * 70)
+    print(f"数据文件: {csv_file_path}")
+    print(f"预测天数: {pred_days} 天（自然日）")
+    print(f"输出目录: {output_dir}")
+
+    # 检查数据文件是否存在
+    if not os.path.exists(csv_file_path):
+        print(f"❌ 数据文件不存在: {csv_file_path}")
+        print("请先运行数据获取脚本生成股票数据文件")
+        return
+
+    # 确保输出目录存在
+    ensure_output_directory(output_dir)
+
+    try:
+        # 1. 加载模型和分词器
+        print("\n步骤1: 加载Kronos模型和分词器...")
+        tokenizer = KronosTokenizer.from_pretrained("NeoQuasar/Kronos-Tokenizer-base")
+        model = Kronos.from_pretrained("NeoQuasar/Kronos-base")
+        print("✅ 模型加载完成")
+
+        # 2. 实例化预测器
+        print("步骤2: 初始化预测器...")
+        predictor = KronosPredictor(model, tokenizer, device="cuda:0", max_context=512)
+        print("✅ 预测器初始化完成")
+
+        # 3. 准备数据
+        print("步骤3: 准备股票数据...")
+        df = prepare_stock_data(csv_file_path, stock_code)
+
+        # 4. 计算预测参数
+        print("步骤4: 计算预测参数...")
+        lookback, pred_len = calculate_prediction_parameters(df, target_days=pred_days)
+
+        if pred_len <= 0:
+            print("❌ 数据量不足，无法进行预测")
+            return
+
+        print(f"✅ 最终参数 - 回看期: {lookback}, 预测期: {pred_len}")
+
+        # 5. 准备输入数据
+        print("步骤5: 准备输入数据...")
+        # 使用最新的数据作为输入
+        x_df = df.loc[-lookback:, ['open', 'high', 'low', 'close', 'volume', 'amount']].reset_index(drop=True)
+        x_timestamp = df.loc[-lookback:, 'timestamps'].reset_index(drop=True)
+
+        # 生成未来日期（考虑节假日）
+        last_historical_date = df['timestamps'].iloc[-1]
+        future_dates = generate_future_dates_with_holidays(last_historical_date, pred_len)
+
+        print(f"输入数据形状: {x_df.shape}")
+        print(f"历史数据时间范围: {x_timestamp.iloc[0]} 到 {x_timestamp.iloc[-1]}")
+        print(f"预测时间范围: {future_dates[0]} 到 {future_dates[-1]}")
+
+        # 6. 执行预测
+        print("步骤6: 执行价格预测...")
+        pred_df = predictor.predict(
+            df=x_df,
+            x_timestamp=x_timestamp,
+            y_timestamp=pd.Series(future_dates),  # 使用未来日期作为预测时间戳
+            pred_len=pred_len,
+            T=1.0,
+            top_p=0.9,
+            sample_count=1,
+            verbose=True
+        )
+
+        print("✅ 预测完成")
+
+        # 7. 显示预测结果
+        print("\n步骤7: 显示预测结果...")
+        print("预测数据前5行:")
+        # 确保预测数据长度与未来日期一致
+        min_len = min(len(pred_df), len(future_dates))
+        pred_df = pred_df.iloc[:min_len]
+        pred_df.index = future_dates[:min_len]
+        print(pred_df.head())
+
+        # 8. 可视化结果
+        print("步骤8: 生成可视化图表...")
+        # 使用最后一部分历史数据和预测数据
+        kline_df = df.loc[-lookback:].reset_index(drop=True)
+        close_df, volume_df = plot_prediction_with_details(kline_df, pred_df, future_dates, stock_code, stock_name,
+                                                           pred_len, output_dir)
+
+        # 9. 生成预测报告
+        print("步骤9: 生成预测报告...")
+        generate_prediction_report(close_df, volume_df, pred_df, future_dates, stock_code, stock_name, output_dir)
+
+        print(f"\n🎉 {stock_name}({stock_code}) 股票预测完成!")
+        print("生成的文件:")
+        print(f"  📊 {os.path.join(output_dir, stock_code + '_prediction_chart.png')} - 预测图表")
+        print(f"  📋 {os.path.join(output_dir, stock_code + '_detailed_predictions.csv')} - 详细预测数据")
+
+        # 显示预测总结
+        if len(close_df['预测数据']) > 0 and not np.isnan(close_df['历史数据'].iloc[-1]):
+            print(f"\n📈 预测总结:")
+            historical_price = close_df['历史数据'].iloc[-1]
+            predicted_price = close_df['预测数据'].iloc[-1]
+            change_pct = (predicted_price / historical_price - 1) * 100
+
+            print(f"  当前价格: {historical_price:.2f} 元")
+            print(f"  预测价格: {predicted_price:.2f} 元")
+            print(f"  预期涨跌: {change_pct:+.2f}%")
+            print(
+                f"  预测时间: {future_dates[0].strftime('%Y-%m-%d')} 到 {future_dates[min_len - 1].strftime('%Y-%m-%d')}")
+
+            if change_pct > 10:
+                print(f"  🚀 模型预测未来{pred_len}个交易日大幅看涨 (+{change_pct:.1f}%)")
+            elif change_pct > 5:
+                print(f"  📈 模型预测未来{pred_len}个交易日看涨 (+{change_pct:.1f}%)")
+            elif change_pct > 0:
+                print(f"  ↗️ 模型预测未来{pred_len}个交易日微涨 (+{change_pct:.1f}%)")
+            elif change_pct > -5:
+                print(f"  ↘️ 模型预测未来{pred_len}个交易日微跌 ({change_pct:.1f}%)")
+            elif change_pct > -10:
+                print(f"  📉 模型预测未来{pred_len}个交易日看跌 ({change_pct:.1f}%)")
+            else:
+                print(f"  🔻 模型预测未来{pred_len}个交易日大幅看跌 ({change_pct:.1f}%)")
+
+    except Exception as e:
+        print(f"❌ 预测过程中出现错误: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+# 使用方法说明
+if __name__ == "__main__":
+    """
+    股票预测工具 - 支持多股票预测
+
+    使用方法：
+    修改下面的 STOCK_CONFIG 来预测不同的股票
+    """
+
+    # ==================== 在这里修改股票配置 ====================
+    STOCK_CONFIG = {
+        "stock_code": "300418",  # 股票代码
+        "stock_name": "昆仑万维",  # 股票名称
+        "data_dir": "./data",  # 数据文件目录
+        "pred_days": 100,  # 预测100个自然日
+        "output_dir": r"D:\lianghuajiaoyi\Kronos\examples\yuce"  # 输出文件目录
+    }
+
+    # 其他股票配置示例：
+    # STOCK_CONFIG = {"stock_code": "000001", "stock_name": "平安银行", "data_dir": "./data", "pred_days": 100, "output_dir": r"D:\lianghuajiaoyi\Kronos\examples\yuce"}
+    # STOCK_CONFIG = {"stock_code": "600036", "stock_name": "招商银行", "data_dir": "./data", "pred_days": 100, "output_dir": r"D:\lianghuajiaoyi\Kronos\examples\yuce"}
+    # STOCK_CONFIG = {"stock_code": "300750", "stock_name": "宁德时代", "data_dir": "./data", "pred_days": 100, "output_dir": r"D:\lianghuajiaoyi\Kronos\examples\yuce"}
+    # =========================================================
+
+    print("🤖 智能股票预测工具")
+    print("=" * 70)
+    print(f"当前预测股票: {STOCK_CONFIG['stock_name']}({STOCK_CONFIG['stock_code']})")
+    print(f"数据目录: {STOCK_CONFIG['data_dir']}")
+    print(f"预测天数: {STOCK_CONFIG['pred_days']} 天（自然日）")
+    print(f"输出目录: {STOCK_CONFIG['output_dir']}")
+    print()
+
+    # 运行主程序
+    main(**STOCK_CONFIG)
+
+    print(f"\n💡 提示：要预测其他股票，请修改代码中的 STOCK_CONFIG 变量")

Kronos/examples/prediction_batch_example.py

@@ -0,0 +1,72 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+import sys
+sys.path.append("../")
+from model import Kronos, KronosTokenizer, KronosPredictor
+
+
+def plot_prediction(kline_df, pred_df):
+    pred_df.index = kline_df.index[-pred_df.shape[0]:]
+    sr_close = kline_df['close']
+    sr_pred_close = pred_df['close']
+    sr_close.name = 'Ground Truth'
+    sr_pred_close.name = "Prediction"
+
+    sr_volume = kline_df['volume']
+    sr_pred_volume = pred_df['volume']
+    sr_volume.name = 'Ground Truth'
+    sr_pred_volume.name = "Prediction"
+
+    close_df = pd.concat([sr_close, sr_pred_close], axis=1)
+    volume_df = pd.concat([sr_volume, sr_pred_volume], axis=1)
+
+    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(8, 6), sharex=True)
+
+    ax1.plot(close_df['Ground Truth'], label='Ground Truth', color='blue', linewidth=1.5)
+    ax1.plot(close_df['Prediction'], label='Prediction', color='red', linewidth=1.5)
+    ax1.set_ylabel('Close Price', fontsize=14)
+    ax1.legend(loc='lower left', fontsize=12)
+    ax1.grid(True)
+
+    ax2.plot(volume_df['Ground Truth'], label='Ground Truth', color='blue', linewidth=1.5)
+    ax2.plot(volume_df['Prediction'], label='Prediction', color='red', linewidth=1.5)
+    ax2.set_ylabel('Volume', fontsize=14)
+    ax2.legend(loc='upper left', fontsize=12)
+    ax2.grid(True)
+
+    plt.tight_layout()
+    plt.show()
+
+
+# 1. Load Model and Tokenizer
+tokenizer = KronosTokenizer.from_pretrained('/home/csc/huggingface/Kronos-Tokenizer-base/')
+model = Kronos.from_pretrained("/home/csc/huggingface/Kronos-base/")
+
+# 2. Instantiate Predictor
+predictor = KronosPredictor(model, tokenizer, device="cuda:0", max_context=512)
+
+# 3. Prepare Data
+df = pd.read_csv("./data/XSHG_5min_600977.csv")
+df['timestamps'] = pd.to_datetime(df['timestamps'])
+
+lookback = 400
+pred_len = 120
+
+dfs = []
+xtsp = []
+ytsp = []
+for i in range(5):
+    idf = df.loc[(i*400):(i*400+lookback-1), ['open', 'high', 'low', 'close', 'volume', 'amount']]
+    i_x_timestamp = df.loc[(i*400):(i*400+lookback-1), 'timestamps']
+    i_y_timestamp = df.loc[(i*400+lookback):(i*400+lookback+pred_len-1), 'timestamps']
+
+    dfs.append(idf)
+    xtsp.append(i_x_timestamp)
+    ytsp.append(i_y_timestamp)
+
+pred_df = predictor.predict_batch(
+    df_list=dfs,
+    x_timestamp_list=xtsp,
+    y_timestamp_list=ytsp,
+    pred_len=pred_len,
+)

Kronos/examples/prediction_cn_markets_day.py

@@ -0,0 +1,208 @@
+# -*- coding: utf-8 -*-
+"""
+prediction_cn_markets_day.py
+
+Description:
+    Predicts future daily K-line (1D) data for A-share markets using Kronos model and akshare.
+    The script automatically downloads the latest historical data, cleans it, and runs model inference.
+
+Usage:
+    python prediction_cn_markets_day.py --symbol 000001
+
+Arguments:
+    --symbol     Stock code (e.g. 002594 for BYD, 000001 for SSE Index)
+
+Output:
+    - Saves the prediction results to ./outputs/pred_<symbol>_data.csv and ./outputs/pred_<symbol>_chart.png
+    - Logs and progress are printed to console
+
+Example:
+    bash> python prediction_cn_markets_day.py --symbol 000001
+    python3 prediction_cn_markets_day.py --symbol 002594
+"""
+
+import os
+import argparse
+import time
+import pandas as pd
+import akshare as ak
+import matplotlib.pyplot as plt
+import sys
+sys.path.append("../")
+from model import Kronos, KronosTokenizer, KronosPredictor
+
+save_dir = "./outputs"
+os.makedirs(save_dir, exist_ok=True)
+
+# Setting
+TOKENIZER_PRETRAINED = "NeoQuasar/Kronos-Tokenizer-base"
+MODEL_PRETRAINED = "NeoQuasar/Kronos-base"
+DEVICE = "cpu"  # "cuda:0"
+MAX_CONTEXT = 512
+LOOKBACK = 400
+PRED_LEN = 120
+T = 1.0
+TOP_P = 0.9
+SAMPLE_COUNT = 1
+
+def load_data(symbol: str) -> pd.DataFrame:
+    print(f"📥 Fetching {symbol} daily data from akshare ...")
+
+    max_retries = 3
+    df = None
+
+    # Retry mechanism
+    for attempt in range(1, max_retries + 1):
+        try:
+            df = ak.stock_zh_a_hist(symbol=symbol, period="daily", adjust="")
+            if df is not None and not df.empty:
+                break
+        except Exception as e:
+            print(f"⚠️ Attempt {attempt}/{max_retries} failed: {e}")
+        time.sleep(1.5)
+
+    # If still empty after retries
+    if df is None or df.empty:
+        print(f"❌ Failed to fetch data for {symbol} after {max_retries} attempts. Exiting.")
+        sys.exit(1)
+    
+    df.rename(columns={
+        "日期": "date",
+        "开盘": "open",
+        "收盘": "close",
+        "最高": "high",
+        "最低": "low",
+        "成交量": "volume",
+        "成交额": "amount"
+    }, inplace=True)
+
+    df["date"] = pd.to_datetime(df["date"])
+    df = df.sort_values("date").reset_index(drop=True)
+
+    # Convert numeric columns
+    numeric_cols = ["open", "high", "low", "close", "volume", "amount"]
+    for col in numeric_cols:
+        df[col] = (
+            df[col]
+            .astype(str)
+            .str.replace(",", "", regex=False)
+            .replace({"--": None, "": None})
+        )
+        df[col] = pd.to_numeric(df[col], errors="coerce")
+
+    # Fix invalid open values
+    open_bad = (df["open"] == 0) | (df["open"].isna())
+    if open_bad.any():
+        print(f"⚠️  Fixed {open_bad.sum()} invalid open values.")
+        df.loc[open_bad, "open"] = df["close"].shift(1)
+        df["open"].fillna(df["close"], inplace=True)
+
+    # Fix missing amount
+    if df["amount"].isna().all() or (df["amount"] == 0).all():
+        df["amount"] = df["close"] * df["volume"]
+
+    print(f"✅ Data loaded: {len(df)} rows, range: {df['date'].min()} ~ {df['date'].max()}")
+
+    print("Data Head:")
+    print(df.head())
+
+    return df
+
+
+def prepare_inputs(df):
+    x_df = df.iloc[-LOOKBACK:][["open","high","low","close","volume","amount"]]
+    x_timestamp = df.iloc[-LOOKBACK:]["date"]
+    y_timestamp = pd.bdate_range(start=df["date"].iloc[-1] + pd.Timedelta(days=1), periods=PRED_LEN)
+    return x_df, pd.Series(x_timestamp), pd.Series(y_timestamp)
+
+def apply_price_limits(pred_df, last_close, limit_rate=0.1):
+    print(f"🔒 Applying ±{limit_rate*100:.0f}% price limit ...")
+
+    # Ensure integer index
+    pred_df = pred_df.reset_index(drop=True)
+
+    # Ensure float64 dtype for safe assignment
+    cols = ["open", "high", "low", "close"]
+    pred_df[cols] = pred_df[cols].astype("float64")
+
+    for i in range(len(pred_df)):
+        limit_up = last_close * (1 + limit_rate)
+        limit_down = last_close * (1 - limit_rate)
+
+        for col in cols:
+            value = pred_df.at[i, col]
+            if pd.notna(value):
+                clipped = max(min(value, limit_up), limit_down)
+                pred_df.at[i, col] = float(clipped)
+
+        last_close = float(pred_df.at[i, "close"])  # ensure float type
+
+    return pred_df
+
+
+def plot_result(df_hist, df_pred, symbol):
+    plt.figure(figsize=(12, 6))
+    plt.plot(df_hist["date"], df_hist["close"], label="Historical", color="blue")
+    plt.plot(df_pred["date"], df_pred["close"], label="Predicted", color="red", linestyle="--")
+    plt.title(f"Kronos Prediction for {symbol}")
+    plt.xlabel("Date")
+    plt.ylabel("Close Price")
+    plt.legend()
+    plt.grid(True)
+    plt.tight_layout()
+    plot_path = os.path.join(save_dir, f"pred_{symbol.replace('.', '_')}_chart.png")
+    plt.savefig(plot_path)
+    plt.close()
+    print(f"📊 Chart saved: {plot_path}")
+
+
+def predict_future(symbol):
+    print(f"🚀 Loading Kronos tokenizer:{TOKENIZER_PRETRAINED} model:{MODEL_PRETRAINED} ...")
+    tokenizer = KronosTokenizer.from_pretrained(TOKENIZER_PRETRAINED)
+    model = Kronos.from_pretrained(MODEL_PRETRAINED)
+    predictor = KronosPredictor(model, tokenizer, device=DEVICE, max_context=MAX_CONTEXT)
+
+    df = load_data(symbol)
+    x_df, x_timestamp, y_timestamp = prepare_inputs(df)
+
+    print("🔮 Generating predictions ...")
+
+    pred_df = predictor.predict(
+        df=x_df,
+        x_timestamp=x_timestamp,
+        y_timestamp=y_timestamp,
+        pred_len=PRED_LEN,
+        T=T,
+        top_p=TOP_P,
+        sample_count=SAMPLE_COUNT,
+    )
+
+    pred_df["date"] = y_timestamp.values
+
+    # Apply ±10% price limit
+    last_close = df["close"].iloc[-1]
+    pred_df = apply_price_limits(pred_df, last_close, limit_rate=0.1)
+
+    # Merge historical and predicted data
+    df_out = pd.concat([
+        df[["date", "open", "high", "low", "close", "volume", "amount"]],
+        pred_df[["date", "open", "high", "low", "close", "volume", "amount"]]
+    ]).reset_index(drop=True)
+
+    # Save CSV
+    out_file = os.path.join(save_dir, f"pred_{symbol.replace('.', '_')}_data.csv")
+    df_out.to_csv(out_file, index=False)
+    print(f"✅ Prediction completed and saved: {out_file}")
+
+    # Plot
+    plot_result(df, pred_df, symbol)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Kronos stock prediction script")
+    parser.add_argument("--symbol", type=str, default="000001", help="Stock code")
+    args = parser.parse_args()
+
+    predict_future(
+        symbol=args.symbol,
+    )

Kronos/examples/prediction_example.py

@@ -0,0 +1,80 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+import sys
+sys.path.append("../")
+from model import Kronos, KronosTokenizer, KronosPredictor
+
+
+def plot_prediction(kline_df, pred_df):
+    pred_df.index = kline_df.index[-pred_df.shape[0]:]
+    sr_close = kline_df['close']
+    sr_pred_close = pred_df['close']
+    sr_close.name = 'Ground Truth'
+    sr_pred_close.name = "Prediction"
+
+    sr_volume = kline_df['volume']
+    sr_pred_volume = pred_df['volume']
+    sr_volume.name = 'Ground Truth'
+    sr_pred_volume.name = "Prediction"
+
+    close_df = pd.concat([sr_close, sr_pred_close], axis=1)
+    volume_df = pd.concat([sr_volume, sr_pred_volume], axis=1)
+
+    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(8, 6), sharex=True)
+
+    ax1.plot(close_df['Ground Truth'], label='Ground Truth', color='blue', linewidth=1.5)
+    ax1.plot(close_df['Prediction'], label='Prediction', color='red', linewidth=1.5)
+    ax1.set_ylabel('Close Price', fontsize=14)
+    ax1.legend(loc='lower left', fontsize=12)
+    ax1.grid(True)
+
+    ax2.plot(volume_df['Ground Truth'], label='Ground Truth', color='blue', linewidth=1.5)
+    ax2.plot(volume_df['Prediction'], label='Prediction', color='red', linewidth=1.5)
+    ax2.set_ylabel('Volume', fontsize=14)
+    ax2.legend(loc='upper left', fontsize=12)
+    ax2.grid(True)
+
+    plt.tight_layout()
+    plt.show()
+
+
+# 1. Load Model and Tokenizer
+tokenizer = KronosTokenizer.from_pretrained("NeoQuasar/Kronos-Tokenizer-base")
+model = Kronos.from_pretrained("NeoQuasar/Kronos-small")
+
+# 2. Instantiate Predictor
+predictor = KronosPredictor(model, tokenizer, max_context=512)
+
+# 3. Prepare Data
+df = pd.read_csv("./data/XSHG_5min_600977.csv")
+df['timestamps'] = pd.to_datetime(df['timestamps'])
+
+lookback = 400
+pred_len = 120
+
+x_df = df.loc[:lookback-1, ['open', 'high', 'low', 'close', 'volume', 'amount']]
+x_timestamp = df.loc[:lookback-1, 'timestamps']
+y_timestamp = df.loc[lookback:lookback+pred_len-1, 'timestamps']
+
+# 4. Make Prediction
+pred_df = predictor.predict(
+    df=x_df,
+    x_timestamp=x_timestamp,
+    y_timestamp=y_timestamp,
+    pred_len=pred_len,
+    T=1.0,
+    top_p=0.9,
+    sample_count=1,
+    verbose=True
+)
+
+# 5. Visualize Results
+print("Forecasted Data Head:")
+print(pred_df.head())
+
+# Combine historical and forecasted data for plotting
+kline_df = df.loc[:lookback+pred_len-1]
+
+# visualize
+plot_prediction(kline_df, pred_df)
+

Kronos/examples/prediction_new.py

@@ -0,0 +1,1333 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+import numpy as np
+import sys
+import os
+from datetime import datetime, timedelta
+import warnings
+import requests
+import json
+import time
+import random
+import akshare as ak
+from typing import Dict, List, Tuple, Optional
+
+warnings.filterwarnings('ignore')
+
+# 添加项目路径以便导入自定义模块
+sys.path.append("../")
+try:
+    from model import Kronos, KronosTokenizer, KronosPredictor
+except ImportError:
+    print("⚠️ 无法导入Kronos模型，预测功能将不可用")
+
+# 设置中文字体
+plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
+plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
+
+
+# ==================== 基础数据获取函数 ====================
+def ensure_output_directory(output_dir):
+    """确保输出目录存在，如果不存在则创建"""
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+        print(f"✅ 创建输出目录: {output_dir}")
+    return output_dir
+
+
+def fetch_real_stock_data(stock_code, period="daily", adjust="qfq"):
+    """
+    使用AKShare获取真实股票数据
+    """
+    try:
+        print(f"📡 正在通过AKShare获取 {stock_code} 的真实股票数据...")
+
+        # 获取股票数据
+        df = ak.stock_zh_a_hist(symbol=stock_code, period=period, adjust=adjust)
+
+        if df is None or df.empty:
+            print(f"❌ 未获取到 {stock_code} 的数据")
+            return None
+
+        # 重命名列以统一格式
+        column_mapping = {
+            '日期': 'timestamps',
+            '开盘': 'open',
+            '收盘': 'close',
+            '最高': 'high',
+            '最低': 'low',
+            '成交量': 'volume',
+            '成交额': 'amount',
+            '振幅': 'amplitude',
+            '涨跌幅': 'pct_chg',
+            '涨跌额': 'change_amount',
+            '换手率': 'turnover'
+        }
+
+        # 只映射存在的列
+        actual_mapping = {k: v for k, v in column_mapping.items() if k in df.columns}
+        df = df.rename(columns=actual_mapping)
+
+        # 确保时间戳格式正确
+        df['timestamps'] = pd.to_datetime(df['timestamps'])
+        df = df.sort_values('timestamps').reset_index(drop=True)
+
+        # 添加股票代码列
+        df['stock_code'] = stock_code
+
+        print(f"✅ 成功获取 {len(df)} 条真实数据")
+        print(f"📈 最新收盘价: {df['close'].iloc[-1]:.2f}元, 涨跌幅: {df['pct_chg'].iloc[-1]:.2f}%")
+        print(f"📅 时间范围: {df['timestamps'].min()} 到 {df['timestamps'].max()}")
+
+        return df
+
+    except Exception as e:
+        print(f"❌ AKShare数据获取失败: {e}")
+        return None
+
+
+def get_stock_data_with_retry_all_history(stock_code="600580", retry_count=2):
+    """
+    优化的数据获取函数 - 优先使用真实API数据
+    """
+    print(f"🔄 尝试获取股票 {stock_code} 的真实历史数据...")
+
+    # 优先使用AKShare获取真实数据
+    df = fetch_real_stock_data(stock_code, "daily", "qfq")
+
+    if df is not None:
+        return df
+    else:
+        print("⚠️ 真实数据获取失败，使用基于真实价格的模拟数据...")
+        return create_realistic_fallback_data(stock_code)
+
+
+def create_realistic_fallback_data(stock_code="600580"):
+    """
+    基于真实价格的备用数据生成函数
+    """
+    # 基于真实市场价格的参考数据
+    real_stock_references = {
+        '600580': {'name': '卧龙电驱', 'current_price': 15.20, 'range': (12.0, 20.0)},
+        '300207': {'name': '欣旺达', 'current_price': 33.79, 'range': (28.0, 38.0)},
+        '300418': {'name': '昆仑万维', 'current_price': 48.59, 'range': (40.0, 55.0)},
+        '002354': {'name': '天娱数科', 'current_price': 15.20, 'range': (12.0, 20.0)},
+        '000001': {'name': '平安银行', 'current_price': 12.50, 'range': (10.0, 16.0)},
+        '600036': {'name': '招商银行', 'current_price': 35.80, 'range': (30.0, 42.0)},
+    }
+
+    stock_info = real_stock_references.get(stock_code, {
+        'name': '未知股票',
+        'current_price': 20.0,
+        'range': (15.0, 25.0)
+    })
+
+    # 生成最近1年的交易日数据
+    end_date = datetime.now()
+    start_date = end_date - timedelta(days=365)
+    dates = pd.bdate_range(start=start_date, end=end_date, freq='B')
+
+    # 生成基于真实价格的价格序列
+    np.random.seed(42)
+    n_points = len(dates)
+
+    # 从当前价格反向生成历史价格
+    current_price = stock_info['current_price']
+    min_price, max_price = stock_info['range']
+
+    # 反向生成价格序列
+    prices = [current_price]
+    for i in range(1, n_points):
+        volatility = 0.02
+        historical_return = np.random.normal(-0.0002, volatility)
+
+        prev_price = prices[0] * (1 + historical_return)
+        prev_price = max(min_price * 0.9, min(max_price * 1.1, prev_price))
+        prices.insert(0, prev_price)
+
+    # 生成OHLC数据
+    stock_data = []
+    for i, date in enumerate(dates):
+        close_price = prices[i]
+
+        daily_volatility = abs(np.random.normal(0, 0.015))
+        open_price = close_price * (1 + np.random.normal(0, 0.005))
+        high_price = max(open_price, close_price) * (1 + daily_volatility)
+        low_price = min(open_price, close_price) * (1 - daily_volatility)
+
+        high_price = max(open_price, close_price, low_price, high_price)
+        low_price = min(open_price, close_price, high_price, low_price)
+
+        volume = int(abs(np.random.normal(1500000, 400000)))
+        amount = volume * close_price
+
+        if i > 0:
+            pct_chg = ((close_price - prices[i - 1]) / prices[i - 1]) * 100
+            change_amount = close_price - prices[i - 1]
+        else:
+            pct_chg = 0
+            change_amount = 0
+
+        stock_data.append({
+            'timestamps': date,
+            'stock_code': stock_code,
+            'open': round(open_price, 2),
+            'close': round(close_price, 2),
+            'high': round(high_price, 2),
+            'low': round(low_price, 2),
+            'volume': volume,
+            'amount': round(amount, 2),
+            'amplitude': round(((high_price - low_price) / open_price) * 100, 2),
+            'pct_chg': round(pct_chg, 2),
+            'change_amount': round(change_amount, 2),
+            'turnover': round(np.random.uniform(3.0, 8.0), 2)
+        })
+
+    df = pd.DataFrame(stock_data)
+    print(f"✅ 已生成基于真实价格的备用数据 {len(df)} 条")
+    return df
+
+
+def save_all_history_stock_data(df, stock_code, save_dir):
+    """
+    保存股票数据到指定目录
+    """
+    if df is not None and not df.empty:
+        os.makedirs(save_dir, exist_ok=True)
+        csv_file = os.path.join(save_dir, f"{stock_code}_stock_data.csv")
+        df_reset = df.reset_index()
+        df_reset.to_csv(csv_file, encoding='utf-8-sig', index=False)
+        print(f"📁 股票数据已保存: {csv_file}")
+        return True
+    return False
+
+
+def get_stock_data(stock_code, data_dir):
+    """
+    获取股票数据，如果数据文件不存在则从API获取真实数据
+    """
+    csv_file_path = os.path.join(data_dir, f"{stock_code}_stock_data.csv")
+
+    if os.path.exists(csv_file_path):
+        print(f"📁 使用现有数据文件: {csv_file_path}")
+        return True, csv_file_path
+    else:
+        print(f"📡 数据文件不存在，从API获取真实数据...")
+        df = get_stock_data_with_retry_all_history(stock_code)
+
+        if df is not None and not df.empty:
+            save_all_history_stock_data(df, stock_code, data_dir)
+            return True, csv_file_path
+        else:
+            print(f"❌ 无法获取股票数据")
+            return False, None
+
+
+def prepare_stock_data(csv_file_path, stock_code, history_years=1):
+    """
+    准备股票数据，转换为Kronos模型需要的格式
+    """
+    print(f"正在加载和预处理股票 {stock_code} 数据...")
+
+    # 读取CSV文件
+    df = pd.read_csv(csv_file_path, encoding='utf-8-sig')
+
+    # 标准化列名
+    column_mapping = {
+        '日期': 'timestamps',
+        '开盘价': 'open',
+        '最高价': 'high',
+        '最低价': 'low',
+        '收盘价': 'close',
+        '成交量': 'volume',
+        '成交额': 'amount',
+        '开盘': 'open',
+        '收盘': 'close',
+        '最高': 'high',
+        '最低': 'low'
+    }
+
+    actual_mapping = {k: v for k, v in column_mapping.items() if k in df.columns}
+    df = df.rename(columns=actual_mapping)
+
+    # 确保时间戳列存在并转换为datetime格式
+    if 'timestamps' not in df.columns:
+        if df.index.name == '日期':
+            df = df.reset_index()
+            df = df.rename(columns={'日期': 'timestamps'})
+
+    df['timestamps'] = pd.to_datetime(df['timestamps'])
+    df = df.sort_values('timestamps').reset_index(drop=True)
+
+    # 根据历史年限筛选数据
+    if history_years > 0:
+        cutoff_date = datetime.now() - timedelta(days=history_years * 365)
+        original_count = len(df)
+        df = df[df['timestamps'] >= cutoff_date]
+        print(f"📅 使用最近 {history_years} 年数据: {len(df)} 条记录 (从 {original_count} 条中筛选)")
+
+    # 数据验证
+    print(f"🔍 数据验证 - 最近5个交易日收盘价:")
+    recent_prices = df[['timestamps', 'close']].tail()
+    for _, row in recent_prices.iterrows():
+        print(f"  {row['timestamps'].strftime('%Y-%m-%d')}: {row['close']:.2f}元")
+
+    current_price = df['close'].iloc[-1]
+    print(f"✅ 数据加载完成，共 {len(df)} 条记录")
+    print(f"时间范围: {df['timestamps'].min()} 到 {df['timestamps'].max()}")
+    print(f"价格范围: {df['close'].min():.2f} - {df['close'].max():.2f}")
+    print(f"当前价格: {current_price:.2f}元")
+
+    return df
+
+
+def calculate_prediction_parameters(df, target_days=60):
+    """
+    根据目标预测天数计算合适的���数
+    """
+    # 计算平均交易日数量
+    total_days = (df['timestamps'].max() - df['timestamps'].min()).days
+    trading_days = len(df)
+    trading_ratio = trading_days / total_days if total_days > 0 else 0.7
+
+    # 计算目标预测的交易日数量
+    pred_trading_days = int(target_days * trading_ratio)
+
+    # 设置回看期数
+    max_lookback = int(len(df) * 0.7)
+    lookback = min(pred_trading_days * 3, max_lookback, len(df) - pred_trading_days)
+    pred_len = min(pred_trading_days, len(df) - lookback)
+
+    # 确保参数在合理范围内
+    lookback = max(100, min(lookback, 400))
+    pred_len = max(20, min(pred_len, 120))
+
+    print(f"📊 参数计算:")
+    print(f"  目标预测天数: {target_days} 天（自然日）")
+    print(f"  预计交易日数量: {pred_trading_days} 天")
+    print(f"  回看期数 (lookback): {lookback}")
+    print(f"  预测期数 (pred_len): {pred_len}")
+
+    return lookback, pred_len
+
+
+def generate_future_dates(last_date, pred_len):
+    """
+    生成未来的交易日日期
+    """
+    future_dates = []
+    current_date = last_date + timedelta(days=1)
+
+    while len(future_dates) < pred_len:
+        if current_date.weekday() < 5:
+            future_dates.append(current_date)
+        current_date += timedelta(days=1)
+
+    print(f"📅 生成的未来交易日: 共 {len(future_dates)} 天")
+    print(f"   起始日期: {future_dates[0].strftime('%Y-%m-%d')}")
+    print(f"   结束日期: {future_dates[-1].strftime('%Y-%m-%d')}")
+
+    return future_dates[:pred_len]
+
+
+def calculate_optimal_interval(min_val, max_val):
+    """
+    计算最优的Y轴刻度间隔
+    """
+    range_val = max_val - min_val
+    if range_val <= 0:
+        return 1.0
+
+    if range_val < 1:
+        interval = 0.1
+    elif range_val < 5:
+        interval = 0.5
+    elif range_val < 10:
+        interval = 1.0
+    elif range_val < 20:
+        interval = 2.0
+    elif range_val < 50:
+        interval = 5.0
+    elif range_val < 100:
+        interval = 10.0
+    elif range_val < 200:
+        interval = 20.0
+    elif range_val < 500:
+        interval = 50.0
+    else:
+        interval = 100.0
+
+    return interval
+
+
+def get_stock_price_reference(stock_code, current_price):
+    """
+    根据当前价格智能计算参考价格范围
+    """
+    price_ranges = {
+        '600580': (current_price * 0.75, current_price * 1.25),
+        '300207': (current_price * 0.75, current_price * 1.25),
+        '300418': (current_price * 0.75, current_price * 1.25),
+        '002354': (current_price * 0.75, current_price * 1.25),
+        '000001': (current_price * 0.75, current_price * 1.25),
+        '600036': (current_price * 0.75, current_price * 1.25),
+    }
+
+    if stock_code in price_ranges:
+        min_price, max_price = price_ranges[stock_code]
+        min_price = max(1.0, min_price)
+        return {'min': min_price, 'max': max_price}
+    else:
+        return {'min': max(1.0, current_price * 0.7), 'max': current_price * 1.3}
+
+
+# ==================== 增强版市场因素分析器 ====================
+class EnhancedMarketFactorAnalyzer:
+    """增强版市场因素分析器 - 整合更多维度的市场因素"""
+
+    def __init__(self):
+        self.market_data = {}
+        self.sector_data = {}
+        self.macro_factors = {}
+        self.policy_factors = {}
+
+    def analyze_market_trend(self, index_codes=["000001", "399001"]):
+        """
+        分析大盘趋势 - 多指数综合分析
+        """
+        try:
+            print(f"📊 综合分析大盘趋势...")
+
+            market_analysis = {}
+
+            for index_code in index_codes:
+                index_name = "上证指数" if index_code == "000001" else "深证成指"
+                print(f"  分析{index_name}({index_code})...")
+
+                # 获取指数数据
+                index_df = ak.stock_zh_index_hist(symbol=index_code, period="daily")
+
+                if index_df is None or index_df.empty:
+                    print(f"  ❌ 无法获取{index_name}数据")
+                    continue
+
+                # 重命名列
+                index_df = index_df.rename(columns={
+                    '日期': 'date', '收盘': 'close', '开盘': 'open',
+                    '最高': 'high', '最低': 'low', '成交量': 'volume'
+                })
+                index_df['date'] = pd.to_datetime(index_df['date'])
+                index_df = index_df.sort_values('date').reset_index(drop=True)
+
+                # 计算技术指标
+                index_df['ma5'] = index_df['close'].rolling(5).mean()
+                index_df['ma20'] = index_df['close'].rolling(20).mean()
+                index_df['ma60'] = index_df['close'].rolling(60).mean()
+                index_df['vol_ma5'] = index_df['volume'].rolling(5).mean()
+
+                # 技术分析
+                current_data = index_df.iloc[-1]
+                prev_data = index_df.iloc[-2]
+
+                # 均线多头排列判断
+                ma_condition = (current_data['ma5'] > current_data['ma20'] > current_data['ma60'])
+
+                # 价格站在20日均线以上
+                price_above_ma20 = current_data['close'] > current_data['ma20']
+
+                # 成交量配合
+                volume_condition = current_data['volume'] > current_data['vol_ma5'] * 0.8
+
+                # 趋势强度
+                trend_strength = self._calculate_trend_strength(index_df)
+
+                is_main_uptrend = ma_condition and price_above_ma20 and trend_strength > 0.6
+
+                market_analysis[index_name] = {
+                    'is_main_uptrend': is_main_uptrend,
+                    'trend_strength': trend_strength,
+                    'current_close': current_data['close'],
+                    'price_change_pct': ((current_data['close'] - prev_data['close']) / prev_data['close']) * 100,
+                    'market_status': '主升浪' if is_main_uptrend else '震荡调整'
+                }
+
+            # 综合判断
+            if market_analysis:
+                avg_trend_strength = np.mean([data['trend_strength'] for data in market_analysis.values()])
+                uptrend_count = sum(1 for data in market_analysis.values() if data['is_main_uptrend'])
+                overall_uptrend = uptrend_count >= len(market_analysis) * 0.5
+
+                final_analysis = {
+                    'overall_is_main_uptrend': overall_uptrend,
+                    'overall_trend_strength': avg_trend_strength,
+                    'detailed_analysis': market_analysis,
+                    'market_status': '主升浪' if overall_uptrend else '震荡调整'
+                }
+
+                print(f"✅ 大盘分析完成: {final_analysis['market_status']}, 综合趋势强度: {avg_trend_strength:.2f}")
+                return final_analysis
+
+            return self._get_default_market_analysis()
+
+        except Exception as e:
+            print(f"❌ 大盘分析错误: {e}")
+            return self._get_default_market_analysis()
+
+    def analyze_sector_resonance(self, stock_code):
+        """
+        分析板块共振效应 - 增强版行业分析
+        """
+        try:
+            print(f"🔄 分析板块共振效应...")
+
+            # 获取股票所属行业和概念
+            industry = "未知"
+            concepts = []
+
+            try:
+                stock_info = ak.stock_individual_info_em(symbol=stock_code)
+                if not stock_info.empty and 'value' in stock_info.columns:
+                    industry_row = stock_info[stock_info['item'] == '行业']
+                    if not industry_row.empty:
+                        industry = industry_row['value'].iloc[0]
+            except:
+                pass
+
+            # 热门板块和概念映射
+            hot_sectors = {
+                '机器人': {'momentum': 0.85, 'limit_up_stocks': 18, 'active': True,
+                           'description': '人形机器人、工业自动化'},
+                '半导体': {'momentum': 0.8, 'limit_up_stocks': 15, 'active': True, 'description': '芯片国产替代'},
+                '人工智能': {'momentum': 0.75, 'limit_up_stocks': 12, 'active': True, 'description': 'AI大模型、算力'},
+                '低空经济': {'momentum': 0.7, 'limit_up_stocks': 10, 'active': True, 'description': '无人机、eVTOL'},
+                '新能源': {'momentum': 0.6, 'limit_up_stocks': 8, 'active': True, 'description': '光伏、储能'},
+                '医药': {'momentum': 0.5, 'limit_up_stocks': 5, 'active': False, 'description': '创新药'}
+            }
+
+            # 判断当前股票所属热门板块
+            matched_sectors = []
+            for sector, data in hot_sectors.items():
+                if (sector in industry or
+                        (stock_code == '600580' and sector in ['机器人', '低空经济']) or  # 卧龙电驱特殊处理
+                        (stock_code == '300207' and sector in ['新能源'])):
+                    matched_sectors.append({
+                        'sector': sector,
+                        'momentum': data['momentum'],
+                        'limit_up_stocks': data['limit_up_stocks'],
+                        'is_active': data['active'],
+                        'description': data['description']
+                    })
+
+            # 计算综合共振分数
+            if matched_sectors:
+                resonance_score = np.mean([sector['momentum'] for sector in matched_sectors])
+                is_sector_hot = any(sector['is_active'] for sector in matched_sectors)
+                main_sector = max(matched_sectors, key=lambda x: x['momentum'])
+            else:
+                resonance_score = 0.5
+                is_sector_hot = False
+                main_sector = {'sector': '传统行业', 'momentum': 0.5, 'description': '无热门概念'}
+
+            analysis = {
+                'industry': industry,
+                'matched_sectors': matched_sectors,
+                'main_sector': main_sector,
+                'is_sector_hot': is_sector_hot,
+                'resonance_score': resonance_score,
+                'sector_count': len(matched_sectors)
+            }
+
+            print(f"✅ 板块分析完成: {industry}, 匹配{len(matched_sectors)}个热门板块, 共振分数: {resonance_score:.2f}")
+            return analysis
+
+        except Exception as e:
+            print(f"❌ 板块分析错误: {e}")
+            return self._get_default_sector_analysis()
+
+    def analyze_macro_factors(self):
+        """
+        分析宏观因素 - 结合国内外政策
+        """
+        try:
+            print(f"🌍 分析宏观因素...")
+
+            # 美国降息周期分析 - 基于最新信息
+            us_rate_analysis = {
+                'current_rate': 4.25,  # 联邦基金利率目标区间4.00%-4.25%:cite[3]
+                'trend': '降息周期',
+                'recent_cut': '2025年9月降息25个基点',
+                'expected_cuts_2025': 2,  # 市场预期2025年还有两次降息:cite[7]
+                'expected_cuts_2026': 2,
+                'impact_on_emerging_markets': 'positive',
+                'usd_index_support': 95.0,  # 美元指数短期支撑位:cite[7]
+                'analysis': '美联储开启宽松周期，利好全球流动性'
+            }
+
+            # 国内政策因素 - 基于最新政策
+            domestic_policy = {
+                'monetary_policy': '稳健偏松',
+                'fiscal_policy': '积极财政',
+                'market_liquidity': '合理充裕',
+                'industrial_policy': '设备更新、以旧换新',  # 大规模设备更新政策:cite[5]
+                'employment_policy': '稳就业政策加力',  # 国务院稳就业政策:cite[8]
+                'analysis': '政策组合拳发力，经济稳中向好'
+            }
+
+            # 行业政策支持
+            industry_policy = {
+                'robot_policy': '机器人产业政策支持',
+                'chip_policy': '国产替代加速推进',
+                'AI_policy': '人工智能发展规划',
+                'low_altitude': '低空经济发展规划'
+            }
+
+            macro_analysis = {
+                'us_rate_cycle': us_rate_analysis,
+                'domestic_policy': domestic_policy,
+                'industry_policy': industry_policy,
+                'global_liquidity_outlook': '改善',
+                'overall_macro_score': 0.75  # 宏观环境整体偏积极
+            }
+
+            print(
+                f"✅ 宏观分析完成: 美国{us_rate_analysis['trend']}, 国内政策积极, 宏观评分: {macro_analysis['overall_macro_score']:.2f}")
+            return macro_analysis
+
+        except Exception as e:
+            print(f"❌ 宏观分析错误: {e}")
+            return self._get_default_macro_analysis()
+
+    def analyze_company_fundamentals(self, stock_code):
+        """
+        分析公司基本面 - 针对特定股票
+        """
+        try:
+            print(f"🏢 分析公司基本面...")
+
+            # 卧龙电驱特殊分析
+            if stock_code == '600580':
+                fundamentals = {
+                    'company_name': '卧龙电驱',
+                    'business_areas': ['工业电机', '机器人关键部件', '航空电机', '新能源汽车驱动'],
+                    'recent_developments': [
+                        '与智元机器人实现双向持股，推进具身智能机器人技术研发:cite[5]',
+                        '成立浙江龙飞电驱，专注航空电机业务:cite[5]',
+                        '发布AI外骨骼机器人及灵巧手:cite[9]',
+                        '布局高爆发关节模组、伺服驱动器等人形机器人关键部件:cite[5]'
+                    ],
+                    'growth_drivers': [
+                        '设备更新政策推动工业电机需求:cite[5]',
+                        '机器人产业快速发展',
+                        '低空经济政策支持',
+                        '出海战略加速'
+                    ],
+                    'risk_factors': [
+                        '机器人业务营收占比仅2.71%，占比较低:cite[1]',
+                        '工业需求景气度波动',
+                        '原料价格波动风险'
+                    ],
+                    'investment_rating': '积极关注',
+                    'fundamental_score': 0.7
+                }
+            else:
+                # 其他股票的基础分析
+                fundamentals = {
+                    'company_name': '未知',
+                    'business_areas': [],
+                    'recent_developments': [],
+                    'growth_drivers': [],
+                    'risk_factors': [],
+                    'investment_rating': '中性',
+                    'fundamental_score': 0.5
+                }
+
+            print(f"✅ 基本面分析完成: {fundamentals['company_name']}, 评分: {fundamentals['fundamental_score']:.2f}")
+            return fundamentals
+
+        except Exception as e:
+            print(f"❌ 基本面分析错误: {e}")
+            return self._get_default_fundamental_analysis()
+
+    def _calculate_trend_strength(self, df):
+        """计算趋势强度"""
+        if len(df) < 20:
+            return 0.5
+
+        ma_slope = (df['ma5'].iloc[-1] - df['ma5'].iloc[-20]) / df['ma5'].iloc[-20]
+        price_slope = (df['close'].iloc[-1] - df['close'].iloc[-20]) / df['close'].iloc[-20]
+
+        volume_trend = df['volume'].iloc[-5:].mean() / df['volume'].iloc[-10:-5].mean()
+
+        strength = (ma_slope * 0.4 + price_slope * 0.4 + min(volume_trend - 1, 0.2) * 0.2)
+        return max(0, min(1, strength * 10))
+
+    def _get_default_market_analysis(self):
+        return {
+            'overall_is_main_uptrend': False,
+            'overall_trend_strength': 0.5,
+            'market_status': '未知',
+            'detailed_analysis': {}
+        }
+
+    def _get_default_sector_analysis(self):
+        return {
+            'industry': '未知',
+            'matched_sectors': [],
+            'main_sector': {'sector': '未知', 'momentum': 0.5, 'description': ''},
+            'is_sector_hot': False,
+            'resonance_score': 0.5,
+            'sector_count': 0
+        }
+
+    def _get_default_macro_analysis(self):
+        return {
+            'us_rate_cycle': {'trend': '未知', 'expected_cuts_2025': 0},
+            'domestic_policy': {'monetary_policy': '中性'},
+            'overall_macro_score': 0.5
+        }
+
+    def _get_default_fundamental_analysis(self):
+        return {
+            'company_name': '未知',
+            'business_areas': [],
+            'recent_developments': [],
+            'growth_drivers': [],
+            'risk_factors': [],
+            'investment_rating': '中性',
+            'fundamental_score': 0.5
+        }
+
+
+# ==================== 增强预测函数 ====================
+def enhance_prediction_with_market_factors(
+        historical_df,
+        prediction_df,
+        stock_code,
+        market_analyzer
+):
+    """
+    使用市场因素增强预测结果 - 多维度综合分析
+    """
+    print("\n🎯 使用多维度市场因素增强预测...")
+
+    # 获取各类市场分析
+    market_analysis = market_analyzer.analyze_market_trend()
+    sector_analysis = market_analyzer.analyze_sector_resonance(stock_code)
+    macro_analysis = market_analyzer.analyze_macro_factors()
+    fundamental_analysis = market_analyzer.analyze_company_fundamentals(stock_code)
+
+    # 计算综合调整因子
+    adjustment_factor = calculate_enhanced_adjustment_factor(
+        market_analysis, sector_analysis, macro_analysis, fundamental_analysis
+    )
+
+    print(f"📈 综合调整因子: {adjustment_factor:.4f}")
+
+    # 应用调整到预测结果
+    enhanced_prediction = prediction_df.copy()
+
+    # 对价格预测进行调整
+    price_columns = ['close', 'open', 'high', 'low']
+    for col in price_columns:
+        if col in enhanced_prediction.columns:
+            # 使用更温和的调整，避免过度乐观或悲观
+            adjusted_value = enhanced_prediction[col] * adjustment_factor
+            # 限制单次调整幅度在±10%以内
+            change_ratio = adjusted_value / enhanced_prediction[col]
+            if change_ratio.max() > 1.1:
+                adjusted_value = enhanced_prediction[col] * 1.1
+            elif change_ratio.min() < 0.9:
+                adjusted_value = enhanced_prediction[col] * 0.9
+            enhanced_prediction[col] = adjusted_value
+
+    # 对成交量进行调整
+    if 'volume' in enhanced_prediction.columns:
+        volume_adjustment = 1 + (adjustment_factor - 1) * 0.3  # 成交量调整更温和
+        enhanced_prediction['volume'] = enhanced_prediction['volume'] * volume_adjustment
+
+    return enhanced_prediction, {
+        'market_analysis': market_analysis,
+        'sector_analysis': sector_analysis,
+        'macro_analysis': macro_analysis,
+        'fundamental_analysis': fundamental_analysis,
+        'adjustment_factor': adjustment_factor
+    }
+
+
+def calculate_enhanced_adjustment_factor(market_analysis, sector_analysis, macro_analysis, fundamental_analysis):
+    """
+    计算基于多维度市场因素的调整因子 - 更平衡的方法
+    """
+    base_factor = 1.0
+    factors_log = []
+
+    # 1. 大盘趋势影响 (权重25%)
+    if market_analysis['overall_is_main_uptrend']:
+        trend_strength = market_analysis['overall_trend_strength']
+        adjustment = 1 + trend_strength * 0.08  # 降低主升浪影响幅度
+        base_factor *= adjustment
+        factors_log.append(f"大盘主升浪: +{trend_strength * 0.08:.3f}")
+    else:
+        trend_strength = market_analysis['overall_trend_strength']
+        # 震荡市不一定悲观，只是增幅较小
+        adjustment = 1 + (trend_strength - 0.5) * 0.04
+        base_factor *= adjustment
+        factors_log.append(f"大盘震荡: {(trend_strength - 0.5) * 0.04:+.3f}")
+
+    # 2. 板块共振影响 (权重25%)
+    resonance_score = sector_analysis['resonance_score']
+    sector_count = sector_analysis['sector_count']
+
+    if sector_analysis['is_sector_hot']:
+        # 热门板块且有多个概念叠加
+        sector_adjustment = 1 + resonance_score * 0.06 + min(sector_count * 0.01, 0.03)
+        base_factor *= sector_adjustment
+        factors_log.append(
+            f"热门板块({sector_count}个): +{resonance_score * 0.06 + min(sector_count * 0.01, 0.03):.3f}")
+    else:
+        # 非热门板块也有基础支撑
+        base_factor *= (1 + (resonance_score - 0.5) * 0.02)
+        factors_log.append(f"一般板块: {(resonance_score - 0.5) * 0.02:+.3f}")
+
+    # 3. 宏观因素影响 (权重20%)
+    macro_score = macro_analysis['overall_macro_score']
+    macro_adjustment = 1 + (macro_score - 0.5) * 0.06
+    base_factor *= macro_adjustment
+    factors_log.append(f"宏观环境: {(macro_score - 0.5) * 0.06:+.3f}")
+
+    # 4. 美国降息周期特殊影响 (权重10%)
+    us_rate_trend = macro_analysis['us_rate_cycle']['trend']
+    if us_rate_trend == '降息周期':
+        expected_cuts = macro_analysis['us_rate_cycle']['expected_cuts_2025']
+        us_adjustment = 1 + expected_cuts * 0.015  # 降低单次降息影响
+        base_factor *= us_adjustment
+        factors_log.append(f"美国降息: +{expected_cuts * 0.015:.3f}")
+
+    # 5. 公司基本面影响 (权重20%)
+    fundamental_score = fundamental_analysis['fundamental_score']
+    fundamental_adjustment = 1 + (fundamental_score - 0.5) * 0.08
+    base_factor *= fundamental_adjustment
+    factors_log.append(f"基本面: {(fundamental_score - 0.5) * 0.08:+.3f}")
+
+    # 输出调整因子详情
+    print("🔍 调整因子详情:")
+    for log in factors_log:
+        print(f"   {log}")
+
+    # 限制调整幅度在更合理的范围内 (0.85 ~ 1.15)
+    final_factor = max(0.85, min(1.15, base_factor))
+
+    if final_factor != base_factor:
+        print(f"⚠️  调整因子从 {base_factor:.3f} 限制到 {final_factor:.3f}")
+
+    return final_factor
+
+
+def create_comprehensive_market_report(enhancement_info, output_dir, stock_code):
+    """
+    创建综合市场分析报告
+    """
+    report = {
+        'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+        'stock_code': stock_code,
+        'market_analysis': enhancement_info['market_analysis'],
+        'sector_analysis': enhancement_info['sector_analysis'],
+        'macro_analysis': enhancement_info['macro_analysis'],
+        'fundamental_analysis': enhancement_info['fundamental_analysis'],
+        'adjustment_factor': enhancement_info['adjustment_factor'],
+        'analysis_summary': generate_analysis_summary(enhancement_info)
+    }
+
+    # 保存报告
+    report_file = os.path.join(output_dir, f'{stock_code}_comprehensive_analysis_report.json')
+    with open(report_file, 'w', encoding='utf-8') as f:
+        json.dump(report, f, ensure_ascii=False, indent=2)
+
+    print(f"📋 综合分析报告已保存: {report_file}")
+    return report
+
+
+def generate_analysis_summary(enhancement_info):
+    """
+    生成分析总结
+    """
+    market = enhancement_info['market_analysis']
+    sector = enhancement_info['sector_analysis']
+    macro = enhancement_info['macro_analysis']
+    fundamental = enhancement_info['fundamental_analysis']
+
+    summary = {
+        'overall_sentiment': '积极' if enhancement_info['adjustment_factor'] > 1.0 else '谨慎',
+        'key_drivers': [],
+        'main_risks': [],
+        'investment_suggestion': ''
+    }
+
+    # 关键驱动因素
+    if market['overall_trend_strength'] > 0.6:
+        summary['key_drivers'].append('大盘趋势向好')
+
+    if sector['is_sector_hot']:
+        summary['key_drivers'].append(f"热门板块:{sector['main_sector']['sector']}")
+
+    if macro['overall_macro_score'] > 0.7:
+        summary['key_drivers'].append('宏观环境有利')
+
+    if fundamental['fundamental_score'] > 0.6:
+        summary['key_drivers'].append('基本面稳健')
+
+    # 主要风险
+    if market['overall_trend_strength'] < 0.4:
+        summary['main_risks'].append('大盘趋势偏弱')
+
+    if not sector['is_sector_hot']:
+        summary['main_risks'].append('非热门板块')
+
+    if len(summary['key_drivers']) > len(summary['main_risks']):
+        summary['investment_suggestion'] = '可考虑逢低关注'
+    else:
+        summary['investment_suggestion'] = '建议谨慎操作'
+
+    return summary
+
+
+# ==================== 增强可视化函数 ====================
+def plot_comprehensive_prediction(
+        historical_df,
+        prediction_df,
+        future_dates,
+        stock_code,
+        stock_name,
+        output_dir,
+        enhancement_info=None
+):
+    """
+    绘制综合预测图表 - 包含更多市场分析信息
+    """
+    ensure_output_directory(output_dir)
+
+    # 设置配色
+    colors = {
+        'historical': '#1f77b4',
+        'prediction': '#ff7f0e',
+        'enhanced': '#2ca02c',
+        'background': '#f8f9fa',
+        'grid': '#e9ecef',
+        'positive': '#2ecc71',
+        'negative': '#e74c3c',
+        'neutral': '#95a5a6'
+    }
+
+    # 创建综合图表
+    fig = plt.figure(figsize=(18, 14))
+    gs = plt.GridSpec(4, 3, figure=fig, height_ratios=[2, 1, 1, 1])
+
+    # 1. 主价格图表
+    ax1 = fig.add_subplot(gs[0, :])
+    ax1.set_facecolor(colors['background'])
+
+    # 2. 成交量图表
+    ax2 = fig.add_subplot(gs[1, :])
+    ax2.set_facecolor(colors['background'])
+
+    # 3. 市场分析图表
+    ax3 = fig.add_subplot(gs[2, 0])
+    ax3.set_facecolor(colors['background'])
+
+    ax4 = fig.add_subplot(gs[2, 1])
+    ax4.set_facecolor(colors['background'])
+
+    ax5 = fig.add_subplot(gs[2, 2])
+    ax5.set_facecolor(colors['background'])
+
+    # 4. 因素分析图表
+    ax6 = fig.add_subplot(gs[3, :])
+    ax6.set_facecolor(colors['background'])
+
+    # 设置背景色
+    fig.patch.set_facecolor('white')
+
+    # 1. 价格图表
+    historical_prices = historical_df.set_index('timestamps')['close']
+    prediction_prices = prediction_df.set_index(pd.DatetimeIndex(future_dates))['close']
+
+    # 获取当前最新价格
+    current_price = historical_prices.iloc[-1]
+
+    # 智能Y轴范围计算
+    all_prices = pd.concat([historical_prices, prediction_prices])
+    data_min = all_prices.min()
+    data_max = all_prices.max()
+
+    price_range = data_max - data_min
+    y_margin = price_range * 0.15
+
+    y_min = max(0, data_min - y_margin)
+    y_max = data_max + y_margin
+
+    # 设置Y轴刻度
+    y_interval = calculate_optimal_interval(y_min, y_max)
+    y_ticks = np.arange(round(y_min / y_interval) * y_interval,
+                        round(y_max / y_interval) * y_interval + y_interval,
+                        y_interval)
+
+    # 绘制历史价格
+    ax1.plot(historical_prices.index, historical_prices.values,
+             color=colors['historical'], linewidth=2, label='历史价格')
+
+    # 绘制预测价格
+    if len(prediction_prices) > 0:
+        # 连接点
+        last_hist_date = historical_prices.index[-1]
+        last_hist_price = historical_prices.iloc[-1]
+        first_pred_date = prediction_prices.index[0]
+
+        # 绘制连接线
+        ax1.plot([last_hist_date, first_pred_date],
+                 [last_hist_price, prediction_prices.iloc[0]],
+                 color=colors['prediction'], linewidth=2.5, linestyle='-')
+
+        # 绘制预测线
+        ax1.plot(prediction_prices.index, prediction_prices.values,
+                 color=colors['prediction'], linewidth=2.5, label='基础预测')
+
+        # 绘制增强预测线
+        if enhancement_info and 'enhanced_prediction' in enhancement_info:
+            enhanced_prices = enhancement_info['enhanced_prediction'].set_index(pd.DatetimeIndex(future_dates))['close']
+            ax1.plot(enhanced_prices.index, enhanced_prices.values,
+                     color=colors['enhanced'], linewidth=2.5, linestyle='--', label='增强预测')
+
+        # 标记预测起点
+        ax1.axvline(x=last_hist_date, color='red', linestyle='--', alpha=0.7, linewidth=1)
+        ax1.annotate('预测起点', xy=(last_hist_date, last_hist_price),
+                     xytext=(10, 10), textcoords='offset points',
+                     fontsize=10, fontweight='bold',
+                     bbox=dict(boxstyle='round,pad=0.3', facecolor='white', alpha=0.8))
+
+    # 设置Y轴范围和刻度
+    ax1.set_ylim(y_min, y_max)
+    ax1.set_yticks(y_ticks)
+
+    ax1.set_ylabel('收盘价 (元)', fontsize=12, fontweight='bold')
+    ax1.legend(loc='upper left', fontsize=11)
+    ax1.grid(True, color=colors['grid'], alpha=0.7)
+
+    title = f'{stock_name}({stock_code}) - 综合因素价格预测\n当前价: {current_price:.2f}元 | 增强因子: {enhancement_info["adjustment_factor"]:.3f}' if enhancement_info else f'{stock_name}({stock_code}) - 价格预测\n当前价: {current_price:.2f}元'
+    ax1.set_title(title, fontsize=14, fontweight='bold', pad=20)
+
+    # 设置x轴格式
+    ax1.xaxis.set_major_formatter(plt.matplotlib.dates.DateFormatter('%Y-%m-%d'))
+    plt.setp(ax1.xaxis.get_majorticklabels(), rotation=45)
+
+    # 2. 成交量图表
+    historical_volume = historical_df.set_index('timestamps')['volume']
+    prediction_volume = prediction_df.set_index(pd.DatetimeIndex(future_dates))['volume']
+
+    # 计算相对成交量（标准化）
+    hist_volume_norm = historical_volume / historical_volume.max()
+    if len(prediction_volume) > 0:
+        pred_volume_norm = prediction_volume / historical_volume.max()
+
+    # 绘制历史成交量
+    ax2.bar(historical_volume.index, hist_volume_norm.values,
+            alpha=0.6, color=colors['historical'], label='历史成交量')
+
+    # 绘制预测成交量
+    if len(prediction_volume) > 0:
+        ax2.bar(prediction_volume.index, pred_volume_norm.values,
+                alpha=0.6, color=colors['prediction'], label='预测成交量')
+
+    ax2.set_ylabel('相对成交量', fontsize=12, fontweight='bold')
+    ax2.legend(loc='upper left', fontsize=11)
+    ax2.grid(True, color=colors['grid'], alpha=0.7)
+    ax2.set_ylim(0, 1.2)
+
+    # 设置x轴格式
+    ax2.xaxis.set_major_formatter(plt.matplotlib.dates.DateFormatter('%Y-%m-%d'))
+    plt.setp(ax2.xaxis.get_majorticklabels(), rotation=45)
+
+    # 3. 市场分析子图
+    if enhancement_info:
+        # 因素权重饼图
+        factors = ['大盘趋势', '板块共振', '宏观环境', '美国降息', '基本面']
+        weights = [25, 25, 20, 10, 20]
+        colors_pie = [colors['historical'], colors['prediction'], colors['enhanced'], '#f39c12', '#9b59b6']
+
+        ax3.pie(weights, labels=factors, autopct='%1.0f%%', colors=colors_pie, startangle=90)
+        ax3.set_title('因素权重分配', fontweight='bold', fontsize=11)
+
+        # 因素评分柱状图
+        scores = [
+            enhancement_info['market_analysis']['overall_trend_strength'],
+            enhancement_info['sector_analysis']['resonance_score'],
+            enhancement_info['macro_analysis']['overall_macro_score'],
+            0.7 if enhancement_info['macro_analysis']['us_rate_cycle']['trend'] == '降息周期' else 0.3,
+            enhancement_info['fundamental_analysis']['fundamental_score']
+        ]
+
+        x_pos = np.arange(len(factors))
+        bars = ax4.bar(x_pos, scores, color=colors_pie, alpha=0.7)
+        ax4.set_xticks(x_pos)
+        ax4.set_xticklabels(factors, rotation=45, fontsize=9)
+        ax4.set_ylim(0, 1)
+        ax4.set_ylabel('评分', fontsize=10)
+        ax4.set_title('各因素当前评分', fontweight='bold', fontsize=11)
+        ax4.grid(True, alpha=0.3)
+
+        # 在柱状图上显示数值
+        for i, bar in enumerate(bars):
+            height = bar.get_height()
+            ax4.text(bar.get_x() + bar.get_width() / 2., height + 0.01,
+                     f'{height:.2f}', ha='center', va='bottom', fontsize=8)
+
+        # 市场状态总结
+        market_status = enhancement_info['market_analysis']['market_status']
+        sector_status = "热门" if enhancement_info['sector_analysis']['is_sector_hot'] else "一般"
+        macro_status = "有利" if enhancement_info['macro_analysis']['overall_macro_score'] > 0.6 else "不利"
+
+        summary_text = f"""市场状态总结:
+
+大盘趋势: {market_status}
+板块热度: {sector_status}
+宏观环境: {macro_status}
+美国利率: {enhancement_info['macro_analysis']['us_rate_cycle']['trend']}
+综合评分: {enhancement_info['adjustment_factor']:.3f}
+
+投资建议: {enhancement_info['fundamental_analysis']['investment_rating']}"""
+
+        ax5.text(0.1, 0.9, summary_text, transform=ax5.transAxes, fontsize=10,
+                 verticalalignment='top', linespacing=1.5)
+        ax5.set_title('市场状态总结', fontweight='bold', fontsize=11)
+        ax5.set_xticks([])
+        ax5.set_yticks([])
+        ax5.spines['top'].set_visible(False)
+        ax5.spines['right'].set_visible(False)
+        ax5.spines['bottom'].set_visible(False)
+        ax5.spines['left'].set_visible(False)
+
+        # 4. 详细因素分析
+        if 'analysis_summary' in enhancement_info:
+            summary = enhancement_info['analysis_summary']
+            drivers_text = "\n".join([f"• {driver}" for driver in summary['key_drivers']]) if summary[
+                'key_drivers'] else "• 暂无明显驱动"
+            risks_text = "\n".join([f"• {risk}" for risk in summary['main_risks']]) if summary[
+                'main_risks'] else "• 风险可控"
+
+            detail_text = f"""关键驱动因素:
+{drivers_text}
+
+主要风险提示:
+{risks_text}
+
+总体情绪: {summary['overall_sentiment']}
+建议: {summary['investment_suggestion']}"""
+
+            ax6.text(0.02, 0.95, detail_text, transform=ax6.transAxes, fontsize=9,
+                     verticalalignment='top', linespacing=1.3)
+            ax6.set_title('详细因素分析', fontweight='bold', fontsize=11)
+            ax6.set_xticks([])
+            ax6.set_yticks([])
+            ax6.spines['top'].set_visible(False)
+            ax6.spines['right'].set_visible(False)
+            ax6.spines['bottom'].set_visible(False)
+            ax6.spines['left'].set_visible(False)
+
+    plt.tight_layout()
+
+    # 保存图片
+    chart_filename = os.path.join(output_dir, f'{stock_code}_comprehensive_prediction.png')
+    plt.savefig(chart_filename, dpi=300, bbox_inches='tight', facecolor='white')
+    print(f"📊 综合预测图表已保存: {chart_filename}")
+
+    plt.show()
+
+    return historical_prices, prediction_prices
+
+
+# ==================== 主预测函数 ====================
+def run_comprehensive_kronos_prediction(stock_code, stock_name, data_dir, pred_days, output_dir, history_years=1):
+    """
+    运行综合版Kronos模型预测流程
+    """
+    print(f"\n🎯 开始 {stock_name}({stock_code}) 综合版Kronos模型价格预测")
+    print("=" * 60)
+
+    # 初始化增强版市场分析器
+    market_analyzer = EnhancedMarketFactorAnalyzer()
+
+    try:
+        # 1. 获取数据
+        print("\n步骤1: 获取股票数据...")
+        success, csv_file_path = get_stock_data(stock_code, data_dir)
+        if not success:
+            print("❌ 无法获取股票数据，预测终止")
+            return
+
+        # 2. 加载模型和分词器
+        print("\n步骤2: 加载Kronos模型和分词器...")
+        try:
+            tokenizer = KronosTokenizer.from_pretrained("NeoQuasar/Kronos-Tokenizer-base")
+            model = Kronos.from_pretrained("NeoQuasar/Kronos-base")
+            print("✅ 模型加载完成 - 使用Kronos-base模型")
+        except Exception as e:
+            print(f"❌ 模型加载失败: {e}")
+            print("⚠️ 预测功能不可用，请检查模型安装")
+            return
+
+        # 3. 实例化预测器
+        print("步骤3: 初始化预测器...")
+        predictor = KronosPredictor(model, tokenizer, device="cuda:0", max_context=512)
+        print("✅ 预测器初始化完成")
+
+        # 4. 准备数据
+        print("步骤4: 准备股票数据...")
+        df = prepare_stock_data(csv_file_path, stock_code, history_years)
+
+        # 5. 计算预测参数
+        print("步骤5: 计算预测参数...")
+        lookback, pred_len = calculate_prediction_parameters(df, target_days=pred_days)
+
+        if pred_len <= 0:
+            print("❌ 数据量不足，无法进行预测")
+            return
+
+        print(f"✅ 最终参数 - 回看期: {lookback}, 预测期: {pred_len}")
+
+        # 6. 准备输入数据
+        print("步骤6: 准备输入数据...")
+        x_df = df.loc[-lookback:, ['open', 'high', 'low', 'close', 'volume', 'amount']].reset_index(drop=True)
+        x_timestamp = df.loc[-lookback:, 'timestamps'].reset_index(drop=True)
+
+        # 生成未来日期
+        last_historical_date = df['timestamps'].iloc[-1]
+        future_dates = generate_future_dates(last_historical_date, pred_len)
+
+        print(f"输入数据形状: {x_df.shape}")
+        print(f"历史数据时间范围: {x_timestamp.iloc[0]} 到 {x_timestamp.iloc[-1]}")
+        print(f"预测时间范围: {future_dates[0]} 到 {future_dates[-1]}")
+
+        # 7. 执行基础预测
+        print("步骤7: 执行基础价格预测...")
+        pred_df = predictor.predict(
+            df=x_df,
+            x_timestamp=x_timestamp,
+            y_timestamp=pd.Series(future_dates),
+            pred_len=pred_len,
+            T=1.0,
+            top_p=0.9,
+            sample_count=1,
+            verbose=True
+        )
+
+        print("✅ 基础预测完成")
+        print("预测数据前5行:")
+        print(pred_df.head())
+
+        # 8. 使用多维度市场因素增强预测
+        print("步骤8: 应用多维度市场因素增强预测...")
+        enhanced_pred_df, enhancement_info = enhance_prediction_with_market_factors(
+            df.loc[-lookback:].reset_index(drop=True),
+            pred_df,
+            stock_code,
+            market_analyzer
+        )
+
+        # 将增强预测结果添加到信息中
+        enhancement_info['enhanced_prediction'] = enhanced_pred_df
+
+        # 9. 创建综合市场分析报告
+        market_report = create_comprehensive_market_report(enhancement_info, output_dir, stock_code)
+
+        # 10. 可视化结果
+        print("步骤9: 生成综合版可视化图表...")
+        historical_df = df.loc[-lookback:].reset_index(drop=True)
+        hist_prices, base_pred_prices = plot_comprehensive_prediction(
+            historical_df, pred_df, future_dates, stock_code, stock_name, output_dir, enhancement_info
+        )
+
+        # 11. 生成综合预测报告
+        print("步骤10: 生成综合预测报告...")
+        if len(enhanced_pred_df) > 0:
+            current_price = hist_prices.iloc[-1]
+            base_predicted_price = base_pred_prices.iloc[-1] if len(base_pred_prices) > 0 else current_price
+            enhanced_predicted_price = enhanced_pred_df.set_index(pd.DatetimeIndex(future_dates))['close'].iloc[-1]
+
+            base_change_pct = (base_predicted_price / current_price - 1) * 100
+            enhanced_change_pct = (enhanced_predicted_price / current_price - 1) * 100
+
+            print(f"\n📈 综合版Kronos模型预测报告")
+            print("=" * 70)
+            print(f"股票: {stock_name}({stock_code})")
+            print(f"当前价格: {current_price:.2f} 元")
+            print(f"基础预测价格: {base_predicted_price:.2f} 元 ({base_change_pct:+.2f}%)")
+            print(f"增强预测价格: {enhanced_predicted_price:.2f} 元 ({enhanced_change_pct:+.2f}%)")
+            print(f"市场因素调整因子: {enhancement_info['adjustment_factor']:.4f}")
+            print(f"大盘状态: {enhancement_info['market_analysis']['market_status']}")
+            print(
+                f"板块共振: {enhancement_info['sector_analysis']['main_sector']['sector']} (分数: {enhancement_info['sector_analysis']['resonance_score']:.2f})")
+            print(f"宏观环境: 美国{enhancement_info['macro_analysis']['us_rate_cycle']['trend']}")
+            print(f"公司评级: {enhancement_info['fundamental_analysis']['investment_rating']}")
+            print(f"预测期间: {pred_len} 个交易日")
+
+            # 输出关键因素
+            print(f"\n🔑 关键影响因素:")
+            for driver in enhancement_info['analysis_summary']['key_drivers']:
+                print(f"  ✅ {driver}")
+            for risk in enhancement_info['analysis_summary']['main_risks']:
+                print(f"  ⚠️  {risk}")
+            print(f"  💡 投资建议: {enhancement_info['analysis_summary']['investment_suggestion']}")
+
+            # 保存详细预测数据
+            prediction_details = pd.DataFrame({
+                '日期': future_dates,
+                '基础预测收盘价': base_pred_prices.values if len(base_pred_prices) > 0 else [current_price] * len(
+                    future_dates),
+                '增强预测收盘价': enhanced_pred_df['close'].values,
+                '预测成交量': enhanced_pred_df['volume'].values
+            })
+
+            prediction_file = os.path.join(output_dir, f'{stock_code}_comprehensive_predictions.csv')
+            prediction_details.to_csv(prediction_file, index=False, encoding='utf-8-sig')
+            print(f"💾 详细预测数据已保存: {prediction_file}")
+
+        print(f"\n🎉 {stock_name}({stock_code}) 综合版Kronos模型预测完成!")
+
+    except Exception as e:
+        print(f"❌ 预测过程中出现错误: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+# ==================== 主函数 ====================
+def main():
+    """
+    主函数：综合版Kronos模型股票预测系统
+    """
+    # ==================== 配置参数 ====================
+    STOCK_CONFIG = {
+        "stock_code": "603288",
+        "stock_name": "海天味业",
+        "data_dir": r"D:\lianghuajiaoyi\Kronos\examples\data",
+        "pred_days": 60,
+        "output_dir": r"D:\lianghuajiaoyi\Kronos\examples\yuce",
+        "history_years": 1
+    }
+
+    print("🤖 综合版Kronos模型股票价格预测系统")
+    print("=" * 50)
+    print("📊 新增功能: 多维度市场因素分析")
+    print("🎯 包含: 大盘趋势 + 板块共振 + 宏观政策 + 公司基本面")
+    print("🚀 使用模型: Kronos-base (更适合3070Ti显卡)")
+    print(f"当前预测股票: {STOCK_CONFIG['stock_name']}({STOCK_CONFIG['stock_code']})")
+    print(f"预测天数: {STOCK_CONFIG['pred_days']} 天")
+    print(f"输出目录: {STOCK_CONFIG['output_dir']}")
+    print()
+
+    # 运行综合版Kronos模型预测流程
+    run_comprehensive_kronos_prediction(**STOCK_CONFIG)
+
+    print(f"\n💡 提示：综合版模型已整合多维度市场环境分析因子")
+
+
+if __name__ == "__main__":
+    main()

Kronos/examples/prediction_new_GUI.py

@@ -0,0 +1,1625 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+import numpy as np
+import sys
+import os
+from datetime import datetime, timedelta
+import warnings
+import requests
+import json
+import time
+import random
+import akshare as ak
+from typing import Dict, List, Tuple, Optional
+import tkinter as tk
+from tkinter import ttk, messagebox, filedialog
+import threading
+from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
+import matplotlib.dates as mdates
+import matplotlib.ticker as ticker
+
+warnings.filterwarnings('ignore')
+
+# 添加项目路径以便导入自定义模块
+sys.path.append("../")
+try:
+    from model import Kronos, KronosTokenizer, KronosPredictor
+except ImportError:
+    print("⚠️ 无法导入Kronos模型，预测功能将不可用")
+
+# 设置中文字体
+plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
+plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
+
+
+class StockPredictorGUI:
+    """股票预测图形界面"""
+
+    def __init__(self, root):
+        self.root = root
+        self.root.title("Kronos股票预测系统")
+        self.root.geometry("800x600")
+        self.root.configure(bg='#f0f0f0')
+
+        # 初始化市场分析器
+        self.market_analyzer = EnhancedMarketFactorAnalyzer()
+
+        # 创建界面
+        self.create_widgets()
+
+        # 默认配置
+        self.default_config = {
+            "stock_code": "600580",
+            "stock_name": "卧龙电驱",
+            "data_dir": r"D:\lianghuajiaoyi\Kronos\examples\data",
+            "output_dir": r"D:\lianghuajiaoyi\Kronos\examples\yuce",
+            "pred_days": 60,
+            "history_years": 1
+        }
+
+    def create_widgets(self):
+        """创建界面组件"""
+        # 主标题
+        title_label = tk.Label(
+            self.root,
+            text="🤖 Kronos股票预测系统",
+            font=("Arial", 16, "bold"),
+            bg='#f0f0f0',
+            fg='#2c3e50'
+        )
+        title_label.pack(pady=10)
+
+        # 说明标签
+        desc_label = tk.Label(
+            self.root,
+            text="基于Kronos模型的多维度股票价格预测系统",
+            font=("Arial", 10),
+            bg='#f0f0f0',
+            fg='#7f8c8d'
+        )
+        desc_label.pack(pady=5)
+
+        # 创建主框架
+        main_frame = tk.Frame(self.root, bg='#f0f0f0')
+        main_frame.pack(fill=tk.BOTH, expand=True, padx=20, pady=10)
+
+        # 输入框架
+        input_frame = tk.LabelFrame(main_frame, text="股票参数设置", font=("Arial", 11, "bold"),
+                                    bg='#f0f0f0', fg='#2c3e50')
+        input_frame.pack(fill=tk.X, pady=10)
+
+        # 股票代码输入
+        tk.Label(input_frame, text="股票代码:", bg='#f0f0f0', font=("Arial", 10)).grid(row=0, column=0, sticky=tk.W,
+                                                                                       padx=5, pady=5)
+        self.stock_code_var = tk.StringVar(value="600580")
+        stock_code_entry = tk.Entry(input_frame, textvariable=self.stock_code_var, font=("Arial", 10), width=15)
+        stock_code_entry.grid(row=0, column=1, padx=5, pady=5)
+
+        # 股票名称输入
+        tk.Label(input_frame, text="股票名称:", bg='#f0f0f0', font=("Arial", 10)).grid(row=0, column=2, sticky=tk.W,
+                                                                                       padx=5, pady=5)
+        self.stock_name_var = tk.StringVar(value="卧龙电驱")
+        stock_name_entry = tk.Entry(input_frame, textvariable=self.stock_name_var, font=("Arial", 10), width=15)
+        stock_name_entry.grid(row=0, column=3, padx=5, pady=5)
+
+        # 预测天数
+        tk.Label(input_frame, text="预测天数:", bg='#f0f0f0', font=("Arial", 10)).grid(row=1, column=0, sticky=tk.W,
+                                                                                       padx=5, pady=5)
+        self.pred_days_var = tk.StringVar(value="60")
+        pred_days_entry = tk.Entry(input_frame, textvariable=self.pred_days_var, font=("Arial", 10), width=15)
+        pred_days_entry.grid(row=1, column=1, padx=5, pady=5)
+
+        # 历史数据年限
+        tk.Label(input_frame, text="历史年限:", bg='#f0f0f0', font=("Arial", 10)).grid(row=1, column=2, sticky=tk.W,
+                                                                                       padx=5, pady=5)
+        self.history_years_var = tk.StringVar(value="1")
+        history_years_entry = tk.Entry(input_frame, textvariable=self.history_years_var, font=("Arial", 10), width=15)
+        history_years_entry.grid(row=1, column=3, padx=5, pady=5)
+
+        # 目录设置框架
+        dir_frame = tk.LabelFrame(main_frame, text="目录设置", font=("Arial", 11, "bold"),
+                                  bg='#f0f0f0', fg='#2c3e50')
+        dir_frame.pack(fill=tk.X, pady=10)
+
+        # 数据目录
+        tk.Label(dir_frame, text="数据目录:", bg='#f0f0f0', font=("Arial", 10)).grid(row=0, column=0, sticky=tk.W,
+                                                                                     padx=5, pady=5)
+        self.data_dir_var = tk.StringVar(value=r"D:\lianghuajiaoyi\Kronos\examples\data")
+        data_dir_entry = tk.Entry(dir_frame, textvariable=self.data_dir_var, font=("Arial", 10), width=40)
+        data_dir_entry.grid(row=0, column=1, padx=5, pady=5)
+        tk.Button(dir_frame, text="浏览", command=self.browse_data_dir, font=("Arial", 9)).grid(row=0, column=2, padx=5,
+                                                                                                pady=5)
+
+        # 输出目录
+        tk.Label(dir_frame, text="输出目录:", bg='#f0f0f0', font=("Arial", 10)).grid(row=1, column=0, sticky=tk.W,
+                                                                                     padx=5, pady=5)
+        self.output_dir_var = tk.StringVar(value=r"D:\lianghuajiaoyi\Kronos\examples\yuce")
+        output_dir_entry = tk.Entry(dir_frame, textvariable=self.output_dir_var, font=("Arial", 10), width=40)
+        output_dir_entry.grid(row=1, column=1, padx=5, pady=5)
+        tk.Button(dir_frame, text="浏览", command=self.browse_output_dir, font=("Arial", 9)).grid(row=1, column=2,
+                                                                                                  padx=5, pady=5)
+
+        # 功能按钮框架
+        button_frame = tk.Frame(main_frame, bg='#f0f0f0')
+        button_frame.pack(pady=20)
+
+        # 预测按钮
+        self.predict_button = tk.Button(
+            button_frame,
+            text="🚀 开始预测",
+            command=self.start_prediction,
+            font=("Arial", 12, "bold"),
+            bg='#3498db',
+            fg='white',
+            width=15,
+            height=2
+        )
+        self.predict_button.pack(side=tk.LEFT, padx=10)
+
+        # 重置按钮
+        reset_button = tk.Button(
+            button_frame,
+            text="🔄 重置",
+            command=self.reset_fields,
+            font=("Arial", 10),
+            bg='#95a5a6',
+            fg='white',
+            width=10,
+            height=2
+        )
+        reset_button.pack(side=tk.LEFT, padx=10)
+
+        # 退出按钮
+        exit_button = tk.Button(
+            button_frame,
+            text="❌ 退出",
+            command=self.root.quit,
+            font=("Arial", 10),
+            bg='#e74c3c',
+            fg='white',
+            width=10,
+            height=2
+        )
+        exit_button.pack(side=tk.LEFT, padx=10)
+
+        # 进度显示
+        self.progress_frame = tk.LabelFrame(main_frame, text="预测进度", font=("Arial", 11, "bold"),
+                                            bg='#f0f0f0', fg='#2c3e50')
+        self.progress_frame.pack(fill=tk.X, pady=10)
+
+        self.progress_var = tk.StringVar(value="等待开始预测...")
+        progress_label = tk.Label(self.progress_frame, textvariable=self.progress_var, bg='#f0f0f0',
+                                  font=("Arial", 10), wraplength=700, justify=tk.LEFT)
+        progress_label.pack(padx=10, pady=10, fill=tk.X)
+
+        # 进度条
+        self.progress_bar = ttk.Progressbar(self.progress_frame, mode='indeterminate')
+        self.progress_bar.pack(fill=tk.X, padx=10, pady=5)
+
+        # 结果展示区域
+        self.result_frame = tk.LabelFrame(main_frame, text="预测结果", font=("Arial", 11, "bold"),
+                                          bg='#f0f0f0', fg='#2c3e50')
+        self.result_frame.pack(fill=tk.BOTH, expand=True, pady=10)
+
+        self.result_text = tk.Text(self.result_frame, height=8, font=("Arial", 9), wrap=tk.WORD)
+        scrollbar = tk.Scrollbar(self.result_frame, command=self.result_text.yview)
+        self.result_text.configure(yscrollcommand=scrollbar.set)
+        self.result_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=5, pady=5)
+        scrollbar.pack(side=tk.RIGHT, fill=tk.Y, pady=5)
+
+    def browse_data_dir(self):
+        """浏览数据目录"""
+        directory = filedialog.askdirectory()
+        if directory:
+            self.data_dir_var.set(directory)
+
+    def browse_output_dir(self):
+        """浏览输出目录"""
+        directory = filedialog.askdirectory()
+        if directory:
+            self.output_dir_var.set(directory)
+
+    def reset_fields(self):
+        """重置输入字段"""
+        self.stock_code_var.set("600580")
+        self.stock_name_var.set("卧龙电驱")
+        self.pred_days_var.set("60")
+        self.history_years_var.set("1")
+        self.data_dir_var.set(r"D:\lianghuajiaoyi\Kronos\examples\data")
+        self.output_dir_var.set(r"D:\lianghuajiaoyi\Kronos\examples\yuce")
+        self.result_text.delete(1.0, tk.END)
+        self.progress_var.set("等待开始预测...")
+
+    def start_prediction(self):
+        """开始预测"""
+        # 验证输入
+        if not self.validate_inputs():
+            return
+
+        # 禁用预测按钮
+        self.predict_button.config(state=tk.DISABLED)
+
+        # 清空结果区域
+        self.result_text.delete(1.0, tk.END)
+
+        # 开始进度条
+        self.progress_bar.start()
+
+        # 在新线程中运行预测
+        prediction_thread = threading.Thread(target=self.run_prediction)
+        prediction_thread.daemon = True
+        prediction_thread.start()
+
+    def validate_inputs(self):
+        """验证输入参数"""
+        try:
+            stock_code = self.stock_code_var.get().strip()
+            stock_name = self.stock_name_var.get().strip()
+            pred_days = int(self.pred_days_var.get())
+            history_years = int(self.history_years_var.get())
+
+            if not stock_code:
+                messagebox.showerror("错误", "请输入股票代码")
+                return False
+
+            if not stock_name:
+                messagebox.showerror("错误", "请输入股票名称")
+                return False
+
+            if pred_days <= 0 or pred_days > 365:
+                messagebox.showerror("错误", "预测天数应在1-365天之间")
+                return False
+
+            if history_years <= 0 or history_years > 10:
+                messagebox.showerror("错误", "历史年限应在1-10年之间")
+                return False
+
+            return True
+
+        except ValueError:
+            messagebox.showerror("错误", "请输入有效的数字")
+            return False
+
+    def run_prediction(self):
+        """运行预测流程"""
+        try:
+            # 获取输入参数
+            stock_code = self.stock_code_var.get().strip()
+            stock_name = self.stock_name_var.get().strip()
+            pred_days = int(self.pred_days_var.get())
+            history_years = int(self.history_years_var.get())
+            data_dir = self.data_dir_var.get()
+            output_dir = self.output_dir_var.get()
+
+            # 更新进度
+            self.update_progress("🎯 开始股票预测流程...")
+
+            # 运行预测
+            success, result = run_comprehensive_prediction_gui(
+                stock_code, stock_name, data_dir, pred_days, output_dir, history_years,
+                progress_callback=self.update_progress,
+                result_callback=self.update_result
+            )
+
+            if success:
+                self.update_progress("✅ 预测完成！")
+                messagebox.showinfo("完成", f"{stock_name}({stock_code})预测完成！\n图表已保存到输出目录。")
+            else:
+                self.update_progress("❌ 预测失败")
+                messagebox.showerror("错误", f"预测失败: {result}")
+
+        except Exception as e:
+            self.update_progress(f"❌ 预测过程出现错误: {str(e)}")
+            messagebox.showerror("错误", f"预测过程出现错误: {str(e)}")
+        finally:
+            # 重新启用预测按钮
+            self.root.after(0, lambda: self.predict_button.config(state=tk.NORMAL))
+            # 停止进度条
+            self.root.after(0, self.progress_bar.stop)
+
+    def update_progress(self, message):
+        """更新进度信息"""
+        self.root.after(0, lambda: self.progress_var.set(message))
+        print(message)  # 同时在控制台输出
+
+    def update_result(self, message):
+        """更新结果信息"""
+        self.root.after(0, lambda: self.result_text.insert(tk.END, message + "\n"))
+        self.root.after(0, lambda: self.result_text.see(tk.END))
+
+
+# ==================== 基础数据获取函数 ====================
+def ensure_output_directory(output_dir):
+    """确保输出目录存在，如果不存在则创建"""
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+        print(f"✅ 创建输出目录: {output_dir}")
+    return output_dir
+
+
+def fetch_real_stock_data(stock_code, period="daily", adjust="qfq"):
+    """
+    使用AKShare获取真实股票数据
+    """
+    try:
+        print(f"📡 正在通过AKShare获取 {stock_code} 的真实股票数据...")
+
+        # 获取股票数据
+        df = ak.stock_zh_a_hist(symbol=stock_code, period=period, adjust=adjust)
+
+        if df is None or df.empty:
+            print(f"❌ 未获取到 {stock_code} 的数据")
+            return None
+
+        # 重命名列以统一格式
+        column_mapping = {
+            '日期': 'timestamps',
+            '开盘': 'open',
+            '收盘': 'close',
+            '最高': 'high',
+            '最低': 'low',
+            '成交量': 'volume',
+            '成交额': 'amount',
+            '振幅': 'amplitude',
+            '涨跌幅': 'pct_chg',
+            '涨跌额': 'change_amount',
+            '换手率': 'turnover'
+        }
+
+        # 只映射存在的列
+        actual_mapping = {k: v for k, v in column_mapping.items() if k in df.columns}
+        df = df.rename(columns=actual_mapping)
+
+        # 确保时间戳格式正确
+        df['timestamps'] = pd.to_datetime(df['timestamps'])
+        df = df.sort_values('timestamps').reset_index(drop=True)
+
+        # 添加股票代码列
+        df['stock_code'] = stock_code
+
+        print(f"✅ 成功获取 {len(df)} 条真实数据")
+        print(f"📈 最新收盘价: {df['close'].iloc[-1]:.2f}元, 涨跌幅: {df['pct_chg'].iloc[-1]:.2f}%")
+        print(f"📅 时间范围: {df['timestamps'].min()} 到 {df['timestamps'].max()}")
+
+        return df
+
+    except Exception as e:
+        print(f"❌ AKShare数据获取失败: {e}")
+        return None
+
+
+def get_stock_data_with_retry_all_history(stock_code="600580", retry_count=2):
+    """
+    优化的数据获取函数 - 优先使用真实API数据
+    """
+    print(f"🔄 尝试获取股票 {stock_code} 的真实历史数据...")
+
+    # 优先使用AKShare获取真实数据
+    df = fetch_real_stock_data(stock_code, "daily", "qfq")
+
+    if df is not None:
+        return df
+    else:
+        print("⚠️ 真实数据获取失败，使用基于真实价格的模拟数据...")
+        return create_realistic_fallback_data(stock_code)
+
+
+def create_realistic_fallback_data(stock_code="600580"):
+    """
+    基于真实价格的备用数据生成函数
+    """
+    # 基于真实市场价格的参考数据
+    real_stock_references = {
+        '600580': {'name': '卧龙电驱', 'current_price': 15.20, 'range': (12.0, 20.0)},
+        '300207': {'name': '欣旺达', 'current_price': 33.79, 'range': (28.0, 38.0)},
+        '300418': {'name': '昆仑万维', 'current_price': 48.59, 'range': (40.0, 55.0)},
+        '002354': {'name': '天娱数科', 'current_price': 15.20, 'range': (12.0, 20.0)},
+        '000001': {'name': '平安银行', 'current_price': 12.50, 'range': (10.0, 16.0)},
+        '600036': {'name': '招商银行', 'current_price': 35.80, 'range': (30.0, 42.0)},
+    }
+
+    stock_info = real_stock_references.get(stock_code, {
+        'name': '未知股票',
+        'current_price': 20.0,
+        'range': (15.0, 25.0)
+    })
+
+    # 生成最近1年的交易日数据
+    end_date = datetime.now()
+    start_date = end_date - timedelta(days=365)
+    dates = pd.bdate_range(start=start_date, end=end_date, freq='B')
+
+    # 生成基于真实价格的价格序列
+    np.random.seed(42)
+    n_points = len(dates)
+
+    # 从当前价格反向生成历史价格
+    current_price = stock_info['current_price']
+    min_price, max_price = stock_info['range']
+
+    # 反向生成价格序列
+    prices = [current_price]
+    for i in range(1, n_points):
+        volatility = 0.02
+        historical_return = np.random.normal(-0.0002, volatility)
+
+        prev_price = prices[0] * (1 + historical_return)
+        prev_price = max(min_price * 0.9, min(max_price * 1.1, prev_price))
+        prices.insert(0, prev_price)
+
+    # 生成OHLC数据
+    stock_data = []
+    for i, date in enumerate(dates):
+        close_price = prices[i]
+
+        daily_volatility = abs(np.random.normal(0, 0.015))
+        open_price = close_price * (1 + np.random.normal(0, 0.005))
+        high_price = max(open_price, close_price) * (1 + daily_volatility)
+        low_price = min(open_price, close_price) * (1 - daily_volatility)
+
+        high_price = max(open_price, close_price, low_price, high_price)
+        low_price = min(open_price, close_price, high_price, low_price)
+
+        volume = int(abs(np.random.normal(1500000, 400000)))
+        amount = volume * close_price
+
+        if i > 0:
+            pct_chg = ((close_price - prices[i - 1]) / prices[i - 1]) * 100
+            change_amount = close_price - prices[i - 1]
+        else:
+            pct_chg = 0
+            change_amount = 0
+
+        stock_data.append({
+            'timestamps': date,
+            'stock_code': stock_code,
+            'open': round(open_price, 2),
+            'close': round(close_price, 2),
+            'high': round(high_price, 2),
+            'low': round(low_price, 2),
+            'volume': volume,
+            'amount': round(amount, 2),
+            'amplitude': round(((high_price - low_price) / open_price) * 100, 2),
+            'pct_chg': round(pct_chg, 2),
+            'change_amount': round(change_amount, 2),
+            'turnover': round(np.random.uniform(3.0, 8.0), 2)
+        })
+
+    df = pd.DataFrame(stock_data)
+    print(f"✅ 已生成基于真实价格的备用数据 {len(df)} 条")
+    return df
+
+
+def save_all_history_stock_data(df, stock_code, save_dir):
+    """
+    保存股票数据到指定目录
+    """
+    if df is not None and not df.empty:
+        os.makedirs(save_dir, exist_ok=True)
+        csv_file = os.path.join(save_dir, f"{stock_code}_stock_data.csv")
+        df_reset = df.reset_index()
+        df_reset.to_csv(csv_file, encoding='utf-8-sig', index=False)
+        print(f"📁 股票数据已保存: {csv_file}")
+        return True
+    return False
+
+
+def get_stock_data(stock_code, data_dir):
+    """
+    获取股票数据，如果数据文件不存在则从API获取真实数据
+    """
+    csv_file_path = os.path.join(data_dir, f"{stock_code}_stock_data.csv")
+
+    if os.path.exists(csv_file_path):
+        print(f"📁 使用现有数据文件: {csv_file_path}")
+        return True, csv_file_path
+    else:
+        print(f"📡 数据文件不存在，从API获取真实数据...")
+        df = get_stock_data_with_retry_all_history(stock_code)
+
+        if df is not None and not df.empty:
+            save_all_history_stock_data(df, stock_code, data_dir)
+            return True, csv_file_path
+        else:
+            print(f"❌ 无法获取股票数据")
+            return False, None
+
+
+def prepare_stock_data(csv_file_path, stock_code, history_years=1):
+    """
+    准备股票数据，转换为Kronos模型需要的格式
+    """
+    print(f"正在加载和预处理股票 {stock_code} 数据...")
+
+    # 读取CSV文件
+    df = pd.read_csv(csv_file_path, encoding='utf-8-sig')
+
+    # 标准化列名
+    column_mapping = {
+        '日期': 'timestamps',
+        '开盘价': 'open',
+        '最高价': 'high',
+        '最低价': 'low',
+        '收盘价': 'close',
+        '成交量': 'volume',
+        '成交额': 'amount',
+        '开盘': 'open',
+        '收盘': 'close',
+        '最高': 'high',
+        '最低': 'low'
+    }
+
+    actual_mapping = {k: v for k, v in column_mapping.items() if k in df.columns}
+    df = df.rename(columns=actual_mapping)
+
+    # 确保时间戳列存在并转换为datetime格式
+    if 'timestamps' not in df.columns:
+        if df.index.name == '日期':
+            df = df.reset_index()
+            df = df.rename(columns={'日期': 'timestamps'})
+
+    df['timestamps'] = pd.to_datetime(df['timestamps'])
+    df = df.sort_values('timestamps').reset_index(drop=True)
+
+    # 根据历史年限筛选数据
+    if history_years > 0:
+        cutoff_date = datetime.now() - timedelta(days=history_years * 365)
+        original_count = len(df)
+        df = df[df['timestamps'] >= cutoff_date]
+        print(f"📅 使用最近 {history_years} 年数据: {len(df)} 条记录 (从 {original_count} 条中筛选)")
+
+    # 数据验证
+    print(f"🔍 数据验证 - 最近5个交易日收盘价:")
+    recent_prices = df[['timestamps', 'close']].tail()
+    for _, row in recent_prices.iterrows():
+        print(f"  {row['timestamps'].strftime('%Y-%m-%d')}: {row['close']:.2f}元")
+
+    current_price = df['close'].iloc[-1]
+    print(f"✅ 数据加载完成，共 {len(df)} 条记录")
+    print(f"时间范围: {df['timestamps'].min()} 到 {df['timestamps'].max()}")
+    print(f"价格范围: {df['close'].min():.2f} - {df['close'].max():.2f}")
+    print(f"当前价格: {current_price:.2f}元")
+
+    return df
+
+
+def calculate_prediction_parameters(df, target_days=60):
+    """
+    根据目标预测天数计算合适的参数
+    """
+    # 计算平均交易日数量
+    total_days = (df['timestamps'].max() - df['timestamps'].min()).days
+    trading_days = len(df)
+    trading_ratio = trading_days / total_days if total_days > 0 else 0.7
+
+    # 计算目标预测的交易日数量
+    pred_trading_days = int(target_days * trading_ratio)
+
+    # 设置回看期数
+    max_lookback = int(len(df) * 0.7)
+    lookback = min(pred_trading_days * 3, max_lookback, len(df) - pred_trading_days)
+    pred_len = min(pred_trading_days, len(df) - lookback)
+
+    # 确保参数在合理范围内
+    lookback = max(100, min(lookback, 400))
+    pred_len = max(20, min(pred_len, 120))
+
+    print(f"📊 参数计算:")
+    print(f"  目标预测天数: {target_days} 天（自然日）")
+    print(f"  预计交易日数量: {pred_trading_days} 天")
+    print(f"  回看期数 (lookback): {lookback}")
+    print(f"  预测期数 (pred_len): {pred_len}")
+
+    return lookback, pred_len
+
+
+def generate_trading_dates_only(last_date, pred_len):
+    """
+    🎯 修复版：只生成交易日，排除周末和法定节假日
+    """
+    # 2025年法定节假日安排（修正版）
+    holidays_2025 = [
+        '2025-01-01',  # 元旦
+        '2025-01-27', '2025-01-28', '2025-01-29', '2025-01-30', '2025-01-31', '2025-02-01', '2025-02-02',  # 春节
+        '2025-04-04', '2025-04-05', '2025-04-06',  # 清明
+        '2025-05-01', '2025-05-02', '2025-05-03',  # 劳动节
+        '2025-06-08', '2025-06-09', '2025-06-10',  # 端午
+        '2025-10-01', '2025-10-02', '2025-10-03', '2025-10-04', '2025-10-05', '2025-10-06', '2025-10-07',  # 国庆节
+    ]
+
+    holidays = [datetime.strptime(date, '%Y-%m-%d').date() for date in holidays_2025]
+
+    trading_dates = []
+    current_date = last_date + timedelta(days=1)
+
+    while len(trading_dates) < pred_len:
+        # 排除周末和节假日
+        if current_date.weekday() < 5 and current_date.date() not in holidays:
+            trading_dates.append(current_date)
+        current_date += timedelta(days=1)
+
+    print(f"📅 生成的纯交易日: 共 {len(trading_dates)} 天")
+    if trading_dates:
+        print(f"   起始: {trading_dates[0].strftime('%Y-%m-%d')}")
+        print(f"   结束: {trading_dates[-1].strftime('%Y-%m-%d')}")
+
+    return trading_dates
+
+
+def calculate_optimal_interval(min_val, max_val):
+    """
+    计算最优的Y轴刻度间隔
+    """
+    range_val = max_val - min_val
+    if range_val <= 0:
+        return 1.0
+
+    if range_val < 1:
+        interval = 0.1
+    elif range_val < 5:
+        interval = 0.5
+    elif range_val < 10:
+        interval = 1.0
+    elif range_val < 20:
+        interval = 2.0
+    elif range_val < 50:
+        interval = 5.0
+    elif range_val < 100:
+        interval = 10.0
+    elif range_val < 200:
+        interval = 20.0
+    elif range_val < 500:
+        interval = 50.0
+    else:
+        interval = 100.0
+
+    return interval
+
+
+# ==================== 增强版市场因素分析器 ====================
+class EnhancedMarketFactorAnalyzer:
+    """增强版市场因素分析器 - 整合更多维度的市场因素"""
+
+    def __init__(self):
+        self.market_data = {}
+        self.sector_data = {}
+        self.macro_factors = {}
+        self.policy_factors = {}
+
+    def analyze_market_trend(self, index_codes=["000001", "399001"]):
+        """
+        分析大盘趋势 - 多指数综合分析
+        """
+        try:
+            print(f"📊 综合分析大盘趋势...")
+
+            market_analysis = {}
+
+            for index_code in index_codes:
+                index_name = "上证指数" if index_code == "000001" else "深证成指"
+                print(f"  分析{index_name}({index_code})...")
+
+                # 获取指数数据
+                index_df = ak.stock_zh_index_hist(symbol=index_code, period="daily")
+
+                if index_df is None or index_df.empty:
+                    print(f"  ❌ 无法获取{index_name}数据")
+                    continue
+
+                # 重命名列
+                index_df = index_df.rename(columns={
+                    '日期': 'date', '收盘': 'close', '开盘': 'open',
+                    '最高': 'high', '最低': 'low', '成交量': 'volume'
+                })
+                index_df['date'] = pd.to_datetime(index_df['date'])
+                index_df = index_df.sort_values('date').reset_index(drop=True)
+
+                # 计算技术指标
+                index_df['ma5'] = index_df['close'].rolling(5).mean()
+                index_df['ma20'] = index_df['close'].rolling(20).mean()
+                index_df['ma60'] = index_df['close'].rolling(60).mean()
+                index_df['vol_ma5'] = index_df['volume'].rolling(5).mean()
+
+                # 技术分析
+                current_data = index_df.iloc[-1]
+                prev_data = index_df.iloc[-2]
+
+                # 均线多头排列判断
+                ma_condition = (current_data['ma5'] > current_data['ma20'] > current_data['ma60'])
+
+                # 价格站在20日均线以上
+                price_above_ma20 = current_data['close'] > current_data['ma20']
+
+                # 成交量配合
+                volume_condition = current_data['volume'] > current_data['vol_ma5'] * 0.8
+
+                # 趋势强度
+                trend_strength = self._calculate_trend_strength(index_df)
+
+                is_main_uptrend = ma_condition and price_above_ma20 and trend_strength > 0.6
+
+                market_analysis[index_name] = {
+                    'is_main_uptrend': is_main_uptrend,
+                    'trend_strength': trend_strength,
+                    'current_close': current_data['close'],
+                    'price_change_pct': ((current_data['close'] - prev_data['close']) / prev_data['close']) * 100,
+                    'market_status': '主升浪' if is_main_uptrend else '震荡调整'
+                }
+
+            # 综合判断
+            if market_analysis:
+                avg_trend_strength = np.mean([data['trend_strength'] for data in market_analysis.values()])
+                uptrend_count = sum(1 for data in market_analysis.values() if data['is_main_uptrend'])
+                overall_uptrend = uptrend_count >= len(market_analysis) * 0.5
+
+                final_analysis = {
+                    'overall_is_main_uptrend': overall_uptrend,
+                    'overall_trend_strength': avg_trend_strength,
+                    'detailed_analysis': market_analysis,
+                    'market_status': '主升浪' if overall_uptrend else '震荡调整'
+                }
+
+                print(f"✅ 大盘分析完成: {final_analysis['market_status']}, 综合趋势强度: {avg_trend_strength:.2f}")
+                return final_analysis
+
+            return self._get_default_market_analysis()
+
+        except Exception as e:
+            print(f"❌ 大盘分析错误: {e}")
+            return self._get_default_market_analysis()
+
+    def analyze_sector_resonance(self, stock_code):
+        """
+        分析板块共振效应 - 增强版行业分析
+        """
+        try:
+            print(f"🔄 分析板块共振效应...")
+
+            # 获取股票所属行业和概念
+            industry = "未知"
+            concepts = []
+
+            try:
+                stock_info = ak.stock_individual_info_em(symbol=stock_code)
+                if not stock_info.empty and 'value' in stock_info.columns:
+                    industry_row = stock_info[stock_info['item'] == '行业']
+                    if not industry_row.empty:
+                        industry = industry_row['value'].iloc[0]
+            except:
+                pass
+
+            # 热门板块和概念映射
+            hot_sectors = {
+                '机器人': {'momentum': 0.85, 'limit_up_stocks': 18, 'active': True,
+                           'description': '人形机器人、工业自动化'},
+                '半导体': {'momentum': 0.8, 'limit_up_stocks': 15, 'active': True, 'description': '芯片国产替代'},
+                '人工智能': {'momentum': 0.75, 'limit_up_stocks': 12, 'active': True, 'description': 'AI大模型、算力'},
+                '低空经济': {'momentum': 0.7, 'limit_up_stocks': 10, 'active': True, 'description': '无人机、eVTOL'},
+                '新能源': {'momentum': 0.6, 'limit_up_stocks': 8, 'active': True, 'description': '光伏、储能'},
+                '医药': {'momentum': 0.5, 'limit_up_stocks': 5, 'active': False, 'description': '创新药'}
+            }
+
+            # 判断当前股票所属热门板块
+            matched_sectors = []
+            for sector, data in hot_sectors.items():
+                if (sector in industry or
+                        (stock_code == '600580' and sector in ['机器人', '低空经济']) or  # 卧龙电驱特殊处理
+                        (stock_code == '300207' and sector in ['新能源'])):
+                    matched_sectors.append({
+                        'sector': sector,
+                        'momentum': data['momentum'],
+                        'limit_up_stocks': data['limit_up_stocks'],
+                        'is_active': data['active'],
+                        'description': data['description']
+                    })
+
+            # 计算综合共振分数
+            if matched_sectors:
+                resonance_score = np.mean([sector['momentum'] for sector in matched_sectors])
+                is_sector_hot = any(sector['is_active'] for sector in matched_sectors)
+                main_sector = max(matched_sectors, key=lambda x: x['momentum'])
+            else:
+                resonance_score = 0.5
+                is_sector_hot = False
+                main_sector = {'sector': '传统行业', 'momentum': 0.5, 'description': '无热门概念'}
+
+            analysis = {
+                'industry': industry,
+                'matched_sectors': matched_sectors,
+                'main_sector': main_sector,
+                'is_sector_hot': is_sector_hot,
+                'resonance_score': resonance_score,
+                'sector_count': len(matched_sectors)
+            }
+
+            print(f"✅ 板块分析完成: {industry}, 匹配{len(matched_sectors)}个热门板块, 共振分数: {resonance_score:.2f}")
+            return analysis
+
+        except Exception as e:
+            print(f"❌ 板块分析错误: {e}")
+            return self._get_default_sector_analysis()
+
+    def analyze_macro_factors(self):
+        """
+        分析宏观因素 - 结合国内外政策
+        """
+        try:
+            print(f"🌍 分析宏观因素...")
+
+            # 美国降息周期分析 - 基于最新信息
+            us_rate_analysis = {
+                'current_rate': 4.25,  # 联邦基金利率目标区间4.00%-4.25%
+                'trend': '降息周期',
+                'recent_cut': '2025年9月降息25个基点',
+                'expected_cuts_2025': 2,  # 市场预期2025年还有两次降息
+                'expected_cuts_2026': 2,
+                'impact_on_emerging_markets': 'positive',
+                'usd_index_support': 95.0,  # 美元指数短期支撑位
+                'analysis': '美联储开启宽松周期，利好全球流动性'
+            }
+
+            # 国内政策因素 - 基于最新政策
+            domestic_policy = {
+                'monetary_policy': '稳健偏松',
+                'fiscal_policy': '积极财政',
+                'market_liquidity': '合理充裕',
+                'industrial_policy': '设备更新、以旧换新',  # 大规模设备更新政策
+                'employment_policy': '稳就业政策加力',  # 国务院稳就业政策
+                'analysis': '政策组合拳发力，经济稳中向好'
+            }
+
+            # 行业政策支持
+            industry_policy = {
+                'robot_policy': '机器人产业政策支持',
+                'chip_policy': '国产替代加速推进',
+                'AI_policy': '人工智能发展规划',
+                'low_altitude': '低空经济发展规划'
+            }
+
+            macro_analysis = {
+                'us_rate_cycle': us_rate_analysis,
+                'domestic_policy': domestic_policy,
+                'industry_policy': industry_policy,
+                'global_liquidity_outlook': '改善',
+                'overall_macro_score': 0.75  # 宏观环境整体偏积极
+            }
+
+            print(
+                f"✅ 宏观分析完成: 美国{us_rate_analysis['trend']}, 国内政策积极, 宏观评分: {macro_analysis['overall_macro_score']:.2f}")
+            return macro_analysis
+
+        except Exception as e:
+            print(f"❌ 宏观分析错误: {e}")
+            return self._get_default_macro_analysis()
+
+    def analyze_company_fundamentals(self, stock_code):
+        """
+        分析公司基本面 - 针对特定股票
+        """
+        try:
+            print(f"🏢 分析公司基本面...")
+
+            # 卧龙电驱特殊分析
+            if stock_code == '600580':
+                fundamentals = {
+                    'company_name': '卧龙电驱',
+                    'business_areas': ['工业电机', '机器人关键部件', '航空电机', '新能源汽车驱动'],
+                    'recent_developments': [
+                        '与智元机器人实现双向持股，推进具身智能机器人技术研发',
+                        '成立浙江龙飞电驱，专注航空电机业务',
+                        '发布AI外骨骼机器人及灵巧手',
+                        '布局高爆发关节模组、伺服驱动器等人形机器人关键部件'
+                    ],
+                    'growth_drivers': [
+                        '设备更新政策推动工业电机需求',
+                        '机器人产业快速发展',
+                        '低空经济政策支持',
+                        '出海战略加速'
+                    ],
+                    'risk_factors': [
+                        '机器人业务营收占比仅2.71%，占比较低',
+                        '工业需求景气度波动',
+                        '原料价格波动风险'
+                    ],
+                    'investment_rating': '积极关注',
+                    'fundamental_score': 0.7
+                }
+            else:
+                # 其他股票的基础分析
+                fundamentals = {
+                    'company_name': '未知',
+                    'business_areas': [],
+                    'recent_developments': [],
+                    'growth_drivers': [],
+                    'risk_factors': [],
+                    'investment_rating': '中性',
+                    'fundamental_score': 0.5
+                }
+
+            print(f"✅ 基本面分析完成: {fundamentals['company_name']}, 评分: {fundamentals['fundamental_score']:.2f}")
+            return fundamentals
+
+        except Exception as e:
+            print(f"❌ 基本面分析错误: {e}")
+            return self._get_default_fundamental_analysis()
+
+    def _calculate_trend_strength(self, df):
+        """计算趋势强度"""
+        if len(df) < 20:
+            return 0.5
+
+        ma_slope = (df['ma5'].iloc[-1] - df['ma5'].iloc[-20]) / df['ma5'].iloc[-20]
+        price_slope = (df['close'].iloc[-1] - df['close'].iloc[-20]) / df['close'].iloc[-20]
+
+        volume_trend = df['volume'].iloc[-5:].mean() / df['volume'].iloc[-10:-5].mean()
+
+        strength = (ma_slope * 0.4 + price_slope * 0.4 + min(volume_trend - 1, 0.2) * 0.2)
+        return max(0, min(1, strength * 10))
+
+    def _get_default_market_analysis(self):
+        return {
+            'overall_is_main_uptrend': False,
+            'overall_trend_strength': 0.5,
+            'market_status': '未知',
+            'detailed_analysis': {}
+        }
+
+    def _get_default_sector_analysis(self):
+        return {
+            'industry': '未知',
+            'matched_sectors': [],
+            'main_sector': {'sector': '未知', 'momentum': 0.5, 'description': ''},
+            'is_sector_hot': False,
+            'resonance_score': 0.5,
+            'sector_count': 0
+        }
+
+    def _get_default_macro_analysis(self):
+        return {
+            'us_rate_cycle': {'trend': '未知', 'expected_cuts_2025': 0},
+            'domestic_policy': {'monetary_policy': '中性'},
+            'overall_macro_score': 0.5
+        }
+
+    def _get_default_fundamental_analysis(self):
+        return {
+            'company_name': '未知',
+            'business_areas': [],
+            'recent_developments': [],
+            'growth_drivers': [],
+            'risk_factors': [],
+            'investment_rating': '中性',
+            'fundamental_score': 0.5
+        }
+
+
+# ==================== 优化的预测平滑函数 ====================
+def smooth_prediction_results(prediction_df, historical_df, smooth_factor=0.3):
+    """
+    🎯 优化预测结果的平滑处理，避免剧烈波动
+    """
+    print("🔄 应用预测结果平滑处理...")
+
+    smoothed_df = prediction_df.copy()
+
+    # 获取历史数据的趋势
+    recent_trend = calculate_recent_trend(historical_df)
+
+    # 对价格序列进行平滑
+    price_columns = ['close', 'open', 'high', 'low']
+    for col in price_columns:
+        if col in smoothed_df.columns:
+            original_values = smoothed_df[col].values
+
+            # 应用移动平均平滑
+            window_size = max(3, min(7, len(original_values) // 5))
+            smoothed_values = pd.Series(original_values).rolling(
+                window=window_size, center=True, min_periods=1
+            ).mean()
+
+            # 结合历史趋势进行微调
+            trend_adjusted = smoothed_values * (1 + recent_trend * smooth_factor)
+
+            smoothed_df[col] = trend_adjusted.values
+
+    # 对成交量进行合理调整
+    if 'volume' in smoothed_df.columns:
+        hist_volume_mean = historical_df['volume'].tail(20).mean()
+        current_volume = smoothed_df['volume'].values
+
+        # 保持成交量在合理范围内
+        volume_factor = 0.8 + 0.4 * np.random.random(len(current_volume))
+        adjusted_volume = current_volume * volume_factor
+
+        # 确保成交量不会异常波动
+        volume_std = historical_df['volume'].tail(50).std()
+        volume_min = hist_volume_mean * 0.3
+        volume_max = hist_volume_mean * 3.0
+
+        smoothed_df['volume'] = np.clip(adjusted_volume, volume_min, volume_max)
+
+    print("✅ 预测结果平滑完成")
+    return smoothed_df
+
+
+def calculate_recent_trend(historical_df, lookback_days=20):
+    """
+    计算近期价格趋势
+    """
+    if len(historical_df) < lookback_days:
+        lookback_days = len(historical_df)
+
+    recent_prices = historical_df['close'].tail(lookback_days).values
+    if len(recent_prices) < 2:
+        return 0
+
+    # 计算线性回归斜率作为趋势
+    x = np.arange(len(recent_prices))
+    slope = np.polyfit(x, recent_prices, 1)[0]
+
+    # 归一化为趋势强度 (-1 到 1)
+    price_range = np.ptp(recent_prices)
+    if price_range > 0:
+        trend_strength = slope / price_range * len(recent_prices)
+    else:
+        trend_strength = 0
+
+    return np.clip(trend_strength, -0.1, 0.1)  # 限制趋势强度
+
+
+def apply_post_holiday_adjustment(prediction_df, future_dates, holiday_periods):
+    """
+    🎯 修复版：应用节后调整，避免国庆后异常下跌
+    """
+    print("🔄 应用节后日历效应调整...")
+
+    adjusted_df = prediction_df.copy()
+
+    for holiday in holiday_periods:
+        holiday_start = pd.Timestamp(holiday['start'])
+        holiday_end = pd.Timestamp(holiday['end'])
+        adjustment_days = holiday['adjustment_days']
+        effect_strength = holiday['effect_strength']
+
+        # 计算调整期结束日期
+        adjustment_end = holiday_end + timedelta(days=adjustment_days)
+
+        # 找到在节后调整期内的日期索引
+        post_holiday_indices = []
+        for i, date in enumerate(future_dates):
+            if holiday_end <= date < adjustment_end:
+                post_holiday_indices.append(i)
+
+        # 应用节后效应调整
+        if post_holiday_indices:
+            for col in ['close', 'open', 'high', 'low']:
+                if col in adjusted_df.columns:
+                    for idx in post_holiday_indices:
+                        adjusted_df.iloc[idx][col] = adjusted_df.iloc[idx][col] * (1 + effect_strength)
+
+    print("✅ 节后调整完成")
+    return adjusted_df
+
+
+# ==================== 价格合理性检查函数 ====================
+def validate_prediction_results(historical_df, prediction_df, max_price_change=0.3):
+    """
+    🎯 验证预测结果的合理性，避免异常价格波动
+    """
+    print("🔍 验证预测结果合理性...")
+
+    validated_df = prediction_df.copy()
+    current_price = historical_df['close'].iloc[-1]
+
+    # 检查价格列的合理性
+    price_columns = ['close', 'open', 'high', 'low']
+
+    for col in price_columns:
+        if col in validated_df.columns:
+            # 计算最大允许的价格变化范围
+            max_allowed_change = current_price * max_price_change
+
+            # 检查每个预测价格
+            for i in range(len(validated_df)):
+                predicted_price = validated_df[col].iloc[i]
+
+                # 如果预测价格超出合理范围，进行修正
+                if abs(predicted_price - current_price) > max_allowed_change:
+                    # 基于历史波动率进行修正
+                    correction_factor = 0.8 + 0.4 * np.random.random()
+                    corrected_price = current_price * (1 + (predicted_price / current_price - 1) * correction_factor)
+                    validated_df.iloc[i][col] = corrected_price
+
+                    print(f"⚠️  修正异常{col}价格: {predicted_price:.2f} -> {corrected_price:.2f}")
+
+    print("✅ 预测结果验证完成")
+    return validated_df
+
+
+# ==================== GUI版本预测函数 ====================
+def run_comprehensive_prediction_gui(stock_code, stock_name, data_dir, pred_days, output_dir, history_years=1,
+                                     progress_callback=None, result_callback=None):
+    """
+    GUI版本的预测函数
+    """
+
+    def update_progress(message):
+        if progress_callback:
+            progress_callback(message)
+        print(message)
+
+    def update_result(message):
+        if result_callback:
+            result_callback(message)
+        print(message)
+
+    try:
+        # 初始化市场分析器
+        market_analyzer = EnhancedMarketFactorAnalyzer()
+
+        update_progress(f"🎯 开始 {stock_name}({stock_code}) 预测流程")
+        update_progress("=" * 50)
+
+        # 1. 获取数据
+        update_progress("\n步骤1: 获取股票数据...")
+        success, csv_file_path = get_stock_data(stock_code, data_dir)
+        if not success:
+            update_result("❌ 无法获取股票数据，预测终止")
+            return False, "无法获取股票数据"
+
+        # 2. 加载模型和分词器
+        update_progress("\n步骤2: 加载Kronos模型和分词器...")
+        try:
+            tokenizer = KronosTokenizer.from_pretrained("NeoQuasar/Kronos-Tokenizer-base")
+            model = Kronos.from_pretrained("NeoQuasar/Kronos-base")
+            update_progress("✅ 模型加载完成 - 使用Kronos-base模型")
+        except Exception as e:
+            error_msg = f"❌ 模型加载失败: {e}"
+            update_result(error_msg)
+            update_progress("⚠️ 预测功能不可用，请检查模型安装")
+            return False, error_msg
+
+        # 3. 实例化预测器
+        update_progress("步骤3: 初始化预测器...")
+        predictor = KronosPredictor(model, tokenizer, device="cuda:0", max_context=512)
+        update_progress("✅ 预测器初始化完成")
+
+        # 4. 准备数据
+        update_progress("步骤4: 准备股票数据...")
+        df = prepare_stock_data(csv_file_path, stock_code, history_years)
+
+        # 5. 计算预测参数
+        update_progress("步骤5: 计算预测参数...")
+        lookback, pred_len = calculate_prediction_parameters(df, target_days=pred_days)
+
+        if pred_len <= 0:
+            update_result("❌ 数据量不足，无法进行预测")
+            return False, "数据量不足"
+
+        update_progress(f"✅ 最终参数 - 回看期: {lookback}, 预测期: {pred_len}")
+
+        # 6. 准备输入数据
+        update_progress("步骤6: 准备输入数据...")
+        x_df = df.loc[-lookback:, ['open', 'high', 'low', 'close', 'volume', 'amount']].reset_index(drop=True)
+        x_timestamp = df.loc[-lookback:, 'timestamps'].reset_index(drop=True)
+
+        # 生成未来日期 - 🎯 修复：只生成交易日
+        last_historical_date = df['timestamps'].iloc[-1]
+        future_dates = generate_trading_dates_only(last_historical_date, pred_len)
+
+        if len(future_dates) < pred_len:
+            update_progress(f"⚠️ 警告：只生成了 {len(future_dates)} 个交易日，少于请求的 {pred_len} 天")
+            pred_len = len(future_dates)
+
+        update_progress(f"输入数据形状: {x_df.shape}")
+        update_progress(f"历史数据时间范围: {x_timestamp.iloc[0]} 到 {x_timestamp.iloc[-1]}")
+        if future_dates:
+            update_progress(f"预测时间范围: {future_dates[0]} 到 {future_dates[-1]}")
+
+        # 7. 执行基础预测
+        update_progress("步骤7: 执行基础价格预测...")
+        pred_df = predictor.predict(
+            df=x_df,
+            x_timestamp=x_timestamp,
+            y_timestamp=pd.Series(future_dates),
+            pred_len=pred_len,
+            T=1.0,
+            top_p=0.9,
+            sample_count=1,
+            verbose=True
+        )
+
+        update_progress("✅ 基础预测完成")
+
+        # 🎯 新增：对基础预测进行合理性检查
+        update_progress("步骤7.2: 验证预测结果合理性...")
+        historical_df_for_validation = df.loc[-lookback:].reset_index(drop=True)
+        validated_pred_df = validate_prediction_results(historical_df_for_validation, pred_df)
+
+        # 🎯 新增：对基础预测进行平滑处理
+        update_progress("步骤7.5: 对预测结果进行平滑优化...")
+        smoothed_pred_df = smooth_prediction_results(validated_pred_df, historical_df_for_validation)
+
+        # 🎯 修复：应用节后调整（特别是国庆节后）
+        holiday_periods = [
+            {
+                'start': '2025-10-01',
+                'end': '2025-10-09',  # 国庆后第一个交易日（10月9日周四）
+                'adjustment_days': 5,
+                'effect_strength': 0.03  # 节后通常有正面效应
+            }
+        ]
+
+        adjusted_pred_df = apply_post_holiday_adjustment(smoothed_pred_df, future_dates, holiday_periods)
+
+        # 8. 使用多维度市场因素增强预测
+        update_progress("步骤8: 应用多维度市场因素增强预测...")
+        enhanced_pred_df, enhancement_info = enhance_prediction_with_market_factors(
+            df.loc[-lookback:].reset_index(drop=True),
+            adjusted_pred_df,  # 使用平滑调整后的预测结果
+            stock_code,
+            market_analyzer
+        )
+
+        # 将增强预测结果添加到信息中
+        enhancement_info['enhanced_prediction'] = enhanced_pred_df
+
+        # 9. 创建综合市场分析报告
+        update_progress("步骤9: 创建市场分析报告...")
+        market_report = create_comprehensive_market_report(enhancement_info, output_dir, stock_code)
+
+        # 10. 生成预测图表
+        update_progress("步骤10: 生成预测图表...")
+        historical_df = df.loc[-lookback:].reset_index(drop=True)
+        chart_path = plot_optimized_prediction_gui(
+            historical_df, adjusted_pred_df, enhanced_pred_df, future_dates,
+            stock_code, stock_name, output_dir, enhancement_info
+        )
+
+        # 11. 生成预测报告
+        update_progress("步骤11: 生成预测报告...")
+        if len(enhanced_pred_df) > 0:
+            current_price = historical_df['close'].iloc[-1]
+            base_predicted_price = adjusted_pred_df['close'].iloc[-1] if len(adjusted_pred_df) > 0 else current_price
+            enhanced_predicted_price = enhanced_pred_df['close'].iloc[-1]
+
+            base_change_pct = (base_predicted_price / current_price - 1) * 100
+            enhanced_change_pct = (enhanced_predicted_price / current_price - 1) * 100
+
+            # 输出预测结果
+            update_result(f"\n📈 {stock_name}({stock_code}) 预测报告")
+            update_result("=" * 50)
+            update_result(f"当前价格: {current_price:.2f} 元")
+            update_result(f"平滑预测价格: {base_predicted_price:.2f} 元 ({base_change_pct:+.2f}%)")
+            update_result(f"增强预测价格: {enhanced_predicted_price:.2f} 元 ({enhanced_change_pct:+.2f}%)")
+            update_result(f"市场因素调整因子: {enhancement_info['adjustment_factor']:.4f}")
+            update_result(f"大盘状态: {enhancement_info['market_analysis']['market_status']}")
+            update_result(f"板块共振: {enhancement_info['sector_analysis']['main_sector']['sector']}")
+            update_result(f"宏观环境: 美国{enhancement_info['macro_analysis']['us_rate_cycle']['trend']}")
+            update_result(f"公司评级: {enhancement_info['fundamental_analysis']['investment_rating']}")
+
+            # 保存详细预测数据
+            prediction_details = pd.DataFrame({
+                '日期': future_dates,
+                '平滑预测收盘价': adjusted_pred_df['close'].values if len(
+                    adjusted_pred_df) > 0 else [current_price] * len(future_dates),
+                '增强预测收盘价': enhanced_pred_df['close'].values,
+                '预测成交量': enhanced_pred_df['volume'].values
+            })
+
+            prediction_file = os.path.join(output_dir, f'{stock_code}_comprehensive_predictions.csv')
+            prediction_details.to_csv(prediction_file, index=False, encoding='utf-8-sig')
+            update_progress(f"💾 详细预测数据已保存: {prediction_file}")
+
+        update_progress(f"\n🎉 {stock_name}({stock_code}) 预测完成!")
+        update_progress(f"📊 预测图表: {chart_path}")
+
+        return True, "预测完成"
+
+    except Exception as e:
+        error_msg = f"❌ 预测过程中出现错误: {e}"
+        update_result(error_msg)
+        import traceback
+        traceback.print_exc()
+        return False, error_msg
+
+
+def enhance_prediction_with_market_factors(historical_df, prediction_df, stock_code, market_analyzer):
+    """
+    使用市场因素增强预测结果
+    """
+    print("\n🎯 使用市场因素增强预测...")
+
+    # 获取各类市场分析
+    market_analysis = market_analyzer.analyze_market_trend()
+    sector_analysis = market_analyzer.analyze_sector_resonance(stock_code)
+    macro_analysis = market_analyzer.analyze_macro_factors()
+    fundamental_analysis = market_analyzer.analyze_company_fundamentals(stock_code)
+
+    # 计算综合调整因子
+    adjustment_factor = calculate_enhanced_adjustment_factor(
+        market_analysis, sector_analysis, macro_analysis, fundamental_analysis
+    )
+
+    print(f"📈 综合调整因子: {adjustment_factor:.4f}")
+
+    # 应用调整到预测结果
+    enhanced_prediction = prediction_df.copy()
+
+    # 对价格预测进行调整
+    price_columns = ['close', 'open', 'high', 'low']
+    for col in price_columns:
+        if col in enhanced_prediction.columns:
+            enhanced_prediction[col] = enhanced_prediction[col] * adjustment_factor
+
+    # 对成交量进行调整
+    if 'volume' in enhanced_prediction.columns:
+        volume_adjustment = 1 + (adjustment_factor - 1) * 0.3
+        enhanced_prediction['volume'] = enhanced_prediction['volume'] * volume_adjustment
+
+    return enhanced_prediction, {
+        'market_analysis': market_analysis,
+        'sector_analysis': sector_analysis,
+        'macro_analysis': macro_analysis,
+        'fundamental_analysis': fundamental_analysis,
+        'adjustment_factor': adjustment_factor
+    }
+
+
+def calculate_enhanced_adjustment_factor(market_analysis, sector_analysis, macro_analysis, fundamental_analysis):
+    """
+    计算基于多维度市场因素的调整因子
+    """
+    base_factor = 1.0
+
+    # 1. 大盘趋势影响 (权���25%)
+    if market_analysis['overall_is_main_uptrend']:
+        trend_strength = market_analysis['overall_trend_strength']
+        base_factor *= (1 + trend_strength * 0.08)
+    else:
+        trend_strength = market_analysis['overall_trend_strength']
+        base_factor *= (1 + (trend_strength - 0.5) * 0.04)
+
+    # 2. 板块共振影响 (权重25%)
+    resonance_score = sector_analysis['resonance_score']
+    sector_count = sector_analysis['sector_count']
+
+    if sector_analysis['is_sector_hot']:
+        base_factor *= (1 + resonance_score * 0.06 + min(sector_count * 0.01, 0.03))
+    else:
+        base_factor *= (1 + (resonance_score - 0.5) * 0.02)
+
+    # 3. 宏观因素影响 (权重20%)
+    macro_score = macro_analysis['overall_macro_score']
+    base_factor *= (1 + (macro_score - 0.5) * 0.06)
+
+    # 4. 美国降息周期特殊影响 (权重10%)
+    us_rate_trend = macro_analysis['us_rate_cycle']['trend']
+    if us_rate_trend == '降息周期':
+        expected_cuts = macro_analysis['us_rate_cycle']['expected_cuts_2025']
+        base_factor *= (1 + expected_cuts * 0.015)
+
+    # 5. 公司基本面影响 (权重20%)
+    fundamental_score = fundamental_analysis['fundamental_score']
+    base_factor *= (1 + (fundamental_score - 0.5) * 0.08)
+
+    # 🎯 限制调整幅度在更合理范围内 (0.9 ~ 1.1)，避免过度调整
+    return max(0.9, min(1.1, base_factor))
+
+
+def create_comprehensive_market_report(enhancement_info, output_dir, stock_code):
+    """
+    创建综合市场分析报告
+    """
+    report = {
+        'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+        'stock_code': stock_code,
+        'market_analysis': enhancement_info['market_analysis'],
+        'sector_analysis': enhancement_info['sector_analysis'],
+        'macro_analysis': enhancement_info['macro_analysis'],
+        'fundamental_analysis': enhancement_info['fundamental_analysis'],
+        'adjustment_factor': enhancement_info['adjustment_factor']
+    }
+
+    # 保存报告
+    report_file = os.path.join(output_dir, f'{stock_code}_comprehensive_analysis_report.json')
+    with open(report_file, 'w', encoding='utf-8') as f:
+        json.dump(report, f, ensure_ascii=False, indent=2)
+
+    print(f"📋 综合分析报告已保存: {report_file}")
+    return report
+
+
+def plot_optimized_prediction_gui(historical_df, base_pred_df, enhanced_pred_df, future_trading_dates,
+                                  stock_code, stock_name, output_dir, enhancement_info=None):
+    """
+    🎯 优化版：清晰显示每个交易日的预测图表
+    """
+    ensure_output_directory(output_dir)
+
+    # 设置配色
+    colors = {
+        'historical': '#1f77b4',
+        'prediction': '#ff7f0e',
+        'enhanced': '#2ca02c',
+        'background': '#f8f9fa',
+        'grid': '#e9ecef'
+    }
+
+    # 创建图表
+    fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(16, 12))
+    fig.suptitle(f'{stock_name}({stock_code}) - 优化版交易日预测图表', fontsize=16, fontweight='bold')
+
+    # 设置背景色
+    fig.patch.set_facecolor('white')
+    for ax in [ax1, ax2, ax3, ax4]:
+        ax.set_facecolor(colors['background'])
+
+    # 🎯 优化1: 使用实际日期作为x轴，但只显示交易日
+    all_dates = list(historical_df['timestamps']) + future_trading_dates
+
+    # 1. 主价格图表
+    current_price = historical_df['close'].iloc[-1]
+
+    # 绘制历史价格
+    ax1.plot(historical_df['timestamps'], historical_df['close'],
+             color=colors['historical'], linewidth=2.5, label='历史价格')
+
+    # 绘制预测价格
+    if len(future_trading_dates) > 0:
+        # 绘制基础预测
+        ax1.plot(future_trading_dates, base_pred_df['close'],
+                 color=colors['prediction'], linewidth=2, label='平滑预测', linestyle='--')
+
+        # 绘制增强预测
+        ax1.plot(future_trading_dates, enhanced_pred_df['close'],
+                 color=colors['enhanced'], linewidth=2.5, label='增强预测')
+
+        # 🎯 修复：使用更安全的关键日期标记
+        mark_key_dates_safe(ax1, future_trading_dates, enhanced_pred_df)
+
+    ax1.set_ylabel('收盘价 (元)', fontsize=12, fontweight='bold')
+    ax1.legend(loc='upper left', fontsize=10)
+    ax1.grid(True, color=colors['grid'], alpha=0.7)
+    ax1.set_title(f'价格走势预测 - 当前价: {current_price:.2f}元', fontweight='bold', fontsize=13)
+
+    # 🎯 优化2: 使用每周标记，避免过于密集
+    ax1.xaxis.set_major_formatter(mdates.DateFormatter('%m-%d'))
+    ax1.xaxis.set_major_locator(mdates.WeekdayLocator(byweekday=mdates.MO, interval=2))  # 每两周一个标记
+    plt.setp(ax1.xaxis.get_majorticklabels(), rotation=45, fontsize=9)
+
+    # 2. 成交量图表
+    ax2.bar(historical_df['timestamps'], historical_df['volume'],
+            alpha=0.6, color=colors['historical'], label='历史成交量')
+
+    if len(future_trading_dates) > 0:
+        ax2.bar(future_trading_dates, enhanced_pred_df['volume'],
+                alpha=0.6, color=colors['enhanced'], label='预测成交量')
+
+    ax2.set_ylabel('成交量', fontsize=12, fontweight='bold')
+    ax2.legend(loc='upper left', fontsize=10)
+    ax2.grid(True, color=colors['grid'], alpha=0.7)
+    ax2.set_title('成交量预测', fontweight='bold', fontsize=13)
+    ax2.xaxis.set_major_formatter(mdates.DateFormatter('%m-%d'))
+    ax2.xaxis.set_major_locator(mdates.WeekdayLocator(byweekday=mdates.MO, interval=2))
+    plt.setp(ax2.xaxis.get_majorticklabels(), rotation=45, fontsize=9)
+
+    # 3. 价格变化率图表
+    ax3.plot(historical_df['timestamps'], historical_df['close'].pct_change() * 100,
+             color=colors['historical'], linewidth=1.5, label='历史涨跌幅', alpha=0.7)
+
+    if len(future_trading_dates) > 0:
+        pred_returns = enhanced_pred_df['close'].pct_change() * 100
+        ax3.plot(future_trading_dates, pred_returns,
+                 color=colors['enhanced'], linewidth=2, label='预测涨跌幅')
+
+        # 添加零线参考
+        ax3.axhline(y=0, color='red', linestyle='-', alpha=0.3, linewidth=1)
+
+    ax3.set_ylabel('日涨跌幅 (%)', fontsize=12, fontweight='bold')
+    ax3.legend(loc='upper left', fontsize=10)
+    ax3.grid(True, color=colors['grid'], alpha=0.7)
+    ax3.set_title('价格变化率分析', fontweight='bold', fontsize=13)
+    ax3.xaxis.set_major_formatter(mdates.DateFormatter('%m-%d'))
+    ax3.xaxis.set_major_locator(mdates.WeekdayLocator(byweekday=mdates.MO, interval=2))
+    plt.setp(ax3.xaxis.get_majorticklabels(), rotation=45, fontsize=9)
+
+    # 4. 市场因素分析
+    if enhancement_info:
+        factors = ['大盘趋势', '板块共振', '宏观环境', '美国降息', '基本面']
+        scores = [
+            enhancement_info['market_analysis']['overall_trend_strength'],
+            enhancement_info['sector_analysis']['resonance_score'],
+            enhancement_info['macro_analysis']['overall_macro_score'],
+            0.7 if enhancement_info['macro_analysis']['us_rate_cycle']['trend'] == '降息周期' else 0.3,
+            enhancement_info['fundamental_analysis']['fundamental_score']
+        ]
+
+        colors_bars = [colors['historical'], colors['prediction'], colors['enhanced'], '#f39c12', '#9b59b6']
+
+        bars = ax4.bar(factors, scores, color=colors_bars, alpha=0.8, edgecolor='black', linewidth=1)
+        ax4.set_ylim(0, 1)
+        ax4.set_ylabel('评分', fontsize=12, fontweight='bold')
+        ax4.set_title('市场因素评分分析', fontweight='bold', fontsize=13)
+        ax4.grid(True, alpha=0.3, axis='y')
+
+        # 在柱状图上显示具体数值
+        for i, (bar, score) in enumerate(zip(bars, scores)):
+            height = bar.get_height()
+            ax4.text(bar.get_x() + bar.get_width() / 2., height + 0.02,
+                     f'{score:.2f}', ha='center', va='bottom', fontsize=10, fontweight='bold')
+
+        # 添加平均线
+        avg_score = np.mean(scores)
+        ax4.axhline(y=avg_score, color='red', linestyle='--', alpha=0.7,
+                    label=f'平均分: {avg_score:.2f}')
+        ax4.legend(loc='upper right', fontsize=9)
+
+    plt.tight_layout()
+
+    # 保存图片
+    chart_filename = os.path.join(output_dir, f'{stock_code}_optimized_prediction.png')
+    plt.savefig(chart_filename, dpi=300, bbox_inches='tight', facecolor='white')
+    plt.close()
+
+    print(f"📊 优化版预测图表已保存: {chart_filename}")
+    return chart_filename
+
+
+def mark_key_dates_safe(ax, future_dates, pred_df):
+    """
+    🎯 安全版：标记关键日期和价格点，避免类型错误
+    """
+    if len(future_dates) == 0 or len(pred_df) == 0:
+        return
+
+    try:
+        # 重置索引确保使用整数索引
+        pred_df_reset = pred_df.reset_index(drop=True)
+
+        # 获取最高点和最低点的整数索引
+        if hasattr(pred_df_reset['close'], 'idxmax'):
+            max_idx = pred_df_reset['close'].idxmax()
+            min_idx = pred_df_reset['close'].idxmin()
+        else:
+            # 备用方法
+            max_idx = np.argmax(pred_df_reset['close'].values)
+            min_idx = np.argmin(pred_df_reset['close'].values)
+
+        # 确保索引在有效范围内
+        max_idx = min(int(max_idx), len(future_dates) - 1)
+        min_idx = min(int(min_idx), len(future_dates) - 1)
+
+        # 标记最高点
+        if 0 <= max_idx < len(future_dates):
+            max_price = pred_df_reset['close'].iloc[max_idx]
+            ax.plot(future_dates[max_idx], max_price,
+                    'v', color='red', markersize=8, label=f'最高点: {max_price:.2f}')
+
+        # 标记最低点
+        if 0 <= min_idx < len(future_dates):
+            min_price = pred_df_reset['close'].iloc[min_idx]
+            ax.plot(future_dates[min_idx], min_price,
+                    '^', color='green', markersize=8, label=f'最低点: {min_price:.2f}')
+
+        # 标记预测结束点
+        if len(future_dates) > 0:
+            final_price = pred_df_reset['close'].iloc[-1]
+            ax.plot(future_dates[-1], final_price,
+                    's', color='blue', markersize=6, label=f'最终预测: {final_price:.2f}')
+
+    except Exception as e:
+        print(f"⚠️ 标记关键日期时出现错误: {e}")
+        # 如果出错，跳过标记但不影响整体流程
+
+
+# ==================== 主函数 ====================
+def main():
+    """主函数：启动GUI界面"""
+    root = tk.Tk()
+    app = StockPredictorGUI(root)
+    root.mainloop()
+
+
+if __name__ == "__main__":
+    main()

Kronos/examples/prediction_wo_vol_example.py

@@ -0,0 +1,68 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+import sys
+sys.path.append("../")
+from model import Kronos, KronosTokenizer, KronosPredictor
+
+
+def plot_prediction(kline_df, pred_df):
+    pred_df.index = kline_df.index[-pred_df.shape[0]:]
+    sr_close = kline_df['close']
+    sr_pred_close = pred_df['close']
+    sr_close.name = 'Ground Truth'
+    sr_pred_close.name = "Prediction"
+
+    close_df = pd.concat([sr_close, sr_pred_close], axis=1)
+
+    fig, ax = plt.subplots(1, 1, figsize=(8, 4))
+
+    ax.plot(close_df['Ground Truth'], label='Ground Truth', color='blue', linewidth=1.5)
+    ax.plot(close_df['Prediction'], label='Prediction', color='red', linewidth=1.5)
+    ax.set_ylabel('Close Price', fontsize=14)
+    ax.legend(loc='lower left', fontsize=12)
+    ax.grid(True)
+
+    plt.tight_layout()
+    plt.show()
+
+
+# 1. Load Model and Tokenizer
+tokenizer = KronosTokenizer.from_pretrained("NeoQuasar/Kronos-Tokenizer-base")
+model = Kronos.from_pretrained("NeoQuasar/Kronos-small")
+
+# 2. Instantiate Predictor
+predictor = KronosPredictor(model, tokenizer, device="cuda:0", max_context=512)
+
+# 3. Prepare Data
+df = pd.read_csv("./data/XSHG_5min_600977.csv")
+df['timestamps'] = pd.to_datetime(df['timestamps'])
+
+lookback = 400
+pred_len = 120
+
+x_df = df.loc[:lookback-1, ['open', 'high', 'low', 'close']]
+x_timestamp = df.loc[:lookback-1, 'timestamps']
+y_timestamp = df.loc[lookback:lookback+pred_len-1, 'timestamps']
+
+# 4. Make Prediction
+pred_df = predictor.predict(
+    df=x_df,
+    x_timestamp=x_timestamp,
+    y_timestamp=y_timestamp,
+    pred_len=pred_len,
+    T=1.0,
+    top_p=0.9,
+    sample_count=1,
+    verbose=True
+)
+
+# 5. Visualize Results
+print("Forecasted Data Head:")
+print(pred_df.head())
+
+# Combine historical and forecasted data for plotting
+kline_df = df.loc[:lookback+pred_len-1]
+
+# visualize
+plot_prediction(kline_df, pred_df)
+

Kronos/examples/run_backtest_kronos.py

@@ -0,0 +1,455 @@
+# run_backtest.py
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import os
+from datetime import datetime, timedelta
+import warnings
+
+warnings.filterwarnings('ignore')
+
+# 设置中文字体
+plt.rcParams['font.sans-serif'] = ['SimHei']
+plt.rcParams['axes.unicode_minus'] = False
+
+
+class KronosBacktester:
+    """
+    Kronos模型回测类
+    """
+
+    def __init__(self, data_dir, model_dir, initial_capital=100000):
+        """
+        初始化回测器
+
+        参数:
+        data_dir: 数据目录
+        model_dir: 模型预测结果目录
+        initial_capital: 初始资金
+        """
+        self.data_dir = data_dir
+        self.model_dir = model_dir
+        self.initial_capital = initial_capital
+        self.results = {}
+
+    def load_historical_data(self, stock_code):
+        """
+        加载历史数据
+        """
+        csv_file = os.path.join(self.data_dir, f"{stock_code}_stock_data.csv")
+        if not os.path.exists(csv_file):
+            raise FileNotFoundError(f"数据文件不存在: {csv_file}")
+
+        df = pd.read_csv(csv_file, encoding='utf-8-sig')
+
+        # 检查列名并标准化
+        column_mapping = {
+            '日期': 'date',
+            '开盘价': 'open',
+            '最高价': 'high',
+            '最低价': 'low',
+            '收盘价': 'close',
+            '成交量': 'volume',
+            '成交额': 'amount'
+        }
+
+        # 重命名列
+        for old_col, new_col in column_mapping.items():
+            if old_col in df.columns:
+                df = df.rename(columns={old_col: new_col})
+
+        df['date'] = pd.to_datetime(df['date'])
+        df.set_index('date', inplace=True)
+        df = df.sort_index()
+
+        print(f"✅ 加载历史数据: {len(df)} 条记录")
+        print(f"时间范围: {df.index.min()} 到 {df.index.max()}")
+
+        return df
+
+    def load_predictions(self, stock_code):
+        """
+        加载模型预测结果
+        """
+        # 尝试不同的预测文件命名
+        pred_files = [
+            os.path.join(self.model_dir, f"{stock_code}_kronos_predictions.csv"),
+            os.path.join(self.model_dir, f"{stock_code}_detailed_predictions.csv"),
+            os.path.join(self.model_dir, f"{stock_code}_predictions.csv")
+        ]
+
+        pred_df = None
+        for pred_file in pred_files:
+            if os.path.exists(pred_file):
+                pred_df = pd.read_csv(pred_file, encoding='utf-8-sig')
+                print(f"✅ 找到预测文件: {pred_file}")
+                break
+
+        if pred_df is None:
+            raise FileNotFoundError(f"未找到预测文件，请检查目录: {self.model_dir}")
+
+        # 标准化列名
+        column_mapping = {
+            '日期': 'date',
+            '预测收盘价': 'predicted_close',
+            '收盘价': 'predicted_close',
+            '预测成交量': 'predicted_volume',
+            '成交量': 'predicted_volume'
+        }
+
+        for old_col, new_col in column_mapping.items():
+            if old_col in pred_df.columns:
+                pred_df = pred_df.rename(columns={old_col: new_col})
+
+        pred_df['date'] = pd.to_datetime(pred_df['date'])
+        pred_df.set_index('date', inplace=True)
+        pred_df = pred_df.sort_index()
+
+        print(f"✅ 加载预测数据: {len(pred_df)} 条记录")
+        print(f"预测时间范围: {pred_df.index.min()} 到 {pred_df.index.max()}")
+
+        return pred_df
+
+    def align_data(self, hist_df, pred_df):
+        """
+        对齐历史数据和预测数据的时间范围
+        """
+        # 找到历史数据的最后日期
+        last_hist_date = hist_df.index.max()
+
+        # 筛选预测数据，从历史数据结束后开始
+        pred_df_aligned = pred_df[pred_df.index > last_hist_date]
+
+        if len(pred_df_aligned) == 0:
+            # 如果没有未来的预测数据，使用所有预测数据
+            pred_df_aligned = pred_df.copy()
+            print("⚠️ 警告：预测数据没有未来的日期，使用所有预测数据")
+
+        print(f"✅ 数据对齐: 历史数据结束于 {last_hist_date}, 预测数据从 {pred_df_aligned.index.min()} 开始")
+
+        return pred_df_aligned
+
+    def calculate_trading_signals(self, hist_df, pred_df, threshold=0.02):
+        """
+        计算交易信号
+        """
+        # 对齐数据
+        pred_df = self.align_data(hist_df, pred_df)
+
+        # 合并历史数据和预测数据
+        combined = pd.concat([
+            hist_df[['close']].rename(columns={'close': 'actual'}),
+            pred_df[['predicted_close']].rename(columns={'predicted_close': 'predicted'})
+        ], axis=1)
+
+        # 计算预测收益率
+        combined['pred_return'] = combined['predicted'].pct_change()
+
+        # 生成交易信号
+        combined['signal'] = 0
+        combined['signal'] = np.where(combined['pred_return'] > threshold, 1,  # 买入信号
+                                      np.where(combined['pred_return'] < -threshold, -1, 0))  # 卖出信号
+
+        # 过滤信号：避免频繁交易
+        combined['position'] = combined['signal'].replace(to_replace=0, method='ffill').fillna(0)
+
+        return combined
+
+    def run_backtest(self, combined_df):
+        """
+        运行回测
+        """
+        # 初始化资金和持仓
+        capital = self.initial_capital
+        position = 0
+        trades = []
+
+        # 回测记录
+        backtest_results = pd.DataFrame(index=combined_df.index)
+        backtest_results['capital'] = capital
+        backtest_results['position'] = 0
+        backtest_results['returns'] = 0.0
+        backtest_results['price'] = combined_df['actual'].combine_first(combined_df['predicted'])
+
+        for i, (date, row) in enumerate(combined_df.iterrows()):
+            current_price = row['actual'] if not pd.isna(row['actual']) else row['predicted']
+            signal = row['position']
+
+            # 跳过无效价格
+            if pd.isna(current_price):
+                continue
+
+            # 执行交易
+            if i > 0:  # 从第二天开始
+                prev_position = backtest_results['position'].iloc[i - 1] if i > 0 else 0
+
+                # 平仓信号
+                if prev_position != 0 and signal == 0:
+                    # 平仓
+                    capital = position * current_price
+                    position = 0
+                    trades.append({
+                        'date': date,
+                        'action': 'SELL',
+                        'price': current_price,
+                        'shares': prev_position,
+                        'capital': capital
+                    })
+
+                # 开仓信号
+                elif prev_position == 0 and signal != 0:
+                    # 计算可买股数（假设全仓交易）
+                    shares = int(capital / current_price)
+                    if shares > 0:
+                        position = shares * signal
+                        capital -= shares * current_price
+                        trades.append({
+                            'date': date,
+                            'action': 'BUY',
+                            'price': current_price,
+                            'shares': shares * signal,
+                            'capital': capital
+                        })
+
+            # 更新持仓市值
+            portfolio_value = capital + position * current_price
+
+            # 记录结果
+            backtest_results.loc[date, 'capital'] = portfolio_value
+            backtest_results.loc[date, 'position'] = position
+            backtest_results.loc[date, 'price'] = current_price
+
+            # 计算日收益率
+            if i > 0:
+                prev_value = backtest_results['capital'].iloc[i - 1]
+                if prev_value > 0:
+                    backtest_results.loc[date, 'returns'] = (portfolio_value - prev_value) / prev_value
+
+        return backtest_results, trades
+
+    def calculate_metrics(self, backtest_results, trades):
+        """
+        计算回测指标
+        """
+        returns = backtest_results['returns'].replace([np.inf, -np.inf], np.nan).dropna()
+
+        if len(returns) == 0:
+            return {
+                '总收益率': 0,
+                '年化收益率': 0,
+                '波动率': 0,
+                '夏普比率': 0,
+                '最大回撤': 0,
+                '胜率': 0,
+                '平均交易收益': 0,
+                '交易次数': 0,
+                '最终资金': self.initial_capital
+            }
+
+        total_return = (backtest_results['capital'].iloc[-1] - self.initial_capital) / self.initial_capital
+        annual_return = (1 + total_return) ** (252 / len(returns)) - 1
+
+        # 波动率
+        volatility = returns.std() * np.sqrt(252)
+
+        # 夏普比率（假设无风险利率为3%）
+        risk_free_rate = 0.03
+        sharpe_ratio = (annual_return - risk_free_rate) / volatility if volatility > 0 else 0
+
+        # 最大回撤
+        cumulative_returns = (1 + returns).cumprod()
+        peak = cumulative_returns.expanding().max()
+        drawdown = (cumulative_returns - peak) / peak
+        max_drawdown = drawdown.min()
+
+        # 交易统计
+        trade_returns = []
+        buy_trades = [t for t in trades if t['action'] == 'BUY']
+        sell_trades = [t for t in trades if t['action'] == 'SELL']
+
+        for i in range(min(len(buy_trades), len(sell_trades))):
+            buy = buy_trades[i]
+            sell = sell_trades[i]
+            trade_return = (sell['price'] - buy['price']) / buy['price']
+            trade_returns.append(trade_return)
+
+        win_rate = len([r for r in trade_returns if r > 0]) / len(trade_returns) if trade_returns else 0
+        avg_trade_return = np.mean(trade_returns) if trade_returns else 0
+
+        metrics = {
+            '总收益率': total_return,
+            '年化收益率': annual_return,
+            '波动率': volatility,
+            '夏普比率': sharpe_ratio,
+            '最大回撤': max_drawdown,
+            '胜率': win_rate,
+            '平均交易收益': avg_trade_return,
+            '交易次数': len(trades),
+            '最终资金': backtest_results['capital'].iloc[-1]
+        }
+
+        return metrics
+
+    def plot_backtest_results(self, backtest_results, metrics, stock_code, output_dir):
+        """
+        绘制回测结果图表
+        """
+        fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(15, 12))
+
+        # 1. 资金曲线
+        ax1.plot(backtest_results.index, backtest_results['capital'],
+                 linewidth=2, label='策略资金曲线', color='#1f77b4')
+        ax1.axhline(y=self.initial_capital, color='red', linestyle='--',
+                    label=f'初始资金 ({self.initial_capital:,.0f}元)')
+        ax1.set_ylabel('资金 (元)', fontsize=12)
+        ax1.legend()
+        ax1.grid(True, alpha=0.3)
+        ax1.set_title(f'{stock_code} Kronos模型回测结果', fontsize=14, fontweight='bold')
+
+        # 2. 收益率曲线
+        cumulative_returns = (1 + backtest_results['returns'].fillna(0)).cumprod()
+        ax2.plot(backtest_results.index, cumulative_returns,
+                 linewidth=2, label='策略累计收益', color='#2ca02c')
+
+        # 基准收益（买入持有）
+        price_returns = backtest_results['price'].pct_change().fillna(0)
+        benchmark_returns = (1 + price_returns).cumprod()
+        ax2.plot(backtest_results.index, benchmark_returns,
+                 linewidth=2, label='基准收益（买入持有）', color='#ff7f0e', alpha=0.7)
+
+        ax2.set_ylabel('累计收益', fontsize=12)
+        ax2.legend()
+        ax2.grid(True, alpha=0.3)
+
+        # 3. 回撤曲线
+        peak = cumulative_returns.expanding().max()
+        drawdown = (cumulative_returns - peak) / peak
+        ax3.fill_between(backtest_results.index, drawdown, 0,
+                         alpha=0.3, color='red', label='回撤')
+        ax3.set_ylabel('回撤', fontsize=12)
+        ax3.set_xlabel('日期', fontsize=12)
+        ax3.legend()
+        ax3.grid(True, alpha=0.3)
+
+        # 添加指标文本
+        metrics_text = (
+            f"总收益率: {metrics['总收益率']:.2%}\n"
+            f"年化收益率: {metrics['年化收益率']:.2%}\n"
+            f"夏普比率: {metrics['夏普比率']:.2f}\n"
+            f"最大回撤: {metrics['最大回撤']:.2%}\n"
+            f"胜率: {metrics['胜率']:.2%}\n"
+            f"交易次数: {metrics['交易次数']}\n"
+            f"最终资金: {metrics['最终资金']:,.0f}元"
+        )
+
+        ax1.text(0.02, 0.98, metrics_text, transform=ax1.transAxes, fontsize=10,
+                 verticalalignment='top', bbox=dict(boxstyle="round,pad=0.3",
+                                                    facecolor="lightyellow", alpha=0.8))
+
+        plt.tight_layout()
+
+        # 保存图表
+        os.makedirs(output_dir, exist_ok=True)
+        chart_file = os.path.join(output_dir, f'{stock_code}_backtest_results.png')
+        plt.savefig(chart_file, dpi=300, bbox_inches='tight')
+        print(f"📊 回测图表已保存: {chart_file}")
+
+        plt.show()
+
+    def run_complete_backtest(self, stock_code, output_dir, threshold=0.02):
+        """
+        运行完整的回测流程
+        """
+        print(f"🎯 开始 {stock_code} 回测分析")
+        print("=" * 50)
+
+        try:
+            # 1. 加载数据
+            print("步骤1: 加载历史数据和预测数据...")
+            hist_df = self.load_historical_data(stock_code)
+            pred_df = self.load_predictions(stock_code)
+
+            # 2. 计算交易信号
+            print("步骤2: 计算交易信号...")
+            combined_df = self.calculate_trading_signals(hist_df, pred_df, threshold)
+
+            # 3. 运行回测
+            print("步骤3: 运行回测...")
+            backtest_results, trades = self.run_backtest(combined_df)
+
+            # 4. 计算指标
+            print("步骤4: 计算回测指标...")
+            metrics = self.calculate_metrics(backtest_results, trades)
+
+            # 5. 绘制结果
+            print("步骤5: 生成回测图表...")
+            self.plot_backtest_results(backtest_results, metrics, stock_code, output_dir)
+
+            # 6. 打印详细报告
+            print("\n" + "=" * 70)
+            print(f"📊 {stock_code} 回测报告")
+            print("=" * 70)
+            for key, value in metrics.items():
+                if isinstance(value, float):
+                    if '率' in key or '收益' in key or '回撤' in key:
+                        print(f"  {key}: {value:.2%}")
+                    else:
+                        print(f"  {key}: {value:.2f}")
+                else:
+                    print(f"  {key}: {value}")
+
+            print(f"\n交易记录 (共{len(trades)}次交易):")
+            for i, trade in enumerate(trades[-10:], 1):  # 显示最后10次交易
+                print(f"  交易{i}: {trade['date'].strftime('%Y-%m-%d')} "
+                      f"{trade['action']} {abs(trade['shares'])}股 @ {trade['price']:.2f}元")
+
+            return metrics, backtest_results, trades
+
+        except Exception as e:
+            print(f"❌ 回测过程中出现错误: {e}")
+            import traceback
+            traceback.print_exc()
+            return None, None, None
+
+
+def main():
+    """
+    主函数：运行Kronos模型回测
+    """
+    # 配置参数
+    BACKTEST_CONFIG = {
+        "stock_code": "000831",  # 要回测的股票代码
+        "data_dir": r"D:\lianghuajiaoyi\Kronos\examples\data",  # 历史数据目录
+        "model_dir": r"D:\lianghuajiaoyi\Kronos\examples\yuce",  # 模型预测结果目录
+        "output_dir": r"D:\lianghuajiaoyi\Kronos\examples\backtest",  # 回测结果输出目录
+        "initial_capital": 100000,  # 初始资金
+        "threshold": 0.02  # 交易阈值（2%）
+    }
+
+    print("🤖 Kronos模型回测系统")
+    print("=" * 50)
+    print(f"回测股票: {BACKTEST_CONFIG['stock_code']}")
+    print(f"初始资金: {BACKTEST_CONFIG['initial_capital']:,.0f}元")
+    print(f"交易阈值: {BACKTEST_CONFIG['threshold']:.1%}")
+    print()
+
+    # 创建回测器并运行
+    backtester = KronosBacktester(
+        data_dir=BACKTEST_CONFIG["data_dir"],
+        model_dir=BACKTEST_CONFIG["model_dir"],
+        initial_capital=BACKTEST_CONFIG["initial_capital"]
+    )
+
+    metrics, results, trades = backtester.run_complete_backtest(
+        stock_code=BACKTEST_CONFIG["stock_code"],
+        output_dir=BACKTEST_CONFIG["output_dir"],
+        threshold=BACKTEST_CONFIG["threshold"]
+    )
+
+    if metrics:
+        print(f"\n✅ {BACKTEST_CONFIG['stock_code']} 回测完成!")
+        print(f"📁 结果保存在: {BACKTEST_CONFIG['output_dir']}")
+
+
+if __name__ == "__main__":
+    main()

Kronos/examples/yuce/000021_comprehensive_analysis_report.json

@@ -0,0 +1,60 @@
+{
+  "timestamp": "2025-10-10 16:09:38",
+  "stock_code": "000021",
+  "market_analysis": {
+    "overall_is_main_uptrend": false,
+    "overall_trend_strength": 0.5,
+    "market_status": "未知",
+    "detailed_analysis": {}
+  },
+  "sector_analysis": {
+    "industry": "消费电子",
+    "matched_sectors": [],
+    "main_sector": {
+      "sector": "传统行业",
+      "momentum": 0.5,
+      "description": "无热门概念"
+    },
+    "is_sector_hot": false,
+    "resonance_score": 0.5,
+    "sector_count": 0
+  },
+  "macro_analysis": {
+    "us_rate_cycle": {
+      "current_rate": 4.25,
+      "trend": "降息周期",
+      "recent_cut": "2025年9月降息25个基点",
+      "expected_cuts_2025": 2,
+      "expected_cuts_2026": 2,
+      "impact_on_emerging_markets": "positive",
+      "usd_index_support": 95.0,
+      "analysis": "美联储开启宽松周期，利好全球流动性"
+    },
+    "domestic_policy": {
+      "monetary_policy": "稳健偏松",
+      "fiscal_policy": "积极财政",
+      "market_liquidity": "合理充裕",
+      "industrial_policy": "设备更新、以旧换新",
+      "employment_policy": "稳就业政策加力",
+      "analysis": "政策组合拳发力，经济稳中向好"
+    },
+    "industry_policy": {
+      "robot_policy": "机器人产业政策支持",
+      "chip_policy": "国产替代加速推进",
+      "AI_policy": "人工智能发展规划",
+      "low_altitude": "低空经济发展规划"
+    },
+    "global_liquidity_outlook": "改善",
+    "overall_macro_score": 0.75
+  },
+  "fundamental_analysis": {
+    "company_name": "未知",
+    "business_areas": [],
+    "recent_developments": [],
+    "growth_drivers": [],
+    "risk_factors": [],
+    "investment_rating": "中性",
+    "fundamental_score": 0.5
+  },
+  "adjustment_factor": 1.04545
+}

Kronos/examples/yuce/002354_comprehensive_analysis_report.json

@@ -0,0 +1,60 @@
+{
+  "timestamp": "2025-10-01 01:55:50",
+  "stock_code": "002354",
+  "market_analysis": {
+    "overall_is_main_uptrend": false,
+    "overall_trend_strength": 0.5,
+    "market_status": "未知",
+    "detailed_analysis": {}
+  },
+  "sector_analysis": {
+    "industry": "互联网服务",
+    "matched_sectors": [],
+    "main_sector": {
+      "sector": "传统行业",
+      "momentum": 0.5,
+      "description": "无热门概念"
+    },
+    "is_sector_hot": false,
+    "resonance_score": 0.5,
+    "sector_count": 0
+  },
+  "macro_analysis": {
+    "us_rate_cycle": {
+      "current_rate": 4.25,
+      "trend": "降息周期",
+      "recent_cut": "2025年9月降息25个基点",
+      "expected_cuts_2025": 2,
+      "expected_cuts_2026": 2,
+      "impact_on_emerging_markets": "positive",
+      "usd_index_support": 95.0,
+      "analysis": "美联储开启宽松周期，利好全球流动性"
+    },
+    "domestic_policy": {
+      "monetary_policy": "稳健偏松",
+      "fiscal_policy": "积极财政",
+      "market_liquidity": "合理充裕",
+      "industrial_policy": "设备更新、以旧换新",
+      "employment_policy": "稳就业政策加力",
+      "analysis": "政策组合拳发力，经济稳中向好"
+    },
+    "industry_policy": {
+      "robot_policy": "机器人产业政策支持",
+      "chip_policy": "国产替代加速推进",
+      "AI_policy": "人工智能发展规划",
+      "low_altitude": "低空经济发展规划"
+    },
+    "global_liquidity_outlook": "改善",
+    "overall_macro_score": 0.75
+  },
+  "fundamental_analysis": {
+    "company_name": "未知",
+    "business_areas": [],
+    "recent_developments": [],
+    "growth_drivers": [],
+    "risk_factors": [],
+    "investment_rating": "中性",
+    "fundamental_score": 0.5
+  },
+  "adjustment_factor": 1.04545
+}

Kronos/examples/yuce/300207_comprehensive_analysis_report.json

@@ -0,0 +1,70 @@
+{
+  "timestamp": "2025-10-01 01:54:37",
+  "stock_code": "300207",
+  "market_analysis": {
+    "overall_is_main_uptrend": false,
+    "overall_trend_strength": 0.5,
+    "market_status": "未知",
+    "detailed_analysis": {}
+  },
+  "sector_analysis": {
+    "industry": "电池",
+    "matched_sectors": [
+      {
+        "sector": "新能源",
+        "momentum": 0.6,
+        "limit_up_stocks": 8,
+        "is_active": true,
+        "description": "光伏、储能"
+      }
+    ],
+    "main_sector": {
+      "sector": "新能源",
+      "momentum": 0.6,
+      "limit_up_stocks": 8,
+      "is_active": true,
+      "description": "光伏、储能"
+    },
+    "is_sector_hot": true,
+    "resonance_score": 0.6,
+    "sector_count": 1
+  },
+  "macro_analysis": {
+    "us_rate_cycle": {
+      "current_rate": 4.25,
+      "trend": "降息周期",
+      "recent_cut": "2025年9月降息25个基点",
+      "expected_cuts_2025": 2,
+      "expected_cuts_2026": 2,
+      "impact_on_emerging_markets": "positive",
+      "usd_index_support": 95.0,
+      "analysis": "美联储开启宽松周期，利好全球流动性"
+    },
+    "domestic_policy": {
+      "monetary_policy": "稳健偏松",
+      "fiscal_policy": "积极财政",
+      "market_liquidity": "合理充裕",
+      "industrial_policy": "设备更新、以旧换新",
+      "employment_policy": "稳就业政策加力",
+      "analysis": "政策组合拳发力，经济稳中向好"
+    },
+    "industry_policy": {
+      "robot_policy": "机器人产业政策支持",
+      "chip_policy": "国产替代加速推进",
+      "AI_policy": "人工智能发展规划",
+      "low_altitude": "低空经济发展规划"
+    },
+    "global_liquidity_outlook": "改善",
+    "overall_macro_score": 0.75
+  },
+  "fundamental_analysis": {
+    "company_name": "未知",
+    "business_areas": [],
+    "recent_developments": [],
+    "growth_drivers": [],
+    "risk_factors": [],
+    "investment_rating": "中性",
+    "fundamental_score": 0.5
+  },
+  "adjustment_factor": 1.0935407000000001
+}

Kronos/examples/yuce/600580_comprehensive_analysis_report.json

@@ -0,0 +1,96 @@
+{
+  "timestamp": "2025-10-01 01:53:45",
+  "stock_code": "600580",
+  "market_analysis": {
+    "overall_is_main_uptrend": false,
+    "overall_trend_strength": 0.5,
+    "market_status": "未知",
+    "detailed_analysis": {}
+  },
+  "sector_analysis": {
+    "industry": "电机",
+    "matched_sectors": [
+      {
+        "sector": "机器人",
+        "momentum": 0.85,
+        "limit_up_stocks": 18,
+        "is_active": true,
+        "description": "人形机器人、工业自动化"
+      },
+      {
+        "sector": "低空经济",
+        "momentum": 0.7,
+        "limit_up_stocks": 10,
+        "is_active": true,
+        "description": "无人机、eVTOL"
+      }
+    ],
+    "main_sector": {
+      "sector": "机器人",
+      "momentum": 0.85,
+      "limit_up_stocks": 18,
+      "is_active": true,
+      "description": "人形机器人、工业自动化"
+    },
+    "is_sector_hot": true,
+    "resonance_score": 0.7749999999999999,
+    "sector_count": 2
+  },
+  "macro_analysis": {
+    "us_rate_cycle": {
+      "current_rate": 4.25,
+      "trend": "降息周期",
+      "recent_cut": "2025年9月降息25个基点",
+      "expected_cuts_2025": 2,
+      "expected_cuts_2026": 2,
+      "impact_on_emerging_markets": "positive",
+      "usd_index_support": 95.0,
+      "analysis": "美联储开启宽松周期，利好全球流动性"
+    },
+    "domestic_policy": {
+      "monetary_policy": "稳健偏松",
+      "fiscal_policy": "积极财政",
+      "market_liquidity": "合理充裕",
+      "industrial_policy": "设备更新、以旧换新",
+      "employment_policy": "稳就业政策加力",
+      "analysis": "政策组合拳发力，经济稳中向好"
+    },
+    "industry_policy": {
+      "robot_policy": "机器人产业政策支持",
+      "chip_policy": "国产替代加速推进",
+      "AI_policy": "人工智能发展规划",
+      "low_altitude": "低空经济发展规划"
+    },
+    "global_liquidity_outlook": "改善",
+    "overall_macro_score": 0.75
+  },
+  "fundamental_analysis": {
+    "company_name": "卧龙电驱",
+    "business_areas": [
+      "工业电机",
+      "机器人关键部件",
+      "航空电机",
+      "新能源汽车驱动"
+    ],
+    "recent_developments": [
+      "与智元机器人实现双向持股，推进具身智能机器人技术研发",
+      "成立浙江龙飞电驱，专注航空电机业务",
+      "发布AI外骨骼机器人及灵巧手",
+      "布局高爆发关节模组、伺服驱动器等人形机器人关键部件"
+    ],
+    "growth_drivers": [
+      "设备更新政策推动工业电机需求",
+      "机器人产业快速发展",
+      "低空经济政策支持",
+      "出海战略加速"
+    ],
+    "risk_factors": [
+      "机器人业务营收占比仅2.71%，占比较低",
+      "工业需求景气度波动",
+      "原料价格波动风险"
+    ],
+    "investment_rating": "积极关注",
+    "fundamental_score": 0.7
+  },
+  "adjustment_factor": 1.1
+}

Kronos/examples/yuce/historical_backtest.py

@@ -0,0 +1,384 @@
+# historical_backtest.py
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import os
+from datetime import datetime, timedelta
+import warnings
+
+warnings.filterwarnings('ignore')
+
+# 设置中文字体
+plt.rcParams['font.sans-serif'] = ['SimHei']
+plt.rcParams['axes.unicode_minus'] = False
+
+
+class HistoricalBacktester:
+    """
+    历史回测类：用历史数据验证模型预测效果
+    """
+
+    def __init__(self, data_dir, initial_capital=100000):
+        self.data_dir = data_dir
+        self.initial_capital = initial_capital
+
+    def load_historical_data(self, stock_code):
+        """加载历史数据"""
+        csv_file = os.path.join(self.data_dir, f"{stock_code}_stock_data.csv")
+        if not os.path.exists(csv_file):
+            raise FileNotFoundError(f"数据文件不存在: {csv_file}")
+
+        df = pd.read_csv(csv_file, encoding='utf-8-sig')
+
+        # 标准化列名
+        column_mapping = {
+            '日期': 'date',
+            '开盘价': 'open',
+            '最高价': 'high',
+            '最低价': 'low',
+            '收盘价': 'close',
+            '成交量': 'volume',
+            '成交额': 'amount'
+        }
+
+        for old_col, new_col in column_mapping.items():
+            if old_col in df.columns:
+                df = df.rename(columns={old_col: new_col})
+
+        df['date'] = pd.to_datetime(df['date'])
+        df.set_index('date', inplace=True)
+        df = df.sort_index()
+
+        print(f"✅ 加载历史数据: {len(df)} 条记录")
+        print(f"时间范围: {df.index.min()} 到 {df.index.max()}")
+
+        return df
+
+    def simulate_model_prediction(self, df, lookback_days=60, pred_days=30):
+        """
+        模拟模型预测：使用历史数据进行"预测"，然后与实际结果对比
+        """
+        results = []
+
+        # 从数据中选取多个时间点进行"预测"
+        test_points = range(lookback_days, len(df) - pred_days, pred_days)
+
+        for start_idx in test_points:
+            # 模拟预测：使用前lookback_days天数据"预测"后pred_days天
+            historical_data = df.iloc[start_idx - lookback_days:start_idx]
+            actual_future = df.iloc[start_idx:start_idx + pred_days]
+
+            # 简单的预测策略（这里应该替换为您的实际模型预测）
+            # 这里使用移动平均作为示例预测
+            pred_close = self.simple_prediction(historical_data, pred_days)
+
+            # 记录结果
+            for i in range(min(len(pred_close), len(actual_future))):
+                results.append({
+                    'date': actual_future.index[i],
+                    'actual_close': actual_future['close'].iloc[i],
+                    'predicted_close': pred_close[i],
+                    'lookback_start': historical_data.index[0],
+                    'prediction_date': historical_data.index[-1]
+                })
+
+        return pd.DataFrame(results)
+
+    def simple_prediction(self, historical_data, pred_days):
+        """简单的预测方法（示例）"""
+        # 使用移动平均 + 随机波动作为预测
+        last_price = historical_data['close'].iloc[-1]
+        avg_volatility = historical_data['close'].pct_change().std()
+
+        predictions = []
+        current_price = last_price
+
+        for _ in range(pred_days):
+            # 模拟价格变化（正态分布）
+            change = np.random.normal(0, avg_volatility)
+            current_price = current_price * (1 + change)
+            predictions.append(current_price)
+
+        return predictions
+
+    def calculate_prediction_accuracy(self, results_df):
+        """计算预测准确率"""
+        results_df['error'] = results_df['predicted_close'] - results_df['actual_close']
+        results_df['error_pct'] = results_df['error'] / results_df['actual_close']
+        results_df['abs_error_pct'] = abs(results_df['error_pct'])
+
+        accuracy_metrics = {
+            '平均绝对误差率': results_df['abs_error_pct'].mean(),
+            '预测准确率': (results_df['abs_error_pct'] < 0.05).mean(),  # 误差小于5%算准确
+            '方向准确率': (np.sign(results_df['predicted_close'].diff()) ==
+                           np.sign(results_df['actual_close'].diff())).mean(),
+            '相关系数': results_df['predicted_close'].corr(results_df['actual_close'])
+        }
+
+        return accuracy_metrics
+
+    def run_trading_strategy(self, results_df, threshold=0.03):
+        """基于预测结果运行交易策略"""
+        capital = self.initial_capital
+        position = 0
+        trades = []
+        portfolio_values = []
+
+        # 按日期排序
+        results_df = results_df.sort_index()
+
+        for date, row in results_df.iterrows():
+            current_price = row['actual_close']
+            predicted_price = row['predicted_close']
+            predicted_return = (predicted_price - current_price) / current_price
+
+            # 交易逻辑
+            if position == 0 and predicted_return > threshold:
+                # 买入信号
+                shares = int(capital / current_price)
+                if shares > 0:
+                    position = shares
+                    capital -= shares * current_price
+                    trades.append({
+                        'date': date,
+                        'action': 'BUY',
+                        'price': current_price,
+                        'shares': shares,
+                        'reason': f'预测上涨{predicted_return:.2%}'
+                    })
+
+            elif position > 0 and predicted_return < -threshold:
+                # 卖出信号
+                capital += position * current_price
+                trades.append({
+                    'date': date,
+                    'action': 'SELL',
+                    'price': current_price,
+                    'shares': position,
+                    'reason': f'预测下跌{predicted_return:.2%}'
+                })
+                position = 0
+
+            # 计算当前资产总值
+            portfolio_value = capital + position * current_price
+            portfolio_values.append({
+                'date': date,
+                'portfolio_value': portfolio_value,
+                'position': position,
+                'price': current_price
+            })
+
+        return pd.DataFrame(portfolio_values), trades
+
+    def calculate_performance(self, portfolio_df, trades):
+        """计算策略表现"""
+        portfolio_df = portfolio_df.set_index('date')
+        returns = portfolio_df['portfolio_value'].pct_change().dropna()
+
+        total_return = (portfolio_df['portfolio_value'].iloc[-1] - self.initial_capital) / self.initial_capital
+
+        if len(returns) > 0:
+            annual_return = (1 + total_return) ** (252 / len(returns)) - 1
+            volatility = returns.std() * np.sqrt(252)
+            sharpe_ratio = (annual_return - 0.03) / volatility if volatility > 0 else 0
+
+            # 最大回撤
+            cumulative = (1 + returns).cumprod()
+            peak = cumulative.expanding().max()
+            drawdown = (cumulative - peak) / peak
+            max_drawdown = drawdown.min()
+        else:
+            annual_return = 0
+            volatility = 0
+            sharpe_ratio = 0
+            max_drawdown = 0
+
+        # 买入持有策略对比
+        buy_hold_return = (portfolio_df['price'].iloc[-1] - portfolio_df['price'].iloc[0]) / portfolio_df['price'].iloc[
+            0]
+
+        performance = {
+            '策略总收益': total_return,
+            '策略年化收益': annual_return,
+            '买入持有收益': buy_hold_return,
+            '波动率': volatility,
+            '夏普比率': sharpe_ratio,
+            '最大回撤': max_drawdown,
+            '交易次数': len(trades),
+            '最终资金': portfolio_df['portfolio_value'].iloc[-1],
+            '超额收益': total_return - buy_hold_return
+        }
+
+        return performance
+
+    def plot_comparison(self, results_df, portfolio_df, stock_code, output_dir):
+        """绘制预测对比图表"""
+        fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(15, 12))
+
+        # 1. 价格预测对比
+        ax1.plot(results_df.index, results_df['actual_close'],
+                 label='实际价格', color='blue', linewidth=2)
+        ax1.plot(results_df.index, results_df['predicted_close'],
+                 label='预测价格', color='red', linestyle='--', alpha=0.7)
+        ax1.set_ylabel('价格 (元)')
+        ax1.legend()
+        ax1.set_title(f'{stock_code} - 价格预测 vs 实际走势', fontsize=14, fontweight='bold')
+        ax1.grid(True, alpha=0.3)
+
+        # 2. 预测误差
+        ax2.bar(results_df.index, results_df['error_pct'] * 100,
+                alpha=0.6, color='orange')
+        ax2.axhline(y=0, color='black', linestyle='-', linewidth=1)
+        ax2.set_ylabel('预测误差 (%)')
+        ax2.set_title('预测误差分析')
+        ax2.grid(True, alpha=0.3)
+
+        # 3. 策略表现
+        ax3.plot(portfolio_df['date'], portfolio_df['portfolio_value'],
+                 label='策略资金曲线', color='green', linewidth=2)
+        ax3.axhline(y=self.initial_capital, color='red', linestyle='--',
+                    label=f'初始资金 ({self.initial_capital:,.0f}元)')
+
+        # 买入持有对比
+        initial_shares = self.initial_capital / portfolio_df['price'].iloc[0]
+        buy_hold_values = portfolio_df['price'] * initial_shares
+        ax3.plot(portfolio_df['date'], buy_hold_values,
+                 label='买入持有策略', color='blue', linestyle=':', alpha=0.7)
+
+        ax3.set_ylabel('资金 (元)')
+        ax3.set_xlabel('日期')
+        ax3.legend()
+        ax3.set_title('策略表现对比')
+        ax3.grid(True, alpha=0.3)
+
+        plt.tight_layout()
+
+        # 保存图表
+        os.makedirs(output_dir, exist_ok=True)
+        chart_file = os.path.join(output_dir, f'{stock_code}_historical_backtest.png')
+        plt.savefig(chart_file, dpi=300, bbox_inches='tight')
+        print(f"📊 历史回测图表已保存: {chart_file}")
+
+        plt.show()
+
+    def run_complete_backtest(self, stock_code, output_dir, lookback_days=60, pred_days=30, threshold=0.03):
+        """运行完整的历史回测"""
+        print(f"🎯 开始 {stock_code} 历史回测分析")
+        print("=" * 60)
+
+        try:
+            # 1. 加载历史数据
+            print("步骤1: 加载历史数据...")
+            df = self.load_historical_data(stock_code)
+
+            # 2. 模拟模型预测
+            print("步骤2: 模拟模型预测...")
+            results_df = self.simulate_model_prediction(df, lookback_days, pred_days)
+
+            # 3. 计算预测准确率
+            print("步骤3: 计算预测准确率...")
+            accuracy_metrics = self.calculate_prediction_accuracy(results_df)
+
+            # 4. 运行交易策略
+            print("步骤4: 运行交易策略...")
+            portfolio_df, trades = self.run_trading_strategy(results_df, threshold)
+
+            # 5. 计算策略表现
+            print("步骤5: 计算策略表现...")
+            performance = self.calculate_performance(portfolio_df, trades)
+
+            # 6. 绘制结果
+            print("步骤6: 生成回测图表...")
+            self.plot_comparison(results_df, portfolio_df, stock_code, output_dir)
+
+            # 7. 打印报告
+            print("\n" + "=" * 70)
+            print(f"📊 {stock_code} 历史回测报告")
+            print("=" * 70)
+
+            print("\n🔍 预测准确率分析:")
+            for metric, value in accuracy_metrics.items():
+                if isinstance(value, float):
+                    print(f"  {metric}: {value:.2%}")
+                else:
+                    print(f"  {metric}: {value:.4f}")
+
+            print("\n💰 策略表现分析:")
+            for metric, value in performance.items():
+                if isinstance(value, float):
+                    if '收益' in metric or '回撤' in metric:
+                        print(f"  {metric}: {value:.2%}")
+                    else:
+                        print(f"  {metric}: {value:.4f}")
+                else:
+                    print(f"  {metric}: {value}")
+
+            print(f"\n📈 交易统计:")
+            print(f"  总交易次数: {len(trades)}")
+            print(f"  买入次数: {len([t for t in trades if t['action'] == 'BUY'])}")
+            print(f"  卖出次数: {len([t for t in trades if t['action'] == 'SELL'])}")
+
+            if len(trades) > 0:
+                print(f"\n最近5次交易:")
+                for trade in trades[-5:]:
+                    print(f"  {trade['date'].strftime('%Y-%m-%d')} {trade['action']} "
+                          f"{trade['shares']}股 @ {trade['price']:.2f}元 - {trade['reason']}")
+
+            return accuracy_metrics, performance, results_df
+
+        except Exception as e:
+            print(f"❌ 回测过程中出现错误: {e}")
+            import traceback
+            traceback.print_exc()
+            return None, None, None
+
+
+def main():
+    """主函数"""
+    # 配置参数
+    BACKTEST_CONFIG = {
+        "stock_code": "300418",
+        "data_dir": r"D:\lianghuajiaoyi\Kronos\examples\data",
+        "output_dir": r"D:\lianghuajiaoyi\Kronos\examples\historical_backtest",
+        "initial_capital": 100000,
+        "lookback_days": 60,  # 使用60天历史数据
+        "pred_days": 30,  # 预测30天
+        "threshold": 0.03  # 3%的交易阈值
+    }
+
+    print("🤖 Kronos模型历史回测系统")
+    print("=" * 50)
+    print(f"回测股票: {BACKTEST_CONFIG['stock_code']}")
+    print(f"回看天数: {BACKTEST_CONFIG['lookback_days']}天")
+    print(f"预测天数: {BACKTEST_CONFIG['pred_days']}天")
+    print(f"初始资金: {BACKTEST_CONFIG['initial_capital']:,.0f}元")
+    print()
+
+    # 创建回测器并运行
+    backtester = HistoricalBacktester(
+        data_dir=BACKTEST_CONFIG["data_dir"],
+        initial_capital=BACKTEST_CONFIG["initial_capital"]
+    )
+
+    accuracy, performance, results = backtester.run_complete_backtest(
+        stock_code=BACKTEST_CONFIG["stock_code"],
+        output_dir=BACKTEST_CONFIG["output_dir"],
+        lookback_days=BACKTEST_CONFIG["lookback_days"],
+        pred_days=BACKTEST_CONFIG["pred_days"],
+        threshold=BACKTEST_CONFIG["threshold"]
+    )
+
+    if accuracy and performance:
+        print(f"\n✅ {BACKTEST_CONFIG['stock_code']} 历史回测完成!")
+
+        # 简单结论
+        if performance['超额收益'] > 0:
+            print("🎉 结论: 模型策略跑赢了买入持有策略!")
+        else:
+            print("⚠️ 结论: 模型策略未能跑赢买入持有策略。")
+
+        print(f"📁 详细结果保存在: {BACKTEST_CONFIG['output_dir']}")
+
+
+if __name__ == "__main__":
+    main()

Kronos/examples/yuce/market_analysis_report.json

@@ -0,0 +1,41 @@
+{
+  "timestamp": "2025-09-30 22:45:36",
+  "market_analysis": {
+    "is_main_uptrend": false,
+    "trend_strength": 0.5,
+    "market_status": "未知",
+    "support_level": null,
+    "resistance_level": null
+  },
+  "sector_analysis": {
+    "industry": "电机",
+    "sector_momentum": 0.5,
+    "sector_limit_up_count": 0,
+    "is_sector_hot": false,
+    "resonance_score": 0.35
+  },
+  "macro_analysis": {
+    "us_rate_cycle": {
+      "current_rate": 4.25,
+      "trend": "降息周期",
+      "expected_cuts_2025": 2,
+      "expected_cuts_2026": 2,
+      "impact_on_emerging_markets": "positive",
+      "usd_index_support": 95.0
+    },
+    "domestic_policy": {
+      "monetary_policy": "宽松",
+      "fiscal_policy": "积极",
+      "market_liquidity": "充足",
+      "holiday_effect": {
+        "effect": "节前震荡，节后上涨概率大",
+        "historical_win_rate": 0.8,
+        "expected_return": 0.0227,
+        "period": "节后5个交易日"
+      }
+    },
+    "global_liquidity_outlook": "改善",
+    "overall_macro_score": 0.7
+  },
+  "adjustment_factor": 1.00776
+}

Kronos/finetune/backtest_external_signal.py

@@ -0,0 +1,41 @@
+"""
+Run Qlib backtest using an external signal CSV.
+
+CSV format expected:
+    trade_date, code, pred, signal_date
+"""
+import sys
+import pickle
+import pandas as pd
+sys.path.append("../")
+from config import Config
+from qlib_test import QlibBacktest
+
+
+SIGNAL_CSV = "/home/hanyueju/MinModel/outputs/joint_signals_val_s2s_oo.csv"
+SIGNAL_NAME = "s2s_oo"   # name shown in the plot legend
+
+
+def load_signal(csv_path: str) -> pd.DataFrame:
+    df = pd.read_csv(csv_path, parse_dates=["trade_date"])
+    df = df[["trade_date", "code", "pred"]].dropna()
+    df["code"] = df["code"].str.upper()
+
+    pivot = df.pivot_table(index="trade_date", columns="code", values="pred")
+    pivot.index = pd.to_datetime(pivot.index)
+    pivot.index.name = "datetime"
+    pivot.columns.name = "instrument"
+    return pivot
+
+
+if __name__ == "__main__":
+    print(f"Loading signal from {SIGNAL_CSV} ...")
+    signal_df = load_signal(SIGNAL_CSV)
+    print(f"Signal shape: {signal_df.shape}")
+    print(signal_df.head(3))
+
+    signals = {SIGNAL_NAME: signal_df}
+
+    config = Config()
+    backtester = QlibBacktest(config)
+    backtester.run_and_plot_results(signals)

Kronos/finetune/build_test_data.py

@@ -0,0 +1,76 @@
+"""
+Build test_data.pkl from 5min adjusted CSV files.
+Only loads the test time range to save memory/disk.
+"""
+import os
+import pickle
+import pandas as pd
+from tqdm import tqdm
+
+# ── Config ────────────────────────────────────────────────────────────────────
+DATA_DIR   = "/home/hanyueju/MinModel/data/one_stock_one_csv_adjusted"
+OUTPUT_DIR = "./data/processed_datasets"
+OUTPUT_FILE = os.path.join(OUTPUT_DIR, "test_data.pkl")
+
+# Match config.py test_time_range.
+# Start a bit earlier to cover the lookback_window (240 bars) before backtest begins.
+TEST_START = "2024-12-20"
+TEST_END   = "2026-04-07"
+
+MIN_BARS = 300  # drop stocks with fewer than this many bars in the test window
+# ─────────────────────────────────────────────────────────────────────────────
+
+def build(data_dir, test_start, test_end):
+    files = sorted(f for f in os.listdir(data_dir) if f.endswith(".csv"))
+    test_data = {}
+
+    for fname in tqdm(files, desc="Loading"):
+        stock_code = fname.replace(".csv", "")
+        path = os.path.join(data_dir, fname)
+
+        try:
+            df = pd.read_csv(
+                path,
+                usecols=["datetime", "open", "high", "low", "close", "volume", "turnover"],
+                parse_dates=["datetime"],
+            )
+        except Exception as e:
+            print(f"  skip {fname}: {e}")
+            continue
+
+        df = df.rename(columns={"volume": "vol", "turnover": "amt"})
+        df = df.set_index("datetime").sort_index()
+        df = df[["open", "high", "low", "close", "vol", "amt"]]
+        df = df.dropna()
+
+        df = df[(df.index >= test_start) & (df.index <= test_end)]
+
+        if len(df) < MIN_BARS:
+            continue
+
+        test_data[stock_code] = df
+
+    return test_data
+
+
+if __name__ == "__main__":
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+    print(f"Building test_data.pkl")
+    print(f"  Source : {DATA_DIR}")
+    print(f"  Range  : {TEST_START} ~ {TEST_END}")
+    print(f"  Output : {OUTPUT_FILE}")
+    print()
+
+    test_data = build(DATA_DIR, TEST_START, TEST_END)
+
+    print(f"\nStocks loaded: {len(test_data)}")
+    sample_key = next(iter(test_data))
+    print(f"Sample ({sample_key}): {len(test_data[sample_key])} bars")
+    print(test_data[sample_key].head(3))
+
+    with open(OUTPUT_FILE, "wb") as f:
+        pickle.dump(test_data, f)
+
+    size_mb = os.path.getsize(OUTPUT_FILE) / 1024 / 1024
+    print(f"\nSaved → {OUTPUT_FILE}  ({size_mb:.1f} MB)")

Kronos/finetune/check.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""查询 processed_datasets/test_data.pkl 覆盖的最早和最晚日期。"""
+
+import argparse
+import pickle
+from pathlib import Path
+
+import pandas as pd
+
+
+DEFAULT_PATH = "finetune/data/processed_datasets/test_data.pkl"
+
+
+def get_datetime_index(df: pd.DataFrame) -> pd.DatetimeIndex:
+    """兼容 DatetimeIndex 或名为 datetime 的普通列。"""
+    if isinstance(df.index, pd.DatetimeIndex):
+        return df.index
+
+    if "datetime" in df.columns:
+        return pd.to_datetime(df["datetime"], errors="coerce").dropna()
+
+    # 某些 pickle 可能把日期列保存成 index，但 index 名称不是 datetime。
+    converted = pd.to_datetime(df.index, errors="coerce")
+    return converted[~converted.isna()]
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("path", nargs="?", default=DEFAULT_PATH, help="pickle 文件路径")
+    args = parser.parse_args()
+
+    path = Path(args.path)
+    print(f"正在加载：{path}")
+    print("注意：该文件约 13GB，加载可能需要较大内存。")
+
+    with path.open("rb") as file:
+        data = pickle.load(file)
+
+    if isinstance(data, dict):
+        items = data.items()
+    elif isinstance(data, pd.DataFrame):
+        items = [("<dataframe>", data)]
+    else:
+        raise TypeError(f"不支持的数据类型：{type(data).__name__}")
+
+    earliest = None
+    latest = None
+    earliest_symbol = latest_symbol = None
+    valid_symbols = 0
+
+    for symbol, df in items:
+        if not isinstance(df, pd.DataFrame) or df.empty:
+            continue
+
+        dates = get_datetime_index(df)
+        if len(dates) == 0:
+            continue
+
+        valid_symbols += 1
+        current_earliest = dates.min()
+        current_latest = dates.max()
+
+        if earliest is None or current_earliest < earliest:
+            earliest, earliest_symbol = current_earliest, symbol
+        if latest is None or current_latest > latest:
+            latest, latest_symbol = current_latest, symbol
+
+    if earliest is None:
+        print("没有找到有效日期。")
+        return
+
+    print(f"股票数量：{valid_symbols}")
+    print(f"最早日期：{earliest}（股票：{earliest_symbol}）")
+    print(f"最晚日期：{latest}（股票：{latest_symbol}）")
+    print(f"覆盖范围：{earliest.date()} ~ {latest.date()}")
+
+
+if __name__ == "__main__":
+    main()

Kronos/finetune/config copy.py

@@ -0,0 +1,133 @@
+import os
+
+class Config:
+    """
+    Configuration class for the entire project.
+    """
+
+    def __init__(self):
+        # =================================================================
+        # Data & Feature Parameters
+        # =================================================================
+        # TODO: Update this path to your Qlib data directory.
+        self.qlib_data_path = "~/.qlib/qlib_data/cn_data_local"
+        self.instrument = 'all'
+
+        # Overall time range for data loading from Qlib.
+        self.dataset_begin_time = "2021-12-01"
+        self.dataset_end_time = '2026-04-05'
+
+        # Sliding window parameters for creating samples.
+        self.lookback_window = 672  # Number of past time steps for input.
+        self.predict_window = 49  # Number of future time steps for prediction.
+        self.max_context = 512  # Maximum context length for the model.
+
+        # Features to be used from the raw data.
+        self.feature_list = ['open', 'high', 'low', 'close', 'vol', 'amt']
+        # Time-based features to be generated.
+        self.time_feature_list = ['minute', 'hour', 'weekday', 'day', 'month']
+
+        # =================================================================
+        # Dataset Splitting & Paths
+        # =================================================================
+        # Note: The validation/test set starts earlier than the training/validation set ends
+        # to account for the `lookback_window`.
+        self.train_time_range = ["2011-01-01", "2015-12-10"]
+        self.val_time_range = ["2015-12-20", "2021-05-10"]
+        self.test_time_range = ["2022-01-01", "2026-04-05"]
+        self.backtest_time_range = ["2022-01-01", "2026-04-05"]
+
+        # TODO: Directory to save the processed, pickled datasets.
+        self.dataset_path = "./data/processed_datasets"
+
+        # =================================================================
+        # Training Hyperparameters
+        # =================================================================
+        self.clip = 5.0  # Clipping value for normalized data to prevent outliers.
+
+        self.epochs = 30
+        self.log_interval = 100  # Log training status every N batches.
+        self.batch_size = 50  # Batch size per GPU.
+
+        # Number of samples to draw for one "epoch" of training/validation.
+        # This is useful for large datasets where a true epoch is too long.
+        self.n_train_iter = 2000 * self.batch_size
+        self.n_val_iter = 400 * self.batch_size
+
+        # Learning rates for different model components.
+        self.tokenizer_learning_rate = 2e-4
+        self.predictor_learning_rate = 4e-5
+
+        # Gradient accumulation to simulate a larger batch size.
+        self.accumulation_steps = 1
+
+        # AdamW optimizer parameters.
+        self.adam_beta1 = 0.9
+        self.adam_beta2 = 0.95
+        self.adam_weight_decay = 0.1
+
+        # Miscellaneous
+        self.seed = 100  # Global random seed for reproducibility.
+
+        # =================================================================
+        # Experiment Logging & Saving
+        # =================================================================
+        self.use_comet = False # Set to False if you don't want to use Comet ML
+        self.comet_config = {
+            # It is highly recommended to load secrets from environment variables
+            # for security purposes. Example: os.getenv("COMET_API_KEY")
+            "api_key": "YOUR_COMET_API_KEY",
+            "project_name": "Kronos-Finetune-Demo",
+            "workspace": "your_comet_workspace" # TODO: Change to your Comet ML workspace name
+        }
+        self.comet_tag = 'finetune_demo'
+        self.comet_name = 'finetune_demo'
+
+        # Base directory for saving model checkpoints and results.
+        # Using a general 'outputs' directory is a common practice.
+        self.save_path = "./outputs/models"
+        self.tokenizer_save_folder_name = 'finetune_tokenizer_demo'
+        self.predictor_save_folder_name = 'finetune_predictor_demo'
+        self.backtest_save_folder_name = 'finetune_backtest_demo'
+
+        # Path for backtesting results.
+        self.backtest_result_path = "./outputs/backtest_results"
+
+        # =================================================================
+        # Model & Checkpoint Paths
+        # =================================================================
+        # TODO: Update these paths to your pretrained model locations.
+        # These can be local paths or Hugging Face Hub model identifiers.
+        self.pretrained_tokenizer_path = "NeoQuasar/Kronos-Tokenizer-base"
+        self.pretrained_predictor_path = "NeoQuasar/Kronos-base"
+
+
+        # Paths to the fine-tuned models, derived from the save_path.
+        # These will be generated automatically during training.
+        self.finetuned_tokenizer_path = f"{self.save_path}/{self.tokenizer_save_folder_name}/checkpoints/best_model"
+        self.finetuned_predictor_path = f"{self.save_path}/{self.predictor_save_folder_name}/checkpoints/best_model"
+
+        # =================================================================
+        # Backtesting Parameters
+        # =================================================================
+        self.backtest_n_symbol_hold = 5  # Number of symbols to hold in the portfolio.
+        self.backtest_n_symbol_drop = 3  # Number of symbols to drop from the pool.
+        self.backtest_hold_thresh = 0  # Minimum holding period for a stock.
+        self.inference_T = 0.6
+        self.inference_top_p = 0.9
+        self.inference_top_k = 0
+        self.inference_sample_count = 5
+        self.backtest_batch_size = 256
+        self.backtest_benchmark = self._set_benchmark(self.instrument)
+
+    def _set_benchmark(self, instrument):
+        dt_benchmark = {
+            'csi800': "SH000906",
+            'csi1000': "SH000852",
+            'csi300': "SH000300",
+            'all': "SH000300",
+        }
+        if instrument in dt_benchmark:
+            return dt_benchmark[instrument]
+        else:
+            raise ValueError(f"Benchmark not defined for instrument: {instrument}")

Kronos/finetune/config.py

@@ -0,0 +1,138 @@
+import os
+
+class Config:
+    """
+    Configuration class for the entire project.
+    """
+
+    def __init__(self):
+        # =================================================================
+        # Data & Feature Parameters
+        # =================================================================
+        # TODO: Update this path to your Qlib data directory.
+        self.qlib_data_path = "~/.qlib/qlib_data/cn_data_local"
+        self.instrument = 'all'
+
+        # Overall time range for data loading from Qlib.
+        self.dataset_begin_time = "2021-12-01"
+        self.dataset_end_time = '2026-04-05'
+
+        # Sliding window parameters for creating samples.
+        self.lookback_window = 672  # Number of past time steps for input.
+        self.predict_window = 49  # Number of future time steps for prediction.
+        self.max_context = 512  # Maximum context length for the model.
+
+        # Features to be used from the raw data.
+        self.feature_list = ['open', 'high', 'low', 'close', 'vol', 'amt']
+        # Time-based features to be generated.
+        self.time_feature_list = ['minute', 'hour', 'weekday', 'day', 'month']
+
+        # =================================================================
+        # Dataset Splitting & Paths
+        # =================================================================
+        # Note: The validation/test set starts earlier than the training/validation set ends
+        # to account for the `lookback_window`.
+        self.train_time_range = ["2011-01-01", "2015-12-10"]
+        self.val_time_range = ["2015-12-20", "2024-05-10"]
+        # Signal dates to retain in qlib_test.py.  The source cache starts
+        # earlier so the 672-bar warm-up can be discarded before saving.
+        self.test_time_range = ["2025-01-01", "2026-04-05"]
+        self.backtest_time_range = ["2025-01-01", "2026-04-05"]
+
+        # TODO: Directory to save the processed, pickled datasets.
+        self.dataset_path = "./data/processed_datasets"
+        self.test_data_file = "test_data.pkl"
+
+        # =================================================================
+        # Training Hyperparameters
+        # =================================================================
+        self.clip = 5.0  # Clipping value for normalized data to prevent outliers.
+
+        self.epochs = 30
+        self.log_interval = 100  # Log training status every N batches.
+        self.batch_size = 50  # Batch size per GPU.
+
+        # Number of samples to draw for one "epoch" of training/validation.
+        # This is useful for large datasets where a true epoch is too long.
+        self.n_train_iter = 2000 * self.batch_size
+        self.n_val_iter = 400 * self.batch_size
+
+        # Learning rates for different model components.
+        self.tokenizer_learning_rate = 2e-4
+        self.predictor_learning_rate = 4e-5
+
+        # Gradient accumulation to simulate a larger batch size.
+        self.accumulation_steps = 1
+
+        # AdamW optimizer parameters.
+        self.adam_beta1 = 0.9
+        self.adam_beta2 = 0.95
+        self.adam_weight_decay = 0.1
+
+        # Miscellaneous
+        self.seed = 100  # Global random seed for reproducibility.
+
+        # =================================================================
+        # Experiment Logging & Saving
+        # =================================================================
+        self.use_comet = False # Set to False if you don't want to use Comet ML
+        self.comet_config = {
+            # It is highly recommended to load secrets from environment variables
+            # for security purposes. Example: os.getenv("COMET_API_KEY")
+            "api_key": "YOUR_COMET_API_KEY",
+            "project_name": "Kronos-Finetune-Demo",
+            "workspace": "your_comet_workspace" # TODO: Change to your Comet ML workspace name
+        }
+        self.comet_tag = 'finetune_demo'
+        self.comet_name = 'finetune_demo'
+
+        # Base directory for saving model checkpoints and results.
+        # Using a general 'outputs' directory is a common practice.
+        self.save_path = "./outputs/models"
+        self.signal_result_path = "./outputs/predictions"
+        self.signal_result_name = "kronos_5min_signals_2022_20260407"
+        self.tokenizer_save_folder_name = 'finetune_tokenizer_demo'
+        self.predictor_save_folder_name = 'finetune_predictor_demo'
+        self.backtest_save_folder_name = 'finetune_backtest_demo'
+
+        # Path for backtesting results.
+        self.backtest_result_path = "./outputs/backtest_results"
+
+        # =================================================================
+        # Model & Checkpoint Paths
+        # =================================================================
+        # TODO: Update these paths to your pretrained model locations.
+        # These can be local paths or Hugging Face Hub model identifiers.
+        self.pretrained_tokenizer_path = "NeoQuasar/Kronos-Tokenizer-base"
+        self.pretrained_predictor_path = "NeoQuasar/Kronos-base"
+
+
+        # Paths to the fine-tuned models, derived from the save_path.
+        # These will be generated automatically during training.
+        self.finetuned_tokenizer_path = f"{self.save_path}/{self.tokenizer_save_folder_name}/checkpoints/best_model"
+        self.finetuned_predictor_path = f"{self.save_path}/{self.predictor_save_folder_name}/checkpoints/best_model"
+
+        # =================================================================
+        # Backtesting Parameters
+        # =================================================================
+        self.backtest_n_symbol_hold = 5  # Number of symbols to hold in the portfolio.
+        self.backtest_n_symbol_drop = 3  # Number of symbols to drop from the pool.
+        self.backtest_hold_thresh = 0  # Minimum holding period for a stock.
+        self.inference_T = 0.6
+        self.inference_top_p = 0.9
+        self.inference_top_k = 0
+        self.inference_sample_count = 5
+        self.backtest_batch_size = 256
+        self.backtest_benchmark = self._set_benchmark(self.instrument)
+
+    def _set_benchmark(self, instrument):
+        dt_benchmark = {
+            'csi800': "SH000906",
+            'csi1000': "SH000852",
+            'csi300': "SH000300",
+            'all': "SH000300",
+        }
+        if instrument in dt_benchmark:
+            return dt_benchmark[instrument]
+        else:
+            raise ValueError(f"Benchmark not defined for instrument: {instrument}")

Kronos/finetune/data/processed_datasets/test_data.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:04e47eb6e1968c2cc1ec9d4ea2c84ad0dc9b83bd1687153ef198c8679381d730
+size 4449693687

Kronos/finetune/dataset.py

@@ -0,0 +1,138 @@
+import pickle
+import random
+import numpy as np
+import torch
+from torch.utils.data import Dataset
+from config import Config
+
+
+class QlibDataset(Dataset):
+    """
+    A PyTorch Dataset for handling Qlib financial time series data.
+
+    This dataset pre-computes all possible start indices for sliding windows
+    and then randomly samples from them during training/validation.
+
+    Args:
+        data_type (str): The type of dataset to load, either 'train' or 'val'.
+
+    Raises:
+        ValueError: If `data_type` is not 'train' or 'val'.
+    """
+
+    def __init__(self, data_type: str = 'train'):
+        self.config = Config()
+        if data_type not in ['train', 'val']:
+            raise ValueError("data_type must be 'train' or 'val'")
+        self.data_type = data_type
+
+        # Use a dedicated random number generator for sampling to avoid
+        # interfering with other random processes (e.g., in model initialization).
+        self.py_rng = random.Random(self.config.seed)
+
+        # Set paths and number of samples based on the data type.
+        if data_type == 'train':
+            self.data_path = f"{self.config.dataset_path}/train_data.pkl"
+            self.n_samples = self.config.n_train_iter
+        else:
+            self.data_path = f"{self.config.dataset_path}/val_data.pkl"
+            self.n_samples = self.config.n_val_iter
+
+        with open(self.data_path, 'rb') as f:
+            self.data = pickle.load(f)
+
+        self.window = self.config.lookback_window + self.config.predict_window + 1
+
+        self.symbols = list(self.data.keys())
+        self.feature_list = self.config.feature_list
+        self.time_feature_list = self.config.time_feature_list
+
+        # Pre-compute all possible (symbol, start_index) pairs.
+        self.indices = []
+        print(f"[{data_type.upper()}] Pre-computing sample indices...")
+        for symbol in self.symbols:
+            df = self.data[symbol].reset_index()
+            series_len = len(df)
+            num_samples = series_len - self.window + 1
+
+            if num_samples > 0:
+                # Generate time features and store them directly in the dataframe.
+                df['minute'] = df['datetime'].dt.minute
+                df['hour'] = df['datetime'].dt.hour
+                df['weekday'] = df['datetime'].dt.weekday
+                df['day'] = df['datetime'].dt.day
+                df['month'] = df['datetime'].dt.month
+                # Keep only necessary columns to save memory.
+                self.data[symbol] = df[self.feature_list + self.time_feature_list]
+
+                # Add all valid starting indices for this symbol to the global list.
+                for i in range(num_samples):
+                    self.indices.append((symbol, i))
+
+        # The effective dataset size is the minimum of the configured iterations
+        # and the total number of available samples.
+        self.n_samples = min(self.n_samples, len(self.indices))
+        print(f"[{data_type.upper()}] Found {len(self.indices)} possible samples. Using {self.n_samples} per epoch.")
+
+    def set_epoch_seed(self, epoch: int):
+        """
+        Sets a new seed for the random sampler for each epoch. This is crucial
+        for reproducibility in distributed training.
+
+        Args:
+            epoch (int): The current epoch number.
+        """
+        epoch_seed = self.config.seed + epoch
+        self.py_rng.seed(epoch_seed)
+
+    def __len__(self) -> int:
+        """Returns the number of samples per epoch."""
+        return self.n_samples
+
+    def __getitem__(self, idx: int) -> tuple[torch.Tensor, torch.Tensor]:
+        
+        # Select a random sample from the entire pool of indices.
+        random_idx = self.py_rng.randint(0, len(self.indices) - 1)
+        symbol, start_idx = self.indices[random_idx]
+
+        # Extract the sliding window from the dataframe.
+        df = self.data[symbol]
+        end_idx = start_idx + self.window
+        win_df = df.iloc[start_idx:end_idx]
+
+        # Separate main features and time features.
+        x = win_df[self.feature_list].values.astype(np.float32)
+        x_stamp = win_df[self.time_feature_list].values.astype(np.float32)
+
+        # Normalize the window. Mean and std are calculated strictly on the
+        # lookback window (past data) to prevent future data leakage.
+        past_len = self.config.lookback_window
+        past_x = x[:past_len]
+
+        x_mean = np.mean(past_x, axis=0)
+        x_std  = np.std(past_x, axis=0)
+
+        # Apply normalization and robust clipping to the entire sequence
+        x = (x - x_mean) / (x_std + 1e-5)
+        x = np.clip(x, -self.config.clip, self.config.clip)
+
+        # Convert to PyTorch tensors.
+        x_tensor = torch.from_numpy(x)
+        x_stamp_tensor = torch.from_numpy(x_stamp)
+
+        return x_tensor, x_stamp_tensor
+
+
+if __name__ == '__main__':
+    # Example usage and verification.
+    print("Creating training dataset instance...")
+    train_dataset = QlibDataset(data_type='train')
+
+    print(f"Dataset length: {len(train_dataset)}")
+
+    if len(train_dataset) > 0:
+        try_x, try_x_stamp = train_dataset[100]  # Index 100 is ignored.
+        print(f"Sample feature shape: {try_x.shape}")
+        print(f"Sample time feature shape: {try_x_stamp.shape}")
+    else:
+        print("Dataset is empty.")

Kronos/finetune/merge_predictions.py

@@ -0,0 +1,431 @@
+import argparse
+import json
+import os
+import pickle
+from collections import defaultdict
+
+import pandas as pd
+
+
+EXPECTED_SIGNALS = ("cc", "oc", "oo2")
+
+
+def atomic_pickle_dump(value, path):
+    """Write a pickle atomically."""
+    parent = os.path.dirname(path)
+    if parent:
+        os.makedirs(parent, exist_ok=True)
+
+    tmp_path = f"{path}.tmp.{os.getpid()}"
+    try:
+        with open(tmp_path, "wb") as f:
+            pickle.dump(value, f, protocol=pickle.HIGHEST_PROTOCOL)
+            f.flush()
+            os.fsync(f.fileno())
+        os.replace(tmp_path, path)
+    finally:
+        if os.path.exists(tmp_path):
+            os.unlink(tmp_path)
+
+
+def atomic_json_dump(value, path):
+    """Write JSON atomically."""
+    parent = os.path.dirname(path)
+    if parent:
+        os.makedirs(parent, exist_ok=True)
+
+    tmp_path = f"{path}.tmp.{os.getpid()}"
+    try:
+        with open(tmp_path, "w", encoding="utf-8") as f:
+            json.dump(value, f, ensure_ascii=False, indent=2)
+            f.flush()
+            os.fsync(f.fileno())
+        os.replace(tmp_path, path)
+    finally:
+        if os.path.exists(tmp_path):
+            os.unlink(tmp_path)
+
+
+def atomic_csv_dump(dataframe, path):
+    """Write a CSV atomically."""
+    parent = os.path.dirname(path)
+    if parent:
+        os.makedirs(parent, exist_ok=True)
+
+    tmp_path = f"{path}.tmp.{os.getpid()}"
+    try:
+        dataframe.to_csv(tmp_path, index=False)
+        os.replace(tmp_path, path)
+    finally:
+        if os.path.exists(tmp_path):
+            os.unlink(tmp_path)
+
+
+def load_json(path):
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def expected_rank_sample_count(full_size, rank, world_size):
+    """Number of items in range(rank, full_size, world_size)."""
+    if rank >= full_size:
+        return 0
+    return (full_size - 1 - rank) // world_size + 1
+
+
+def validate_and_load_manifests(
+    shard_dir,
+    expected_world_size,
+):
+    manifests = []
+
+    for rank in range(expected_world_size):
+        manifest_path = os.path.join(
+            shard_dir,
+            f"rank_{rank:04d}.done.json",
+        )
+        if not os.path.isfile(manifest_path):
+            raise RuntimeError(
+                f"Rank {rank} is incomplete: missing {manifest_path}"
+            )
+
+        manifest = load_json(manifest_path)
+
+        if manifest.get("rank") != rank:
+            raise RuntimeError(
+                f"{manifest_path}: expected rank {rank}, "
+                f"got {manifest.get('rank')}"
+            )
+        if manifest.get("world_size") != expected_world_size:
+            raise RuntimeError(
+                f"{manifest_path}: expected world_size "
+                f"{expected_world_size}, "
+                f"got {manifest.get('world_size')}"
+            )
+        if tuple(manifest.get("signals", [])) != EXPECTED_SIGNALS:
+            raise RuntimeError(
+                f"{manifest_path}: unexpected signals "
+                f"{manifest.get('signals')}"
+            )
+
+        manifests.append(manifest)
+
+    run_ids = {manifest.get("run_id") for manifest in manifests}
+    if len(run_ids) != 1:
+        raise RuntimeError(
+            f"Manifests belong to different runs: {run_ids}"
+        )
+
+    full_sizes = {
+        manifest.get("full_dataset_size")
+        for manifest in manifests
+    }
+    if len(full_sizes) != 1 or None in full_sizes:
+        raise RuntimeError(
+            f"Inconsistent full_dataset_size values: {full_sizes}"
+        )
+
+    full_dataset_size = next(iter(full_sizes))
+
+    for manifest in manifests:
+        rank = manifest["rank"]
+        assigned = expected_rank_sample_count(
+            full_dataset_size,
+            rank,
+            expected_world_size,
+        )
+        if manifest.get("num_samples") != assigned:
+            raise RuntimeError(
+                f"Rank {rank}: manifest contains "
+                f"{manifest.get('num_samples')} samples, "
+                f"but deterministic partitioning assigns {assigned}"
+            )
+
+    total_samples = sum(
+        manifest["num_samples"]
+        for manifest in manifests
+    )
+    if total_samples != full_dataset_size:
+        raise RuntimeError(
+            f"Sample coverage mismatch: manifests contain "
+            f"{total_samples} samples, but the full dataset has "
+            f"{full_dataset_size}"
+        )
+
+    return manifests, run_ids.pop(), full_dataset_size
+
+
+def load_all_shards(shard_dir, manifests):
+    merged = defaultdict(list)
+
+    for manifest in manifests:
+        rank = manifest["rank"]
+        rank_record_counts = defaultdict(int)
+
+        for part_index in range(manifest["parts"]):
+            part_path = os.path.join(
+                shard_dir,
+                f"rank_{rank:04d}_part_{part_index:06d}.pkl",
+            )
+            if not os.path.isfile(part_path):
+                raise RuntimeError(
+                    f"Rank {rank} is missing shard part: {part_path}"
+                )
+
+            with open(part_path, "rb") as f:
+                part_result = pickle.load(f)
+
+            unexpected = set(part_result) - set(EXPECTED_SIGNALS)
+            if unexpected:
+                raise RuntimeError(
+                    f"{part_path}: unexpected signals {unexpected}"
+                )
+
+            for signal_name, records in part_result.items():
+                merged[signal_name].extend(records)
+                rank_record_counts[signal_name] += len(records)
+
+        for signal_name in EXPECTED_SIGNALS:
+            actual = rank_record_counts[signal_name]
+            expected = manifest["num_samples"]
+            if actual != expected:
+                raise RuntimeError(
+                    f"Rank {rank}, signal {signal_name}: loaded "
+                    f"{actual} records, expected {expected}"
+                )
+
+        print(
+            f"Loaded rank {rank:04d}: "
+            f"{manifest['num_samples']} samples from "
+            f"{manifest['parts']} part(s)"
+        )
+
+    return merged
+
+
+def records_to_prediction_dataframes(
+    merged,
+    full_dataset_size,
+):
+    prediction_dfs = {}
+
+    for signal_name in EXPECTED_SIGNALS:
+        records = merged.get(signal_name, [])
+
+        if len(records) != full_dataset_size:
+            raise RuntimeError(
+                f"{signal_name}: loaded {len(records)} records, "
+                f"expected {full_dataset_size}"
+            )
+
+        frame = pd.DataFrame(
+            records,
+            columns=["datetime", "instrument", "score"],
+        )
+        frame["datetime"] = pd.to_datetime(frame["datetime"])
+
+        duplicate_mask = frame.duplicated(
+            subset=["datetime", "instrument"],
+            keep=False,
+        )
+        if duplicate_mask.any():
+            duplicate_examples = frame.loc[
+                duplicate_mask,
+                ["datetime", "instrument"],
+            ].head(10)
+            raise RuntimeError(
+                f"{signal_name}: found "
+                f"{int(duplicate_mask.sum())} duplicated "
+                f"(datetime, instrument) rows. Examples:\n"
+                f"{duplicate_examples.to_string(index=False)}"
+            )
+
+        # pivot, rather than pivot_table, ensures duplicates can never be
+        # silently averaged.
+        prediction_dfs[signal_name] = (
+            frame
+            .pivot(
+                index="datetime",
+                columns="instrument",
+                values="score",
+            )
+            .sort_index()
+            .sort_index(axis=1)
+        )
+
+    return prediction_dfs
+
+
+def save_outputs(
+    prediction_dfs,
+    save_dir,
+    shard_dir,
+    run_id,
+    world_size,
+    full_dataset_size,
+):
+    os.makedirs(save_dir, exist_ok=True)
+
+    predictions_path = os.path.join(
+        save_dir,
+        "predictions.pkl",
+    )
+    atomic_pickle_dump(prediction_dfs, predictions_path)
+    print(f"Saved complete predictions: {predictions_path}")
+
+    valid_row_counts = {}
+    for signal_name, prediction_df in prediction_dfs.items():
+        long_df = (
+            prediction_df
+            .rename_axis("signal_date", axis="index")
+            .rename_axis("code", axis="columns")
+            .reset_index()
+            .melt(
+                id_vars="signal_date",
+                var_name="code",
+                value_name="pred",
+            )
+            .dropna(subset=["pred"])
+            .sort_values(["signal_date", "code"])
+            .reset_index(drop=True)
+        )
+
+        long_path = os.path.join(
+            save_dir,
+            f"signals_{signal_name}.csv",
+        )
+        atomic_csv_dump(long_df, long_path)
+        valid_row_counts[signal_name] = len(long_df)
+        print(
+            f"Saved {signal_name}: {len(long_df)} valid rows -> "
+            f"{long_path}"
+        )
+
+    all_dates = [
+        pd.Timestamp(date)
+        for prediction_df in prediction_dfs.values()
+        for date in prediction_df.index
+    ]
+
+    source_metadata_path = os.path.join(
+        shard_dir,
+        "run_metadata.json",
+    )
+    source_metadata = (
+        load_json(source_metadata_path)
+        if os.path.isfile(source_metadata_path)
+        else {}
+    )
+
+    metadata = {
+        **source_metadata,
+        "run_id": run_id,
+        "world_size": world_size,
+        "shard_dir": os.path.abspath(shard_dir),
+        "full_dataset_size": full_dataset_size,
+        "signals": list(EXPECTED_SIGNALS),
+        "valid_rows": valid_row_counts,
+        "actual_signal_start": (
+            min(all_dates).strftime("%Y-%m-%d")
+            if all_dates
+            else None
+        ),
+        "actual_signal_end": (
+            max(all_dates).strftime("%Y-%m-%d")
+            if all_dates
+            else None
+        ),
+        "label_or_metrics_generated": False,
+        "qlib_backtest_generated": False,
+    }
+
+    metadata_path = os.path.join(
+        save_dir,
+        "prediction_metadata.json",
+    )
+    atomic_json_dump(metadata, metadata_path)
+    print(f"Saved metadata: {metadata_path}")
+
+
+def merge_predictions(
+    shard_dir,
+    save_dir,
+    expected_world_size,
+):
+    shard_dir = os.path.abspath(shard_dir)
+    save_dir = os.path.abspath(save_dir)
+
+    if not os.path.isdir(shard_dir):
+        raise FileNotFoundError(
+            f"Shard directory does not exist: {shard_dir}"
+        )
+
+    manifests, run_id, full_dataset_size = (
+        validate_and_load_manifests(
+            shard_dir,
+            expected_world_size,
+        )
+    )
+
+    print(
+        f"Validated run {run_id}: {expected_world_size} rank(s), "
+        f"{full_dataset_size} total samples"
+    )
+
+    merged = load_all_shards(shard_dir, manifests)
+    prediction_dfs = records_to_prediction_dataframes(
+        merged,
+        full_dataset_size,
+    )
+    save_outputs(
+        prediction_dfs,
+        save_dir,
+        shard_dir,
+        run_id,
+        expected_world_size,
+        full_dataset_size,
+    )
+
+    print("Merge completed successfully.")
+
+
+def build_argument_parser():
+    parser = argparse.ArgumentParser(
+        description=(
+            "Validate and merge distributed Kronos prediction shards."
+        )
+    )
+    parser.add_argument(
+        "--shard-dir",
+        required=True,
+        help="Directory containing rank_XXXX_part_XXXXXX.pkl files.",
+    )
+    parser.add_argument(
+        "--save-dir",
+        required=True,
+        help="Directory for predictions.pkl and signals_*.csv.",
+    )
+    parser.add_argument(
+        "--world-size",
+        type=int,
+        required=True,
+        help="Total number of ranks used by the inference run.",
+    )
+    return parser
+
+
+def main():
+    args = build_argument_parser().parse_args()
+
+    if args.world_size <= 0:
+        raise ValueError("--world-size must be positive")
+
+    merge_predictions(
+        shard_dir=args.shard_dir,
+        save_dir=args.save_dir,
+        expected_world_size=args.world_size,
+    )
+
+
+if __name__ == "__main__":
+    main()

Kronos/finetune/outputs/backtest_results/finetune_backtest_demo/predictions.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2d947b7221a569bd2b8bb05a5ff2bf8786300d40541ac9f9a0633a8d4f89d5c0
+size 25311074

Kronos/finetune/qlib_data_preprocess.py

@@ -0,0 +1,130 @@
+import os
+import pickle
+import numpy as np
+import pandas as pd
+import qlib
+from qlib.config import REG_CN
+from qlib.data import D
+from qlib.data.dataset.loader import QlibDataLoader
+from tqdm import trange
+
+from config import Config
+
+
+class QlibDataPreprocessor:
+    """
+    A class to handle the loading, processing, and splitting of Qlib financial data.
+    """
+
+    def __init__(self):
+        """Initializes the preprocessor with configuration and data fields."""
+        self.config = Config()
+        self.data_fields = ['open', 'close', 'high', 'low', 'volume', 'vwap']
+        self.data = {}  # A dictionary to store processed data for each symbol.
+
+    def initialize_qlib(self):
+        """Initializes the Qlib environment."""
+        print("Initializing Qlib...")
+        qlib.init(provider_uri=self.config.qlib_data_path, region=REG_CN)
+
+    def load_qlib_data(self):
+        """
+        Loads raw data from Qlib, processes it symbol by symbol, and stores
+        it in the `self.data` attribute.
+        """
+        print("Loading and processing data from Qlib...")
+        data_fields_qlib = ['$' + f for f in self.data_fields]
+        cal: np.ndarray = D.calendar()
+
+        # Determine the actual start and end times to load, including buffer for lookback and predict windows.
+        start_index = cal.searchsorted(pd.Timestamp(self.config.dataset_begin_time))
+        end_index = cal.searchsorted(pd.Timestamp(self.config.dataset_end_time))
+
+        # Check if start_index lookbackw_window will cause negative index
+        adjusted_start_index = max(start_index - self.config.lookback_window, 0)
+        real_start_time = cal[adjusted_start_index]
+
+        # Check if end_index exceeds the range of the array
+        if end_index >= len(cal):
+            end_index = len(cal) - 1
+        elif cal[end_index] != pd.Timestamp(self.config.dataset_end_time):
+            end_index -= 1
+
+        # Check if end_index+predictw_window will exceed the range of the array
+        adjusted_end_index = min(end_index + self.config.predict_window, len(cal) - 1)
+        real_end_time = cal[adjusted_end_index]
+
+        # Load data using Qlib's data loader.
+        data_df = QlibDataLoader(config=data_fields_qlib).load(
+            self.config.instrument, real_start_time, real_end_time
+        )
+        data_df = data_df.stack().unstack(level=1)  # Reshape for easier access.
+
+        symbol_list = list(data_df.columns)
+        for i in trange(len(symbol_list), desc="Processing Symbols"):
+            symbol = symbol_list[i]
+            symbol_df = data_df[symbol]
+
+            # Pivot the table to have features as columns and datetime as index.
+            symbol_df = symbol_df.reset_index().rename(columns={'level_1': 'field'})
+            symbol_df = pd.pivot(symbol_df, index='datetime', columns='field', values=symbol)
+            symbol_df = symbol_df.rename(columns={f'${field}': field for field in self.data_fields})
+
+            # Calculate amount and select final features.
+            symbol_df['vol'] = symbol_df['volume']
+            symbol_df['amt'] = (symbol_df['open'] + symbol_df['high'] + symbol_df['low'] + symbol_df['close']) / 4 * symbol_df['vol']
+            symbol_df = symbol_df[self.config.feature_list]
+
+            # Filter out symbols with insufficient data.
+            symbol_df = symbol_df.dropna()
+            if len(symbol_df) < self.config.lookback_window + self.config.predict_window + 1:
+                continue
+
+            self.data[symbol] = symbol_df
+
+    def prepare_dataset(self):
+        """
+        Splits the loaded data into train, validation, and test sets and saves them to disk.
+        """
+        print("Splitting data into train, validation, and test sets...")
+        train_data, val_data, test_data = {}, {}, {}
+
+        symbol_list = list(self.data.keys())
+        for i in trange(len(symbol_list), desc="Preparing Datasets"):
+            symbol = symbol_list[i]
+            symbol_df = self.data[symbol]
+
+            # Define time ranges from config.
+            train_start, train_end = self.config.train_time_range
+            val_start, val_end = self.config.val_time_range
+            test_start, test_end = self.config.test_time_range
+
+            # Create boolean masks for each dataset split.
+            train_mask = (symbol_df.index >= train_start) & (symbol_df.index <= train_end)
+            val_mask = (symbol_df.index >= val_start) & (symbol_df.index <= val_end)
+            test_mask = (symbol_df.index >= test_start) & (symbol_df.index <= test_end)
+
+            # Apply masks to create the final datasets.
+            train_data[symbol] = symbol_df[train_mask]
+            val_data[symbol] = symbol_df[val_mask]
+            test_data[symbol] = symbol_df[test_mask]
+
+        # Save the datasets using pickle.
+        os.makedirs(self.config.dataset_path, exist_ok=True)
+        with open(f"{self.config.dataset_path}/train_data.pkl", 'wb') as f:
+            pickle.dump(train_data, f)
+        with open(f"{self.config.dataset_path}/val_data.pkl", 'wb') as f:
+            pickle.dump(val_data, f)
+        with open(f"{self.config.dataset_path}/test_data.pkl", 'wb') as f:
+            pickle.dump(test_data, f)
+
+        print("Datasets prepared and saved successfully.")
+
+
+if __name__ == '__main__':
+    # This block allows the script to be run directly to perform data preprocessing.
+    preprocessor = QlibDataPreprocessor()
+    preprocessor.initialize_qlib()
+    preprocessor.load_qlib_data()
+    preprocessor.prepare_dataset()
+

Kronos/finetune/qlib_test copy.py

@@ -0,0 +1,438 @@
+import os
+import sys
+import argparse
+import pickle
+from collections import defaultdict
+
+import numpy as np
+import pandas as pd
+import torch
+import torch.distributed as dist
+from torch.utils.data import Dataset, DataLoader, Subset
+from tqdm import trange, tqdm
+from matplotlib import pyplot as plt
+
+import qlib
+from qlib.config import REG_CN
+from qlib.backtest import backtest, executor, CommonInfrastructure
+from qlib.contrib.evaluate import risk_analysis
+from qlib.contrib.strategy import TopkDropoutStrategy
+from qlib.utils import flatten_dict
+from qlib.utils.time import Freq
+
+# Ensure project root is in the Python path
+sys.path.append("../")
+from config import Config
+from model.kronos import Kronos, KronosTokenizer, auto_regressive_inference
+from utils.training_utils import setup_ddp, cleanup_ddp
+
+
+# =================================================================================
+# 1. Data Loading and Processing for Inference
+# =================================================================================
+
+class QlibTestDataset(Dataset):
+    """
+    PyTorch Dataset for handling Qlib test data, specifically for inference.
+
+    This dataset iterates through all possible sliding windows sequentially. It also
+    yields metadata like symbol and timestamp, which are crucial for mapping
+    predictions back to the original time series.
+    """
+
+    def __init__(self, data: dict, config: Config):
+        self.data = data
+        self.config = config
+        self.window_size = config.lookback_window + config.predict_window
+        self.symbols = list(self.data.keys())
+        self.feature_list = config.feature_list
+        self.time_feature_list = config.time_feature_list
+        self.indices = []
+
+        print("Preprocessing and building indices for test dataset...")
+        for symbol in self.symbols:
+            df = self.data[symbol].reset_index()
+            # Generate time features on-the-fly
+            df['minute'] = df['datetime'].dt.minute
+            df['hour'] = df['datetime'].dt.hour
+            df['weekday'] = df['datetime'].dt.weekday
+            df['day'] = df['datetime'].dt.day
+            df['month'] = df['datetime'].dt.month
+            self.data[symbol] = df  # Store preprocessed dataframe
+
+            num_samples = len(df) - self.window_size + 1
+            if num_samples > 0:
+                for i in range(0, num_samples, 48):
+                    timestamp = df.iloc[i + self.config.lookback_window - 1]['datetime']
+                    self.indices.append((symbol, i, timestamp))
+
+    def __len__(self) -> int:
+        return len(self.indices)
+
+    def __getitem__(self, idx: int):
+        symbol, start_idx, timestamp = self.indices[idx]
+        df = self.data[symbol]
+
+        context_end = start_idx + self.config.lookback_window
+        predict_end = context_end + self.config.predict_window
+
+        context_df = df.iloc[start_idx:context_end]
+        predict_df = df.iloc[context_end:predict_end]
+
+        x = context_df[self.feature_list].values.astype(np.float32)
+        x_stamp = context_df[self.time_feature_list].values.astype(np.float32)
+        y_stamp = predict_df[self.time_feature_list].values.astype(np.float32)
+
+        # Instance-level normalization, consistent with training
+        x_mean, x_std = np.mean(x, axis=0), np.std(x, axis=0)
+        x = (x - x_mean) / (x_std + 1e-5)
+        x = np.clip(x, -self.config.clip, self.config.clip)
+
+        return torch.from_numpy(x), torch.from_numpy(x_stamp), torch.from_numpy(y_stamp), symbol, timestamp
+
+
+# =================================================================================
+# 2. Backtesting Logic
+# =================================================================================
+
+class QlibBacktest:
+    """
+    A wrapper class for conducting backtesting experiments using Qlib.
+    """
+
+    def __init__(self, config: Config):
+        self.config = config
+        self.initialize_qlib()
+
+    def initialize_qlib(self):
+        """Initializes the Qlib environment."""
+        print("Initializing Qlib for backtesting...")
+        qlib.init(provider_uri=self.config.qlib_data_path, region=REG_CN)
+
+    def run_single_backtest(self, signal_series: pd.Series):
+        """
+        Runs a single backtest for a given prediction signal.
+
+        Returns:
+            tuple: (report_df, analysis, bench_analysis)
+        """
+        strategy = TopkDropoutStrategy(
+            topk=self.config.backtest_n_symbol_hold,
+            n_drop=self.config.backtest_n_symbol_drop,
+            hold_thresh=self.config.backtest_hold_thresh,
+            signal=signal_series,
+        )
+        executor_config = {
+            "time_per_step": "day",
+            "generate_portfolio_metrics": True,
+            "delay_execution": True,
+        }
+        backtest_config = {
+            "start_time": self.config.backtest_time_range[0],
+            "end_time": self.config.backtest_time_range[1],
+            "account": 100_000_000,
+            "benchmark": self.config.backtest_benchmark,
+            "exchange_kwargs": {
+                "freq": "day", "limit_threshold": 0.095, "deal_price": "open",
+                "open_cost": 0.001, "close_cost": 0.0015, "min_cost": 5,
+            },
+            "executor": executor.SimulatorExecutor(**executor_config),
+        }
+
+        portfolio_metric_dict, _ = backtest(strategy=strategy, **backtest_config)
+        analysis_freq = "{0}{1}".format(*Freq.parse("day"))
+        report, _ = portfolio_metric_dict.get(analysis_freq)
+
+        bench_analysis = risk_analysis(report["bench"], freq=analysis_freq)
+        analysis = {
+            "excess_return_without_cost": risk_analysis(report["return"] - report["bench"], freq=analysis_freq),
+            "excess_return_with_cost": risk_analysis(report["return"] - report["bench"] - report["cost"], freq=analysis_freq),
+        }
+        print("\n--- Backtest Analysis ---")
+        print("Benchmark Return:", bench_analysis, sep='\n')
+        print("\nExcess Return (w/o cost):", analysis["excess_return_without_cost"], sep='\n')
+        print("\nExcess Return (w/ cost):", analysis["excess_return_with_cost"], sep='\n')
+
+        report_df = pd.DataFrame({
+            "cum_bench": report["bench"].cumsum(),
+            "cum_return_w_cost": (report["return"] - report["cost"]).cumsum(),
+            "cum_ex_return_w_cost": (report["return"] - report["bench"] - report["cost"]).cumsum(),
+        })
+        return report_df, analysis, bench_analysis
+
+    def run_and_plot_results(self, signals: dict, save_dir: str = None):
+        """
+        Runs backtests for multiple signals, plots cumulative return curves,
+        and saves metrics + curves to files if save_dir is provided.
+        """
+        import datetime
+        return_df, ex_return_df, bench_df = pd.DataFrame(), pd.DataFrame(), pd.DataFrame()
+        all_analysis = {}
+
+        for signal_name, pred_df in signals.items():
+            print(f"\nBacktesting signal: {signal_name}...")
+            pred_series = pred_df.stack()
+            pred_series.index.names = ['datetime', 'instrument']
+            pred_series = pred_series.swaplevel().sort_index()
+            report_df, analysis, bench_analysis = self.run_single_backtest(pred_series)
+
+            return_df[signal_name] = report_df['cum_return_w_cost']
+            ex_return_df[signal_name] = report_df['cum_ex_return_w_cost']
+            if 'return' not in bench_df:
+                bench_df['return'] = report_df['cum_bench']
+            all_analysis[signal_name] = {'analysis': analysis, 'bench_analysis': bench_analysis}
+
+        # Plotting results
+        fig, axes = plt.subplots(2, 1, figsize=(12, 8), sharex=True)
+        return_df.plot(ax=axes[0], title='Cumulative Return with Cost', grid=True)
+        axes[0].plot(bench_df['return'], label=self.config.instrument.upper(), color='black', linestyle='--')
+        axes[0].legend()
+        axes[0].set_ylabel("Cumulative Return")
+
+        ex_return_df.plot(ax=axes[1], title='Cumulative Excess Return with Cost', grid=True)
+        axes[1].legend()
+        axes[1].set_xlabel("Date")
+        axes[1].set_ylabel("Cumulative Excess Return")
+
+        plt.tight_layout()
+
+        if save_dir:
+            os.makedirs(save_dir, exist_ok=True)
+
+            # Save plot
+            plot_path = os.path.join(save_dir, "backtest_curves.png")
+            plt.savefig(plot_path, dpi=200)
+            print(f"Plot saved to {plot_path}")
+
+            # Save cumulative return curves as CSV
+            curves_df = pd.concat([bench_df, return_df, ex_return_df], axis=1)
+            curves_df.columns = (
+                ['bench_cumret'] +
+                [f'{s}_cumret' for s in return_df.columns] +
+                [f'{s}_cum_exret' for s in ex_return_df.columns]
+            )
+            curves_path = os.path.join(save_dir, "backtest_curves.csv")
+            curves_df.to_csv(curves_path)
+            print(f"Curves saved to {curves_path}")
+
+            # Save metrics summary as text
+            summary_path = os.path.join(save_dir, "backtest_summary.txt")
+            with open(summary_path, 'w') as f:
+                f.write(f"Generated: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+                f.write(f"Backtest Period: {self.config.backtest_time_range[0]} ~ {self.config.backtest_time_range[1]}\n")
+                f.write(f"Hold Top-K: {self.config.backtest_n_symbol_hold}, Drop: {self.config.backtest_n_symbol_drop}\n\n")
+                for signal_name, data in all_analysis.items():
+                    f.write(f"{'='*50}\n")
+                    f.write(f"Signal: {signal_name}\n")
+                    f.write(f"{'='*50}\n")
+                    f.write("Benchmark:\n")
+                    f.write(data['bench_analysis'].to_string())
+                    f.write("\n\nExcess Return (w/o cost):\n")
+                    f.write(data['analysis']['excess_return_without_cost'].to_string())
+                    f.write("\n\nExcess Return (w/ cost):\n")
+                    f.write(data['analysis']['excess_return_with_cost'].to_string())
+                    f.write("\n\n")
+            print(f"Summary saved to {summary_path}")
+
+        else:
+            plt.savefig("../figures/backtest_result_example.png", dpi=200)
+
+        plt.show()
+
+
+# =================================================================================
+# 3. Inference Logic
+# =================================================================================
+
+def load_models(device: torch.device) -> tuple[KronosTokenizer, Kronos]:
+    """Loads the fine-tuned tokenizer and predictor model."""
+    print(f"Loading models onto device: {device}...")
+    # tokenizer = KronosTokenizer.from_pretrained(config['tokenizer_path']).to(device).eval()
+    # model = Kronos.from_pretrained(config['model_path']).to(device).eval()
+    tokenizer = KronosTokenizer.from_pretrained("NeoQuasar/Kronos-Tokenizer-base").to(device).to(torch.bfloat16).eval()
+    model = Kronos.from_pretrained("NeoQuasar/Kronos-base").to(device).to(torch.bfloat16).eval()
+    # model = torch.compile(model)
+    return tokenizer, model
+
+
+def collate_fn_for_inference(batch):
+    """
+    Custom collate function to handle batches containing Tensors, strings, and Timestamps.
+
+    Args:
+        batch (list): A list of samples, where each sample is the tuple returned by
+                      QlibTestDataset.__getitem__.
+
+    Returns:
+        A single tuple containing the batched data.
+    """
+    # Unzip the list of samples into separate lists for each data type
+    x, x_stamp, y_stamp, symbols, timestamps = zip(*batch)
+
+    # Stack the tensors to create a batch
+    x_batch = torch.stack(x, dim=0)
+    x_stamp_batch = torch.stack(x_stamp, dim=0)
+    y_stamp_batch = torch.stack(y_stamp, dim=0)
+
+    # Return the strings and timestamps as lists
+    return x_batch, x_stamp_batch, y_stamp_batch, list(symbols), list(timestamps)
+
+
+def generate_predictions(config: dict, test_data: dict, rank: int = 0, world_size: int = 1, local_rank: int = 0):
+    """
+    Runs inference on the test dataset to generate prediction signals.
+    Supports both single-GPU and multi-GPU (torchrun) modes.
+
+    In multi-GPU mode, each rank processes a disjoint slice of the dataset.
+    Results are gathered to rank 0, which returns the merged DataFrames.
+    Other ranks return None.
+    """
+    device = torch.device(f"cuda:{local_rank}" if torch.cuda.is_available() else "cpu")
+    tokenizer, model = load_models(device)
+
+    full_dataset = QlibTestDataset(data=test_data, config=Config())
+
+    # Each rank handles every world_size-th sample: rank0→[0,2,4,...], rank1→[1,3,5,...]
+    rank_indices = list(range(rank, len(full_dataset), world_size))
+    dataset = Subset(full_dataset, rank_indices)
+
+    loader = DataLoader(
+        dataset,
+        batch_size=config['batch_size'] // config['sample_count'],
+        shuffle=False,
+        num_workers=8,
+        collate_fn=collate_fn_for_inference
+    )
+
+    results = defaultdict(list)
+    with torch.no_grad(), torch.autocast(device_type='cuda', dtype=torch.bfloat16):
+        for x, x_stamp, y_stamp, symbols, timestamps in tqdm(loader, desc=f"Inference [rank {rank}]", disable=rank != 0):
+            preds = auto_regressive_inference(
+                tokenizer, model, x.to(device), x_stamp.to(device), y_stamp.to(device),
+                max_context=config['max_context'], pred_len=config['pred_len'], clip=config['clip'],
+                T=config['T'], top_k=config['top_k'], top_p=config['top_p'], sample_count=config['sample_count']
+            )
+            # You can try commenting on this line to keep the history data
+            preds = preds[:, -config['pred_len']:, :]
+
+            # Convert to float32 numpy for signal calculation
+            if isinstance(preds, torch.Tensor):
+                preds = preds.float().cpu().numpy()
+
+            # The 'close' price is at index 3 in `feature_list`
+            last_day_close = x[:, -1, 3].numpy()
+            signals = {
+                'last': preds[:, -1, 3] - last_day_close,
+                'mean': np.mean(preds[:, :, 3], axis=1) - last_day_close,
+                'max': np.max(preds[:, :, 3], axis=1) - last_day_close,
+                'min': np.min(preds[:, :, 3], axis=1) - last_day_close,
+            }
+
+            for i in range(len(symbols)):
+                for sig_type, sig_values in signals.items():
+                    results[sig_type].append((timestamps[i], symbols[i], sig_values[i]))
+
+    # Gather results from all ranks to rank 0
+    if world_size > 1:
+        all_results = [None] * world_size
+        dist.all_gather_object(all_results, dict(results))
+    else:
+        all_results = [dict(results)]
+
+    if rank != 0:
+        return None
+
+    # Merge results from all ranks and build DataFrames
+    if rank == 0:
+        print("Post-processing predictions into DataFrames...")
+    merged = defaultdict(list)
+    for rank_result in all_results:
+        for sig_type, records in rank_result.items():
+            merged[sig_type].extend(records)
+
+    prediction_dfs = {}
+    for sig_type, records in merged.items():
+        df = pd.DataFrame(records, columns=['datetime', 'instrument', 'score'])
+        pivot_df = df.pivot_table(index='datetime', columns='instrument', values='score')
+        prediction_dfs[sig_type] = pivot_df.sort_index()
+
+    return prediction_dfs
+
+
+# =================================================================================
+# 4. Main Execution
+# =================================================================================
+
+def main():
+    """Main function to set up config, run inference, and execute backtesting.
+
+    Single-GPU:  python qlib_test.py --device cuda:0
+    Multi-GPU:   torchrun --standalone --nproc_per_node=N qlib_test.py
+    """
+    # Detect whether launched by torchrun (multi-GPU) or plain python (single-GPU)
+    is_distributed = int(os.environ.get("WORLD_SIZE", 1)) > 1
+
+    if is_distributed:
+        rank, world_size, local_rank = setup_ddp()
+    else:
+        parser = argparse.ArgumentParser(description="Run Kronos Inference and Backtesting")
+        parser.add_argument("--device", type=str, default="cuda:0", help="Device for inference (e.g., 'cuda:0', 'cpu')")
+        args = parser.parse_args()
+        rank, world_size = 0, 1
+        local_rank = int(args.device.split(":")[-1]) if args.device.startswith("cuda:") else 0
+
+    # --- 1. Configuration Setup ---
+    base_config = Config()
+
+    run_config = {
+        'data_path': base_config.dataset_path,
+        'result_save_path': base_config.backtest_result_path,
+        'result_name': base_config.backtest_save_folder_name,
+        'tokenizer_path': base_config.finetuned_tokenizer_path,
+        'model_path': base_config.finetuned_predictor_path,
+        'max_context': base_config.max_context,
+        'pred_len': base_config.predict_window,
+        'clip': base_config.clip,
+        'T': base_config.inference_T,
+        'top_k': base_config.inference_top_k,
+        'top_p': base_config.inference_top_p,
+        'sample_count': base_config.inference_sample_count,
+        'batch_size': base_config.backtest_batch_size,
+    }
+
+    if rank == 0:
+        print(f"--- Running with {world_size} GPU(s) ---")
+        for key, val in run_config.items():
+            print(f"{key:>20}: {val}")
+        print("-" * 35)
+
+    # --- 2. Load Data (all ranks load, avoids rank-0 bottleneck) ---
+    test_data_path = os.path.join(run_config['data_path'], "test_data.pkl")
+    if rank == 0:
+        print(f"Loading test data from {test_data_path}...")
+    with open(test_data_path, 'rb') as f:
+        test_data = pickle.load(f)
+
+    # --- 3. Generate Predictions ---
+    model_preds = generate_predictions(run_config, test_data, rank=rank, world_size=world_size, local_rank=local_rank)
+
+    # --- 4 & 5. Save and Backtest (rank 0 only) ---
+    if rank == 0:
+        save_dir = os.path.join(run_config['result_save_path'], run_config['result_name'])
+        os.makedirs(save_dir, exist_ok=True)
+        predictions_file = os.path.join(save_dir, "predictions.pkl")
+        print(f"Saving prediction signals to {predictions_file}...")
+        with open(predictions_file, 'wb') as f:
+            pickle.dump(model_preds, f)
+
+        backtester = QlibBacktest(base_config)
+        backtester.run_and_plot_results(model_preds, save_dir=save_dir)
+
+    if is_distributed:
+        cleanup_ddp()
+
+
+if __name__ == '__main__':
+    main()
+
+

Kronos/finetune/qlib_test.py

@@ -0,0 +1,645 @@
+import argparse
+import json
+import os
+import pickle
+import sys
+import time
+from collections import defaultdict
+from contextlib import nullcontext
+
+import numpy as np
+import pandas as pd
+import torch
+import torch.distributed as dist
+from torch.utils.data import DataLoader, Dataset, Subset
+from tqdm import tqdm
+
+
+# Keep the original project layout assumption: this script normally lives in a
+# subdirectory directly below the project root.
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+PROJECT_ROOT = os.path.abspath(os.path.join(SCRIPT_DIR, ".."))
+if PROJECT_ROOT not in sys.path:
+    sys.path.insert(0, PROJECT_ROOT)
+
+from config import Config
+from model.kronos import Kronos, KronosTokenizer, auto_regressive_inference
+from utils.training_utils import cleanup_ddp, setup_ddp
+
+
+SIGNAL_NAMES = ("cc", "oc", "oo2")
+
+
+def _atomic_pickle_dump(value, path):
+    """Write a pickle atomically so interruption cannot leave a partial file."""
+    parent = os.path.dirname(path)
+    if parent:
+        os.makedirs(parent, exist_ok=True)
+
+    tmp_path = f"{path}.tmp.{os.getpid()}"
+    try:
+        with open(tmp_path, "wb") as f:
+            pickle.dump(value, f, protocol=pickle.HIGHEST_PROTOCOL)
+            f.flush()
+            os.fsync(f.fileno())
+        os.replace(tmp_path, path)
+    finally:
+        if os.path.exists(tmp_path):
+            os.unlink(tmp_path)
+
+
+def _atomic_json_dump(value, path):
+    """Write JSON atomically."""
+    parent = os.path.dirname(path)
+    if parent:
+        os.makedirs(parent, exist_ok=True)
+
+    tmp_path = f"{path}.tmp.{os.getpid()}"
+    try:
+        with open(tmp_path, "w", encoding="utf-8") as f:
+            json.dump(value, f, ensure_ascii=False, indent=2)
+            f.flush()
+            os.fsync(f.fileno())
+        os.replace(tmp_path, path)
+    finally:
+        if os.path.exists(tmp_path):
+            os.unlink(tmp_path)
+
+
+def _validate_run_id(run_id):
+    """Prevent a run id from accidentally escaping the shard parent directory."""
+    if not run_id:
+        raise ValueError("run_id cannot be empty")
+    if os.path.basename(run_id) != run_id or run_id in {".", ".."}:
+        raise ValueError(
+            "run_id must be a directory name, not a path; "
+            f"received: {run_id!r}"
+        )
+    return run_id
+
+
+def _new_distributed_run_id(rank, world_size, requested_run_id=None):
+    """Resolve one shard-directory name shared by all ranks.
+
+    Supplying --run-id (or KRONOS_RUN_ID) is recommended because it makes the
+    later offline merge command deterministic.  If no id is supplied, rank 0
+    creates one and broadcasts it before inference starts.  There is no
+    collective communication after inference begins.
+    """
+    if requested_run_id:
+        return _validate_run_id(requested_run_id)
+
+    if world_size == 1:
+        return _validate_run_id(
+            f"single_{time.strftime('%Y%m%d_%H%M%S')}_{os.getpid()}"
+        )
+
+    shared_run_id = [
+        f"run_{time.strftime('%Y%m%d_%H%M%S')}_{os.getpid()}"
+        if rank == 0
+        else None
+    ]
+    dist.broadcast_object_list(shared_run_id, src=0)
+    return _validate_run_id(shared_run_id[0])
+
+
+class QlibTestDataset(Dataset):
+    """Sequential inference windows with symbol and signal-date metadata."""
+
+    def __init__(self, data, config):
+        self.data = data
+        self.config = config
+        self.window_size = config.lookback_window + config.predict_window
+        self.symbols = list(self.data.keys())
+        self.feature_list = config.feature_list
+        self.time_feature_list = config.time_feature_list
+        self.signal_start = pd.Timestamp(
+            config.test_time_range[0]
+        ).normalize()
+        self.signal_end = pd.Timestamp(
+            config.test_time_range[1]
+        ).normalize()
+        self.indices = []
+
+        print("Preprocessing and building indices for test dataset...", flush=True)
+
+        for symbol in self.symbols:
+            df = self.data[symbol].reset_index()
+
+            if "datetime" not in df.columns:
+                raise KeyError(
+                    f"{symbol}: reset_index() did not produce a datetime column"
+                )
+
+            df["datetime"] = pd.to_datetime(df["datetime"])
+            df["minute"] = df["datetime"].dt.minute
+            df["hour"] = df["datetime"].dt.hour
+            df["weekday"] = df["datetime"].dt.weekday
+            df["day"] = df["datetime"].dt.day
+            df["month"] = df["datetime"].dt.month
+            self.data[symbol] = df
+
+            num_samples = len(df) - self.window_size + 1
+            if num_samples <= 0:
+                continue
+
+            # One signal window every 48 five-minute bars, matching the
+            # original inference logic.
+            for start_idx in range(0, num_samples, 48):
+                timestamp = pd.Timestamp(
+                    df.iloc[
+                        start_idx + self.config.lookback_window - 1
+                    ]["datetime"]
+                )
+                signal_date = timestamp.normalize()
+
+                if self.signal_start <= signal_date <= self.signal_end:
+                    self.indices.append((symbol, start_idx, signal_date))
+
+        print(
+            f"Inference signal range: {self.signal_start.date()} ~ "
+            f"{self.signal_end.date()} | valid samples: {len(self.indices)}",
+            flush=True,
+        )
+
+    def __len__(self):
+        return len(self.indices)
+
+    def __getitem__(self, idx):
+        symbol, start_idx, signal_date = self.indices[idx]
+        df = self.data[symbol]
+
+        context_end = start_idx + self.config.lookback_window
+        predict_end = context_end + self.config.predict_window
+
+        context_df = df.iloc[start_idx:context_end]
+        predict_df = df.iloc[context_end:predict_end]
+
+        x = context_df[self.feature_list].values.astype(np.float32)
+        x_stamp = context_df[
+            self.time_feature_list
+        ].values.astype(np.float32)
+        y_stamp = predict_df[
+            self.time_feature_list
+        ].values.astype(np.float32)
+
+        # Raw last context bar.  It is used as the denominator for returns.
+        current_values = x[-1].copy()
+
+        # Instance-level normalization, consistent with training.
+        x_mean = np.mean(x, axis=0)
+        x_std = np.std(x, axis=0)
+        x = (x - x_mean) / (x_std + 1e-5)
+        x = np.clip(x, -self.config.clip, self.config.clip)
+
+        return (
+            torch.from_numpy(x),
+            torch.from_numpy(x_stamp),
+            torch.from_numpy(y_stamp),
+            symbol,
+            signal_date,
+            torch.from_numpy(current_values),
+            torch.from_numpy(x_mean.astype(np.float32)),
+            torch.from_numpy(x_std.astype(np.float32)),
+        )
+
+
+def collate_fn_for_inference(batch):
+    """Stack tensor fields while preserving symbols and pandas timestamps."""
+    (
+        x,
+        x_stamp,
+        y_stamp,
+        symbols,
+        timestamps,
+        current_values,
+        x_mean,
+        x_std,
+    ) = zip(*batch)
+
+    return (
+        torch.stack(x, dim=0),
+        torch.stack(x_stamp, dim=0),
+        torch.stack(y_stamp, dim=0),
+        list(symbols),
+        list(timestamps),
+        torch.stack(current_values, dim=0),
+        torch.stack(x_mean, dim=0),
+        torch.stack(x_std, dim=0),
+    )
+
+
+def load_models(config, device):
+    """Load the tokenizer and predictor onto one rank's device."""
+    print(f"Loading models onto device: {device}...", flush=True)
+
+    model_dtype = (
+        torch.bfloat16
+        if device.type == "cuda"
+        else torch.float32
+    )
+
+    tokenizer = (
+        KronosTokenizer
+        .from_pretrained(config["tokenizer_path"])
+        .to(device)
+        .to(model_dtype)
+        .eval()
+    )
+    model = (
+        Kronos
+        .from_pretrained(config["model_path"])
+        .to(device)
+        .to(model_dtype)
+        .eval()
+    )
+    return tokenizer, model
+
+
+def _calculate_return(numerator, denominator):
+    """Calculate numerator / denominator - 1 with invalid values as NaN."""
+    result = np.full(numerator.shape, np.nan, dtype=np.float32)
+    valid = (
+        np.isfinite(numerator)
+        & np.isfinite(denominator)
+        & (np.abs(denominator) > 1e-8)
+    )
+    result[valid] = numerator[valid] / denominator[valid] - 1.0
+    return result
+
+
+def generate_prediction_shards(
+    config,
+    base_config,
+    test_data,
+    rank=0,
+    world_size=1,
+    local_rank=0,
+):
+    """Run one rank's inference and persist independent checkpoint shards.
+
+    Every rank writes its own part files and one final .done.json manifest.
+    No rank waits for another rank after inference.  Final output construction
+    is intentionally delegated to merge_predictions.py.
+    """
+    device = torch.device(
+        config.get("device", f"cuda:{local_rank}")
+    )
+
+    if device.type == "cuda" and not torch.cuda.is_available():
+        raise RuntimeError(f"Requested {device}, but CUDA is unavailable")
+    if config["pred_len"] < 49:
+        raise ValueError(
+            "predict_window must be at least 49 for cc/oc/oo2 signals"
+        )
+    if config["sample_count"] <= 0:
+        raise ValueError("sample_count must be positive")
+
+    tokenizer, model = load_models(config, device)
+    full_dataset = QlibTestDataset(test_data, base_config)
+
+    # range is a compact sequence; unlike list(range(...)), it does not create
+    # another large Python list on every rank.
+    rank_indices = range(rank, len(full_dataset), world_size)
+    rank_dataset = Subset(full_dataset, rank_indices)
+
+    per_rank_batch_size = max(
+        1,
+        config["batch_size"] // config["sample_count"],
+    )
+
+    loader = DataLoader(
+        rank_dataset,
+        batch_size=per_rank_batch_size,
+        shuffle=False,
+        num_workers=0,
+        collate_fn=collate_fn_for_inference,
+    )
+
+    shard_dir = config["shard_dir"]
+    checkpoint_batches = max(
+        1,
+        int(config.get("checkpoint_batches", 64)),
+    )
+    os.makedirs(shard_dir, exist_ok=True)
+
+    # If the same run id is deliberately rerun, an old completion marker must
+    # never make the offline merger believe this rank has already completed.
+    manifest_path = os.path.join(
+        shard_dir,
+        f"rank_{rank:04d}.done.json",
+    )
+    if os.path.exists(manifest_path):
+        os.unlink(manifest_path)
+
+    results = defaultdict(list)
+    part_index = 0
+    batch_count = 0
+    processed_samples = 0
+
+    autocast_context = (
+        torch.autocast(
+            device_type="cuda",
+            dtype=torch.bfloat16,
+        )
+        if device.type == "cuda"
+        else nullcontext()
+    )
+
+    with torch.no_grad(), autocast_context:
+        for batch_index, batch in enumerate(
+            tqdm(
+                loader,
+                desc=f"Inference [rank {rank}]",
+                disable=rank != 0,
+            ),
+            start=1,
+        ):
+            (
+                x,
+                x_stamp,
+                y_stamp,
+                symbols,
+                timestamps,
+                current_values,
+                x_mean,
+                x_std,
+            ) = batch
+
+            preds = auto_regressive_inference(
+                tokenizer,
+                model,
+                x.to(device),
+                x_stamp.to(device),
+                y_stamp.to(device),
+                max_context=config["max_context"],
+                pred_len=config["pred_len"],
+                clip=config["clip"],
+                T=config["T"],
+                top_k=config["top_k"],
+                top_p=config["top_p"],
+                sample_count=config["sample_count"],
+            )
+
+            # Keep only the generated future bars if the helper also returns
+            # history.
+            preds = preds[:, -config["pred_len"]:, :]
+
+            if isinstance(preds, torch.Tensor):
+                preds = preds.float().cpu().numpy()
+            else:
+                preds = np.asarray(preds, dtype=np.float32)
+
+            # Undo the per-instance normalization before computing returns.
+            x_mean_np = x_mean.numpy()[:, None, :]
+            x_std_np = x_std.numpy()[:, None, :]
+            preds_raw = preds * (x_std_np + 1e-5) + x_mean_np
+            current_values_np = current_values.numpy()
+
+            current_close = current_values_np[:, 3]
+            signals = {
+                # T+1 last close / T close - 1
+                "cc": _calculate_return(
+                    preds_raw[:, 47, 3],
+                    current_close,
+                ),
+                # T+1 first open / T close - 1
+                "oc": _calculate_return(
+                    preds_raw[:, 0, 0],
+                    current_close,
+                ),
+                # T+2 first open / T+1 first open - 1
+                "oo2": _calculate_return(
+                    preds_raw[:, 48, 0],
+                    preds_raw[:, 0, 0],
+                ),
+            }
+
+            for sample_offset, (timestamp, symbol) in enumerate(
+                zip(timestamps, symbols)
+            ):
+                for signal_name in SIGNAL_NAMES:
+                    results[signal_name].append(
+                        (
+                            timestamp,
+                            symbol,
+                            signals[signal_name][sample_offset],
+                        )
+                    )
+
+            batch_count = batch_index
+            processed_samples += len(symbols)
+
+            if batch_index % checkpoint_batches == 0:
+                part_path = os.path.join(
+                    shard_dir,
+                    f"rank_{rank:04d}_part_{part_index:06d}.pkl",
+                )
+                _atomic_pickle_dump(dict(results), part_path)
+                results = defaultdict(list)
+                part_index += 1
+
+    # Write the last partial part.  An empty rank still writes one empty part,
+    # which makes its successful completion explicit.
+    if results or part_index == 0:
+        part_path = os.path.join(
+            shard_dir,
+            f"rank_{rank:04d}_part_{part_index:06d}.pkl",
+        )
+        _atomic_pickle_dump(dict(results), part_path)
+        part_index += 1
+
+    expected_rank_samples = len(rank_dataset)
+    if processed_samples != expected_rank_samples:
+        raise RuntimeError(
+            f"Rank {rank} processed {processed_samples} samples, "
+            f"but its assigned subset contains {expected_rank_samples}"
+        )
+
+    manifest = {
+        "run_id": config["run_id"],
+        "rank": rank,
+        "world_size": world_size,
+        "batches": batch_count,
+        "parts": part_index,
+        "num_samples": processed_samples,
+        "full_dataset_size": len(full_dataset),
+        "signals": list(SIGNAL_NAMES),
+    }
+    _atomic_json_dump(manifest, manifest_path)
+
+    print(
+        f"[rank {rank}] Complete: {processed_samples} samples, "
+        f"{part_index} shard(s) -> {shard_dir}",
+        flush=True,
+    )
+
+
+def build_argument_parser():
+    parser = argparse.ArgumentParser(
+        description=(
+            "Generate Kronos prediction shards. "
+            "Run merge_predictions.py after all ranks finish."
+        )
+    )
+    parser.add_argument(
+        "--device",
+        default="cuda:0",
+        help="Single-process device. torchrun assigns devices automatically.",
+    )
+    parser.add_argument(
+        "--run-id",
+        default=os.environ.get("KRONOS_RUN_ID"),
+        help=(
+            "Shared shard run id. Defaults to KRONOS_RUN_ID, or an "
+            "automatically generated id."
+        ),
+    )
+    parser.add_argument(
+        "--checkpoint-batches",
+        type=int,
+        default=int(
+            os.environ.get("KRONOS_CHECKPOINT_BATCHES", "64")
+        ),
+        help="Write one checkpoint shard every N inference batches.",
+    )
+    # Compatibility with torchrun versions that inject this CLI argument.
+    parser.add_argument(
+        "--local-rank",
+        "--local_rank",
+        type=int,
+        default=None,
+        help=argparse.SUPPRESS,
+    )
+    return parser
+
+
+def main():
+    args = build_argument_parser().parse_args()
+    is_distributed = int(os.environ.get("WORLD_SIZE", "1")) > 1
+
+    if is_distributed:
+        rank, world_size, local_rank = setup_ddp()
+        requested_device = (
+            f"cuda:{local_rank}"
+            if torch.cuda.is_available()
+            else "cpu"
+        )
+    else:
+        rank = 0
+        world_size = 1
+        local_rank = (
+            int(args.device.split(":")[-1])
+            if args.device.startswith("cuda:")
+            else 0
+        )
+        requested_device = args.device
+
+    try:
+        run_id = _new_distributed_run_id(
+            rank,
+            world_size,
+            requested_run_id=args.run_id,
+        )
+
+        base_config = Config()
+        result_dir = os.path.join(
+            base_config.signal_result_path,
+            base_config.signal_result_name,
+        )
+        shard_dir = os.path.join(
+            result_dir,
+            ".inference_shards",
+            run_id,
+        )
+
+        run_config = {
+            "run_id": run_id,
+            "device": requested_device,
+            "data_path": base_config.dataset_path,
+            "test_data_file": base_config.test_data_file,
+            "result_save_path": base_config.signal_result_path,
+            "result_name": base_config.signal_result_name,
+            "tokenizer_path": base_config.pretrained_tokenizer_path,
+            "model_path": base_config.pretrained_predictor_path,
+            "max_context": base_config.max_context,
+            "pred_len": base_config.predict_window,
+            "clip": base_config.clip,
+            "T": base_config.inference_T,
+            "top_k": base_config.inference_top_k,
+            "top_p": base_config.inference_top_p,
+            "sample_count": base_config.inference_sample_count,
+            "batch_size": base_config.backtest_batch_size,
+            "shard_dir": shard_dir,
+            "checkpoint_batches": args.checkpoint_batches,
+        }
+
+        if rank == 0:
+            os.makedirs(shard_dir, exist_ok=True)
+
+            run_metadata = {
+                "run_id": run_id,
+                "world_size": world_size,
+                "created_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+                "source_test_data": os.path.join(
+                    run_config["data_path"],
+                    run_config["test_data_file"],
+                ),
+                "signal_start": base_config.test_time_range[0],
+                "signal_end": base_config.test_time_range[1],
+                "lookback_window": base_config.lookback_window,
+                "predict_window": base_config.predict_window,
+                "stride_bars": 48,
+                "signals": list(SIGNAL_NAMES),
+                "feature_list": base_config.feature_list,
+            }
+            _atomic_json_dump(
+                run_metadata,
+                os.path.join(shard_dir, "run_metadata.json"),
+            )
+
+            print(f"--- Running with {world_size} process(es) ---")
+            for key, value in run_config.items():
+                print(f"{key:>20}: {value}")
+            print("-" * 45, flush=True)
+
+        test_data_path = os.path.join(
+            run_config["data_path"],
+            run_config["test_data_file"],
+        )
+        print(
+            f"[rank {rank}] Loading test data from {test_data_path}...",
+            flush=True,
+        )
+        with open(test_data_path, "rb") as f:
+            test_data = pickle.load(f)
+
+        generate_prediction_shards(
+            run_config,
+            base_config,
+            test_data,
+            rank=rank,
+            world_size=world_size,
+            local_rank=local_rank,
+        )
+
+        if rank == 0:
+            print(
+                "\nInference ranks write shards only; no online merge is "
+                "performed.\n"
+                "After torchrun exits successfully, run:\n"
+                f"  python merge_predictions.py "
+                f"--shard-dir {shard_dir} "
+                f"--save-dir {result_dir} "
+                f"--world-size {world_size}",
+                flush=True,
+            )
+    finally:
+        # The user's cleanup_ddp() only calls destroy_process_group(); it has
+        # no barrier, so completed ranks do not wait for slower ranks here.
+        if is_distributed:
+            cleanup_ddp()
+
+
+if __name__ == "__main__":
+    main()

Kronos/finetune/train_predictor.py

@@ -0,0 +1,244 @@
+import os
+import sys
+import json
+import time
+from time import gmtime, strftime
+import torch.distributed as dist
+import torch
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from torch.nn.parallel import DistributedDataParallel as DDP
+
+import comet_ml
+
+# Ensure project root is in path
+sys.path.append('../')
+from config import Config
+from dataset import QlibDataset
+from model.kronos import KronosTokenizer, Kronos
+# Import shared utilities
+from utils.training_utils import (
+    setup_ddp,
+    cleanup_ddp,
+    set_seed,
+    get_model_size,
+    format_time
+)
+
+
+def create_dataloaders(config: dict, rank: int, world_size: int):
+    """
+    Creates and returns distributed dataloaders for training and validation.
+
+    Args:
+        config (dict): A dictionary of configuration parameters.
+        rank (int): The global rank of the current process.
+        world_size (int): The total number of processes.
+
+    Returns:
+        tuple: (train_loader, val_loader, train_dataset, valid_dataset).
+    """
+    print(f"[Rank {rank}] Creating distributed dataloaders...")
+    train_dataset = QlibDataset('train')
+    valid_dataset = QlibDataset('val')
+    print(f"[Rank {rank}] Train dataset size: {len(train_dataset)}, Validation dataset size: {len(valid_dataset)}")
+
+    train_sampler = DistributedSampler(train_dataset, num_replicas=world_size, rank=rank, shuffle=True)
+    val_sampler = DistributedSampler(valid_dataset, num_replicas=world_size, rank=rank, shuffle=False)
+
+    train_loader = DataLoader(
+        train_dataset, batch_size=config['batch_size'], sampler=train_sampler,
+        num_workers=config.get('num_workers', 2), pin_memory=True, drop_last=True
+    )
+    val_loader = DataLoader(
+        valid_dataset, batch_size=config['batch_size'], sampler=val_sampler,
+        num_workers=config.get('num_workers', 2), pin_memory=True, drop_last=False
+    )
+    return train_loader, val_loader, train_dataset, valid_dataset
+
+
+def train_model(model, tokenizer, device, config, save_dir, logger, rank, world_size):
+    """
+    The main training and validation loop for the predictor.
+    """
+    start_time = time.time()
+    if rank == 0:
+        effective_bs = config['batch_size'] * world_size
+        print(f"Effective BATCHSIZE per GPU: {config['batch_size']}, Total: {effective_bs}")
+
+    train_loader, val_loader, train_dataset, valid_dataset = create_dataloaders(config, rank, world_size)
+
+    optimizer = torch.optim.AdamW(
+        model.parameters(),
+        lr=config['predictor_learning_rate'],
+        betas=(config['adam_beta1'], config['adam_beta2']),
+        weight_decay=config['adam_weight_decay']
+    )
+    scheduler = torch.optim.lr_scheduler.OneCycleLR(
+        optimizer, max_lr=config['predictor_learning_rate'],
+        steps_per_epoch=len(train_loader), epochs=config['epochs'],
+        pct_start=0.03, div_factor=10
+    )
+
+    best_val_loss = float('inf')
+    dt_result = {}
+    batch_idx_global = 0
+
+    for epoch_idx in range(config['epochs']):
+        epoch_start_time = time.time()
+        model.train()
+        train_loader.sampler.set_epoch(epoch_idx)
+
+        train_dataset.set_epoch_seed(epoch_idx * 10000 + rank)
+        valid_dataset.set_epoch_seed(0)
+
+        for i, (batch_x, batch_x_stamp) in enumerate(train_loader):
+            batch_x = batch_x.to(device, non_blocking=True)
+            batch_x_stamp = batch_x_stamp.to(device, non_blocking=True)
+
+            # Tokenize input data on-the-fly
+            with torch.no_grad():
+                token_seq_0, token_seq_1 = tokenizer.encode(batch_x, half=True)
+
+            # Prepare inputs and targets for the language model
+            token_in = [token_seq_0[:, :-1], token_seq_1[:, :-1]]
+            token_out = [token_seq_0[:, 1:], token_seq_1[:, 1:]]
+
+            # Forward pass and loss calculation
+            logits = model(token_in[0], token_in[1], batch_x_stamp[:, :-1, :])
+            loss, s1_loss, s2_loss = model.module.head.compute_loss(logits[0], logits[1], token_out[0], token_out[1])
+
+            # Backward pass and optimization
+            optimizer.zero_grad()
+            loss.backward()
+            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=3.0)
+            optimizer.step()
+            scheduler.step()
+
+            # Logging (Master Process Only)
+            if rank == 0 and (batch_idx_global + 1) % config['log_interval'] == 0:
+                lr = optimizer.param_groups[0]['lr']
+                print(
+                    f"[Rank {rank}, Epoch {epoch_idx + 1}/{config['epochs']}, Step {i + 1}/{len(train_loader)}] "
+                    f"LR {lr:.6f}, Loss: {loss.item():.4f}"
+                )
+            if rank == 0 and logger:
+                lr = optimizer.param_groups[0]['lr']
+                logger.log_metric('train_predictor_loss_batch', loss.item(), step=batch_idx_global)
+                logger.log_metric('train_S1_loss_each_batch', s1_loss.item(), step=batch_idx_global)
+                logger.log_metric('train_S2_loss_each_batch', s2_loss.item(), step=batch_idx_global)
+                logger.log_metric('predictor_learning_rate', lr, step=batch_idx_global)
+
+            batch_idx_global += 1
+
+        # --- Validation Loop ---
+        model.eval()
+        tot_val_loss_sum_rank = 0.0
+        val_batches_processed_rank = 0
+        with torch.no_grad():
+            for batch_x, batch_x_stamp in val_loader:
+                batch_x = batch_x.to(device, non_blocking=True)
+                batch_x_stamp = batch_x_stamp.to(device, non_blocking=True)
+
+                token_seq_0, token_seq_1 = tokenizer.encode(batch_x, half=True)
+                token_in = [token_seq_0[:, :-1], token_seq_1[:, :-1]]
+                token_out = [token_seq_0[:, 1:], token_seq_1[:, 1:]]
+
+                logits = model(token_in[0], token_in[1], batch_x_stamp[:, :-1, :])
+                val_loss, _, _ = model.module.head.compute_loss(logits[0], logits[1], token_out[0], token_out[1])
+
+                tot_val_loss_sum_rank += val_loss.item()
+                val_batches_processed_rank += 1
+
+        # Reduce validation metrics
+        val_loss_sum_tensor = torch.tensor(tot_val_loss_sum_rank, device=device)
+        val_batches_tensor = torch.tensor(val_batches_processed_rank, device=device)
+        dist.all_reduce(val_loss_sum_tensor, op=dist.ReduceOp.SUM)
+        dist.all_reduce(val_batches_tensor, op=dist.ReduceOp.SUM)
+
+        avg_val_loss = val_loss_sum_tensor.item() / val_batches_tensor.item() if val_batches_tensor.item() > 0 else 0
+
+        # --- End of Epoch Summary & Checkpointing (Master Process Only) ---
+        if rank == 0:
+            print(f"\n--- Epoch {epoch_idx + 1}/{config['epochs']} Summary ---")
+            print(f"Validation Loss: {avg_val_loss:.4f}")
+            print(f"Time This Epoch: {format_time(time.time() - epoch_start_time)}")
+            print(f"Total Time Elapsed: {format_time(time.time() - start_time)}\n")
+            if logger:
+                logger.log_metric('val_predictor_loss_epoch', avg_val_loss, epoch=epoch_idx)
+
+            if avg_val_loss < best_val_loss:
+                best_val_loss = avg_val_loss
+                save_path = f"{save_dir}/checkpoints/best_model"
+                model.module.save_pretrained(save_path)
+                print(f"Best model saved to {save_path} (Val Loss: {best_val_loss:.4f})")
+
+        dist.barrier()
+
+    dt_result['best_val_loss'] = best_val_loss
+    return dt_result
+
+
+def main(config: dict):
+    """Main function to orchestrate the DDP training process."""
+    rank, world_size, local_rank = setup_ddp()
+    device = torch.device(f"cuda:{local_rank}")
+    set_seed(config['seed'], rank)
+
+    save_dir = os.path.join(config['save_path'], config['predictor_save_folder_name'])
+
+    # Logger and summary setup (master process only)
+    comet_logger, master_summary = None, {}
+    if rank == 0:
+        os.makedirs(os.path.join(save_dir, 'checkpoints'), exist_ok=True)
+        master_summary = {
+            'start_time': strftime("%Y-%m-%dT%H-%M-%S", gmtime()),
+            'save_directory': save_dir,
+            'world_size': world_size,
+        }
+        if config['use_comet']:
+            comet_logger = comet_ml.Experiment(
+                api_key=config['comet_config']['api_key'],
+                project_name=config['comet_config']['project_name'],
+                workspace=config['comet_config']['workspace'],
+            )
+            comet_logger.add_tag(config['comet_tag'])
+            comet_logger.set_name(config['comet_name'])
+            comet_logger.log_parameters(config)
+            print("Comet Logger Initialized.")
+
+    dist.barrier()
+
+    # Model Initialization
+    tokenizer = KronosTokenizer.from_pretrained(config['finetuned_tokenizer_path'])
+    tokenizer.eval().to(device)
+
+    model = Kronos.from_pretrained(config['pretrained_predictor_path'])
+    model.to(device)
+    model = DDP(model, device_ids=[local_rank], find_unused_parameters=False)
+
+    if rank == 0:
+        print(f"Predictor Model Size: {get_model_size(model.module)}")
+
+    # Start Training
+    dt_result = train_model(
+        model, tokenizer, device, config, save_dir, comet_logger, rank, world_size
+    )
+
+    if rank == 0:
+        master_summary['final_result'] = dt_result
+        with open(os.path.join(save_dir, 'summary.json'), 'w') as f:
+            json.dump(master_summary, f, indent=4)
+        print('Training finished. Summary file saved.')
+        if comet_logger: comet_logger.end()
+
+    cleanup_ddp()
+
+
+if __name__ == '__main__':
+    # Usage: torchrun --standalone --nproc_per_node=NUM_GPUS train_predictor.py
+    if "WORLD_SIZE" not in os.environ:
+        raise RuntimeError("This script must be launched with `torchrun`.")
+
+    config_instance = Config()
+    main(config_instance.__dict__)

Kronos/finetune/train_tokenizer.py

@@ -0,0 +1,281 @@
+import os
+import sys
+import json
+import time
+from time import gmtime, strftime
+import argparse
+import datetime
+import torch.distributed as dist
+import torch
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from torch.nn.parallel import DistributedDataParallel as DDP
+
+import comet_ml
+
+# Ensure project root is in path
+sys.path.append("../")
+from config import Config
+from dataset import QlibDataset
+from model.kronos import KronosTokenizer
+# Import shared utilities
+from utils.training_utils import (
+    setup_ddp,
+    cleanup_ddp,
+    set_seed,
+    get_model_size,
+    format_time,
+)
+
+
+def create_dataloaders(config: dict, rank: int, world_size: int):
+    """
+    Creates and returns distributed dataloaders for training and validation.
+
+    Args:
+        config (dict): A dictionary of configuration parameters.
+        rank (int): The global rank of the current process.
+        world_size (int): The total number of processes.
+
+    Returns:
+        tuple: A tuple containing (train_loader, val_loader, train_dataset, valid_dataset).
+    """
+    print(f"[Rank {rank}] Creating distributed dataloaders...")
+    train_dataset = QlibDataset('train')
+    valid_dataset = QlibDataset('val')
+    print(f"[Rank {rank}] Train dataset size: {len(train_dataset)}, Validation dataset size: {len(valid_dataset)}")
+
+    train_sampler = DistributedSampler(train_dataset, num_replicas=world_size, rank=rank, shuffle=True)
+    val_sampler = DistributedSampler(valid_dataset, num_replicas=world_size, rank=rank, shuffle=False)
+
+    train_loader = DataLoader(
+        train_dataset,
+        batch_size=config['batch_size'],
+        sampler=train_sampler,
+        shuffle=False,  # Shuffle is handled by the sampler
+        num_workers=config.get('num_workers', 2),
+        pin_memory=True,
+        drop_last=True
+    )
+    val_loader = DataLoader(
+        valid_dataset,
+        batch_size=config['batch_size'],
+        sampler=val_sampler,
+        shuffle=False,
+        num_workers=config.get('num_workers', 2),
+        pin_memory=True,
+        drop_last=False
+    )
+    print(f"[Rank {rank}] Dataloaders created. Train steps/epoch: {len(train_loader)}, Val steps: {len(val_loader)}")
+    return train_loader, val_loader, train_dataset, valid_dataset
+
+
+def train_model(model, device, config, save_dir, logger, rank, world_size):
+    """
+    The main training and validation loop for the tokenizer.
+
+    Args:
+        model (DDP): The DDP-wrapped model to train.
+        device (torch.device): The device for the current process.
+        config (dict): Configuration dictionary.
+        save_dir (str): Directory to save checkpoints.
+        logger (comet_ml.Experiment): Comet logger instance.
+        rank (int): Global rank of the process.
+        world_size (int): Total number of processes.
+
+    Returns:
+        tuple: A tuple containing the trained model and a dictionary of results.
+    """
+    start_time = time.time()
+    if rank == 0:
+        effective_bs = config['batch_size'] * world_size * config['accumulation_steps']
+        print(f"[Rank {rank}] BATCHSIZE (per GPU): {config['batch_size']}")
+        print(f"[Rank {rank}] Effective total batch size: {effective_bs}")
+
+    train_loader, val_loader, train_dataset, valid_dataset = create_dataloaders(config, rank, world_size)
+
+    optimizer = torch.optim.AdamW(
+        model.parameters(),
+        lr=config['tokenizer_learning_rate'],
+        weight_decay=config['adam_weight_decay']
+    )
+
+    scheduler = torch.optim.lr_scheduler.OneCycleLR(
+        optimizer=optimizer,
+        max_lr=config['tokenizer_learning_rate'],
+        steps_per_epoch=len(train_loader),
+        epochs=config['epochs'],
+        pct_start=0.03,
+        div_factor=10
+    )
+
+    best_val_loss = float('inf')
+    dt_result = {}
+    batch_idx_global_train = 0
+
+    for epoch_idx in range(config['epochs']):
+        epoch_start_time = time.time()
+        model.train()
+        train_loader.sampler.set_epoch(epoch_idx)
+
+        # Set dataset seeds for reproducible sampling
+        train_dataset.set_epoch_seed(epoch_idx * 10000 + rank)
+        valid_dataset.set_epoch_seed(0)  # Keep validation sampling consistent
+
+        for i, (ori_batch_x, _) in enumerate(train_loader):
+            ori_batch_x = ori_batch_x.to(device, non_blocking=True)
+
+            # --- Gradient Accumulation Loop ---
+            current_batch_total_loss = 0.0
+            for j in range(config['accumulation_steps']):
+                start_idx = j * (ori_batch_x.shape[0] // config['accumulation_steps'])
+                end_idx = (j + 1) * (ori_batch_x.shape[0] // config['accumulation_steps'])
+                batch_x = ori_batch_x[start_idx:end_idx]
+
+                # Forward pass
+                zs, bsq_loss, _, _ = model(batch_x)
+                z_pre, z = zs
+
+                # Loss calculation
+                recon_loss_pre = F.mse_loss(z_pre, batch_x)
+                recon_loss_all = F.mse_loss(z, batch_x)
+                recon_loss = recon_loss_pre + recon_loss_all
+                loss = (recon_loss + bsq_loss) / 2  # Assuming w_1=w_2=1
+
+                loss_scaled = loss / config['accumulation_steps']
+                current_batch_total_loss += loss.item()
+                loss_scaled.backward()
+
+            # --- Optimizer Step after Accumulation ---
+            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=2.0)
+            optimizer.step()
+            scheduler.step()
+            optimizer.zero_grad()
+
+            # --- Logging (Master Process Only) ---
+            if rank == 0 and (batch_idx_global_train + 1) % config['log_interval'] == 0:
+                avg_loss = current_batch_total_loss / config['accumulation_steps']
+                print(
+                    f"[Rank {rank}, Epoch {epoch_idx + 1}/{config['epochs']}, Step {i + 1}/{len(train_loader)}] "
+                    f"LR {optimizer.param_groups[0]['lr']:.6f}, Loss: {avg_loss:.4f}"
+                )
+            if rank == 0 and logger:
+                avg_loss = current_batch_total_loss / config['accumulation_steps']
+                logger.log_metric('train_tokenizer_loss_batch', avg_loss, step=batch_idx_global_train)
+                logger.log_metric(f'train_vqvae_vq_loss_each_batch', bsq_loss.item(), step=batch_idx_global_train)
+                logger.log_metric(f'train_recon_loss_pre_each_batch', recon_loss_pre.item(), step=batch_idx_global_train)
+                logger.log_metric(f'train_recon_loss_each_batch', recon_loss_all.item(), step=batch_idx_global_train)
+                logger.log_metric('tokenizer_learning_rate', optimizer.param_groups[0]["lr"], step=batch_idx_global_train)
+
+            batch_idx_global_train += 1
+
+        # --- Validation Loop ---
+        model.eval()
+        tot_val_loss_sum_rank = 0.0
+        val_sample_count_rank = 0
+        with torch.no_grad():
+            for ori_batch_x, _ in val_loader:
+                ori_batch_x = ori_batch_x.to(device, non_blocking=True)
+                zs, _, _, _ = model(ori_batch_x)
+                _, z = zs
+                val_loss_item = F.mse_loss(z, ori_batch_x)
+
+                tot_val_loss_sum_rank += val_loss_item.item() * ori_batch_x.size(0)
+                val_sample_count_rank += ori_batch_x.size(0)
+
+        # Reduce validation losses from all processes
+        val_loss_sum_tensor = torch.tensor(tot_val_loss_sum_rank, device=device)
+        val_count_tensor = torch.tensor(val_sample_count_rank, device=device)
+        dist.all_reduce(val_loss_sum_tensor, op=dist.ReduceOp.SUM)
+        dist.all_reduce(val_count_tensor, op=dist.ReduceOp.SUM)
+
+        avg_val_loss = val_loss_sum_tensor.item() / val_count_tensor.item() if val_count_tensor.item() > 0 else 0
+
+        # --- End of Epoch Summary & Checkpointing (Master Process Only) ---
+        if rank == 0:
+            print(f"\n--- Epoch {epoch_idx + 1}/{config['epochs']} Summary ---")
+            print(f"Validation Loss: {avg_val_loss:.4f}")
+            print(f"Time This Epoch: {format_time(time.time() - epoch_start_time)}")
+            print(f"Total Time Elapsed: {format_time(time.time() - start_time)}\n")
+            if logger:
+                logger.log_metric('val_tokenizer_loss_epoch', avg_val_loss, epoch=epoch_idx)
+
+            if avg_val_loss < best_val_loss:
+                best_val_loss = avg_val_loss
+                save_path = f"{save_dir}/checkpoints/best_model"
+                model.module.save_pretrained(save_path)
+                print(f"Best model saved to {save_path} (Val Loss: {best_val_loss:.4f})")
+                if logger:
+                    logger.log_model("best_model", save_path)
+
+        dist.barrier()  # Ensure all processes finish the epoch before starting the next one.
+
+    dt_result['best_val_loss'] = best_val_loss
+    return model, dt_result
+
+
+def main(config: dict):
+    """
+    Main function to orchestrate the DDP training process.
+    """
+    rank, world_size, local_rank = setup_ddp()
+    device = torch.device(f"cuda:{local_rank}")
+    set_seed(config['seed'], rank)
+
+    save_dir = os.path.join(config['save_path'], config['tokenizer_save_folder_name'])
+
+    # Logger and summary setup (master process only)
+    comet_logger, master_summary = None, {}
+    if rank == 0:
+        os.makedirs(os.path.join(save_dir, 'checkpoints'), exist_ok=True)
+        master_summary = {
+            'start_time': strftime("%Y-%m-%dT%H-%M-%S", gmtime()),
+            'save_directory': save_dir,
+            'world_size': world_size,
+        }
+        if config['use_comet']:
+            comet_logger = comet_ml.Experiment(
+                api_key=config['comet_config']['api_key'],
+                project_name=config['comet_config']['project_name'],
+                workspace=config['comet_config']['workspace'],
+            )
+            comet_logger.add_tag(config['comet_tag'])
+            comet_logger.set_name(config['comet_name'])
+            comet_logger.log_parameters(config)
+            print("Comet Logger Initialized.")
+
+    dist.barrier()  # Ensure save directory is created before proceeding
+
+    # Model Initialization
+    model = KronosTokenizer.from_pretrained(config['pretrained_tokenizer_path'])
+    model.to(device)
+    model = DDP(model, device_ids=[local_rank], find_unused_parameters=False)
+
+    if rank == 0:
+        print(f"Model Size: {get_model_size(model.module)}")
+
+    # Start Training
+    _, dt_result = train_model(
+        model, device, config, save_dir, comet_logger, rank, world_size
+    )
+
+    # Finalize and save summary (master process only)
+    if rank == 0:
+        master_summary['final_result'] = dt_result
+        with open(os.path.join(save_dir, 'summary.json'), 'w') as f:
+            json.dump(master_summary, f, indent=4)
+        print('Training finished. Summary file saved.')
+        if comet_logger:
+            comet_logger.end()
+
+    cleanup_ddp()
+
+
+if __name__ == '__main__':
+    # Usage: torchrun --standalone --nproc_per_node=NUM_GPUS train_tokenizer.py
+    if "WORLD_SIZE" not in os.environ:
+        raise RuntimeError("This script must be launched with `torchrun`.")
+
+    config_instance = Config()
+    main(config_instance.__dict__)

Kronos/finetune/utils/training_utils.py

@@ -0,0 +1,118 @@
+import os
+import random
+import datetime
+import numpy as np
+import torch
+import torch.distributed as dist
+
+
+def setup_ddp():
+    """
+    Initializes the distributed data parallel environment.
+
+    This function relies on environment variables set by `torchrun` or a similar
+    launcher. It initializes the process group and sets the CUDA device for the
+    current process.
+
+    Returns:
+        tuple: A tuple containing (rank, world_size, local_rank).
+    """
+    if not dist.is_available():
+        raise RuntimeError("torch.distributed is not available.")
+
+    dist.init_process_group(backend="nccl")
+    rank = int(os.environ["RANK"])
+    world_size = int(os.environ["WORLD_SIZE"])
+    local_rank = int(os.environ["LOCAL_RANK"])
+    torch.cuda.set_device(local_rank)
+    print(
+        f"[DDP Setup] Global Rank: {rank}/{world_size}, "
+        f"Local Rank (GPU): {local_rank} on device {torch.cuda.current_device()}"
+    )
+    return rank, world_size, local_rank
+
+
+def cleanup_ddp():
+    """Cleans up the distributed process group."""
+    if dist.is_initialized():
+        dist.destroy_process_group()
+
+
+def set_seed(seed: int, rank: int = 0):
+    """
+    Sets the random seed for reproducibility across all relevant libraries.
+
+    Args:
+        seed (int): The base seed value.
+        rank (int): The process rank, used to ensure different processes have
+                    different seeds, which can be important for data loading.
+    """
+    actual_seed = seed + rank
+    random.seed(actual_seed)
+    np.random.seed(actual_seed)
+    torch.manual_seed(actual_seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(actual_seed)
+        # The two lines below can impact performance, so they are often
+        # reserved for final experiments where reproducibility is critical.
+        torch.backends.cudnn.deterministic = True
+        torch.backends.cudnn.benchmark = False
+
+
+def get_model_size(model: torch.nn.Module) -> str:
+    """
+    Calculates the number of trainable parameters in a PyTorch model and returns
+    it as a human-readable string.
+
+    Args:
+        model (torch.nn.Module): The PyTorch model.
+
+    Returns:
+        str: A string representing the model size (e.g., "175.0B", "7.1M", "50.5K").
+    """
+    total_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+
+    if total_params >= 1e9:
+        return f"{total_params / 1e9:.1f}B"  # Billions
+    elif total_params >= 1e6:
+        return f"{total_params / 1e6:.1f}M"  # Millions
+    else:
+        return f"{total_params / 1e3:.1f}K"  # Thousands
+
+
+def reduce_tensor(tensor: torch.Tensor, world_size: int, op=dist.ReduceOp.SUM) -> torch.Tensor:
+    """
+    Reduces a tensor's value across all processes in a distributed setup.
+
+    Args:
+        tensor (torch.Tensor): The tensor to be reduced.
+        world_size (int): The total number of processes.
+        op (dist.ReduceOp, optional): The reduction operation (SUM, AVG, etc.).
+                                      Defaults to dist.ReduceOp.SUM.
+
+    Returns:
+        torch.Tensor: The reduced tensor, which will be identical on all processes.
+    """
+    rt = tensor.clone()
+    dist.all_reduce(rt, op=op)
+    # Note: `dist.ReduceOp.AVG` is available in newer torch versions.
+    # For compatibility, manual division is sometimes used after a SUM.
+    if op == dist.ReduceOp.AVG:
+        rt /= world_size
+    return rt
+
+
+def format_time(seconds: float) -> str:
+    """
+    Formats a duration in seconds into a human-readable H:M:S string.
+
+    Args:
+        seconds (float): The total seconds.
+
+    Returns:
+        str: The formatted time string (e.g., "0:15:32").
+    """
+    return str(datetime.timedelta(seconds=int(seconds)))
+
+
+

Kronos/finetune_csv/README.md

@@ -0,0 +1,120 @@
+# Kronos Fine-tuning on Custom CSV Datasets
+
+This module provides a comprehensive pipeline for fine-tuning Kronos models on your own CSV-formatted financial data. It supports both sequential training (tokenizer followed by predictor) and individual component training, with full distributed training capabilities.
+
+
+## 1. Data Preparation
+
+### Required Data Format
+
+Your CSV file must contain the following columns:
+- `timestamps`: DateTime stamps for each data point
+- `open`: Opening price
+- `high`: Highest price
+- `low`: Lowest price  
+- `close`: Closing price
+- `volume`: Trading volume
+- `amount`: Trading amount
+
+(volume and amount can be 0 if not available)
+
+### Sample Data Format
+
+| timestamps | open | close | high | low | volume | amount |
+|------------|------|-------|------|-----|--------|--------|
+| 2019/11/26 9:35 | 182.45215 | 184.45215 | 184.95215 | 182.45215 | 15136000 | 0 |
+| 2019/11/26 9:40 | 184.35215 | 183.85215 | 184.55215 | 183.45215 | 4433300 | 0 |
+| 2019/11/26 9:45 | 183.85215 | 183.35215 | 183.95215 | 182.95215 | 3070900 | 0 |
+
+> **Reference**: Check `data/HK_ali_09988_kline_5min_all.csv` for a complete example of the proper data format.
+
+
+## 2. Config Preparation
+
+
+Please edit the correct data path & pretrained model path and set your training parameters.
+
+```yaml
+# Data configuration
+data:
+  data_path: "/path/to/your/data.csv"
+  lookback_window: 512        # Historical data points to use
+  predict_window: 48           # Future points to predict
+  max_context: 512            # Maximum context length
+
+...
+
+```
+There are some other settings here, please see `configs/config_ali09988_candle-5min.yaml` for more comments.
+
+## 3. Training
+
+### Method 1: Sequential Training (Recommended)
+
+The `train_sequential.py` script handles the complete training pipeline automatically:
+
+```bash
+# Complete training (tokenizer + predictor)
+python train_sequential.py --config configs/config_ali09988_candle-5min.yaml
+
+# Skip existing models
+python train_sequential.py --config configs/config_ali09988_candle-5min.yaml --skip-existing
+
+# Only train tokenizer
+python train_sequential.py --config configs/config_ali09988_candle-5min.yaml --skip-basemodel
+
+# Only train predictor
+python train_sequential.py --config configs/config_ali09988_candle-5min.yaml --skip-tokenizer
+```
+
+### Method 2: Individual Component Training
+
+Train each component separately for more control:
+
+```bash
+# Step 1: Train tokenizer
+python finetune_tokenizer.py --config configs/config_ali09988_candle-5min.yaml
+
+# Step 2: Train predictor (requires fine-tuned tokenizer)
+python finetune_base_model.py --config configs/config_ali09988_candle-5min.yaml
+```
+
+### DDP Training
+
+For faster training on multiple GPUs:
+
+```bash
+# Set communication backend (nccl for NVIDIA GPUs, gloo for CPU/mixed)
+DIST_BACKEND=nccl \
+torchrun --standalone --nproc_per_node=8 train_sequential.py --config configs/config_ali09988_candle-5min.yaml
+```
+
+## 4. Training Results
+
+The training process generates several outputs:
+
+### Model Checkpoints
+- **Tokenizer**: Saved to `{base_save_path}/{exp_name}/tokenizer/best_model/`
+- **Predictor**: Saved to `{base_save_path}/{exp_name}/basemodel/best_model/`
+
+### Training Logs
+- **Console output**: Real-time training progress and metrics
+- **Log files**: Detailed logs saved to `{base_save_path}/logs/`
+- **Validation tracking**: Best models are saved based on validation loss
+
+## 5. Prediction Vis
+
+The following images show example training results on alibaba (HK stock) data:
+
+![Training Result 1](examples/HK_ali_09988_kline_5min_all_historical_20250919_073929.png)
+
+![Training Result 2](examples/HK_ali_09988_kline_5min_all_historical_20250919_073944.png)
+
+![Training Result 3](examples/HK_ali_09988_kline_5min_all_historical_20250919_074012.png)
+
+![Training Result 4](examples/HK_ali_09988_kline_5min_all_historical_20250919_074042.png)
+
+![Training Result 5](examples/HK_ali_09988_kline_5min_all_historical_20250919_074251.png)
+
+
+