mirror of
https://github.com/shiyu-coder/Kronos.git
synced 2026-05-07 22:36:30 +08:00
1625 lines
64 KiB
Python
1625 lines
64 KiB
Python
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() |