空间站广场

论文

Notebooks

比赛

课程

Apps

镜像市场

实验室

Uni-Lab

我的主页

我的Notebooks

我的知识库

我的足迹

我的工作空间

任务

节点

镜像

文件

数据集

项目

数据库

公开

基于ResNet的改进CNN模型实现的双参数预测电池EIS

notebook

Deep Learning

Machine Learning

AI4S

notebookDeep LearningMachine LearningAI4S

AllanKay

更新于 2024-12-25

推荐镜像 :mfy:02

推荐机型 :c2_m4_cpu

0. 模型梗概

模块 1：特征提取

模块 2：数据标准化

模块 3：数据加载与处理

模块 4：训练与验证

模块 5：主函数

整体分析与改进优势

1. 数据加载和处理的优化

2. 模型架构的增强

3. 训练和验证的改进

4. 可视化的增强

5. 错误处理与调试

6. 平均R²和RMSE的计算与展示

7. 训练轮次的调整

改进总结

附录1：整合版代码（含解析）

附录2：输出结果与分析

1.epoch=200

2.epoch=300

3.epoch=500

附录3：参考文献

0. 模型梗概

本改进代码，基于文献Journal of Power Sources和已有公开模型Data-driven EIS Prediction，做出全流程优化，改进代码相比原文献代码，更加模块化、鲁棒性更强，同时在模型设计和评估指标的丰富性上都有显著提升。分为以下五个模块：

模块 1：特征提取

逻辑独立，专注于根据频率点提取特征。频率点查找采用 argmin，适合于离散频率点的近似匹配。

模块 2：数据标准化

逻辑独立，支持归一化操作，适应多种数据范围。提供 min_val 和 max_val 参数，允许对数据进行一致性归一化（例如跨批次处理时）。

模块 3：数据加载与处理

将特征提取和标准化整合，调用 extract_features 和 normalize_data。确保 normalize=True 时，数据已被标准化。

模块 4：训练与验证

分别定义训练过程和验证过程，支持批量训练与评估。

模块 5：主函数

使用调整后的数据加载模块，简化了主函数逻辑。提供更清晰的流水线，包括加载、分割、训练和可视化。

代码

文本

模块 1：特征提取

功能说明：提取指定频率点的特征，包括阻抗的实部 (Re) 和虚部 (Im)。从原始数据中精确定位接近目标频率点的数据，返回一个统一格式的特征张量

代码

文本

逻辑拆解：

张量化：将频率和阻抗数据从 Pandas 转换为 PyTorch 张量，方便后续的高效操作。
频率点近似匹配：使用 torch.abs(freq - f).argmin() 找到离目标频率最近的索引。
堆叠特征：将 Re 和 Im 的特征值堆叠为 [2, len(freqs)] 格式，支持后续输入到模型。

代码

文本

[ ]

import os

import pandas as pd

import torch

import torch.nn as nn

import torch.optim as optim

from torch.utils.data import DataLoader, TensorDataset

import matplotlib.pyplot as plt

import seaborn as sns

from sklearn.metrics import mean_squared_error, r2_score

import random

def extract_features(data, char_freqs):

"""

提取指定频率点的特征。

Parameters:

- data: 每个样本的数据（DataFrame）。

- char_freqs: 指定的频率点列表。

Returns:

- 特定频率点的特征，包含 Re(Z) 和 Im(Z) 两部分。

"""

# 将频率和阻抗数据转换为 PyTorch 的张量

freq = torch.tensor(data['freq/Hz'].to_numpy(), dtype=torch.float32)

re = torch.tensor(data['Re(Z)/Ohm'].to_numpy(), dtype=torch.float32)

im = torch.tensor(data['-Im(Z)/Ohm'].to_numpy(), dtype=torch.float32)

# 提取每个指定频率点的 Re(Z) 和 Im(Z) 数据

char_r = [re[torch.abs(freq - f).argmin()] for f in char_freqs]

char_i = [im[torch.abs(freq - f).argmin()] for f in char_freqs]

# 将实部和虚部堆叠成一个张量，返回格式 [2, len(freqs)]

char_features = torch.stack([torch.tensor(char_r), torch.tensor(char_i)], dim=0)

return char_features

代码

文本

模块 2：数据标准化

功能说明对输入数据进行归一化，将其压缩到 [0, 1] 范围。支持用户指定的最小值和最大值，也可自动计算。

代码

文本

逻辑拆解：

自动计算最小值和最大值：如果未提供 min_val 和 max_val，从数据中计算。
计算范围：避免除以零的情况，通过设置一个很小的数值 1e-8。
归一化：将数据调整为 [0, 1]，公式为 (data - min_val) / range_val。

代码

文本

[ ]

def normalize_data(data, min_val=None, max_val=None):

"""

对输入数据进行标准化处理。

Parameters:

- data: 输入的张量（Tensor）。

- min_val: 最小值，用于归一化。如果为 None，则从数据中计算。

- max_val: 最大值，用于归一化。如果为 None，则从数据中计算。

Returns:

- 标准化后的数据。

"""

# 如果未指定 min_val 和 max_val，则从数据中计算

if min_val is None:

min_val = torch.min(data, dim=1, keepdim=True).values

if max_val is None:

max_val = torch.max(data, dim=1, keepdim=True).values

# 计算范围，避免除以零的情况

range_val = max_val - min_val

range_val[range_val == 0] = 1e-8

# 标准化公式

return (data - min_val) / range_val, min_val, max_val

代码

文本

模块 3：数据加载与处理

功能说明从目录中加载原始数据。调用 extract_features 提取指定频率点的特征。根据需求调用 normalize_data 对特征进行标准化处理。

代码

文本

逻辑拆解：

遍历文件：检查目录下所有 .csv 文件并加载。
按周期提取特征：对每个 cycle 分别调用 extract_features。
可选标准化：如果 normalize=True，调用 normalize_data 进行归一化。

代码

文本

[ ]

def load_and_process_data(data_path, char_freqs, normalize=True):

"""

从目录中加载数据，提取特征并进行标准化处理。

Parameters:

- data_path: 数据目录路径。

- char_freqs: 指定的频率点列表。

- normalize: 是否对特征进行标准化。

Returns:

- EIS_data: 包含样本名称和特征的列表。

"""

EIS_data = []

for file in os.listdir(data_path):

if file.endswith('.csv'):

file_path = os.path.join(data_path, file)

sample_name = file.split('_')[-1].split('.')[0]

data = pd.read_csv(file_path)

cycles = sorted(set(data['cycle number']))

for cycle in cycles:

# 提取一个周期内的特征

cycle_data = data[data['cycle number'] == cycle]

features = extract_features(cycle_data, char_freqs)

# 标准化处理

if normalize:

features, _, _ = normalize_data(features)

# 添加样本名称和特征

EIS_data.append((f"{sample_name}_cyc{cycle}", features))

return EIS_data

代码

文本

模块 4：训练与验证

功能说明分别定义训练过程和验证过程，支持批量训练与评估。

代码

文本

逻辑拆解：

训练过程：前向传播、计算损失、反向传播、参数更新。
验证过程：仅执行前向传播和损失计算，记录预测值和真实值。

代码

文本

[ ]

def train_epoch(model, train_loader, optimizer, criterion, device):

"""

单轮训练过程。

"""

model.train()

total_loss = 0.0

for batch_input, batch_output in train_loader:

batch_input, batch_output = batch_input.to(device), batch_output.to(device)

optimizer.zero_grad()

output = model(batch_input)

loss = criterion(output, batch_output)

loss.backward()

optimizer.step()

total_loss += loss.item() * batch_input.size(0)

return total_loss / len(train_loader.dataset)

def validate_epoch(model, valid_loader, criterion, device):

"""

单轮验证过程。

"""

model.eval()

total_loss = 0.0

predictions, targets = [], []

with torch.no_grad():

for batch_input, batch_output in valid_loader:

batch_input, batch_output = batch_input.to(device), batch_output.to(device)

output = model(batch_input)

loss = criterion(output, batch_output)

total_loss += loss.item() * batch_input.size(0)

predictions.append(output.cpu())

targets.append(batch_output.cpu())

return total_loss / len(valid_loader.dataset), torch.cat(predictions), torch.cat(targets)

代码

文本

模块 5：主函数

功能说明组织数据加载、特征处理、训练与验证的整体流程。

代码

文本

[ ]

def normalize_data(data, min_val=None, max_val=None):

"""

对输入数据进行标准化处理。

Parameters:

- data: 输入的张量（Tensor）。

- min_val: 最小值，用于归一化。如果为 None，则从数据中计算。

- max_val: 最大值，用于归一化。如果为 None，则从数据中计算。

Returns:

- 标准化后的数据。

"""

if min_val is None:

min_val = torch.min(data, dim=1, keepdim=True).values

if max_val is None:

max_val = torch.max(data, dim=1, keepdim=True).values

# 避免除以零的情况

range_val = max_val - min_val

range_val[range_val == 0] = 1e-8

return (data - min_val) / range_val, min_val, max_val

代码

文本

整体分析与改进优势

1. 数据加载和处理的优化

改动内容：

重构了load_data函数：
- 从指定频率点（CHAR_F）提取Re(Z)和-Im(Z)特征。
- 使用torch.stack高效地将特征组合成具有明确维度的张量。
增加cycle number 作为模型输入特征，能够显著提升模型的表现与结果解释能力。

优点：

模块化改进：
- 数据加载、预处理和特征提取的逻辑分离，更清晰、更易维护。
动态特征提取：
- 支持从指定频率点灵活提取特征，便于适配不同任务需求。 -cycle number（循环次数）作为特征
- 能显著提高模型的预测能力、泛化能力及物理解释性。 -它能够帮助模型捕捉实验的时间序列关系，减少误差，并提供更丰富的分析维度，使结果更贴近实验实际情况 -对于动态变化明显的实验数据，cycle number** 是一个关键且不可忽略的输入特征。

2. 模型架构的增强

改动内容：

引入了残差块（ResidualBlock类）。
使用自适应池化层和卷积层代替简单的全连接层（EISConvNet类）。

优点：

残差学习：
- 解决深层网络中的梯度消失问题，提高模型在深层架构下的性能。
更好地处理序列数据：
- 自适应池化允许模型处理不同长度的输入序列，同时保持输出的一致性。
可扩展性：
- 模型设计更加灵活，可以轻松增加深度和宽度。

3. 训练和验证的改进

改动内容：

增加了独立的训练函数train_epoch和验证函数validate_epoch。
在训练过程中动态计算并记录R²和RMSE。

优点：

代码可读性：
- 将训练和验证逻辑独立出来，提高代码的逻辑清晰度。
更全面的评估：
- 同时记录R²和RMSE，为模型的预测能力提供更全面的评估指标。

4. 可视化的增强

改动内容：

增加了以下绘图函数：
- 损失曲线（plot_loss）：标题中显示平均R²和RMSE。
- 真实值与预测值的散点图（plot_predictions_scatter）。
- 残差分析（plot_residual_analysis），包括残差分布图和QQ图。

优点：

更好的分析能力：
- 通过多种可视化图表，更清晰地了解模型的行为和性能。
视觉效果改进：
- 使用透明度（alpha）和网格线（grid）提升了图表的美观性和可读性。

5. 错误处理与调试

改动内容：

增加了对空数据集的检查（if len(EIS_data) == 0）。
使用pad_or_truncate函数动态地对输入数据进行填充或截断。

优点：

更高的鲁棒性：
- 确保当数据集为空或格式错误时，及时抛出异常。
更好的适配性：
- 对于不同长度的输入序列，自动填充或截断以保证维度一致性。

6. 平均R²和RMSE的计算与展示

改动内容：

在所有epoch结束后，计算并展示平均R²和RMSE。
将这些平均值直接标注在损失曲线图上。

优点：

总结性指标：
- 提供训练过程的整体表现，为模型选择提供依据。

7. 训练轮次的调整

改动内容：

将训练循环扩展为300轮，并每10轮输出一次结果。

优点：

更充分的优化：
- 增加训练轮次，确保模型能够充分收敛。
定期输出：
- 每10轮输出一次结果，避免日志过于冗长，同时保持训练过程的可跟踪性。

改进总结

模块化设计：
- 数据加载、训练、验证、绘图等功能独立封装，便于扩展与维护。
模型架构优化：
- 残差块和自适应池化提升了深层网络的学习能力。
多样化的可视化：
- 通过预测值与真实值散点图、残差分析等图表，直观地展示模型性能。
全面的指标评估：
- 同时记录并展示R²和RMSE，为模型性能提供多维度衡量。
训练流程更加完善：
- 增加epoch轮次并定期输出，进一步提升模型训练的收敛性和可视化能力。

代码

文本

附录1：整合版代码（含解析）

代码

文本

[ ]

999

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

›

⌄

以下是更详细的注释版本：

```python

import os

import pandas as pd

import torch

import torch.nn as nn

import torch.optim as optim

from torch.utils.data import DataLoader, TensorDataset

import matplotlib.pyplot as plt

import seaborn as sns

from sklearn.metrics import mean_squared_error, r2_score

import random

# ----------------------------

# 数据加载与特征提取

# ----------------------------

def load_data(data_path, char_freqs):

"""

从指定路径加载数据，并根据特定频率提取特征。

参数：

- data_path: 数据文件所在的文件夹路径

- char_freqs: 用于特征提取的特定频率列表

- EIS_data: 包含样本名和提取特征的列表

"""

EIS_data = []

for file in os.listdir(data_path):

if file.endswith('.csv'): # 确保只处理CSV文件

file_path = os.path.join(data_path, file)

sample_name = file.split('_')[-1].split('.')[0] # 提取样本名称

data = pd.read_csv(file_path) # 读取CSV文件

cycles = sorted(set(data['cycle number'])) # 获取循环次数

for cycle in cycles:

# 针对每个循环提取数据

cycle_data = data[data['cycle number'] == cycle]

freq = torch.tensor(cycle_data['freq/Hz'].to_numpy(), dtype=torch.float32) # 频率

re = torch.tensor(cycle_data['Re(Z)/Ohm'].to_numpy(), dtype=torch.float32) # 实部

im = torch.tensor(cycle_data['-Im(Z)/Ohm'].to_numpy(), dtype=torch.float32) # 虚部

# 根据给定的频率提取特征

char_r = [re[torch.abs(freq - f).argmin()] for f in char_freqs]

char_i = [im[torch.abs(freq - f).argmin()] for f in char_freqs]

cycle_feature = torch.tensor([cycle], dtype=torch.float32) # 当前循环次数特征

# 将特征组合成一个张量（2个通道：实部和虚部）

char_features = torch.stack([torch.tensor(char_r), torch.tensor(char_i)], dim=0)

EIS_data.append((f"{sample_name}_cyc{cycle}", char_features)) # 保存样本名和特征

return EIS_data

def pad_or_truncate(data, target_length):

"""

将数据填充或截断到固定长度。

参数：

- data: 输入张量

- target_length: 目标长度

- 填充或截断后的张量

"""

if len(data[0]) > target_length: # 如果数据长度超出目标，截断

return data[:, :target_length]

elif len(data[0]) < target_length: # 如果数据长度不足，填充0

padding = torch.zeros((data.size(0), target_length - data.size(1))) # 填充的张量

return torch.cat([data, padding], dim=1) # 拼接填充部分

return data

# ----------------------------

# 模型定义

# ----------------------------

class ResidualBlock(nn.Module):

"""

定义残差块（Residual Block）。

"""

def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, padding=1):

super(ResidualBlock, self).__init__()

# 第一层卷积

self.conv1 = nn.Conv1d(in_channels, out_channels, kernel_size, stride, padding)

self.bn1 = nn.BatchNorm1d(out_channels) # 批归一化

# 第二层卷积

self.conv2 = nn.Conv1d(out_channels, out_channels, kernel_size, stride, padding)

self.bn2 = nn.BatchNorm1d(out_channels)

# 如果输入和输出通道数不一致，则通过1x1卷积调整shortcut的形状

self.downsample = nn.Conv1d(in_channels, out_channels, kernel_size=1) if in_channels != out_channels else None

self.relu = nn.ReLU() # 激活函数

def forward(self, x):

shortcut = x # 保留原始输入

x = self.relu(self.bn1(self.conv1(x))) # 第一层卷积 + 批归一化 + 激活

x = self.bn2(self.conv2(x)) # 第二层卷积 + 批归一化

if self.downsample: # 如果需要调整shortcut的通道数

shortcut = self.downsample(shortcut)

x += shortcut # 残差连接

return self.relu(x) # 激活输出

class EISConvNet(nn.Module):

"""

定义包含残差块的卷积神经网络模型。

"""

def __init__(self):

super(EISConvNet, self).__init__()

self.conv1 = nn.Conv1d(2, 16, kernel_size=3, stride=1, padding=1) # 初始卷积层

self.resblock1 = ResidualBlock(16, 32) # 第一个残差块

self.resblock2 = ResidualBlock(32, 64) # 第二个残差块

self.pool = nn.AdaptiveMaxPool1d(60) # 自适应池化，将序列长度固定为60

self.fc = nn.Conv1d(64, 2, kernel_size=1) # 最后一层卷积，输出2个通道

def forward(self, x):

x = self.conv1(x) # 初始卷积

x = self.resblock1(x) # 第一个残差块

x = self.resblock2(x) # 第二个残差块

x = self.pool(x) # 自适应池化

x = self.fc(x) # 最后一层全连接卷积

return x

# ----------------------------

# 训练与验证函数

# ----------------------------

def train_epoch(model, train_loader, optimizer, criterion, device):

"""

训练一个epoch。

"""

model.train() # 设置为训练模式

total_loss = 0.0

for batch_input, batch_output in train_loader:

batch_input, batch_output = batch_input.to(device), batch_output.to(device)

optimizer.zero_grad() # 清空梯度

output = model(batch_input) # 前向传播

loss = criterion(output, batch_output) # 计算损失

loss.backward() # 反向传播

optimizer.step() # 更新权重

total_loss += loss.item() * batch_input.size(0) # 累积损失

return total_loss / len(train_loader.dataset)

def validate_epoch(model, valid_loader, criterion, device):

"""

验证一个epoch。

"""

model.eval() # 设置为评估模式

total_loss = 0.0

predictions, targets = [], []

with torch.no_grad(): # 禁用梯度计算

for batch_input, batch_output in valid_loader:

batch_input, batch_output = batch_input.to(device), batch_output.to(device)

output = model(batch_input) # 前向传播

loss = criterion(output, batch_output) # 计算损失

total_loss += loss.item() * batch_input.size(0) # 累积损失

predictions.append(output.cpu()) # 保存预测值

targets.append(batch_output.cpu()) # 保存目标值

return total_loss / len(valid_loader.dataset), torch.cat(predictions), torch.cat(targets)

# ----------------------------

# 数据可视化函数

# ----------------------------

def plot_loss(train_losses, valid_losses):

"""

绘制训练和验证损失曲线。

"""

plt.figure(figsize=(10, 6))

plt.plot(train_losses, color="blue", alpha=0.7, label='Train Loss')

plt.plot(valid_losses, color="red", alpha=0.7, label='Valid Loss')

plt.xlabel('Epochs')

plt.ylabel('Loss')

plt.title('Training and Validation Loss')

plt.legend()

plt.grid(color='black', linestyle='--', linewidth=0.5)

plt.show()

def plot_predictions_scatter(y_true, y_pred):

"""

绘制预测值与真实值的散点对比图。

"""

plt.figure(figsize=(8, 8))

plt.scatter(y_true.flatten(), y_pred.flatten(), alpha=0.4, color="blue", label="Predictions")

plt.plot([0, 1], [0, 1], color="black", linestyle="--", label="Ideal")

plt.xlabel("True Values (Normalized)")

plt.ylabel("Predicted Values (Normalized)")

plt.title("Predictions vs. True Values")

plt.legend()

plt.grid(color='black', linestyle='--', linewidth=0.5)

plt.show()

def plot_residual_analysis(y_true, y_pred):

"""

绘制残差分析，包括残差分布和QQ图。

"""

residuals = y_true.flatten() - y_pred.flatten()

plt.figure(figsize=(12, 6))

# 残差分布

plt.subplot(1, 2, 1)

sns.histplot(residuals, kde=True, bins=50, color="blue", alpha=0.7)

plt.title("Residual Distribution")

plt.xlabel("Residuals")

plt.ylabel("Frequency")

plt.grid(color='black', linestyle='--', linewidth=0.5)

# QQ 图

plt.subplot(1, 2, 2)

sns.histplot(residuals, kde=True, bins=50, color="red", alpha=0.7)

plt.title("QQ Plot of Residuals")

plt.grid(color='black', linestyle='--', linewidth=0.5)

plt.tight_layout()

plt.show()

# ----------------------------

# 主函数

# ----------------------------

def main():

"""

主函数：加载数据、训练模型、验证模型、可视化结果。

"""

data_path = '/personal/EIS review/EIS review11.27/public_data_camb/' # 数据路径

CHAR_F = [115.78, 35.93, 7.76, 1.42] # 特征频率

# 加载数据

EIS_data = load_data(data_path, CHAR_F)

print(f"Total samples: {len(EIS_data)}")

if len(EIS_data) == 0

代码

文本

附录2：输出结果与分析

代码

文本

1.epoch=200

代码

文本

Total samples: 1350 Epoch 10, Train Loss: 0.000041, Valid Loss: 0.000019, R²: 0.9996, RMSE: 0.0044 Epoch 20, Train Loss: 0.000034, Valid Loss: 0.000023, R²: 0.9995, RMSE: 0.0048 Epoch 30, Train Loss: 0.000051, Valid Loss: 0.000033, R²: 0.9993, RMSE: 0.0058 Epoch 40, Train Loss: 0.000021, Valid Loss: 0.000008, R²: 0.9998, RMSE: 0.0028 Epoch 50, Train Loss: 0.000048, Valid Loss: 0.000015, R²: 0.9997, RMSE: 0.0039 Epoch 60, Train Loss: 0.000048, Valid Loss: 0.000013, R²: 0.9997, RMSE: 0.0036 Epoch 70, Train Loss: 0.000017, Valid Loss: 0.000049, R²: 0.9989, RMSE: 0.0070 Epoch 80, Train Loss: 0.000038, Valid Loss: 0.000044, R²: 0.9990, RMSE: 0.0066 Epoch 90, Train Loss: 0.000018, Valid Loss: 0.000007, R²: 0.9998, RMSE: 0.0027 Epoch 100, Train Loss: 0.000031, Valid Loss: 0.000028, R²: 0.9994, RMSE: 0.0053 Epoch 110, Train Loss: 0.000022, Valid Loss: 0.000045, R²: 0.9990, RMSE: 0.0067 Epoch 120, Train Loss: 0.000026, Valid Loss: 0.000025, R²: 0.9994, RMSE: 0.0050 Epoch 130, Train Loss: 0.000024, Valid Loss: 0.000011, R²: 0.9998, RMSE: 0.0033 Epoch 140, Train Loss: 0.000025, Valid Loss: 0.000060, R²: 0.9987, RMSE: 0.0077 Epoch 150, Train Loss: 0.000013, Valid Loss: 0.000008, R²: 0.9998, RMSE: 0.0028 Epoch 160, Train Loss: 0.000018, Valid Loss: 0.000011, R²: 0.9998, RMSE: 0.0033 Epoch 170, Train Loss: 0.000021, Valid Loss: 0.000044, R²: 0.9990, RMSE: 0.0066 Epoch 180, Train Loss: 0.000014, Valid Loss: 0.000003, R²: 0.9999, RMSE: 0.0018 Epoch 190, Train Loss: 0.000017, Valid Loss: 0.000008, R²: 0.9998, RMSE: 0.0027 Epoch 200, Train Loss: 0.000028, Valid Loss: 0.000038, R²: 0.9992, RMSE: 0.0061

代码

文本

alt

代码

文本

alt

代码

文本

2.epoch=300

代码

文本

Total samples: 1350 Epoch 10, Train Loss: 0.000104, Valid Loss: 0.000111, R²: 0.9975, RMSE: 0.0105

Epoch 20, Train Loss: 0.000078, Valid Loss: 0.000138, R²: 0.9969, RMSE: 0.0117

Epoch 30, Train Loss: 0.000055, Valid Loss: 0.000031, R²: 0.9993, RMSE: 0.0055

Epoch 40, Train Loss: 0.000038, Valid Loss: 0.000024, R²: 0.9995, RMSE: 0.0049

Epoch 50, Train Loss: 0.000055, Valid Loss: 0.000010, R²: 0.9998, RMSE: 0.0032

Epoch 60, Train Loss: 0.000059, Valid Loss: 0.000039, R²: 0.9991, RMSE: 0.0063

Epoch 70, Train Loss: 0.000049, Valid Loss: 0.000030, R²: 0.9993, RMSE: 0.0055

Epoch 80, Train Loss: 0.000026, Valid Loss: 0.000031, R²: 0.9993, RMSE: 0.0055

Epoch 90, Train Loss: 0.000035, Valid Loss: 0.000023, R²: 0.9995, RMSE: 0.0048

Epoch 100, Train Loss: 0.000035, Valid Loss: 0.000062, R²: 0.9986, RMSE: 0.0079

Epoch 110, Train Loss: 0.000025, Valid Loss: 0.000054, R²: 0.9988, RMSE: 0.0074

Epoch 120, Train Loss: 0.000022, Valid Loss: 0.000029, R²: 0.9993, RMSE: 0.0054

Epoch 130, Train Loss: 0.000021, Valid Loss: 0.000017, R²: 0.9996, RMSE: 0.0042

Epoch 140, Train Loss: 0.000025, Valid Loss: 0.000017, R²: 0.9996, RMSE: 0.0041

Epoch 150, Train Loss: 0.000022, Valid Loss: 0.000013, R²: 0.9997, RMSE: 0.0036

Epoch 160, Train Loss: 0.000022, Valid Loss: 0.000045, R²: 0.9990, RMSE: 0.0067

Epoch 170, Train Loss: 0.000042, Valid Loss: 0.000069, R²: 0.9985, RMSE: 0.0083

Epoch 180, Train Loss: 0.000027, Valid Loss: 0.000026, R²: 0.9994, RMSE: 0.0051

Epoch 190, Train Loss: 0.000023, Valid Loss: 0.000014, R²: 0.9997, RMSE: 0.0037

Epoch 200, Train Loss: 0.000045, Valid Loss: 0.000028, R²: 0.9994, RMSE: 0.0053

Epoch 210, Train Loss: 0.000021, Valid Loss: 0.000037, R²: 0.9992, RMSE: 0.0061

Epoch 220, Train Loss: 0.000036, Valid Loss: 0.000041, R²: 0.9991, RMSE: 0.0064

Epoch 230, Train Loss: 0.000017, Valid Loss: 0.000019, R²: 0.9996, RMSE: 0.0044

Epoch 240, Train Loss: 0.000024, Valid Loss: 0.000006, R²: 0.9999, RMSE: 0.0024

Epoch 250, Train Loss: 0.000028, Valid Loss: 0.000010, R²: 0.9998, RMSE: 0.0032

Epoch 260, Train Loss: 0.000018, Valid Loss: 0.000006, R²: 0.9999, RMSE: 0.0025

Epoch 270, Train Loss: 0.000014, Valid Loss: 0.000003, R²: 0.9999, RMSE: 0.0018

Epoch 280, Train Loss: 0.000012, Valid Loss: 0.000009, R²: 0.9998, RMSE: 0.0030

Epoch 290, Train Loss: 0.000013, Valid Loss: 0.000012, R²: 0.9997, RMSE: 0.0035

Epoch 300, Train Loss: 0.000013, Valid Loss: 0.000011, R²: 0.9998, RMSE: 0.0033

代码

文本

alt

代码

文本

alt

代码

文本

alt

代码

文本

3.epoch=500

代码

文本

Total samples: 1350 Epoch 10, Train Loss: 0.000052, Valid Loss: 0.000023 Epoch 20, Train Loss: 0.000067, Valid Loss: 0.000056 Epoch 30, Train Loss: 0.000072, Valid Loss: 0.000066 Epoch 40, Train Loss: 0.000026, Valid Loss: 0.000027 Epoch 50, Train Loss: 0.000033, Valid Loss: 0.000201 Epoch 60, Train Loss: 0.000021, Valid Loss: 0.000013 Epoch 70, Train Loss: 0.000037, Valid Loss: 0.000032 Epoch 80, Train Loss: 0.000064, Valid Loss: 0.000079 Epoch 90, Train Loss: 0.000024, Valid Loss: 0.000039 Epoch 100, Train Loss: 0.000045, Valid Loss: 0.000072 Epoch 110, Train Loss: 0.000025, Valid Loss: 0.000034 Epoch 120, Train Loss: 0.000025, Valid Loss: 0.000016 Epoch 130, Train Loss: 0.000022, Valid Loss: 0.000010 Epoch 140, Train Loss: 0.000019, Valid Loss: 0.000021 Epoch 150, Train Loss: 0.000021, Valid Loss: 0.000008 Epoch 160, Train Loss: 0.000023, Valid Loss: 0.000020 Epoch 170, Train Loss: 0.000027, Valid Loss: 0.000018 Epoch 180, Train Loss: 0.000035, Valid Loss: 0.000015 Epoch 190, Train Loss: 0.000020, Valid Loss: 0.000013 Epoch 200, Train Loss: 0.000021, Valid Loss: 0.000024 Epoch 210, Train Loss: 0.000024, Valid Loss: 0.000019 Epoch 220, Train Loss: 0.000014, Valid Loss: 0.000013 Epoch 230, Train Loss: 0.000036, Valid Loss: 0.000023 Epoch 240, Train Loss: 0.000022, Valid Loss: 0.000002 Epoch 250, Train Loss: 0.000023, Valid Loss: 0.000008 Epoch 260, Train Loss: 0.000010, Valid Loss: 0.000003 Epoch 270, Train Loss: 0.000012, Valid Loss: 0.000003 Epoch 280, Train Loss: 0.000012, Valid Loss: 0.000006 Epoch 290, Train Loss: 0.000016, Valid Loss: 0.000012 Epoch 300, Train Loss: 0.000012, Valid Loss: 0.000005 Epoch 310, Train Loss: 0.000022, Valid Loss: 0.000011 Epoch 320, Train Loss: 0.000017, Valid Loss: 0.000013 Epoch 330, Train Loss: 0.000014, Valid Loss: 0.000009 Epoch 340, Train Loss: 0.000012, Valid Loss: 0.000031 Epoch 350, Train Loss: 0.000014, Valid Loss: 0.000011 Epoch 360, Train Loss: 0.000012, Valid Loss: 0.000015 Epoch 370, Train Loss: 0.000024, Valid Loss: 0.000005 Epoch 380, Train Loss: 0.000016, Valid Loss: 0.000024 Epoch 390, Train Loss: 0.000011, Valid Loss: 0.000011 Epoch 400, Train Loss: 0.000006, Valid Loss: 0.000004 Epoch 410, Train Loss: 0.000017, Valid Loss: 0.000026 Epoch 420, Train Loss: 0.000021, Valid Loss: 0.000032 Epoch 430, Train Loss: 0.000014, Valid Loss: 0.000005 Epoch 440, Train Loss: 0.000013, Valid Loss: 0.000004 Epoch 450, Train Loss: 0.000009, Valid Loss: 0.000002 Epoch 460, Train Loss: 0.000009, Valid Loss: 0.000004 Epoch 470, Train Loss: 0.000006, Valid Loss: 0.000004 Epoch 480, Train Loss: 0.000008, Valid Loss: 0.000002 Epoch 490, Train Loss: 0.000015, Valid Loss: 0.000015 Epoch 500, Train Loss: 0.000021, Valid Loss: 0.000024

代码

文本

alt

代码

文本

alt

代码

文本

alt

代码

文本

附录3：参考文献

代码

文本

1.使用四个特征频率下的阻抗预测全频段：https://bohrium.dp.tech/notebooks/86866189178

2.关于基于 ResNet 的思想的参考文献：https://arxiv.org/abs/1512.03385

3.用于时间序列或信号处理的 CNN：https://ieeexplore.ieee.org/document/7966039

4.将 CNN 应用于时间序列数据（如频率和阻抗）的特定优势： https://ieeexplore.ieee.org/document/7966039

代码

文本

notebook

Deep Learning

Machine Learning

AI4S

notebookDeep LearningMachine LearningAI4S

点个赞吧

本文被以下合集收录

机器学习与DFT精华帖

gtang

更新于 2024-12-19

53 篇41 人关注