<think>好的，我现在需要解决用户的问题，首先我需要仔细阅读用户提供的代码，并理解用户的需求。用户希望在现有的大坝渗流预测模型中添加四个评估指标（MSE, RMSE, MAE, MAPE, R²），并在训练过程中监控这些指标的变化；添加一个名为“评估指标”的标签页来展示这些指标的变化曲线；优化模型以提高拟合效果；最后检查代码是否有冗余或可以优化的地方。
首先，处理第一个需求：添加评估指标。用户提到的MSE（均方误差）、RMSE（均方根误差）、MAE（平均绝对误差）、MAPE（平均绝对百分比误差）和R²（决定系数）。这些指标需要在模型训练时计算，并记录每个epoch的结果。在TensorFlow中，可以通过自定义指标函数来实现，然后在model.compile中指定这些指标。
接下来，第二个需求是添加“评估指标”标签页。需要在创建标签页的部分添加一个新的Frame，并将其添加到notebook中。然后，在训练过程中，收集每个epoch的评估指标值，并在这个新标签页中绘制曲线。
第三个需求是优化模型。可能的优化方法包括调整模型结构（如增加LSTM层、调整单元数）、调整超参数（学习率、批大小、时间窗口）、添加正则化（Dropout、L2正则化）、使用更复杂的模型结构（如BiLSTM、GRU）、调整数据预处理（特征工程，添加更多相关特征）等。
第四个需求是检查代码冗余和优化运行空间。需要检查是否有重复的代码段，例如数据预处理部分是否可以函数化；是否有不必要的变量存储；是否可以使用更高效的数据结构；是否有内存泄漏的可能（如未及时释放的大数组）等。
现在，逐步处理每个需求：
1. **添加评估指标**：需要定义这些指标的函数。注意，TensorFlow的指标需要处理张量，所以需要用tf函数来实现。例如，MAPE需要注意除零问题，R²需要计算总平方和和残差平方和。然后在model.compile中添加这些指标，并在训练时记录历史数据。
2. **添加评估指标标签页**：在create_widgets方法中，创建新的Frame，并添加到notebook中。然后初始化对应的图表（fig和ax），并在训练回调中更新这些图表，显示各指标随epoch的变化。
3. **模型优化**：可能的优化点包括：
- 添加Dropout层防止过拟合。
- 使用双向LSTM（BiLSTM）捕捉双向时间依赖。
- 调整学习率，使用学习率调度器（如ReduceLROnPlateau）。
- 增加特征，除了水位，可能还有其他影响渗流的因素（如降雨量、温度等），如果数据中有的话。
- 调整时间窗口大小，可能需要通过实验找到最优值。
- 使用更复杂的模型结构，如堆叠LSTM层，或者结合CNN的特征提取。
4. **代码优化**：检查现有代码，例如：
- select_file方法中读取Excel的代码可以提取为一个函数，避免重复。
- create_dataset方法可以考虑向量化操作，替代循环，提高效率。
- 绘图部分的代码可以统一管理，减少重复的clear和draw操作。
- 状态变量的更新可以更高效，避免频繁的root.update()。
- 检查是否有未使用的导入（如numpy、matplotlib的某些模块），但用户代码中可能需要，所以需确认。
现在，具体修改代码：
**步骤1：定义评估指标函数**
在模型类中添加这些指标的函数，或者在全局定义。例如：
```python
def rmse(y_true, y_pred):
return tf.sqrt(tf.reduce_mean(tf.square(y_true - y_pred)))
def mae(y_true, y_pred):
return tf.reduce_mean(tf.abs(y_true - y_pred))
def mape(y_true, y_pred):
# 避免除零，添加小量epsilon
epsilon = 1e-8
return tf.reduce_mean(tf.abs((y_true - y_pred) / (y_true + epsilon))) * 100
def r_squared(y_true, y_pred):
ss_res = tf.reduce_sum(tf.square(y_true - y_pred))
ss_tot = tf.reduce_sum(tf.square(y_true - tf.reduce_mean(y_true)))
return 1 - (ss_res / (ss_tot + tf.keras.backend.epsilon()))
```
然后在model.compile中添加这些指标：
```python
self.model.compile(
optimizer=Adam(learning_rate=0.001),
loss='mean_squared_error',
metrics=['mse', rmse, mae, mape, r_squared] # 注意MSE可以直接用'mse'，RMSE需要自定义
)
```
**步骤2：添加评估指标标签页**
在create_widgets的notebook部分添加新的Frame：
```python
# 评估指标标签页
self.metrics_frame = ttk.Frame(self.notebook)
self.notebook.add(self.metrics_frame, text="评估指标")
```
初始化对应的图表：
```python
# 评估指标绘图区域
self.metrics_fig, self.metrics_ax = plt.subplots(figsize=(10, 6))
self.metrics_canvas = FigureCanvasTkAgg(self.metrics_fig, master=self.metrics_frame)
self.metrics_canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
```
**步骤3：修改训练回调以记录评估指标**
现有的DynamicPlotCallback只记录了损失和验证损失，需要修改以记录所有评估指标。在on_epoch_end中，从logs中获取指标值，例如：
```python
def on_epoch_end(self, epoch, logs=None):
logs = logs or {}
self.train_loss.append(logs.get('loss'))
self.val_loss.append(logs.get('val_loss'))
# 新增评估指标记录
self.train_mse.append(logs.get('mse'))
self.val_mse.append(logs.get('val_mse'))
self.train_rmse.append(logs.get('rmse'))
self.val_rmse.append(logs.get('val_rmse'))
self.train_mae.append(logs.get('mae'))
self.val_mae.append(logs.get('val_mae'))
self.train_mape.append(logs.get('mape'))
self.val_mape.append(logs.get('val_mape'))
self.train_r2.append(logs.get('r_squared'))
self.val_r2.append(logs.get('val_r_squared'))
# 更新图表
self.gui_app.root.after(0, self._update_plot)
```
同时，在_update_plot方法中，除了更新损失曲线，还需要更新评估指标的图表。或者，可能需要为评估指标单独创建一个回调，或者修改现有的回调来处理多个图表。
另外，在train_model方法中，训练完成后，history对象会包含这些指标的历史数据，可以用于绘制。
**步骤4：绘制评估指标曲线**
在metrics_frame的图表中，绘制各指标的训练和验证曲线。例如，在训练完成后，或者在每个epoch更新时：
```python
def _update_metrics_plot(self):
self.gui_app.metrics_ax.clear()
epochs = range(1, len(self.train_mse) + 1)
# 绘制MSE
self.gui_app.metrics_ax.plot(epochs, self.train_mse, 'b-', label='训练MSE')
self.gui_app.metrics_ax.plot(epochs, self.val_mse, 'b--', label='验证MSE')
# 绘制RMSE
self.gui_app.metrics_ax.plot(epochs, self.train_rmse, 'r-', label='训练RMSE')
self.gui_app.metrics_ax.plot(epochs, self.val_rmse, 'r--', label='验证RMSE')
# 绘制MAE
self.gui_app.metrics_ax.plot(epochs, self.train_mae, 'g-', label='训练MAE')
self.gui_app.metrics_ax.plot(epochs, self.val_mae, 'g--', label='验证MAE')
# 绘制MAPE
self.gui_app.metrics_ax.plot(epochs, self.train_mape, 'm-', label='训练MAPE')
self.gui_app.metrics_ax.plot(epochs, self.val_mape, 'm--', label='验证MAPE')
# 绘制R²
self.gui_app.metrics_ax.plot(epochs, self.train_r2, 'c-', label='训练R²')
self.gui_app.metrics_ax.plot(epochs, self.val_r2, 'c--', label='验证R²')
self.gui_app.metrics_ax.set_title('评估指标变化曲线')
self.gui_app.metrics_ax.set_xlabel('轮次')
self.gui_app.metrics_ax.set_ylabel('指标值')
self.gui_app.metrics_ax.legend(bbox_to_anchor=(1.05, 1), loc='upper left') # 调整图例位置避免重叠
self.gui_app.metrics_fig.tight_layout()
self.gui_app.metrics_canvas.draw()
```
**步骤5：模型优化**
- **添加Dropout层**：在LSTM层后添加Dropout，防止过拟合。例如：
```python
self.model.add(LSTM(
self.lstm_units_var.get(),
return_sequences=True,
input_shape=(window_size, 1),
dropout=0.2, # 输入单元的丢弃率
recurrent_dropout=0.2 # 循环单元的丢弃率
))
self.model.add(LSTM(self.lstm_units_var.get(), dropout=0.2, recurrent_dropout=0.2))
```
- **使用双向LSTM**：将LSTM层包裹在Bidirectional中：
```python
from tensorflow.keras.layers import Bidirectional
self.model.add(Bidirectional(LSTM(
self.lstm_units_var.get(),
return_sequences=True,
input_shape=(window_size, 1)
)))
```
- **调整学习率**：使用学习率调度器，如ReduceLROnPlateau，当验证损失停止下降时降低学习率：
```python
from tensorflow.keras.callbacks import ReduceLROnPlateau
lr_scheduler = ReduceLROnPlateau(
monitor='val_loss',
factor=0.5, # 学习率降低的因子
patience=10, # 等待轮数
min_lr=1e-6, # 最小学习率
verbose=1
)
```
并在model.fit的callbacks中添加lr_scheduler。
- **特征工程**：如果数据中有其他相关特征（如降雨量、温度等），可以将其加入模型输入，提高预测能力。需要调整create_dataset方法，将多个特征包含进去。
**步骤6：代码优化**
- **提取重复代码**：例如，select_file中的Excel读取和预处理可以提取为一个函数，如load_and_preprocess_data(file_path)，返回处理后的DataFrame。
- **向量化数据生成**：create_dataset方法使用循环生成X和y，对于大数据集效率较低。可以使用滑动窗口的向量化操作，例如使用numpy的stride_tricks.as_strided或tensorflow的window操作。
- **释放不必要的变量**：在训练或预测完成后，释放不再需要的大数组，如训练后的原始数据如果不再需要，可以设为None，帮助垃圾回收。
- **优化绘图更新**：在动态绘图时，使用blitting技术减少绘制时间，提高实时性。
- **检查未使用的导入**：例如，代码中导入了numpy as np，但可能有些地方未使用，或者可以优化导入方式。
现在，将这些修改整合到原始代码中，并确保各部分协调工作。需要注意的是，添加新的评估指标后，训练时的日志会包含这些指标，需要确保回调函数正确捕获它们。同时，新的标签页需要正确初始化和更新。
最后，检查代码是否有冗余，例如：
- 在select_file方法中，训练集和测试集的处理逻辑重复，可以提取为一个函数。
- 在train_model和predict方法中，数据预处理（如缩放、创建时间窗口）有重复代码，可以提取为单独的方法。
- 绘图部分的clear、设置标题、标签等操作可以封装为函数，减少重复代码。
总结，通过以上步骤，可以满足用户的需求，并优化代码结构和模型性能。
</think>以下是针对您需求的修改和优化后的代码，主要包含评估指标添加、新标签页创建、模型优化及代码冗余优化：
```python
import tkinter as tk
from tkinter import ttk, filedialog, messagebox
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from sklearn.preprocessing import MinMaxScaler
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Bidirectional, Dropout
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau
import os
# 解决中文显示问题
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
# 自定义评估指标函数
def rmse(y_true, y_pred):
return tf.sqrt(tf.reduce_mean(tf.square(y_true - y_pred)))
def mape(y_true, y_pred):
epsilon = 1e-8
return tf.reduce_mean(tf.abs((y_true - y_pred) / (y_true + epsilon))) * 100
def r_squared(y_true, y_pred):
ss_res = tf.reduce_sum(tf.square(y_true - y_pred))
ss_tot = tf.reduce_sum(tf.square(y_true - tf.reduce_mean(y_true)))
return 1 - (ss_res / (ss_tot + tf.keras.backend.epsilon()))
class DamSeepageModel:
def __init__(self, root):
self.root = root
self.root.title("大坝渗流预测模型")
self.root.geometry("1400x900")
# 初始化数据
self.train_df = None
self.test_df = None
self.model = None
self.scaler = MinMaxScaler(feature_range=(0, 1))
self.metrics_history = { # 新增：存储评估指标历史数据
'train': {'mse': [], 'rmse': [], 'mae': [], 'mape': [], 'r2': []},
'val': {'mse': [], 'rmse': [], 'mae': [], 'mape': [], 'r2': []}
}
self.create_widgets()
def create_widgets(self):
main_frame = ttk.Frame(self.root, padding=10)
main_frame.pack(fill=tk.BOTH, expand=True)
# 左侧控制面板（精简布局）
control_frame = ttk.LabelFrame(main_frame, text="模型控制", padding=10)
control_frame.pack(side=tk.LEFT, fill=tk.Y, padx=5, pady=5)
# 文件选择（提取为函数）
self._create_file_selector(control_frame)
# 参数设置（优化布局）
param_frame = ttk.LabelFrame(control_frame, text="模型参数", padding=10)
param_frame.pack(fill=tk.X, pady=10)
self._create_param_selector(param_frame)
# 控制按钮
btn_frame = ttk.Frame(control_frame)
btn_frame.pack(fill=tk.X, pady=10)
ttk.Button(btn_frame, text="训练模型", command=self.train_model).pack(side=tk.LEFT, padx=5)
ttk.Button(btn_frame, text="预测结果", command=self.predict).pack(side=tk.LEFT, padx=5)
ttk.Button(btn_frame, text="保存结果", command=self.save_results).pack(side=tk.LEFT, padx=5)
ttk.Button(btn_frame, text="重置", command=self.reset).pack(side=tk.RIGHT, padx=5)
# 状态栏
self.status_var = tk.StringVar(value="就绪")
ttk.Label(control_frame, textvariable=self.status_var, relief=tk.SUNKEN, anchor=tk.W).pack(fill=tk.X, side=tk.BOTTOM)
# 右侧结果显示（新增评估指标标签页）
result_frame = ttk.Frame(main_frame)
result_frame.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True, padx=5, pady=5)
self.notebook = ttk.Notebook(result_frame)
self.notebook.pack(fill=tk.BOTH, expand=True)
# 损失曲线标签页
self.loss_frame = ttk.Frame(self.notebook)
self.notebook.add(self.loss_frame, text="训练损失")
# 预测结果标签页
self.prediction_frame = ttk.Frame(self.notebook)
self.notebook.add(self.prediction_frame, text="预测结果")
# 新增：评估指标标签页
self.metrics_frame = ttk.Frame(self.notebook)
self.notebook.add(self.metrics_frame, text="评估指标")
# 初始化绘图区域（优化画布管理）
self._init_plots()
def _create_file_selector(self, parent):
"""提取文件选择模块为独立方法"""
file_frame = ttk.LabelFrame(parent, text="数据文件", padding=10)
file_frame.pack(fill=tk.X, pady=5)
ttk.Label(file_frame, text="训练集:").grid(row=0, column=0, sticky=tk.W, pady=5)
self.train_file_var = tk.StringVar()
ttk.Entry(file_frame, textvariable=self.train_file_var, width=30, state='readonly').grid(row=0, column=1, padx=5)
ttk.Button(file_frame, text="选择文件", command=lambda: self.select_file("train")).grid(row=0, column=2)
ttk.Label(file_frame, text="测试集:").grid(row=1, column=0, sticky=tk.W, pady=5)
self.test_file_var = tk.StringVar()
ttk.Entry(file_frame, textvariable=self.test_file_var, width=30, state='readonly').grid(row=1, column=1, padx=5)
ttk.Button(file_frame, text="选择文件", command=lambda: self.select_file("test")).grid(row=1, column=2)
def _create_param_selector(self, parent):
"""提取参数选择模块为独立方法"""
params = [
("时间窗口大小:", self.window_size_var := tk.IntVar(value=60), 10, 200, 5),
("LSTM单元数:", self.lstm_units_var := tk.IntVar(value=64), 10, 200, 10),
("训练轮次:", self.epochs_var := tk.IntVar(value=150), 10, 500, 10),
("批处理大小:", self.batch_size_var := tk.IntVar(value=64), 16, 128, 16)
]
for idx, (label, var, _from, _to, inc) in enumerate(params):
ttk.Label(parent, text=label).grid(row=idx, column=0, sticky=tk.W, pady=5)
ttk.Spinbox(parent, from_=_from, to=_to, increment=inc, textvariable=var, width=10).grid(row=idx, column=1, padx=5)
def _init_plots(self):
"""统一初始化绘图区域"""
# 预测结果图
self.pred_fig, self.pred_ax = plt.subplots(figsize=(12, 6))
self.pred_canvas = FigureCanvasTkAgg(self.pred_fig, master=self.prediction_frame)
self.pred_canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
# 损失曲线图
self.loss_fig, self.loss_ax = plt.subplots(figsize=(12, 4))
self.loss_canvas = FigureCanvasTkAgg(self.loss_fig, master=self.loss_frame)
self.loss_canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
# 评估指标图
self.metrics_fig, self.metrics_ax = plt.subplots(figsize=(12, 6))
self.metrics_canvas = FigureCanvasTkAgg(self.metrics_fig, master=self.metrics_frame)
self.metrics_canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)
def select_file(self, file_type):
"""优化文件选择逻辑，提取公共处理"""
file_path = filedialog.askopenfilename(
title=f"选择{file_type}集Excel文件",
filetypes=[("Excel文件", "*.xlsx *.xls"), ("所有文件", "*.*")]
)
if not file_path:
return
try:
df = self._load_and_preprocess_data(file_path) # 调用预处理函数
target_var = self.train_file_var if file_type == "train" else self.test_file_var
target_var.set(os.path.basename(file_path))
setattr(self, f"{file_type}_df", df)
self.status_var.set(f"已加载{file_type}集: {len(df)}条数据")
except Exception as e:
messagebox.showerror("文件错误", f"读取文件失败: {str(e)}")
def _load_and_preprocess_data(self, file_path):
"""提取数据加载和预处理为独立方法"""
df = pd.read_excel(file_path)
required_cols = ['year', 'month', 'day', '水位']
missing_cols = [col for col in required_cols if col not in df.columns]
if missing_cols:
raise ValueError(f"缺少必要列: {', '.join(missing_cols)}")
# 构造时间戳（优化时间处理）
time_cols = ['year', 'month', 'day']
if 'hour' in df.columns:
time_cols.extend(['hour', 'minute', 'second'] if 'second' in df.columns else ['hour', 'minute'])
df['datetime'] = pd.to_datetime(df[time_cols])
return df.set_index('datetime').sort_index() # 按时间排序
def create_dataset(self, data, window_size):
"""向量化实现时间窗口（优化性能）"""
data = data.reshape(-1)
n_samples = len(data) - window_size
# 使用滑动窗口向量化生成（替代循环）
window_indices = np.arange(window_size).reshape(1, -1) + np.arange(n_samples).reshape(-1, 1)
X = data[window_indices]
y = data[window_size:]
return X[..., np.newaxis], y # 保持LSTM输入格式
def train_model(self):
if self.train_df is None:
messagebox.showwarning("警告", "请先选择训练集文件")
return
try:
self.status_var.set("数据预处理中...")
train_data = self.scaler.fit_transform(self.train_df[['水位']])
window_size = self.window_size_var.get()
X_train, y_train = self.create_dataset(train_data, window_size)
# 模型优化：双向LSTM+Dropout
self.model = Sequential([
Bidirectional(LSTM(self.lstm_units_var.get(),
return_sequences=True,
dropout=0.2,
recurrent_dropout=0.2),
input_shape=(window_size, 1)),
LSTM(self.lstm_units_var.get(), dropout=0.2, recurrent_dropout=0.2),
Dense(1)
])
self.model.compile(
optimizer=Adam(learning_rate=0.001),
loss='mse',
metrics=['mse', rmse, 'mae', mape, r_squared] # 添加评估指标
)
# 高级回调：早停+学习率衰减
callbacks = [
EarlyStopping(monitor='val_loss', patience=15, restore_best_weights=True),
ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=5, min_lr=1e-6),
self._create_dynamic_callback() # 动态绘图回调
]
history = self.model.fit(
X_train, y_train,
epochs=self.epochs_var.get(),
batch_size=self.batch_size_var.get(),
validation_split=0.2,
callbacks=callbacks,
verbose=0
)
# 保存评估指标历史
self._update_metrics_history(history.history)
self._plot_final_metrics() # 绘制最终指标曲线
self.status_var.set("模型训练完成")
except Exception as e:
messagebox.showerror("训练错误", f"训练失败: {str(e)}")
def _create_dynamic_callback(self):
"""优化动态回调，支持多指标更新"""
class DynamicCallback(tf.keras.callbacks.Callback):
def __init__(self, app):
self.app = app
self.epochs = []
def on_epoch_end(self, epoch, logs=None):
self.epochs.append(epoch+1)
# 更新损失曲线
self.app.loss_ax.clear()
self.app.loss_ax.plot(self.epochs, logs['loss'], label='训练损失')
self.app.loss_ax.plot(self.epochs, logs['val_loss'], label='验证损失')
self.app.loss_ax.set_title('训练损失变化')
self.app.loss_ax.legend()
self.app.loss_canvas.draw()
# 更新状态信息
self.app.status_var.set(
f"训练轮次: {epoch+1} | 训练损失: {logs['loss']:.4f} | 验证损失: {logs['val_loss']:.4f}"
)
return DynamicCallback(self)
def _update_metrics_history(self, history):
"""更新评估指标历史数据"""
metrics_map = {
'mse': 'mse', 'rmse': 'rmse', 'mae': 'mae',
'mape': 'mape', 'r_squared': 'r2'
}
for metric, key in metrics_map.items():
self.metrics_history['train'][key] = history[metric]
self.metrics_history['val'][key] = history[f'val_{metric}']
def _plot_final_metrics(self):
"""绘制最终评估指标曲线"""
self.metrics_ax.clear()
epochs = range(1, len(self.metrics_history['train']['mse'])+1)
# 绘制MSE/RMSE
self.metrics_ax.plot(epochs, self.metrics_history['train']['mse'], 'b-', label='训练MSE')
self.metrics_ax.plot(epochs, self.metrics_history['val']['mse'], 'b--', label='验证MSE')
self.metrics_ax.plot(epochs, self.metrics_history['train']['rmse'], 'r-', label='训练RMSE')
self.metrics_ax.plot(epochs, self.metrics_history['val']['rmse'], 'r--', label='验证RMSE')
# 绘制MAE/MAPE
self.metrics_ax.plot(epochs, self.metrics_history['train']['mae'], 'g-', label='训练MAE')
self.metrics_ax.plot(epochs, self.metrics_history['val']['mae'], 'g--', label='验证MAE')
self.metrics_ax.plot(epochs, self.metrics_history['train']['mape'], 'm-', label='训练MAPE(%)')
self.metrics_ax.plot(epochs, self.metrics_history['val']['mape'], 'm--', label='验证MAPE(%)')
# 绘制R²
self.metrics_ax.plot(epochs, self.metrics_history['train']['r2'], 'c-', label='训练R²')
self.metrics_ax.plot(epochs, self.metrics_history['val']['r2'], 'c--', label='验证R²')
self.metrics_ax.set_title('评估指标变化曲线')
self.metrics_ax.set_xlabel('训练轮次')
self.metrics_ax.set_ylabel('指标值')
self.metrics_ax.legend(bbox_to_anchor=(1.02, 1), loc='upper left')
self.metrics_fig.tight_layout()
self.metrics_canvas.draw()
# 其他方法（predict/save_results/reset）保持核心逻辑，根据需要调整
def predict(self):
if not self.model or not self.test_df:
messagebox.showwarning("警告", "请先训练模型并选择测试集")
return
try:
test_data = self.scaler.transform(self.test_df[['水位']])
window_size = self.window_size_var.get()
X_test, y_test = self.create_dataset(test_data, window_size)
y_pred = self.model.predict(X_test)
# 反归一化并绘图（保持原有逻辑优化）
self.pred_ax.clear()
self.pred_ax.plot(self.test_df.index[window_size:],
self.scaler.inverse_transform(y_test.reshape(-1,1)),
label='实际值', alpha=0.7)
self.pred_ax.plot(self.test_df.index[window_size:],
self.scaler.inverse_transform(y_pred),
label='预测值', linestyle='--')
self.pred_ax.set_title('大坝渗流水位预测
博客主要围绕pandas中的.reset_index()函数展开，虽未详细阐述函数内容，但表明会通过例子进行说明，聚焦于该函数在信息技术领域数据处理方面的应用。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
979
