如何添加绘制损失函数曲线

Terence888

1. #使用dnn模型（k折交叉验证）
   
2. import torch
   
3. import torch.nn as nn
   
4. from torch.utils import data
   
5. from torch.utils.data import Dataset,DataLoader
   
6. from torch import optim
   
7. 
   
8. #定义神经网络模型
   
9. 
   
10. 
    
11. class SimpleNN(nn.Module):
    
12.     def __init__(self):
    
13.         super(SimpleNN,self).__init__()
    
14.         self.hidden_layer1 = nn.Linear(154,1024)
    
15.         self.hidden_layer2 = nn.Linear(1024,1024)
    
16.         self.hidden_layer3 = nn.Linear(1024,256)
    
17.         #self.hidden_layer4 = nn.Linear(1024,1024)
    
18.         self.output_layer = nn.Linear(256,1)
    
19.         self.dropout = nn.Dropout(p=0.2)
    
20.         nn.init.xavier_uniform_(self.hidden_layer1.weight)
    
21.         nn.init.xavier_uniform_(self.hidden_layer2.weight)
    
22.         nn.init.xavier_uniform_(self.hidden_layer3.weight)
    
23.         #nn.init.xavier_uniform_(self.hidden_layer4.weight)
    
24.         nn.init.xavier_uniform_(self.output_layer.weight)
    
25.     def forward(self,x):
    
26.         inputs = x
    
27.         layer1_out = torch.nn.functional.relu(self.hidden_layer1(inputs))
    
28.         layer1_out = self.dropout(layer1_out)
    
29.         layer2_out = torch.nn.functional.relu(self.hidden_layer2(layer1_out))
    
30.         layer2_out = self.dropout(layer2_out)
    
31.         layer3_out = torch.nn.functional.relu(self.hidden_layer3(layer2_out))
    
32.         layer3_out = self.dropout(layer3_out)
    
33.         #layer4_out = torch.nn.functional.gelu(self.hidden_layer4(layer3_out))
    
34.         #layer4_out = self.dropout(layer4_out)
    
35.         #output = torch.relu(self.output_layer(layer4_out))
    
36.         output = torch.relu(self.output_layer(layer3_out))
    
37.         return output
    
38. 
    
39. # 设置超参数
    
40. k = 5
    
41. batch_size = 64
    
42. num_epochs = 1000
    
43. weight_decay = 0.001
    
44. 
    
45. #初始化模型和优化器
    
46. dnn_model = SimpleNN().to(device)  # 将模型移到GPU上
    
47. optimizer = optim.AdamW(dnn_model.parameters(),lr=0.0001,weight_decay=weight_decay) #定义优化器
    
48. 
    
49. 
    
50. #k折交叉验证选取训练集与验证集
    
51. def get_k_fold_data(k, i, X, y):
    
52.     assert k > 1
    
53.     fold_size = len(X) // k
    
54.     X_train, y_train = None, None
    
55.     for j in range(k):
    
56.         start = j * fold_size
    
57.         end = (j + 1) * fold_size
    
58.         if j == i:
    
59.             X_valid, y_valid = X.iloc[start:end], y.iloc[start:end]
    
60.         elif X_train is None:
    
61.             X_train, y_train = X.iloc[start:end], y.iloc[start:end]
    
62.         else:
    
63.             X_train = pd.concat([X_train, X.iloc[start:end]], ignore_index=True)
    
64.             y_train = pd.concat([y_train, y.iloc[start:end]], ignore_index=True)
    
65.     return X_train, y_train, X_valid, y_valid
    
66. 
    
67. 
    
68. 
    
69. 
    
70. #初始化列表
    
71. train_ls, valid_ls = [], []
    
72. 
    
73. for i in range(k):
    
74.     X_train, y_train, X_valid, y_valid = get_k_fold_data(k, i, X, y)
    
75.     print(f'FOLD {i}')
    
76.     print('--------------------------------')
    
77.    
    
78. 
    
79.     # 将DataFrame数据转换为NumPy数组，然后再转换为PyTorch张量，并且移动到GPU上
    
80.     X_train = torch.tensor(X_train.astype(np.float32).values, dtype=torch.float32).to(device)
    
81.     y_train = torch.tensor(y_train.astype(np.float32).values, dtype=torch.float32).to(device)
    
82.     X_valid = torch.tensor(X_valid.astype(np.float32).values, dtype=torch.float32).to(device)
    
83.     y_valid = torch.tensor(y_valid.astype(np.float32).values, dtype=torch.float32).to(device)
    
84.    
    
85.    
    
86.     #创建数据集
    
87.     train_ds = data.TensorDataset(X_train, y_train)
    
88.     valid_ds = data.TensorDataset(X_valid, y_valid)
    
89. 
    
90.     # 获取一个数据迭代器
    
91.     train_iter = DataLoader(dataset=train_ds,batch_size=batch_size,shuffle=True,num_workers=0)#shuffle=True相当于sampler=RandomSampler(dataset)
    
92.     valid_iter = DataLoader(dataset=valid_ds,batch_size=batch_size,shuffle=True,num_workers=0)
    
93.    
    
94.     #开始迭代
    
95.     for epoch in range(num_epochs):
    
96.         train_loss = 0
    
97.         for tensor_x, tensor_y in train_iter:#训练集执行梯度更新
    
98.             tensor_x = tensor_x.float()
    
99.             tensor_y = tensor_y.float().reshape(-1, 1)
    
100.             optimizer.zero_grad() #梯度清零
     
101.             pre_train = dnn_model(tensor_x)
     
102.             train_l = MSLE_loss(pre_train, tensor_y) #损失应避免与全局变量loss重名
     
103.             train_l.backward()#前向传播
     
104.             optimizer.step()#梯度下降
     
105. 
     
106.             train_loss += train_l.item() * len(tensor_x)
     
107.             
     
108.         train_loss /= len(train_ds) #每次迭代平均损失
     
109.         
     
110.         if epoch % 50 == 0:
     
111.             print('Loss: {}  Epoch:{}'.format(train_loss, epoch))
     
112.             #print(train_l)
     
113.         
     
114.         
     
115.         with torch.no_grad():
     
116.             valid_loss = 0
     
117.             
     
118.             for tensor_x, tensor_y in valid_iter:
     
119.                 tensor_x = tensor_x.float()
     
120.                 tensor_y = tensor_y.float().reshape(-1, 1)
     
121.                 pre_valid = dnn_model(tensor_x)
     
122.                 valid_l = MSLE_loss(pre_valid, tensor_y)
     
123.                 valid_loss += valid_l.item() * len(tensor_x)
     
124.                   
     
125.             valid_loss /= len(valid_ds)
     
126.                   
     
127.             if epoch % 50 == 0:
     
128.                 print('Valid Loss: {}  Epoch:{}'.format(valid_loss, epoch))
     
129.                 #print(valid_l)
     
130.         
     
131.       #将每折的损失添加到列表中
     
132.     train_ls.append(train_loss)
     
133.     valid_ls.append(valid_loss)
     
134. 
     
135.         
     
136. print('Training Ended')
     
137. print('Train Average Loss: {} Valid Average Loss: {}'.format(np.mean(train_ls),np.mean(valid_ls)))

复制代码

如何在上述代码中绘制损失函数曲线?训练损失和验证损失画在同一张图

FishC

要在训练过程中绘制损失函数曲线，你可以利用`matplotlib`库来绘制损失随训练迭代次数变化的图。我们可以在每个epoch结束时记录训练和验证损失，然后在所有epochs结束后再绘制这些数据。

以下是如何修改你的代码以绘制损失曲线的步骤：

1. 在代码最前面添加`matplotlib`库的导入：
   

1. import matplotlib.pyplot as plt

复制代码

2. 在每个epoch结束时，记录下当前epoch的训练和验证损失：

   

1. # 初始化列表来存储每个epoch的损失
   
2.     epoch_train_losses = []
   
3.     epoch_valid_losses = []
   
4. 
   
5.     for epoch in range(num_epochs):
   
6.         train_loss = 0
   
7.         ...
   
8.         train_loss /= len(train_ds)
   
9.         epoch_train_losses.append(train_loss)  # 记录训练损失
   
10. 
    
11.         with torch.no_grad():
    
12.             valid_loss = 0
    
13.             ...
    
14.             valid_loss /= len(valid_ds)
    
15.             epoch_valid_losses.append(valid_loss)  # 记录验证损失

复制代码

3. 在所有k折训练完成后，绘制损失曲线：

   

1. # 训练结束后绘制损失曲线
   
2.     plt.plot(range(num_epochs), epoch_train_losses, label='Train Loss')
   
3.     plt.plot(range(num_epochs), epoch_valid_losses, label='Validation Loss')
   
4.     plt.xlabel('Epoch')
   
5.     plt.ylabel('Loss')
   
6.     plt.title('Loss Curve')
   
7.     plt.legend()
   
8.     plt.show()

复制代码

注意：
- 确保`matplotlib`库已经安装，你可以通过运行`pip install matplotlib`来安装它。
- 上述代码在每个epoch记录损失，并在所有训练结束后绘图。根据需要，你可以调整记录频率，比如每隔几个epoch记录一次以减少数据量。
- 如果你希望在每折k折结束时绘制其损失曲线，可以在k折内部引入这样的绘图代码，然后为不同folds追加在一起绘图。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

Terence888

FishC 发表于 2024-10-29 10:16
要在训练过程中绘制损失函数曲线，你可以利用`matplotlib`库来绘制损失随训练迭代次数变化的图。我们可以在 ...

1. ---------------------------------------------------------------------------
   
2. ValueError                                Traceback (most recent call last)
   
3. Cell In[41], line 2
   
4.       1 # 训练结束后绘制损失曲线
   
5. ----> 2 plt.plot(range(num_epochs), epoch_train_losses, label='Train Loss')
   
6.       3 plt.plot(range(num_epochs), epoch_valid_losses, label='Validation Loss')
   
7.       4 plt.xlabel('Epoch')
   
8. 
   
9. File /opt/conda/lib/python3.10/site-packages/matplotlib/pyplot.py:2812, in plot(scalex, scaley, data, *args, **kwargs)
   
10.    2810 @_copy_docstring_and_deprecators(Axes.plot)
    
11.    2811 def plot(*args, scalex=True, scaley=True, data=None, **kwargs):
    
12. -> 2812     return gca().plot(
    
13.    2813         *args, scalex=scalex, scaley=scaley,
    
14.    2814         **({"data": data} if data is not None else {}), **kwargs)
    
15. 
    
16. File /opt/conda/lib/python3.10/site-packages/matplotlib/axes/_axes.py:1688, in Axes.plot(self, scalex, scaley, data, *args, **kwargs)
    
17.    1445 """
    
18.    1446 Plot y versus x as lines and/or markers.
    
19.    1447
    
20.    (...)
    
21.    1685 (``'green'``) or hex strings (``'#008000'``).
    
22.    1686 """
    
23.    1687 kwargs = cbook.normalize_kwargs(kwargs, mlines.Line2D)
    
24. -> 1688 lines = [*self._get_lines(*args, data=data, **kwargs)]
    
25.    1689 for line in lines:
    
26.    1690     self.add_line(line)
    
27. 
    
28. File /opt/conda/lib/python3.10/site-packages/matplotlib/axes/_base.py:311, in _process_plot_var_args.__call__(self, data, *args, **kwargs)
    
29.     309     this += args[0],
    
30.     310     args = args[1:]
    
31. --> 311 yield from self._plot_args(
    
32.     312     this, kwargs, ambiguous_fmt_datakey=ambiguous_fmt_datakey)
    
33. 
    
34. File /opt/conda/lib/python3.10/site-packages/matplotlib/axes/_base.py:504, in _process_plot_var_args._plot_args(self, tup, kwargs, return_kwargs, ambiguous_fmt_datakey)
    
35.     501     self.axes.yaxis.update_units(y)
    
36.     503 if x.shape[0] != y.shape[0]:
    
37. --> 504     raise ValueError(f"x and y must have same first dimension, but "
    
38.     505                      f"have shapes {x.shape} and {y.shape}")
    
39.     506 if x.ndim > 2 or y.ndim > 2:
    
40.     507     raise ValueError(f"x and y can be no greater than 2D, but have "
    
41.     508                      f"shapes {x.shape} and {y.shape}")
    
42. 
    
43. ValueError: x and y must have same first dimension, but have shapes (350,) and (1750,)

复制代码

上述代码修改后报错

FishC

Terence888 发表于 2024-10-29 10:47
-------------------------------------------------- ...

报错的原因是`x`和`y`的长度不匹配，可能是由于在每个epoch都进行了多个k-fold的累积。

要解决这个问题，可以在每个k-fold的最后阶段计算平均损失。这是如何做的：

1. 在每个fold开始时，初始化一个临时的存储器：

   

1. fold_train_losses = []
   
2.     fold_valid_losses = []

复制代码

2. 在epoch循环内记录损失：

   

1. fold_train_losses.append(train_loss)
   
2.     fold_valid_losses.append(valid_loss)

复制代码

3. 在k-fold结束时，累加这些损失：

   

1. if i == 0:
   
2.         epoch_train_losses = fold_train_losses
   
3.         epoch_valid_losses = fold_valid_losses
   
4.     else:
   
5.         epoch_train_losses = [x + y for x, y in zip(epoch_train_losses, fold_train_losses)]
   
6.         epoch_valid_losses = [x + y for x, y in zip(epoch_valid_losses, fold_valid_losses)]

复制代码

4. 在k-fold循环结束后，计算平均损失：

   

1. epoch_train_losses = [x / k for x in epoch_train_losses]
   
2.     epoch_valid_losses = [x / k for x in epoch_valid_losses]

复制代码

5. 然后绘制图形：

   

1. plt.plot(range(num_epochs), epoch_train_losses, label='Train Loss')
   
2.     plt.plot(range(num_epochs), epoch_valid_losses, label='Validation Loss')
   
3.     plt.xlabel('Epoch')
   
4.     plt.ylabel('Loss')
   
5.     plt.title('Loss Curve')
   
6.     plt.legend()
   
7.     plt.show()

复制代码

这样可以确保`x`和`y`的长度一致，并且每个epoch的损失值是所有fold平均后的值。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

Terence888

FishC 发表于 2024-10-29 11:04
报错的原因是`x`和`y`的长度不匹配，可能是由于在每个epoch都进行了多个k-fold的累积。

要解决这个 ...

1. #使用dnn模型（k折交叉验证）
   
2. import torch
   
3. import torch.nn as nn
   
4. from torch.utils import data
   
5. from torch.utils.data import Dataset,DataLoader
   
6. from torch import optim
   
7. 
   
8. #定义神经网络模型
   
9. 
   
10. 
    
11. class SimpleNN(nn.Module):
    
12.     def __init__(self):
    
13.         super(SimpleNN,self).__init__()
    
14.         self.hidden_layer1 = nn.Linear(154,1024)
    
15.         self.hidden_layer2 = nn.Linear(1024,1024)
    
16.         self.hidden_layer3 = nn.Linear(1024,256)
    
17.         #self.hidden_layer4 = nn.Linear(1024,1024)
    
18.         self.output_layer = nn.Linear(256,1)
    
19.         self.dropout = nn.Dropout(p=0.2)
    
20.         nn.init.xavier_uniform_(self.hidden_layer1.weight)
    
21.         nn.init.xavier_uniform_(self.hidden_layer2.weight)
    
22.         nn.init.xavier_uniform_(self.hidden_layer3.weight)
    
23.         #nn.init.xavier_uniform_(self.hidden_layer4.weight)
    
24.         nn.init.xavier_uniform_(self.output_layer.weight)
    
25.     def forward(self,x):
    
26.         inputs = x
    
27.         layer1_out = torch.nn.functional.relu(self.hidden_layer1(inputs))
    
28.         layer1_out = self.dropout(layer1_out)
    
29.         layer2_out = torch.nn.functional.relu(self.hidden_layer2(layer1_out))
    
30.         layer2_out = self.dropout(layer2_out)
    
31.         layer3_out = torch.nn.functional.relu(self.hidden_layer3(layer2_out))
    
32.         layer3_out = self.dropout(layer3_out)
    
33.         #layer4_out = torch.nn.functional.gelu(self.hidden_layer4(layer3_out))
    
34.         #layer4_out = self.dropout(layer4_out)
    
35.         #output = torch.relu(self.output_layer(layer4_out))
    
36.         output = torch.relu(self.output_layer(layer3_out))
    
37.         return output
    
38. 
    
39. # 设置超参数
    
40. k = 5
    
41. batch_size = 112
    
42. num_epochs = 350
    
43. weight_decay = 0.001
    
44. 
    
45. #初始化模型和优化器
    
46. dnn_model = SimpleNN().to(device)  # 将模型移到GPU上
    
47. optimizer = optim.Adam(dnn_model.parameters(),lr=0.0001,weight_decay=weight_decay) #定义优化器
    
48. 
    
49. 
    
50. #k折交叉验证选取训练集与验证集
    
51. def get_k_fold_data(k, i, X, y):
    
52.     assert k > 1
    
53.     fold_size = len(X) // k
    
54.     X_train, y_train = None, None
    
55.     for j in range(k):
    
56.         start = j * fold_size
    
57.         end = (j + 1) * fold_size
    
58.         if j == i:
    
59.             X_valid, y_valid = X.iloc[start:end], y.iloc[start:end]
    
60.         elif X_train is None:
    
61.             X_train, y_train = X.iloc[start:end], y.iloc[start:end]
    
62.         else:
    
63.             X_train = pd.concat([X_train, X.iloc[start:end]], ignore_index=True)
    
64.             y_train = pd.concat([y_train, y.iloc[start:end]], ignore_index=True)
    
65.     return X_train, y_train, X_valid, y_valid
    
66. 
    
67. 
    
68. 
    
69. 
    
70. #初始化列表
    
71. train_ls, valid_ls = [], []
    
72. 
    
73. for i in range(k):
    
74.     X_train, y_train, X_valid, y_valid = get_k_fold_data(k, i, X, y)
    
75.     print(f'FOLD {i}')
    
76.     print('--------------------------------')
    
77.    
    
78. 
    
79.     # 将DataFrame数据转换为NumPy数组，然后再转换为PyTorch张量，并且移动到GPU上
    
80.     X_train = torch.tensor(X_train.astype(np.float32).values, dtype=torch.float32).to(device)
    
81.     y_train = torch.tensor(y_train.astype(np.float32).values, dtype=torch.float32).to(device)
    
82.     X_valid = torch.tensor(X_valid.astype(np.float32).values, dtype=torch.float32).to(device)
    
83.     y_valid = torch.tensor(y_valid.astype(np.float32).values, dtype=torch.float32).to(device)
    
84.    
    
85.    
    
86.     #创建数据集
    
87.     train_ds = data.TensorDataset(X_train, y_train)
    
88.     valid_ds = data.TensorDataset(X_valid, y_valid)
    
89. 
    
90.     # 获取一个数据迭代器
    
91.     train_iter = DataLoader(dataset=train_ds,batch_size=batch_size,shuffle=True,num_workers=0)#shuffle=True相当于sampler=RandomSampler(dataset)
    
92.     valid_iter = DataLoader(dataset=valid_ds,batch_size=batch_size,shuffle=True,num_workers=0)
    
93.    
    
94.     #开始迭代
    
95.     for epoch in range(num_epochs):
    
96.         train_loss = 0
    
97.         for tensor_x, tensor_y in train_iter:#训练集执行梯度更新
    
98.             tensor_x = tensor_x.float()
    
99.             tensor_y = tensor_y.float().reshape(-1, 1)
    
100.             optimizer.zero_grad() #梯度清零
     
101.             pre_train = dnn_model(tensor_x)
     
102.             train_l = MSLE_loss(pre_train, tensor_y) #损失应避免与全局变量loss重名
     
103.             train_l.backward()#前向传播
     
104.             optimizer.step()#梯度下降
     
105. 
     
106.             train_loss += train_l.item() * len(tensor_x)
     
107.             
     
108.         train_loss /= len(train_ds) #每次迭代平均损失
     
109.         
     
110.         
     
111.         if epoch % 50 == 0:
     
112.             print('Loss: {}  Epoch:{}'.format(train_loss, epoch))
     
113.             
     
114.         
     
115.         
     
116.         with torch.no_grad():
     
117.             valid_loss = 0
     
118.             
     
119.             for tensor_x, tensor_y in valid_iter:
     
120.                 tensor_x = tensor_x.float()
     
121.                 tensor_y = tensor_y.float().reshape(-1, 1)
     
122.                 pre_valid = dnn_model(tensor_x)
     
123.                 valid_l = MSLE_loss(pre_valid, tensor_y)
     
124.                 valid_loss += valid_l.item() * len(tensor_x)
     
125.                   
     
126.             valid_loss /= len(valid_ds)
     
127.             
     
128.                   
     
129.             if epoch % 50 == 0:
     
130.                 print('Valid Loss: {}  Epoch:{}'.format(valid_loss, epoch))
     
131.                
     
132.     if i == 0:
     
133.             d2l.plot(list(range(1, num_epochs + 1)), [train_loss, valid_loss],
     
134.                      xlabel='epoch', ylabel='rmse', xlim=[1, num_epochs],
     
135.                      legend=['train', 'valid'], yscale='log')   
     
136.       #将每折的损失添加到列表中
     
137.     train_ls.append(train_loss)
     
138.     valid_ls.append(valid_loss)
     
139. 
     
140.         
     
141. print('Training Ended')
     
142. print('Train Average Loss: {} Valid Average Loss: {}'.format(np.mean(train_ls),np.mean(valid_ls)))

复制代码

绘制图像时报错

1. ---------------------------------------------------------------------------
   
2. ValueError                                Traceback (most recent call last)
   
3. Cell In[44], line 133
   
4.     130             print('Valid Loss: {}  Epoch:{}'.format(valid_loss, epoch))
   
5.     132 if i == 0:
   
6. --> 133         d2l.plot(list(range(1, num_epochs + 1)), [train_loss, valid_loss],
   
7.     134                  xlabel='epoch', ylabel='rmse', xlim=[1, num_epochs],
   
8.     135                  legend=['train', 'valid'], yscale='log')   
   
9.     136   #将每折的损失添加到列表中
   
10.     137 train_ls.append(train_loss)
    
11. 
    
12. Cell In[43], line 101, in plot(X, Y, xlabel, ylabel, legend, xlim, ylim, xscale, yscale, fmts, figsize, axes)
    
13.      99 for x, y, fmt in zip(X, Y, fmts):
    
14.     100     if len(x):
    
15. --> 101         axes.plot(x, y, fmt)
    
16.     102     else:
    
17.     103         axes.plot(y, fmt)
    
18. 
    
19. File /opt/conda/lib/python3.10/site-packages/matplotlib/axes/_axes.py:1688, in Axes.plot(self, scalex, scaley, data, *args, **kwargs)
    
20.    1445 """
    
21.    1446 Plot y versus x as lines and/or markers.
    
22.    1447
    
23.    (...)
    
24.    1685 (``'green'``) or hex strings (``'#008000'``).
    
25.    1686 """
    
26.    1687 kwargs = cbook.normalize_kwargs(kwargs, mlines.Line2D)
    
27. -> 1688 lines = [*self._get_lines(*args, data=data, **kwargs)]
    
28.    1689 for line in lines:
    
29.    1690     self.add_line(line)
    
30. 
    
31. File /opt/conda/lib/python3.10/site-packages/matplotlib/axes/_base.py:311, in _process_plot_var_args.__call__(self, data, *args, **kwargs)
    
32.     309     this += args[0],
    
33.     310     args = args[1:]
    
34. --> 311 yield from self._plot_args(
    
35.     312     this, kwargs, ambiguous_fmt_datakey=ambiguous_fmt_datakey)
    
36. 
    
37. File /opt/conda/lib/python3.10/site-packages/matplotlib/axes/_base.py:504, in _process_plot_var_args._plot_args(self, tup, kwargs, return_kwargs, ambiguous_fmt_datakey)
    
38.     501     self.axes.yaxis.update_units(y)
    
39.     503 if x.shape[0] != y.shape[0]:
    
40. --> 504     raise ValueError(f"x and y must have same first dimension, but "
    
41.     505                      f"have shapes {x.shape} and {y.shape}")
    
42.     506 if x.ndim > 2 or y.ndim > 2:
    
43.     507     raise ValueError(f"x and y can be no greater than 2D, but have "
    
44.     508                      f"shapes {x.shape} and {y.shape}")
    
45. 
    
46. ValueError: x and y must have same first dimension, but have shapes (350,) and (2,)

复制代码

如何修改

FishC

Terence888 发表于 2024-10-29 11:34
#使用dnn模型（k折交叉验证）
import torch
import ...

你遇到的错误是因为`x`和`y`列表在绘图时的维度不匹配。具体地说，是绘图函数`d2l.plot`中所传的`y`数据有问题。结合你的代码，我来帮你理清思路，并给出完整、正确的损失曲线绘制方法。

首先，我们需要在每次迭代过程中记录下训练和验证损失，并确保它们和`x`轴所表示的`epoch`数量是一致的。以下是一些清晰的步骤及代码示例：

1. 确保导入了`matplotlib`库：

  

1. import matplotlib.pyplot as plt

复制代码

2. 初始化列表来存储每个epoch的损失：

  

1. train_ls = []
   
2.    valid_ls = []

复制代码

3. 在训练循环内部添加记录损失的逻辑：

  

1. for epoch in range(num_epochs):
   
2.        train_loss = 0
   
3.        ...
   
4.        train_loss /= len(train_ds)
   
5.        fold_train_losses.append(train_loss)  # 记录训练损失
   
6. 
   
7.        valid_loss = 0
   
8.        ...
   
9.        valid_loss /= len(valid_ds)
   
10.        fold_valid_losses.append(valid_loss)  # 记录验证损失

复制代码

4. 在k-fold循环外进行绘图：

  

1. # 初始化列表以记录平均损失
   
2.    avg_train_losses = [0] * num_epochs
   
3.    avg_valid_losses = [0] * num_epochs
   
4. 
   
5.    # 对于每个Fold，计算损失
   
6.    for epoch in range(num_epochs):
   
7.        avg_train_losses[epoch] += fold_train_losses[epoch] / k
   
8.        avg_valid_losses[epoch] += fold_valid_losses[epoch] / k
   
9. 
   
10.    # 画图
    
11.    plt.plot(range(1, num_epochs + 1), avg_train_losses, label='Train Loss')
    
12.    plt.plot(range(1, num_epochs + 1), avg_valid_losses, label='Validation Loss')
    
13.    plt.xlabel('Epoch')
    
14.    plt.ylabel('Loss')
    
15.    plt.title('Loss Curve')
    
16.    plt.legend()
    
17.    plt.show()

复制代码

这里，我们在每个Epoch的基础上累加来自不同Folds的损失，并计算其平均值。这会确保绘图时数据维度是一致的。`avg_train_losses`和`avg_valid_losses`都是长度为`num_epochs`的列表，这样可以保证`x`和`y`在绘图时的维度相同。

希望这能解决你在绘图过程中遇到的问题！如果在某个地方有不清楚或需要进一步解释的细节，请随时告知！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。