import os
|
import pickle
|
import pandas as pd
|
import numpy as np
|
import tkinter as tk
|
import tkinter.font as tkfont
|
from tkinter import ttk
|
from datetime import timedelta
|
from time import time
|
import matplotlib.pyplot as plt
|
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
|
from xgboost import XGBRegressor
|
from lunardate import LunarDate
|
from sklearn.model_selection import train_test_split
|
from sklearn.metrics import mean_squared_error, mean_absolute_error
|
import matplotlib
|
|
# 配置 matplotlib 中文显示
|
matplotlib.rcParams['font.sans-serif'] = ['SimHei', 'Microsoft YaHei', 'SimSun', 'Arial Unicode MS']
|
matplotlib.rcParams['axes.unicode_minus'] = False
|
matplotlib.rcParams['font.family'] = 'sans-serif'
|
|
# 全局缓存变量及特征名称（此处 feature_columns 仅为占位）
|
cached_model = None
|
last_training_time = None
|
feature_columns = None
|
|
# -------------------------------
|
# 数据加载与预处理函数
|
# -------------------------------
|
def load_data(upstream_file, downstream_file, qinglong_lake_file=None):
|
try:
|
upstream_df = pd.read_csv(upstream_file)
|
downstream_df = pd.read_csv(downstream_file)
|
if qinglong_lake_file:
|
qinglong_lake_df = pd.read_csv(qinglong_lake_file)
|
except FileNotFoundError:
|
print("文件未找到，请检查路径")
|
return None
|
|
# 假设原始数据列依次为 ['DateTime', 'TagName', 'Value']
|
upstream_df.columns = ['DateTime', 'TagName', 'Value']
|
downstream_df.columns = ['DateTime', 'TagName', 'Value']
|
if qinglong_lake_file:
|
qinglong_lake_df.columns = ['DateTime', 'TagName', 'Value']
|
|
# 转换时间格式及数值处理
|
upstream_df['DateTime'] = pd.to_datetime(upstream_df['DateTime'])
|
downstream_df['DateTime'] = pd.to_datetime(downstream_df['DateTime'])
|
if qinglong_lake_file:
|
qinglong_lake_df['DateTime'] = pd.to_datetime(qinglong_lake_df['DateTime'])
|
upstream_df['Value'] = pd.to_numeric(upstream_df['Value'], errors='coerce')
|
downstream_df['Value'] = pd.to_numeric(downstream_df['Value'], errors='coerce')
|
if qinglong_lake_file:
|
qinglong_lake_df['Value'] = pd.to_numeric(qinglong_lake_df['Value'], errors='coerce')
|
|
# 过滤盐度小于5的数据
|
upstream_df = upstream_df[upstream_df['Value'] >= 5]
|
downstream_df = downstream_df[downstream_df['Value'] >= 5]
|
if qinglong_lake_file:
|
qinglong_lake_df = qinglong_lake_df[qinglong_lake_df['Value'] >= 5]
|
|
# 将0替换为NaN，并利用3倍标准差法处理异常值
|
for df in [upstream_df, downstream_df]:
|
df.loc[df['Value'] == 0, 'Value'] = np.nan
|
mean_val, std_val = df['Value'].mean(), df['Value'].std()
|
lower_bound, upper_bound = mean_val - 3 * std_val, mean_val + 3 * std_val
|
df.loc[(df['Value'] < lower_bound) | (df['Value'] > upper_bound), 'Value'] = np.nan
|
if qinglong_lake_file:
|
qinglong_lake_df.loc[qinglong_lake_df['Value'] == 0, 'Value'] = np.nan
|
mean_val, std_val = qinglong_lake_df['Value'].mean(), qinglong_lake_df['Value'].std()
|
lower_bound, upper_bound = mean_val - 3 * std_val, mean_val + 3 * std_val
|
qinglong_lake_df.loc[(qinglong_lake_df['Value'] < lower_bound) | (qinglong_lake_df['Value'] > upper_bound), 'Value'] = np.nan
|
|
# 重命名 Value 列并保留需要的列
|
upstream_df = upstream_df.rename(columns={'Value': 'upstream'})[['DateTime', 'upstream']]
|
downstream_df = downstream_df.rename(columns={'Value': 'downstream'})[['DateTime', 'downstream']]
|
if qinglong_lake_file:
|
qinglong_lake_df = qinglong_lake_df.rename(columns={'Value': 'qinglong_lake'})[['DateTime', 'qinglong_lake']]
|
|
# 合并数据
|
merged_df = pd.merge(upstream_df, downstream_df, on='DateTime', how='inner')
|
if qinglong_lake_file:
|
merged_df = pd.merge(merged_df, qinglong_lake_df, on='DateTime', how='left')
|
|
print(f"合并前数据行数: {len(merged_df)}")
|
merged_df = merged_df.set_index('DateTime')
|
|
# 插值：先用线性，再用时间插值，最后用前向后向填充
|
merged_df['upstream'] = merged_df['upstream'].interpolate(method='linear', limit=4)
|
merged_df['downstream'] = merged_df['downstream'].interpolate(method='linear', limit=4)
|
if qinglong_lake_file:
|
merged_df['qinglong_lake'] = merged_df['qinglong_lake'].interpolate(method='linear', limit=4)
|
merged_df['upstream'] = merged_df['upstream'].interpolate(method='time', limit=24)
|
merged_df['downstream'] = merged_df['downstream'].interpolate(method='time', limit=24)
|
if qinglong_lake_file:
|
merged_df['qinglong_lake'] = merged_df['qinglong_lake'].interpolate(method='time', limit=24)
|
merged_df['upstream'] = merged_df['upstream'].fillna(method='ffill').fillna(method='bfill')
|
merged_df['downstream'] = merged_df['downstream'].fillna(method='ffill').fillna(method='bfill')
|
if qinglong_lake_file:
|
merged_df['qinglong_lake'] = merged_df['qinglong_lake'].fillna(method='ffill').fillna(method='bfill')
|
|
# 平滑处理：使用滑动窗口移动平均
|
merged_df['upstream_smooth'] = merged_df['upstream'].rolling(window=24, min_periods=1, center=True).mean()
|
merged_df['downstream_smooth'] = merged_df['downstream'].rolling(window=24, min_periods=1, center=True).mean()
|
if qinglong_lake_file:
|
merged_df['qinglong_lake_smooth'] = merged_df['qinglong_lake'].rolling(window=24, min_periods=1, center=True).mean()
|
# 对低盐度部分用更大窗口平滑
|
low_sal_mask = merged_df['upstream'] < 50
|
if low_sal_mask.any():
|
merged_df.loc[low_sal_mask, 'upstream_smooth'] = merged_df.loc[low_sal_mask, 'upstream']\
|
.rolling(window=48, min_periods=1, center=True).mean()
|
|
merged_df = merged_df.dropna()
|
merged_df = merged_df[merged_df['upstream'].apply(np.isfinite)]
|
merged_df = merged_df[merged_df['downstream'].apply(np.isfinite)]
|
if qinglong_lake_file:
|
merged_df = merged_df[merged_df['qinglong_lake'].apply(np.isfinite)]
|
merged_df = merged_df.reset_index()
|
print(f"清洗后数据行数: {len(merged_df)}")
|
print(f"上游盐度范围: {merged_df['upstream'].min()} - {merged_df['upstream'].max()}")
|
print(f"下游盐度范围: {merged_df['downstream'].min()} - {merged_df['downstream'].max()}")
|
if qinglong_lake_file:
|
print(f"青龙湖盐度范围: {merged_df['qinglong_lake'].min()} - {merged_df['qinglong_lake'].max()}")
|
merged_df = merged_df.sort_values('DateTime')
|
return merged_df
|
|
# -------------------------------
|
# 添加农历（潮汐）特征
|
# -------------------------------
|
def add_lunar_features(df):
|
lunar_day, lunar_phase_sin, lunar_phase_cos, is_high_tide = [], [], [], []
|
for dt in df['DateTime']:
|
ld = LunarDate.fromSolarDate(dt.year, dt.month, dt.day)
|
lunar_day.append(ld.day)
|
lunar_phase_sin.append(np.sin(2 * np.pi * ld.day / 15))
|
lunar_phase_cos.append(np.cos(2 * np.pi * ld.day / 15))
|
is_high_tide.append(1 if (ld.day <= 5 or (ld.day >= 16 and ld.day <= 20)) else 0)
|
df['lunar_day'] = lunar_day
|
df['lunar_phase_sin'] = lunar_phase_sin
|
df['lunar_phase_cos'] = lunar_phase_cos
|
df['is_high_tide'] = is_high_tide
|
return df
|
|
# -------------------------------
|
# 批量生成延迟特征（向量化，利用 shift）
|
# -------------------------------
|
def batch_create_delay_features(df, delay_hours):
|
for delay in delay_hours:
|
df[f'upstream_delay_{delay}h'] = df['upstream'].shift(delay)
|
df[f'downstream_delay_{delay}h'] = df['downstream'].shift(delay)
|
return df
|
|
# -------------------------------
|
# 向量化构造训练样本（优化特征工程）
|
# -------------------------------
|
def create_features_vectorized(df, look_back=96, forecast_horizon=5):
|
"""
|
利用 numpy 的 sliding_window_view 对历史窗口、下游窗口、标签进行批量切片，
|
其他特征（时间、农历、统计、延迟特征）直接批量读取后拼接
|
"""
|
# 这里定义 total_samples 为：
|
total_samples = len(df) - look_back - forecast_horizon + 1
|
if total_samples <= 0:
|
print("数据不足以创建特征")
|
return np.array([]), np.array([])
|
|
# 利用 sliding_window_view 构造历史窗口（上游连续 look_back 个数据）
|
upstream_array = df['upstream'].values # shape (n,)
|
# 滑动窗口，结果 shape (n - look_back + 1, look_back)
|
from numpy.lib.stride_tricks import sliding_window_view
|
window_up = sliding_window_view(upstream_array, window_shape=look_back)[:total_samples, :]
|
|
# 下游最近 24 小时：利用滑动窗口构造，窗口大小为 24
|
downstream_array = df['downstream'].values
|
window_down_full = sliding_window_view(downstream_array, window_shape=24)
|
# 对于标签和下游窗口，原逻辑：取 df['downstream'].iloc[i+look_back-24:i+look_back]
|
# 则对应索引为 i+look_back-24， i 从 0 到 total_samples-1
|
window_down = window_down_full[look_back-24 : look_back-24 + total_samples, :]
|
|
# 时间特征与农历特征等：取样区间为 df.iloc[look_back: len(df)-forecast_horizon+1]
|
sample_df = df.iloc[look_back: len(df)-forecast_horizon+1].copy()
|
basic_time = sample_df['DateTime'].dt.hour.values.reshape(-1, 1) / 24.0
|
weekday = sample_df['DateTime'].dt.dayofweek.values.reshape(-1, 1) / 7.0
|
month = sample_df['DateTime'].dt.month.values.reshape(-1, 1) / 12.0
|
basic_time_feats = np.hstack([basic_time, weekday, month])
|
|
lunar_feats = sample_df[['lunar_phase_sin','lunar_phase_cos','is_high_tide']].values
|
# 统计特征（预先利用 rolling 已计算好，注意取出对应行）
|
try:
|
stats_up = sample_df[['mean_1d_up','mean_3d_up','std_1d_up','max_1d_up','min_1d_up']].values
|
stats_down = sample_df[['mean_1d_down','mean_3d_down','std_1d_down','max_1d_down','min_1d_down']].values
|
except KeyError as e:
|
print(f"统计特征列不存在: {e}，请确保先计算统计特征")
|
return np.array([]), np.array([])
|
|
# 延迟特征：假设所有延迟特征列名均以 "upstream_delay_" 或 "downstream_delay_" 开头
|
delay_cols = [col for col in sample_df.columns if col.startswith('upstream_delay_') or col.startswith('downstream_delay_')]
|
delay_feats = sample_df[delay_cols].values
|
|
# 拼接所有特征：先将历史窗口（window_up）与下游窗口（window_down）拼接，再拼接其他特征
|
X = np.hstack([window_up, window_down, basic_time_feats, lunar_feats, stats_up, stats_down, delay_feats])
|
|
# 构造标签：利用滑动窗口构造 forecast_horizon 内的下游数据
|
label_full = sliding_window_view(downstream_array, window_shape=forecast_horizon)
|
# 标签区间对应从 index = look_back 到 look_back + total_samples
|
y = label_full[look_back: look_back + total_samples, :]
|
global feature_columns
|
feature_columns = ["combined_vector_features"]
|
print(f"向量化特征工程完成，有效样本数: {X.shape[0]}")
|
return X, y
|
|
# -------------------------------
|
# 获取模型准确度指标
|
# -------------------------------
|
def get_model_metrics():
|
"""获取保存在模型缓存中的准确度指标"""
|
model_cache_file = 'salinity_model.pkl'
|
if os.path.exists(model_cache_file):
|
try:
|
with open(model_cache_file, 'rb') as f:
|
model_data = pickle.load(f)
|
return {
|
'rmse': model_data.get('rmse', None),
|
'mae': model_data.get('mae', None)
|
}
|
except Exception as e:
|
print(f"获取模型指标失败: {e}")
|
return None
|
|
# -------------------------------
|
# 模型训练与预测，展示验证准确度（RMSE, MAE）
|
# -------------------------------
|
def train_and_predict(df, start_time, force_retrain=False):
|
global cached_model, last_training_time
|
model_cache_file = 'salinity_model.pkl'
|
model_needs_training = True
|
|
if os.path.exists(model_cache_file) and force_retrain:
|
try:
|
os.remove(model_cache_file)
|
print("已删除旧模型缓存（强制重新训练）")
|
except Exception as e:
|
print("删除缓存异常:", e)
|
|
train_df = df[df['DateTime'] < start_time].copy()
|
if not force_retrain and cached_model is not None and last_training_time is not None:
|
if last_training_time >= train_df['DateTime'].max():
|
model_needs_training = False
|
print(f"使用缓存模型，训练时间: {last_training_time}")
|
elif not force_retrain and os.path.exists(model_cache_file):
|
try:
|
with open(model_cache_file, 'rb') as f:
|
model_data = pickle.load(f)
|
cached_model = model_data['model']
|
last_training_time = model_data['training_time']
|
if last_training_time >= train_df['DateTime'].max():
|
model_needs_training = False
|
print(f"从文件加载模型，训练时间: {last_training_time}")
|
except Exception as e:
|
print("加载模型失败:", e)
|
|
if model_needs_training:
|
print("开始训练新模型...")
|
if len(train_df) < 100:
|
print("训练数据不足")
|
return None, None, None, None
|
|
start_train = time()
|
X, y = create_features_vectorized(train_df, look_back=96, forecast_horizon=5)
|
if len(X) == 0 or len(y) == 0:
|
print("样本生成不足，训练终止")
|
return None, None, None, None
|
print(f"训练样本数量: {X.shape[0]}")
|
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)
|
model = XGBRegressor(
|
n_estimators=300,
|
learning_rate=0.03,
|
max_depth=5,
|
min_child_weight=2,
|
subsample=0.85,
|
colsample_bytree=0.85,
|
gamma=0.1,
|
reg_alpha=0.2,
|
reg_lambda=1.5,
|
n_jobs=-1,
|
random_state=42
|
)
|
try:
|
model.fit(X_train, y_train,
|
eval_set=[(X_val, y_val)], eval_metric='rmse',
|
early_stopping_rounds=20, verbose=False)
|
# 在验证集上计算 RMSE 和 MAE
|
y_val_pred = model.predict(X_val)
|
rmse = np.sqrt(mean_squared_error(y_val, y_val_pred))
|
mae = mean_absolute_error(y_val, y_val_pred)
|
print(f"验证集 RMSE: {rmse:.4f}, MAE: {mae:.4f}")
|
last_training_time = start_time
|
cached_model = model
|
with open(model_cache_file, 'wb') as f:
|
pickle.dump({
|
'model': model,
|
'training_time': last_training_time,
|
'feature_columns': feature_columns,
|
'rmse': rmse,
|
'mae': mae
|
}, f)
|
print(f"模型训练完成，耗时: {time() - start_train:.2f}秒")
|
except Exception as e:
|
print("模型训练异常:", e)
|
return None, None, None, None
|
else:
|
model = cached_model
|
|
# 预测部分：构造单个预测样本（与训练时特征构造一致）
|
try:
|
# 这里采用与 create_features_vectorized 类似的思路构造预测样本
|
# 取最近数据足够构成历史窗口和其他特征
|
n = len(df)
|
if n < 96 + 5:
|
print("预测数据不足")
|
return None, None, None, None
|
|
# 使用 sliding_window_view 构造最新的上游和下游窗口
|
upstream_array = df['upstream'].values
|
window_up = np.lib.stride_tricks.sliding_window_view(upstream_array, window_shape=96)[-1, :]
|
downstream_array = df['downstream'].values
|
window_down = np.lib.stride_tricks.sliding_window_view(downstream_array, window_shape=24)[-1, :]
|
|
# 时间特征和农历特征基于当前预测开始时刻
|
hour_norm = start_time.hour / 24.0
|
weekday_norm = start_time.dayofweek / 7.0
|
month_norm = start_time.month / 12.0
|
basic_time_feats = np.array([hour_norm, weekday_norm, month_norm]).reshape(1, -1)
|
ld = LunarDate.fromSolarDate(start_time.year, start_time.month, start_time.day)
|
lunar_feats = np.array([np.sin(2*np.pi*ld.day/15),
|
np.cos(2*np.pi*ld.day/15),
|
1 if (ld.day <=5 or (ld.day >=16 and ld.day<=20)) else 0]).reshape(1, -1)
|
|
# 统计特征：用最新 24/72 小时数据（取末尾24/72）
|
try:
|
# 优先使用DataFrame中已计算的统计特征
|
stats_up = df[['mean_1d_up','mean_3d_up','std_1d_up','max_1d_up','min_1d_up']].iloc[-1:].values
|
stats_down = df[['mean_1d_down','mean_3d_down','std_1d_down','max_1d_down','min_1d_down']].iloc[-1:].values
|
except KeyError:
|
# 如果不存在，则直接计算
|
recent_up = df['upstream'].values[-24:]
|
stats_up = np.array([np.mean(recent_up),
|
np.mean(df['upstream'].values[-72:]),
|
np.std(recent_up),
|
np.max(recent_up),
|
np.min(recent_up)]).reshape(1, -1)
|
recent_down = df['downstream'].values[-24:]
|
stats_down = np.array([np.mean(recent_down),
|
np.mean(df['downstream'].values[-72:]),
|
np.std(recent_down),
|
np.max(recent_down),
|
np.min(recent_down)]).reshape(1, -1)
|
|
# 延迟特征：直接从最后一行延迟特征取值
|
delay_cols = [col for col in df.columns if col.startswith('upstream_delay_') or col.startswith('downstream_delay_')]
|
delay_feats = df[delay_cols].iloc[-1:].values # shape (1, ?)
|
|
# 拼接所有预测特征
|
X_pred = np.hstack([window_up.reshape(1, -1),
|
window_down.reshape(1, -1),
|
basic_time_feats, lunar_feats, stats_up, stats_down, delay_feats])
|
if np.isnan(X_pred).any() or np.isinf(X_pred).any():
|
X_pred = np.nan_to_num(X_pred, nan=0.0, posinf=1e6, neginf=-1e6)
|
predictions = model.predict(X_pred)
|
# 生成未来日期标签（预测未来 5 天）
|
future_dates = [start_time + timedelta(days=i) for i in range(5)]
|
print("预测完成")
|
|
# 获取模型指标
|
metrics = None
|
if os.path.exists(model_cache_file):
|
try:
|
with open(model_cache_file, 'rb') as f:
|
model_data = pickle.load(f)
|
metrics = {
|
'rmse': model_data.get('rmse', None),
|
'mae': model_data.get('mae', None)
|
}
|
except Exception as e:
|
print(f"获取模型指标失败: {e}")
|
|
return future_dates, predictions.flatten(), model, metrics
|
except Exception as e:
|
print("预测过程异常:", e)
|
return None, None, None, None
|
|
# -------------------------------
|
# GUI界面部分
|
# -------------------------------
|
def run_gui():
|
def configure_gui_fonts():
|
font_names = ['微软雅黑', 'Microsoft YaHei', 'SimSun', 'SimHei']
|
for font_name in font_names:
|
try:
|
default_font = tkfont.nametofont("TkDefaultFont")
|
default_font.configure(family=font_name)
|
text_font = tkfont.nametofont("TkTextFont")
|
text_font.configure(family=font_name)
|
fixed_font = tkfont.nametofont("TkFixedFont")
|
fixed_font.configure(family=font_name)
|
return True
|
except Exception as e:
|
continue
|
return False
|
|
def on_predict():
|
try:
|
predict_start = time()
|
status_label.config(text="预测中...")
|
root.update()
|
start_time_dt = pd.to_datetime(entry.get())
|
force_retrain = retrain_var.get()
|
future_dates, predictions, model, metrics = train_and_predict(df, start_time_dt, force_retrain)
|
if future_dates is None or predictions is None:
|
status_label.config(text="预测失败")
|
return
|
|
# 获取并显示模型准确度指标
|
if metrics:
|
metrics_text = f"模型准确度 - RMSE: {metrics['rmse']:.4f}, MAE: {metrics['mae']:.4f}"
|
metrics_label.config(text=metrics_text)
|
|
ax.clear()
|
# 绘制历史数据（最近 120 天）
|
history_end = min(start_time_dt, df['DateTime'].max())
|
history_start = history_end - timedelta(days=120)
|
hist_data = df[(df['DateTime'] >= history_start) & (df['DateTime'] <= history_end)]
|
ax.plot(hist_data['DateTime'], hist_data['downstream'], label='一取水(下游)盐度', color='blue', linewidth=1.5)
|
ax.plot(hist_data['DateTime'], hist_data['upstream_smooth'], label='青龙港(上游)盐度', color='purple', linewidth=1.5, alpha=0.7)
|
if 'qinglong_lake_smooth' in hist_data.columns:
|
ax.plot(hist_data['DateTime'], hist_data['qinglong_lake_smooth'], label='青龙湖盐度', color='green', linewidth=1.5, alpha=0.7)
|
ax.plot(future_dates, predictions, marker='o', linestyle='--', label='预测盐度', color='red', linewidth=2)
|
actual_data = df[(df['DateTime'] >= start_time_dt) & (df['DateTime'] <= future_dates[-1])]
|
if not actual_data.empty:
|
ax.plot(actual_data['DateTime'], actual_data['downstream'], marker='s', linestyle='-', label='实际盐度', color='orange', linewidth=2)
|
std_dev = hist_data['downstream'].std() * 0.5
|
ax.fill_between(future_dates, predictions - std_dev, predictions + std_dev, color='red', alpha=0.2)
|
ax.set_xlabel('日期')
|
ax.set_ylabel('盐度')
|
ax.set_title(f"从 {start_time_dt.strftime('%Y-%m-%d %H:%M:%S')} 开始的盐度预测")
|
ax.legend(loc='upper left')
|
fig.tight_layout()
|
canvas.draw()
|
predict_time = time() - predict_start
|
status_label.config(text=f"预测完成 (耗时: {predict_time:.2f}秒)")
|
result_text = "预测结果:\n"
|
for i, (date, pred) in enumerate(zip(future_dates, predictions)):
|
result_text += f"第 {i+1} 天 ({date.strftime('%Y-%m-%d')}): {pred:.2f}\n"
|
result_label.config(text=result_text)
|
except Exception as e:
|
status_label.config(text=f"错误: {str(e)}")
|
|
def on_scroll(event):
|
xlim = ax.get_xlim()
|
ylim = ax.get_ylim()
|
zoom_factor = 1.1
|
x_data = event.xdata if event.xdata is not None else (xlim[0]+xlim[1])/2
|
y_data = event.ydata if event.ydata is not None else (ylim[0]+ylim[1])/2
|
x_rel = (x_data - xlim[0]) / (xlim[1] - xlim[0])
|
y_rel = (y_data - ylim[0]) / (ylim[1] - ylim[0])
|
if event.step > 0:
|
new_width = (xlim[1]-xlim[0]) / zoom_factor
|
new_height = (ylim[1]-ylim[0]) / zoom_factor
|
x0 = x_data - x_rel * new_width
|
y0 = y_data - y_rel * new_height
|
ax.set_xlim([x0, x0+new_width])
|
ax.set_ylim([y0, y0+new_height])
|
else:
|
new_width = (xlim[1]-xlim[0]) * zoom_factor
|
new_height = (ylim[1]-ylim[0]) * zoom_factor
|
x0 = x_data - x_rel * new_width
|
y0 = y_data - y_rel * new_height
|
ax.set_xlim([x0, x0+new_width])
|
ax.set_ylim([y0, y0+new_height])
|
canvas.draw_idle()
|
|
def update_cursor(event):
|
if event.inaxes == ax:
|
canvas.get_tk_widget().config(cursor="fleur")
|
else:
|
canvas.get_tk_widget().config(cursor="")
|
|
def reset_view():
|
display_history()
|
status_label.config(text="图表视图已重置")
|
|
root = tk.Tk()
|
root.title("青龙港-陈行盐度预测系统")
|
try:
|
configure_gui_fonts()
|
except Exception as e:
|
print("字体配置异常:", e)
|
input_frame = ttk.Frame(root, padding="10")
|
input_frame.pack(fill=tk.X)
|
control_frame = ttk.Frame(root, padding="5")
|
control_frame.pack(fill=tk.X)
|
result_frame = ttk.Frame(root, padding="10")
|
result_frame.pack(fill=tk.BOTH, expand=True)
|
ttk.Label(input_frame, text="输入开始时间 (YYYY-MM-DD HH:MM:SS)").pack(side=tk.LEFT)
|
entry = ttk.Entry(input_frame, width=25)
|
entry.pack(side=tk.LEFT, padx=5)
|
predict_button = ttk.Button(input_frame, text="预测", command=on_predict)
|
predict_button.pack(side=tk.LEFT)
|
status_label = ttk.Label(input_frame, text="提示: 第一次运行请勾选'强制重新训练模型'")
|
status_label.pack(side=tk.LEFT, padx=10)
|
retrain_var = tk.BooleanVar(value=False)
|
ttk.Checkbutton(control_frame, text="强制重新训练模型", variable=retrain_var).pack(side=tk.LEFT)
|
legend_label = ttk.Label(control_frame, text="图例: 紫色=青龙港上游数据, 蓝色=一取水下游数据, 红色=预测值, 绿色=实际值")
|
legend_label.pack(side=tk.LEFT, padx=10)
|
reset_button = ttk.Button(control_frame, text="重置视图", command=reset_view)
|
reset_button.pack(side=tk.LEFT, padx=5)
|
|
# 添加显示模型准确度的标签
|
metrics_frame = ttk.Frame(root, padding="5")
|
metrics_frame.pack(fill=tk.X)
|
model_metrics = get_model_metrics()
|
metrics_text = "模型准确度: 未知" if not model_metrics else f"模型准确度 - RMSE: {model_metrics['rmse']:.4f}, MAE: {model_metrics['mae']:.4f}"
|
metrics_label = ttk.Label(metrics_frame, text=metrics_text)
|
metrics_label.pack(side=tk.LEFT, padx=10)
|
|
result_label = ttk.Label(result_frame, text="", justify=tk.LEFT)
|
result_label.pack(side=tk.RIGHT, fill=tk.Y)
|
fig, ax = plt.subplots(figsize=(10,5), dpi=100)
|
canvas = FigureCanvasTkAgg(fig, master=result_frame)
|
canvas.get_tk_widget().pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
|
toolbar_frame = ttk.Frame(result_frame)
|
toolbar_frame.pack(side=tk.BOTTOM, fill=tk.X)
|
toolbar = NavigationToolbar2Tk(canvas, toolbar_frame)
|
toolbar.update()
|
canvas.mpl_connect('scroll_event', on_scroll)
|
canvas.mpl_connect('motion_notify_event', update_cursor)
|
|
def display_history():
|
ax.clear()
|
end_date = df['DateTime'].max()
|
start_date = max(df['DateTime'].min(), end_date - timedelta(days=60))
|
hist_data = df[(df['DateTime']>=start_date)&(df['DateTime']<=end_date)]
|
ax.plot(hist_data['DateTime'], hist_data['downstream'], label='一取水(下游)盐度', color='blue', linewidth=1.5)
|
ax.plot(hist_data['DateTime'], hist_data['upstream_smooth'], label='青龙港(上游)盐度', color='purple', linewidth=1.5, alpha=0.7)
|
ax.set_xlabel('日期')
|
ax.set_ylabel('盐度')
|
ax.set_title('历史盐度数据对比')
|
ax.legend()
|
fig.tight_layout()
|
canvas.draw()
|
|
display_history()
|
root.mainloop()
|
|
# -------------------------------
|
# 主程序入口：加载数据、添加特征、生成延迟特征后启动GUI
|
# -------------------------------
|
def save_processed_data(df, filename='processed_data.pkl'):
|
try:
|
df.to_pickle(filename)
|
print(f"已保存处理后的数据到 {filename}")
|
return True
|
except Exception as e:
|
print(f"保存数据失败: {e}")
|
return False
|
|
def load_processed_data(filename='processed_data.pkl'):
|
try:
|
if os.path.exists(filename):
|
df = pd.read_pickle(filename)
|
print(f"已从 {filename} 加载处理后的数据")
|
return df
|
else:
|
print(f"找不到处理后的数据文件 {filename}")
|
return None
|
except Exception as e:
|
print(f"加载数据失败: {e}")
|
return None
|
|
# 尝试加载处理后的数据，如果不存在则重新处理
|
processed_data = load_processed_data()
|
if processed_data is not None:
|
df = processed_data
|
else:
|
df = load_data('青龙港1.csv', '一取水.csv')
|
if df is not None:
|
df = add_lunar_features(df)
|
delay_hours = [1,2,3,4,6,12,24,36,48,60,72,84,96,108,120]
|
df = batch_create_delay_features(df, delay_hours)
|
|
# 添加统计特征
|
df['mean_1d_up'] = df['upstream'].rolling(window=24, min_periods=1).mean()
|
df['mean_3d_up'] = df['upstream'].rolling(window=72, min_periods=1).mean()
|
df['std_1d_up'] = df['upstream'].rolling(window=24, min_periods=1).std()
|
df['max_1d_up'] = df['upstream'].rolling(window=24, min_periods=1).max()
|
df['min_1d_up'] = df['upstream'].rolling(window=24, min_periods=1).min()
|
|
df['mean_1d_down'] = df['downstream'].rolling(window=24, min_periods=1).mean()
|
df['mean_3d_down'] = df['downstream'].rolling(window=72, min_periods=1).mean()
|
df['std_1d_down'] = df['downstream'].rolling(window=24, min_periods=1).std()
|
df['max_1d_down'] = df['downstream'].rolling(window=24, min_periods=1).max()
|
df['min_1d_down'] = df['downstream'].rolling(window=24, min_periods=1).min()
|
|
# 保存处理后的数据
|
save_processed_data(df)
|
|
if df is not None:
|
run_gui()
|
else:
|
print("数据加载失败，无法运行预测。")
|
