import pandas as pd import numpy as np import tkinter as tk from tkinter import ttk from datetime import timedelta import matplotlib.pyplot as plt from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk from sklearn.model_selection import train_test_split from sklearn.preprocessing import MinMaxScaler import tensorflow as tf from tensorflow.keras.models import Sequential, load_model, save_model from tensorflow.keras.layers import LSTM, Dense, Dropout from tensorflow.keras.callbacks import EarlyStopping import pickle import os from time import time 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' # 使用无衬线字体 # 缓存变量 cached_model = None last_training_time = None feature_columns = None feature_scaler = None target_scaler = 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'] # 将 'DateTime' 列转换为日期格式 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，以便后续进行插值处理 upstream_df.loc[upstream_df['Value'] == 0, 'Value'] = np.nan downstream_df.loc[downstream_df['Value'] == 0, 'Value'] = np.nan if qinglong_lake_file: qinglong_lake_df.loc[qinglong_lake_df['Value'] == 0, 'Value'] = np.nan # 使用基本统计方法识别并替换异常值 (3倍标准差法) for df in [upstream_df, downstream_df]: mean = df['Value'].mean() std = df['Value'].std() lower_bound = mean - 3 * std upper_bound = mean + 3 * std # 将超出范围的值替换为NaN df.loc[(df['Value'] < lower_bound) | (df['Value'] > upper_bound), 'Value'] = np.nan if qinglong_lake_file: mean = qinglong_lake_df['Value'].mean() std = qinglong_lake_df['Value'].std() lower_bound = mean - 3 * std upper_bound = mean + 3 * std qinglong_lake_df.loc[(qinglong_lake_df['Value'] < lower_bound) | (qinglong_lake_df['Value'] > upper_bound), 'Value'] = np.nan # 重命名 'Value' 为 'upstream' 和 'downstream' 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') # 处理 NaN 和无效值 print(f"合并前数据行数: {len(merged_df)}") # 设置DateTime为索引以允许时间插值 merged_df = merged_df.set_index('DateTime') # 使用多种插值方法处理NaN值 # 1. 首先使用线性插值填充短时间的NaN 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) # 2. 对于较长时间的NaN，使用时间加权插值 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) # 3. 对于仍然存在的NaN，使用前向填充和后向填充 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') # 4. 添加平滑处理 # 使用移动平均进行平滑处理 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() # 对青龙港数据中盐度值低于50的部分进行额外平滑处理 low_salinity_mask = merged_df['upstream'] < 50 if low_salinity_mask.any(): # 对低盐度部分使用更大的平滑窗口 merged_df.loc[low_salinity_mask, 'upstream_smooth'] = merged_df.loc[low_salinity_mask, 'upstream'].rolling( window=48, min_periods=1, center=True).mean() # 删除剩余的NaN和无穷大值 merged_df = merged_df.dropna() merged_df = merged_df[merged_df['upstream'].apply(lambda x: np.isfinite(x))] merged_df = merged_df[merged_df['downstream'].apply(lambda x: np.isfinite(x))] if qinglong_lake_file: merged_df = merged_df[merged_df['qinglong_lake'].apply(lambda x: np.isfinite(x))] # 重置索引，将DateTime重新作为列 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 # 特征工程 - LSTM版本 def create_sequences(df, look_back=96, forecast_horizon=5): print("开始特征工程(LSTM序列模式)...") start_time = time() # 提取主要特征列 upstream = df['upstream'].values downstream = df['downstream'].values # 预先计算时间特征 date_features = np.array([ [x.hour/24, x.dayofweek/7, x.month/12] for x in df['DateTime'] ]) # 创建X和y序列 X = [] y = [] # 计算可用的样本数 total_samples = len(df) - look_back - forecast_horizon if total_samples <= 0: print("数据不足以创建特征") return np.array([]), np.array([]) print(f"开始创建序列，总样本数: {total_samples}") # 批量处理以提高效率 batch_size = 1000 for batch_start in range(0, total_samples, batch_size): batch_end = min(batch_start + batch_size, total_samples) print(f"处理样本批次: {batch_start}-{batch_end}/{total_samples}") for i in range(batch_start, batch_end): # 获取当前时间窗口索引 end_idx = i + look_back # 基本序列特征 upstream_seq = upstream[i:end_idx] downstream_seq = downstream[i:end_idx] time_seq = date_features[i:end_idx] # 跳过含有NaN的窗口 if np.isnan(upstream_seq).any() or np.isnan(downstream_seq).any(): continue # 合并特征 [samples, timesteps, features] # 每个时间步包含: 上游盐度, 下游盐度, 时间特征(小时,星期,月份) input_seq = np.column_stack([ upstream_seq, downstream_seq, time_seq ]) # 目标是预测未来forecast_horizon天的下游盐度 target_seq = downstream[end_idx:end_idx+forecast_horizon] # 确保目标没有NaN if not np.isnan(target_seq).any(): X.append(input_seq) y.append(target_seq) X = np.array(X) y = np.array(y) if len(X) == 0 or len(y) == 0: print("警告：没有能够生成有效的特征和标签对") return np.array([]), np.array([]) end_time = time() print(f"特征工程完成，有效样本数: {len(X)}，特征形状: {X.shape}，标签形状: {y.shape}，耗时: {end_time-start_time:.2f}秒") # 保存特征列名称以备将来使用 global feature_columns feature_columns = ['upstream', 'downstream', 'hour', 'day_of_week', 'month'] return X, y # 构建LSTM模型 def build_lstm_model(input_shape, output_length): model = Sequential([ LSTM(units=64, return_sequences=True, input_shape=input_shape), Dropout(0.2), LSTM(units=32), Dropout(0.2), Dense(output_length) ]) model.compile(optimizer='adam', loss='mse', metrics=['mae']) return model # 训练和预测 def train_and_predict(df, start_time, force_retrain=False): global cached_model, last_training_time, feature_scaler, target_scaler # 检查是否有缓存的模型和上次训练的时间 model_cache_file = 'salinity_lstm_model.h5' scaler_cache_file = 'salinity_scalers.pkl' model_needs_training = True # 特征结构已改变，强制重新训练 - 删除旧模型文件 if os.path.exists(model_cache_file) and force_retrain: try: os.remove(model_cache_file) if os.path.exists(scaler_cache_file): os.remove(scaler_cache_file) print("特征结构已更改，已删除旧模型缓存") except: pass # 只使用时间点之前的数据 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 and feature_scaler is not None and target_scaler 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) and os.path.exists(scaler_cache_file): try: cached_model = load_model(model_cache_file) with open(scaler_cache_file, 'rb') as f: scalers = pickle.load(f) feature_scaler = scalers['feature_scaler'] target_scaler = scalers['target_scaler'] last_training_time = scalers['training_time'] # 如果上次训练后没有新数据，使用缓存的模型 if last_training_time >= train_df['DateTime'].max(): model_needs_training = False print(f"从文件加载模型 (上次训练时间: {last_training_time})") except Exception as e: print(f"加载模型失败: {e}") if model_needs_training: print("需要训练新模型...") if len(train_df) < 10: # 确保有足够的训练数据 print("训练数据不足") return None, None, None # 检查训练数据质量 print(f"训练数据范围: {train_df['DateTime'].min()} 到 {train_df['DateTime'].max()}") print(f"训练数据中NaN值统计:\n上游: {train_df['upstream'].isna().sum()}\n下游: {train_df['downstream'].isna().sum()}") # 计时开始 start_time_training = time() # 进行特征工程 X, y = create_sequences(train_df) # 检查是否有足够的样本 if len(X) == 0 or len(y) == 0: print("没有足够的有效样本进行训练") return None, None, None # 检查样本数量 print(f"用于训练的样本数: {len(X)}") # 创建并应用缩放器 - 为LSTM缩放数据 feature_scaler = MinMaxScaler(feature_range=(0, 1)) # 对每个样本的每个时间点进行缩放 # 原始形状 [samples, timesteps, features] n_samples, n_timesteps, n_features = X.shape X_reshaped = X.reshape(n_samples * n_timesteps, n_features) X_scaled = feature_scaler.fit_transform(X_reshaped) X_scaled = X_scaled.reshape(n_samples, n_timesteps, n_features) # 对目标变量进行缩放 target_scaler = MinMaxScaler(feature_range=(0, 1)) y_scaled = target_scaler.fit_transform(y) # 划分训练集和验证集 X_train, X_val, y_train, y_val = train_test_split(X_scaled, y_scaled, test_size=0.2, random_state=42) # 构建LSTM模型 input_shape = (X_train.shape[1], X_train.shape[2]) output_length = y_train.shape[1] model = build_lstm_model(input_shape, output_length) # 训练模型 try: print("开始训练模型...") # 早停设置 early_stopping = EarlyStopping( monitor='val_loss', patience=20, restore_best_weights=True ) # 训练模型 history = model.fit( X_train, y_train, validation_data=(X_val, y_val), epochs=10, #修改记得 batch_size=32, callbacks=[early_stopping], verbose=1 ) # 计算验证集性能 val_pred_scaled = model.predict(X_val) val_pred = target_scaler.inverse_transform(val_pred_scaled) y_val_inv = target_scaler.inverse_transform(y_val) rmse = np.sqrt(np.mean((val_pred - y_val_inv) ** 2)) print(f"验证集RMSE: {rmse:.4f}") # 记录训练时间 last_training_time = start_time # 缓存模型 cached_model = model # 保存模型到文件 model.save(model_cache_file) with open(scaler_cache_file, 'wb') as f: pickle.dump({ 'feature_scaler': feature_scaler, 'target_scaler': target_scaler, 'training_time': last_training_time, 'feature_columns': feature_columns, 'rmse': rmse }, f) print(f"模型训练完成，耗时: {time()-start_time_training:.2f}秒") except Exception as e: print(f"模型训练失败: {e}") return None, None, None else: # 使用缓存的模型 model = cached_model # 准备最新数据进行预测 try: print("准备预测数据...") look_back = 96 # 确保与训练时一致 # 获取更多的历史数据以考虑延迟 latest_data = df[df['DateTime'] < start_time].tail(look_back).copy() if len(latest_data) < look_back: # 确保有足够的历史数据 print("预测所需的历史数据不足") return None, None, None # 处理可能的NaN值 if latest_data['upstream'].isna().any() or latest_data['downstream'].isna().any(): latest_data['upstream'] = latest_data['upstream'].fillna(method='ffill').fillna(method='bfill') latest_data['downstream'] = latest_data['downstream'].fillna(method='ffill').fillna(method='bfill') # 提取特征序列 upstream_seq = latest_data['upstream'].values downstream_seq = latest_data['downstream'].values # 时间特征 time_seq = np.array([ [x.hour/24, x.dayofweek/7, x.month/12] for x in latest_data['DateTime'] ]) # 合并特征 input_seq = np.column_stack([ upstream_seq, downstream_seq, time_seq ]) # 检查特征是否有效 if np.isnan(input_seq).any() or np.isinf(input_seq).any(): print("预测特征包含无效值") input_seq = np.nan_to_num(input_seq, nan=0.0, posinf=1e6, neginf=-1e6) # 增加批次维度并缩放 input_seq = input_seq.reshape(1, look_back, -1) input_seq_reshaped = input_seq.reshape(look_back, -1) input_seq_scaled = feature_scaler.transform(input_seq_reshaped) input_seq_scaled = input_seq_scaled.reshape(1, look_back, -1) # 预测 print("执行预测...") predictions_scaled = model.predict(input_seq_scaled) # 反向缩放 predictions = target_scaler.inverse_transform(predictions_scaled)[0] # 生成未来日期 forecast_horizon = 5 # 确保与训练时一致 future_dates = [start_time + timedelta(days=i) for i in range(forecast_horizon)] print("预测成功完成") return future_dates, predictions, model except Exception as e: print(f"预测过程发生错误: {e}") return None, None, None # GUI 界面 def run_gui(): # 配置tkinter中文显示 def configure_gui_fonts(): # 尝试设置支持中文的字体 font_names = ['微软雅黑', 'Microsoft YaHei', 'SimSun', 'SimHei'] for font_name in font_names: try: default_font = tk.font.nametofont("TkDefaultFont") default_font.configure(family=font_name) text_font = tk.font.nametofont("TkTextFont") text_font.configure(family=font_name) fixed_font = tk.font.nametofont("TkFixedFont") fixed_font.configure(family=font_name) return True except: continue return False def on_predict(): try: predict_start_time = time() status_label.config(text="预测中...") root.update() start_time = pd.to_datetime(entry.get()) # 检查模型缓存情况 cache_exists = os.path.exists('salinity_lstm_model.h5') if cache_exists and not retrain_var.get(): try: with open('salinity_scalers.pkl', 'rb') as f: scalers = pickle.load(f) # 检查模型特征数量是否一致 model_features = scalers.get('feature_columns', []) expected_features = ['upstream', 'downstream', 'hour', 'day_of_week', 'month'] if len(model_features) != len(expected_features): status_label.config(text="特征结构已更改，请勾选'强制重新训练模型'") return except: pass force_retrain = retrain_var.get() future_dates, predictions, model = train_and_predict(df, start_time, force_retrain) if future_dates is None or predictions is None: status_label.config(text="预测失败") return # 清空之前的图形 ax.clear() # 绘制历史数据 history_end = min(start_time, df['DateTime'].max()) history_start = history_end - timedelta(days=120) # 显示近30天的历史数据 history_data = df[(df['DateTime'] >= history_start) & (df['DateTime'] <= history_end)] # 绘制一取水(下游)的历史数据 ax.plot(history_data['DateTime'], history_data['downstream'], label='一取水(下游)盐度', color='blue', linewidth=1.5) # 绘制青龙港(上游)的历史数据 - 使用平滑后的数据 ax.plot(history_data['DateTime'], history_data['upstream_smooth'], label='青龙港(上游)盐度', color='purple', linewidth=1.5, alpha=0.7) # 绘制青龙湖的历史数据 - 使用平滑后的数据 if 'qinglong_lake_smooth' in history_data.columns: ax.plot(history_data['DateTime'], history_data['qinglong_lake_smooth'], label='青龙湖盐度', color='green', linewidth=1.5, alpha=0.7) # 获取预测期间的真实值（如果有） actual_data = df[(df['DateTime'] >= start_time) & (df['DateTime'] <= future_dates[-1])] # 绘制预测数据 ax.plot(future_dates, predictions, marker='o', linestyle='--', label='预测盐度', color='red', linewidth=2) # 如果有真实值，绘制真实值 if not actual_data.empty: ax.plot(actual_data['DateTime'], actual_data['downstream'], marker='s', linestyle='-', label='真实盐度', color='orange', linewidth=2) # 计算预测误差 # 找到最接近预测日期的实际值 actual_values = [] for pred_date in future_dates: # 找到最接近的日期 closest_idx = (actual_data['DateTime'] - pred_date).abs().idxmin() actual_values.append(actual_data.loc[closest_idx, 'downstream']) if len(actual_values) == len(predictions): mse = np.mean((np.array(actual_values) - predictions) ** 2) rmse = np.sqrt(mse) mae = np.mean(np.abs(np.array(actual_values) - predictions)) # 在图上显示误差指标 error_text = f"RMSE: {rmse:.2f}, MAE: {mae:.2f}" ax.text(0.02, 0.05, error_text, transform=ax.transAxes, bbox=dict(facecolor='white', alpha=0.8)) # 添加置信区间 std_dev = history_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.strftime('%Y-%m-%d %H:%M:%S')} 开始的盐度预测") ax.legend(loc='upper left') # 调整布局，防止标签被遮挡 fig.tight_layout() # 更新画布显示 canvas.draw() # 计算预测总耗时 predict_time = time() - predict_start_time # 更新状态 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" # 如果有真实值，添加到结果中 if not actual_data.empty and i < len(actual_values): result_text += f" 实际盐度: {actual_values[i]:.2f}\n" result_text += f" 误差: {abs(actual_values[i] - 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 y_data = event.ydata # 如果鼠标不在坐标轴内，则使用轴中心 if x_data is None: x_data = (xlim[0] + xlim[1]) / 2 if y_data is None: y_data = (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]) # 检查滚轮的滚动方向 - 使用event.step替代event.button，更准确 # 向上滚动(放大)为正值，向下滚动(缩小)为负值 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 x1 = x0 + new_width y1 = y0 + new_height ax.set_xlim([x0, x1]) ax.set_ylim([y0, y1]) 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 x1 = x0 + new_width y1 = y0 + new_height ax.set_xlim([x0, x1]) ax.set_ylim([y0, y1]) # 更新画布显示 canvas.draw_idle() # 定义鼠标拖动功能 def on_mouse_press(event): if event.button == 1: # 左键 canvas.mpl_disconnect(hover_cid) canvas._pan_start = (event.x, event.y) canvas._xlim = ax.get_xlim() canvas._ylim = ax.get_ylim() canvas.mpl_connect('motion_notify_event', on_mouse_move) def on_mouse_release(event): if event.button == 1: # 左键 canvas.mpl_disconnect(move_cid[0]) global hover_cid hover_cid = canvas.mpl_connect('motion_notify_event', update_cursor) def on_mouse_move(event): if event.button == 1 and hasattr(canvas, '_pan_start'): dx = event.x - canvas._pan_start[0] dy = event.y - canvas._pan_start[1] # 转换像素移动到数据坐标移动 x_span = canvas._xlim[1] - canvas._xlim[0] y_span = canvas._ylim[1] - canvas._ylim[0] # 转换因子(用于将像素移动转换为数据范围移动) width, height = canvas.get_width_height() x_scale = x_span / width y_scale = y_span / height # 计算新的限制 xlim = [canvas._xlim[0] - dx * x_scale, canvas._xlim[1] - dx * x_scale] ylim = [canvas._ylim[0] + dy * y_scale, canvas._ylim[1] + dy * y_scale] # 设置新的限制 ax.set_xlim(xlim) ax.set_ylim(ylim) 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: import tkinter.font as tkfont configure_gui_fonts() except: print("无法配置GUI字体，可能影响中文显示") # 创建框架 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) # 结果标签 result_label = ttk.Label(result_frame, text="", justify=tk.LEFT) result_label.pack(side=tk.RIGHT, fill=tk.Y) # 绘图区域 - 设置dpi提高清晰度 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() # 添加自定义重置按钮 reset_button = ttk.Button(control_frame, text="重置视图", command=reset_view) reset_button.pack(side=tk.LEFT, padx=5) # 连接鼠标事件 canvas.mpl_connect('button_press_event', on_mouse_press) canvas.mpl_connect('button_release_event', on_mouse_release) canvas.mpl_connect('scroll_event', on_scroll) # 全局变量，用于存储事件连接ID move_cid = [None] hover_cid = canvas.mpl_connect('motion_notify_event', update_cursor) # 默认加载历史数据 def display_history(): # 清空之前的图形 ax.clear() # 确保显示全部历史数据但不超过60天 end_date = df['DateTime'].max() start_date = max(df['DateTime'].min(), end_date - timedelta(days=60)) display_data = df[(df['DateTime'] >= start_date) & (df['DateTime'] <= end_date)] # 绘制一取水(下游)历史数据 ax.plot(display_data['DateTime'], display_data['downstream'], label='一取水(下游)盐度', color='blue', linewidth=1.5) # 绘制青龙港(上游)的历史数据 - 使用平滑后的数据 ax.plot(display_data['DateTime'], display_data['upstream_smooth'], label='青龙港(上游)盐度', color='purple', linewidth=1.5, alpha=0.7) # # 绘制青龙港历史数据 - 使用平滑后的数据 # if 'qinglong_lake_smooth' in display_data.columns: # ax.plot(display_data['DateTime'], display_data['qinglong_lake_smooth'], # label='青龙湖盐度', color='green', linewidth=1.5, alpha=0.7) # 设置标题、标签和图例 ax.set_xlabel('日期') ax.set_ylabel('盐度') ax.set_title('历史盐度数据对比') ax.legend() # 调整布局，防止标签被遮挡 fig.tight_layout() # 更新画布显示 canvas.draw() # 默认加载历史数据 display_history() # 启动GUI root.mainloop() # 运行 df = load_data('青龙港1.csv', '一取水.csv', ) # 如果数据加载成功，则运行GUI界面 if df is not None: run_gui() else: print("数据加载失败，无法运行预测。")