设为首页收藏本站
切换到窄版

鱼C论坛

 找回密码
 立即注册
鱼C论坛»论坛 › 编程语言专区 › Python交流 › 损失上百万如何解决
12下一页
返回列表 发新帖
查看: 738|回复: 23

损失上百万如何解决

[复制链接]
Terence888
发表于 2024-10-24 23:38:23 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能^_^

您需要 登录 才可以下载或查看，没有账号？立即注册

x

  2. #使用dnn模型（k折交叉验证）
  3. import torch
  4. import torch.nn as nn
  5. from torch.utils import data
  6. from torch.utils.data import Dataset,DataLoader
  7. from torch import optim

  9. #定义神经网络模型
  10. dropout1, dropout2 = 0.3, 0.6
  11. class SimpleNN(nn.Module):
  12.     def __init__(self):
  13.         super(SimpleNN, self).__init__()  # 继承需要用 SimpleNN
  14.         self.dense = nn.Sequential(
  15.             nn.Flatten(),
  16.             nn.Linear(154, 256),
  17.             nn.ReLU(),  
  18.             nn.Dropout(dropout1),
  19.             nn.Linear(256, 128),
  20.             nn.ReLU(),  
  21.             nn.Dropout(dropout2),
  22.             nn.Linear(128, 1),
  23.         )
  24.       
  25.     def forward(self, X):
  26.         output = self.dense(X)
  27.         return output
  28.    
  29. #初始化模型和优化器
  30. dnn_model = SimpleNN()
  31. loss = nn.MSELoss() #定义损失函数
  32. optimizer = optim.Adam(dnn_model.parameters(),lr=0.0001,weight_decay=0) #定义优化器


  35. #k折交叉验证选取训练集与验证集
  36. def get_k_fold_data(k, i, X, y):
  37.     assert k > 1
  38.     fold_size = len(X) // k
  39.     X_train, y_train = None, None
  40.     for j in range(k):
  41.         start = j * fold_size
  42.         end = (j + 1) * fold_size
  43.         if j == i:
  44.             X_valid, y_valid = X.iloc[start:end], y.iloc[start:end]
  45.         elif X_train is None:
  46.             X_train, y_train = X.iloc[start:end], y.iloc[start:end]
  47.         else:
  48.             X_train = pd.concat([X_train, X.iloc[start:end]], ignore_index=True)
  49.             y_train = pd.concat([y_train, y.iloc[start:end]], ignore_index=True)
  50.     return X_train, y_train, X_valid, y_valid


  53. # 开始训练
  54. k = 5
  55. batch_size = 64
  56. num_epochs = 100
  57. #weight_decay = 0

  59. #初始化损失
  60. train_l_sum, valid_l_sum = 0, 0

  62. #初始化列表
  63. train_ls, valid_ls = [], []

  65. for i in range(k):
  66.     X_train, y_train, X_valid, y_valid = get_k_fold_data(k, i, X, y)
  67.     print(f'FOLD {i}')
  68.     print('--------------------------------')
  69.    

  71.     #将DataFrame数据转换为NumPy数组，然后再转换为PyTorch张量
  72.     X_train = torch.tensor(X_train.astype(np.float32).values, dtype=torch.float32)
  73.     y_train = torch.tensor(y_train.astype(np.float32).values, dtype=torch.float32)
  74.     X_valid = torch.tensor(X_valid.astype(np.float32).values, dtype=torch.float32)
  75.     y_valid = torch.tensor(y_valid.astype(np.float32).values, dtype=torch.float32)
  76.    
  77.     #创建数据集
  78.     train_dataset = data.TensorDataset(X_train, y_train)
  79.     valid_dataset = data.TensorDataset(X_valid, y_valid)

  81.     # 获取一个数据迭代器
  82.     train_iter = DataLoader(dataset=train_dataset,batch_size=batch_size,shuffle=True,num_workers=2)#shuffle=True相当于sampler=RandomSampler(dataset)
  83.     valid_iter = DataLoader(dataset=valid_dataset,batch_size=batch_size,shuffle=True,num_workers=2)
  84.    
  85.     #开始迭代
  86.     for epoch in range(num_epochs):
  87.         train_loss = 0
  88.         for tensor_x, tensor_y in train_iter:#训练集执行梯度更新
  89.             tensor_x = tensor_x.float()
  90.             tensor_y = tensor_y.float().reshape(-1, 1)
  91.             optimizer.zero_grad() #梯度清零
  92.             pre_train = dnn_model(tensor_x)
  93.             train_l = loss(pre_train, tensor_y) #损失应避免与全局变量loss重名
  94.             train_l.backward()#前向传播
  95.             optimizer.step()#梯度下降

  97.             train_loss += train_l.item() * len(tensor_x) #批量规模损失累加
  98.             
  99.         train_loss /= len(tensor_x) #每次迭代平均损失
  100.         
  101.         if epoch % 20 == 0:
  102.             print('Loss: {}  Epoch:{}'.format(train_loss, epoch))
  103.         
  104.         with torch.no_grad():
  105.             valid_loss = 0
  106.             
  107.             for tensor_x, tensor_y in valid_iter:
  108.                 tensor_x = tensor_x.float()
  109.                 tensor_y = tensor_y.float().reshape(-1, 1)
  110.                 pre_valid = dnn_model(tensor_x)
  111.                 valid_l = loss(pre_valid, tensor_y)
  112.                 valid_loss += valid_l.item() * len(tensor_x)
  113.                   
  114.             valid_loss /= len(tensor_x)
  115.                   
  116.             if epoch % 20 == 0:
  117.                 print('Valid Loss: {}  Epoch:{}'.format(valid_loss, epoch))
  118.         
  119.     #将每折的损失添加到列表中
  120.     train_ls.append(train_loss)
  121.     valid_ls.append(valid_loss)

  123.         
  124. print('Training Ended')
  125. print('Train Average Loss: {} Valid Average Loss: {}'.format(np.mean(train_l),np.mean(valid_l)))
复制代码


结果
  1. FOLD 0
  2. --------------------------------
  3. Loss: 3789863458133.3335  Epoch:0
  4. Valid Loss: 320499525807.54285  Epoch:0
  5. Loss: 530483369472.0  Epoch:200
  6. Valid Loss: 33814231434.971428  Epoch:200
  7. Loss: 378945008640.0  Epoch:400
  8. Valid Loss: 30172513587.2  Epoch:400
  9. Loss: 341601432192.0  Epoch:600
  10. Valid Loss: 22432290753.82857  Epoch:600
复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

FishC
发表于 2024-10-24 23:38:29 | 显示全部楼层
训练损失和验证损失非常高，考虑几个可能的解决方案：

1. **数据标准化**：确保输入数据经过标准化处理。这可以通过减去均值并除以标准差实现。

2. **学习率调整**：当前学习率可能过高(或过低)，尝试不同的学习率，比如使用学习率调度器逐步调整学习率。

3. **模型复杂度**：模型可能过于简单或复杂。可以试着增加或减少网络层数和神经元数量。

4. **正则化**：试着引入正则化（例如 L2 正则化）来减少过拟合。

5. **Batch Normalization**：在模型层之间加入批量归一化层，有助于稳定训练过程。

6. **数据质量和数量**：检查是否有异常数据或缺失值，确保数据集足够大并具有代表性。

7. **过拟合与欠拟合**：从训练与验证损失的差异和下降趋势判断模型是否过拟合或欠拟合。

按照这些方法逐步调试，观察每次修改对损失的影响，逐步改善模型性能。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

Terence888
 楼主| 发表于 2024-10-25 19:19:08 | 显示全部楼层
FishC 发表于 2024-10-24 23:38
训练损失和验证损失非常高，考虑几个可能的解决方案：

1. **数据标准化**：确保输入数据经过标准化处理 ...

上述代码写的有错吗
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

FishC
发表于 2024-10-25 19:19:23 | 显示全部楼层
Terence888 发表于 2024-10-25 19:19
上述代码写的有错吗


上面的代码有一些问题需要修正：

1. **`pd.concat`中的`X.iloc`和`y.iloc`**：
   - 在`get_k_fold_data`函数中，`X.iloc`和`y.iloc`需要指定行范围，比如`X.iloc[start:end]`。

2. **`torch.tensor`应该用`X_train.values`**：
   - `torch.tensor`在转换DataFrame时应使用`X_train.values`而不是`X_train.astype(np.float32).values`。

3. **`train_ls, valid_ls`初始化**：
   - 应该初始化为空列表：`train_ls, valid_ls = [], []`。

4. **`len(tensor_x)`修正为`len(train_dataset)`或`len(valid_dataset)`**：
   - 计算损失平均值应使用完整数据集长度。

5. **损失命名**：
   - `train_l_sum`和`valid_l_sum`是多余的变量，如果不用可以删除。

6. **最后打印损失**：
   - 修正为：`np.mean(train_ls)`和`np.mean(valid_ls)`。

以下是修正后的代码示例：

  1. import torch
  2. import torch.nn as nn
  3. from torch.utils.data import DataLoader, TensorDataset
  4. from torch import optim
  5. import numpy as np
  6. import pandas as pd

  8. # 定义神经网络模型
  9. dropout1, dropout2 = 0.3, 0.6

  11. class SimpleNN(nn.Module):
  12.     def __init__(self):
  13.         super(SimpleNN, self).__init__()
  14.         self.dense = nn.Sequential(
  15.             nn.Flatten(),
  16.             nn.Linear(154, 256),
  17.             nn.ReLU(),
  18.             nn.Dropout(dropout1),
  19.             nn.Linear(256, 128),
  20.             nn.ReLU(),
  21.             nn.Dropout(dropout2),
  22.             nn.Linear(128, 1),
  23.         )

  25.     def forward(self, X):
  26.         return self.dense(X)

  28. # 初始化模型和优化器
  29. dnn_model = SimpleNN()
  30. loss = nn.MSELoss()
  31. optimizer = optim.Adam(dnn_model.parameters(), lr=0.0001, weight_decay=0)

  33. # k折交叉验证
  34. def get_k_fold_data(k, i, X, y):
  35.     assert k > 1
  36.     fold_size = len(X) // k
  37.     X_train, y_train = None, None
  38.     for j in range(k):
  39.         start = j * fold_size
  40.         end = (j + 1) * fold_size
  41.         if j == i:
  42.             X_valid, y_valid = X.iloc[start:end], y.iloc[start:end]
  43.         elif X_train is None:
  44.             X_train, y_train = X.iloc[start:end], y.iloc[start:end]
  45.         else:
  46.             X_train = pd.concat([X_train, X.iloc[start:end]], ignore_index=True)
  47.             y_train = pd.concat([y_train, y.iloc[start:end]], ignore_index=True)
  48.     return X_train, y_train, X_valid, y_valid

  50. # 开始训练
  51. k = 5
  52. batch_size = 64
  53. num_epochs = 100

  55. train_ls, valid_ls = [], []

  57. for i in range(k):
  58.     X_train, y_train, X_valid, y_valid = get_k_fold_data(k, i, X, y)
  59.     print(f'FOLD {i}')
  60.     print('--------------------------------')

  62.     X_train = torch.tensor(X_train.values, dtype=torch.float32)
  63.     y_train = torch.tensor(y_train.values, dtype=torch.float32)
  64.     X_valid = torch.tensor(X_valid.values, dtype=torch.float32)
  65.     y_valid = torch.tensor(y_valid.values, dtype=torch.float32)

  67.     train_dataset = TensorDataset(X_train, y_train)
  68.     valid_dataset = TensorDataset(X_valid, y_valid)

  70.     train_iter = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
  71.     valid_iter = DataLoader(dataset=valid_dataset, batch_size=batch_size, shuffle=True)

  73.     for epoch in range(num_epochs):
  74.         train_loss = 0
  75.         for tensor_x, tensor_y in train_iter:
  76.             tensor_x = tensor_x.float()
  77.             tensor_y = tensor_y.float().reshape(-1, 1)
  78.             optimizer.zero_grad()
  79.             pre_train = dnn_model(tensor_x)
  80.             train_l = loss(pre_train, tensor_y)
  81.             train_l.backward()
  82.             optimizer.step()

  84.             train_loss += train_l.item() * len(tensor_x)

  86.         train_loss /= len(train_dataset)

  88.         if epoch % 20 == 0:
  89.             print(f'Loss: {train_loss}  Epoch:{epoch}')

  91.         with torch.no_grad():
  92.             valid_loss = 0
  93.             for tensor_x, tensor_y in valid_iter:
  94.                 tensor_x = tensor_x.float()
  95.                 tensor_y = tensor_y.float().reshape(-1, 1)
  96.                 pre_valid = dnn_model(tensor_x)
  97.                 valid_l = loss(pre_valid, tensor_y)
  98.                 valid_loss += valid_l.item() * len(tensor_x)

  100.             valid_loss /= len(valid_dataset)

  102.             if epoch % 20 == 0:
  103.                 print(f'Valid Loss: {valid_loss}  Epoch:{epoch}')

  105.     train_ls.append(train_loss)
  106.     valid_ls.append(valid_loss)

  108. print('Training Ended')
  109. print('Train Average Loss: {} Valid Average Loss: {}'.format(np.mean(train_ls), np.mean(valid_ls)))
复制代码


如果问题仍持续，检查数据的质量和适用性。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

Terence888
 楼主| 发表于 2024-10-25 19:40:42 | 显示全部楼层
FishC 发表于 2024-10-25 19:19
上面的代码有一些问题需要修正：

1. **`pd.concat`中的`X.iloc`和`y.iloc`**：
  1. FOLD 0
  2. --------------------------------
  3. Loss: 97.42294922967751  Epoch:0
  4. Valid Loss: 6.524005912031446  Epoch:0
  5. Loss: 16.883943930268288  Epoch:20
  6. Valid Loss: 1.2612734511494637  Epoch:20
  7. Loss: 12.02363520860672  Epoch:40
  8. Valid Loss: 1.4185494550636837  Epoch:40
  9. Loss: 10.411116076012453  Epoch:60
  10. Valid Loss: 1.0686074222837176  Epoch:60
  11. Loss: 10.3524863148729  Epoch:80
  12. Valid Loss: 1.3295930474996567  Epoch:80
  13. FOLD 1
  14. --------------------------------
  15. Loss: 9.407793649161855  Epoch:0
  16. Valid Loss: 0.7865632244518825  Epoch:0
  17. Loss: 7.4260556523998575  Epoch:20
  18. Valid Loss: 0.8285839977008956  Epoch:20
  19. Loss: 7.77119686237226  Epoch:40
  20. Valid Loss: 0.8801546487425055  Epoch:40
  21. Loss: 7.2721458574136095  Epoch:60
  22. Valid Loss: 0.8985730343631335  Epoch:60
  23. Loss: 7.1905520757039385  Epoch:80
  24. Valid Loss: 0.8706890802298274  Epoch:80
  25. FOLD 2
  26. --------------------------------
  27. Loss: 7.54795270661513  Epoch:0
  28. Valid Loss: 0.6300470565046583  Epoch:0
  29. Loss: 6.906829031805198  Epoch:20
  30. Valid Loss: 1.0208279056208474  Epoch:20
  31. Loss: 7.556330171103279  Epoch:40
  32. Valid Loss: 0.7214151620864868  Epoch:40
  33. Loss: 5.766326169172923  Epoch:60
  34. Valid Loss: 0.9135981251086508  Epoch:60
  35. Loss: 5.499882264683644  Epoch:80
  36. Valid Loss: 0.5656084013836724  Epoch:80
  37. FOLD 3
  38. --------------------------------
  39. Loss: 5.7565529346466064  Epoch:0
  40. Valid Loss: 0.41647012499826297  Epoch:0
  41. Loss: 5.3368079115947085  Epoch:20
  42. Valid Loss: 0.5377804839185306  Epoch:20
  43. Loss: 5.869775238136451  Epoch:40
  44. Valid Loss: 0.6251639655658177  Epoch:40
  45. Loss: 5.750744904081027  Epoch:60
  46. Valid Loss: 0.38832607098988126  Epoch:60
  47. Loss: 6.132762424647808  Epoch:80
  48. Valid Loss: 0.5039193288023983  Epoch:80
  49. FOLD 4
  50. --------------------------------
  51. Loss: 4.891226700196664  Epoch:0
  52. Valid Loss: 0.44391103706189566  Epoch:0
  53. Loss: 4.8997232268253965  Epoch:20
  54. Valid Loss: 0.4042023944003241  Epoch:20
  55. Loss: 4.657132951542735  Epoch:40
  56. Valid Loss: 0.521915601832526  Epoch:40
  57. Loss: 5.400473614611353  Epoch:60
  58. Valid Loss: 0.5404082979474749  Epoch:60
复制代码


验证集损失低于训练集是什么原因
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

FishC
发表于 2024-10-25 19:40:51 | 显示全部楼层
Terence888 发表于 2024-10-25 19:40
FOLD 0
--------------------------------
Loss: 97 ...


验证集损失低于训练集的情况可以通过以下方面进行分析：

1. **数据不均衡**：
   - 验证集可能比训练集更简单，或训练集包含更多的噪声。

2. **正则化**：
   - 正则化可能在训练集上发挥过度作用，限制了模型的学习能力。

3. **小样本问题**：
   - 数据量较小时，不同数据集之间的损失差异可能较大。

4. **过拟合初期**：
   - 在训练初期，模型可能暂时在验证集上表现好，但随着训练深入，可能会反弹。

5. **数据分割**：
   - 检查数据分割的方法，确保训练集和验证集的分配方式和数据分布一致。

可以采取以下措施进行进一步验证和调整：

- 增加训练数据。
- 重新检查数据集的分配，确保其合理性。
- 尝试不同的模型架构和超参数设置。
- 使用交叉验证来更全面地评估模型性能。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

Terence888
 楼主| 发表于 2024-10-25 20:50:06 | 显示全部楼层
FishC 发表于 2024-10-25 19:40
验证集损失低于训练集的情况可以通过以下方面进行分析：

1. **数据不均衡**：
  1. full_dataset.fillna(0)
  2. full_dataset.select_dtypes().mean()
复制代码

  1. ---------------------------------------------------------------------------
  2. ValueError                                Traceback (most recent call last)
  3. /tmp/ipykernel_30/2491567194.py in ?()
  4.       1 full_dataset.fillna(0)
  5. ----> 2 full_dataset.select_dtypes().mean()

  7. /opt/conda/lib/python3.10/site-packages/pandas/core/frame.py in ?(self, include, exclude)
  8.    5038
  9.    5039         selection = (frozenset(include), frozenset(exclude))
  10.    5040
  11.    5041         if not any(selection):
  12. -> 5042             raise ValueError("at least one of include or exclude must be nonempty")
  13.    5043
  14.    5044         # convert the myriad valid dtypes object to a single representation
  15.    5045         def check_int_infer_dtype(dtypes):

  17. ValueError: at least one of include or exclude must be nonempty
复制代码

要求数值型特征的平均值，并对其进行从大到小排序
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

FishC
发表于 2024-10-25 20:50:17 | 显示全部楼层
Terence888 发表于 2024-10-25 20:50
full_dataset.fillna(0)
full_dataset.select_dtypes ...


要对数据集中所有数值型特征的平均值进行计算，并按照从大到小的顺序进行排序，可以按照以下步骤进行操作：

1. 使用 `fillna(0)` 对数据集中所有缺失值填充为 0。
2. 使用 `select_dtypes(include=['number'])` 选择出所有数值型列。
3. 使用 `mean()` 计算每个数值型列的平均值。
4. 使用 `sort_values(ascending=False)` 对这些平均值从大到小排序。

以下是完整的代码示例：

  1. import pandas as pd

  3. # 假设 full_dataset 是你的 DataFrame
  4. # 使用 fillna(0) 方法填充缺失值
  5. full_dataset = full_dataset.fillna(0)

  7. # 选择所有数值型列，并计算它们的平均值，然后进行排序
  8. numeric_means = full_dataset.select_dtypes(include=['number']).mean().sort_values(ascending=False)

  10. print(numeric_means)
复制代码


这个代码示例会首先填充数据集中的所有缺失值，然后选择所有数值型列，并计算这些列的平均值，最后将这些平均值按照从大到小的顺序进行排序并输出。

如果你的数据集不包含任何数值型列，这个操作仍将产生错误。再次确保你的数据集中确实包含数值型列，并正确地使用上述步骤。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

Terence888
 楼主| 发表于 2024-10-25 22:32:16 | 显示全部楼层
FishC 发表于 2024-10-25 19:40
验证集损失低于训练集的情况可以通过以下方面进行分析：

1. **数据不均衡**：

  2. #使用dnn模型（k折交叉验证）
  3. import torch
  4. import torch.nn as nn
  5. from torch.utils import data
  6. from torch.utils.data import Dataset,DataLoader
  7. from torch import optim

  9. #定义神经网络模型
  10. dropout1, dropout2 = 0.2, 0.2
  11. class SimpleNN(nn.Module):
  12.     def __init__(self):
  13.         super(SimpleNN, self).__init__()  # 继承需要用 SimpleNN
  14.         self.dense = nn.Sequential(
  15.             nn.Flatten(),
  16.             nn.Linear(154, 256),
  17.             nn.ReLU(),  
  18.             nn.Dropout(dropout1),
  19.             nn.Linear(256, 128),
  20.             nn.ReLU(),  
  21.             nn.Dropout(dropout2),
  22.             nn.Linear(128, 1),
  23.         )
  24.       
  25.     def forward(self, X):
  26.         output = self.dense(X)
  27.         return output
  28.    
  29. #初始化模型和优化器
  30. dnn_model = SimpleNN()
  31. loss = nn.MSELoss() #定义损失函数
  32. optimizer = optim.Adam(dnn_model.parameters(),lr=0.0001,weight_decay=0) #定义优化器


  35. #k折交叉验证选取训练集与验证集
  36. def get_k_fold_data(k, i, X, y):
  37.     assert k > 1
  38.     fold_size = len(X) // k
  39.     X_train, y_train = None, None
  40.     for j in range(k):
  41.         start = j * fold_size
  42.         end = (j + 1) * fold_size
  43.         if j == i:
  44.             X_valid, y_valid = X.iloc[start:end], y.iloc[start:end]
  45.         elif X_train is None:
  46.             X_train, y_train = X.iloc[start:end], y.iloc[start:end]
  47.         else:
  48.             X_train = pd.concat([X_train, X.iloc[start:end]], ignore_index=True)
  49.             y_train = pd.concat([y_train, y.iloc[start:end]], ignore_index=True)
  50.     return X_train, y_train, X_valid, y_valid


  53. # 开始训练
  54. k = 5
  55. batch_size = 64
  56. num_epochs = 100
  57. #weight_decay = 0

  59. #初始化损失
  60. train_l_sum, valid_l_sum = 0, 0

  62. #初始化列表
  63. train_ls, valid_ls = [], []

  65. for i in range(k):
  66.     X_train, y_train, X_valid, y_valid = get_k_fold_data(k, i, X, y)
  67.     print(f'FOLD {i}')
  68.     print('--------------------------------')
  69.    

  71.     #将DataFrame数据转换为NumPy数组，然后再转换为PyTorch张量
  72.     X_train = torch.tensor(X_train.astype(np.float32).values, dtype=torch.float32)
  73.     y_train = torch.tensor(y_train.astype(np.float32).values, dtype=torch.float32)
  74.     X_valid = torch.tensor(X_valid.astype(np.float32).values, dtype=torch.float32)
  75.     y_valid = torch.tensor(y_valid.astype(np.float32).values, dtype=torch.float32)
  76.    
  77.     #创建数据集
  78.     train_dataset = data.TensorDataset(X_train, y_train)
  79.     valid_dataset = data.TensorDataset(X_valid, y_valid)

  81.     # 获取一个数据迭代器
  82.     train_iter = DataLoader(dataset=train_dataset,batch_size=batch_size,shuffle=True,num_workers=2)#shuffle=True相当于sampler=RandomSampler(dataset)
  83.     valid_iter = DataLoader(dataset=valid_dataset,batch_size=batch_size,shuffle=True,num_workers=2)
  84.    
  85.     #开始迭代
  86.     for epoch in range(num_epochs):
  87.         train_loss = 0
  88.         for tensor_x, tensor_y in train_iter:#训练集执行梯度更新
  89.             tensor_x = tensor_x.float()
  90.             tensor_y = tensor_y.float().reshape(-1, 1)
  91.             optimizer.zero_grad() #梯度清零
  92.             pre_train = dnn_model(tensor_x)
  93.             train_l = loss(pre_train, tensor_y) #损失应避免与全局变量loss重名
  94.             train_l.backward()#前向传播
  95.             optimizer.step()#梯度下降

  97.             train_loss += train_l.item() * len(tensor_x) #批量规模损失累加
  98.             
  99.         train_loss /= len(tensor_x) #每次迭代平均损失
  100.         
  101.         if epoch % 20 == 0:
  102.             print('Loss: {}  Epoch:{}'.format(train_loss, epoch))
  103.         
  104.         with torch.no_grad():
  105.             valid_loss = 0
  106.             
  107.             for tensor_x, tensor_y in valid_iter:
  108.                 tensor_x = tensor_x.float()
  109.                 tensor_y = tensor_y.float().reshape(-1, 1)
  110.                 pre_valid = dnn_model(tensor_x)
  111.                 valid_l = loss(pre_valid, tensor_y)
  112.                 valid_loss += valid_l.item() * len(tensor_x)
  113.                   
  114.             valid_loss /= len(tensor_x)
  115.                   
  116.             if epoch % 20 == 0:
  117.                 print('Valid Loss: {}  Epoch:{}'.format(valid_loss, epoch))
  118.         
  119.     #将每折的损失添加到列表中
  120.     train_ls.append(train_loss)
  121.     valid_ls.append(valid_loss)

  123.         
  124. print('Training Ended')
  125. print('Train Average Loss: {} Valid Average Loss: {}'.format(np.mean(train_ls),np.mean(valid_ls)))
复制代码


上述模型如何减小正则化
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

FishC
发表于 2024-10-25 22:45:22 | 显示全部楼层
Terence888 发表于 2024-10-25 22:32
#使用dnn模型（k折交叉验证）
import torch
import ...


在您的代码中，可以通过以下方式调整正则化来减少其影响：

1. **权重衰减（weight decay）**：
   - 在优化器中 `weight_decay` 参数设置为小于当前的值，例如 `weight_decay=0.0001`。如果设置为 0，则完全没有正则化。

2. **Dropout**：
   - 减小 Dropout 率，可以减小正则化。例如，设置 `dropout1, dropout2` 为 0.1。

以下是修改的代码示例：

  1. # 初始化模型和优化器
  2. dropout1, dropout2 = 0.1, 0.1  # 更新 Dropout 率
  3. dnn_model = SimpleNN()
  4. optimizer = optim.Adam(dnn_model.parameters(), lr=0.0001, weight_decay=0.0001)  # 调整 weight_decay
复制代码


通过这些调整，您可以减小模型的正则化效果，从而可能改善训练集的表现。但同时要小心不要过拟合，必要时可以通过交叉验证进行评估。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

Terence888
 楼主| 发表于 2024-10-25 23:26:09 | 显示全部楼层
FishC 发表于 2024-10-25 22:45
在您的代码中，可以通过以下方式调整正则化来减少其影响：

1. **权重衰减（weight decay）**：

  2. #tensor_test_x = torch.FloatTensor(X_test)

  4. with torch.no_grad():
  5.     test_output = dnn_model(X_test)
  6.     submission = pd.DataFrame({'PassengerId': X_test['PassengerId'], 'SalePrice': test_output})
  7.     submission.to_csv('submission.csv', index=False)
复制代码


提交答案时碰到以下问题
  1. ---------------------------------------------------------------------------
  2. AttributeError                            Traceback (most recent call last)
  3. /tmp/ipykernel_30/3230020909.py in ?()
  4.       1 #tensor_test_x = torch.FloatTensor(X_test)
  5.       2
  6.       3 with torch.no_grad():
  7. ----> 4     test_output = dnn_model(X_test)
  8.       5     submission = pd.DataFrame({'PassengerId': X_test['PassengerId'], 'SalePrice': test_output})
  9.       6     submission.to_csv('submission.csv', index=False)

  11. /opt/conda/lib/python3.10/site-packages/torch/nn/modules/module.py in ?(self, *args, **kwargs)
  12.    1549     def _wrapped_call_impl(self, *args, **kwargs):
  13.    1550         if self._compiled_call_impl is not None:
  14.    1551             return self._compiled_call_impl(*args, **kwargs)  # type: ignore[misc]
  15.    1552         else:
  16. -> 1553             return self._call_impl(*args, **kwargs)

  18. /opt/conda/lib/python3.10/site-packages/torch/nn/modules/module.py in ?(self, *args, **kwargs)
  19.    1558         # this function, and just call forward.
  20.    1559         if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks or self._forward_pre_hooks
  21.    1560                 or _global_backward_pre_hooks or _global_backward_hooks
  22.    1561                 or _global_forward_hooks or _global_forward_pre_hooks):
  23. -> 1562             return forward_call(*args, **kwargs)
  24.    1563
  25.    1564         try:
  26.    1565             result = None

  28. /tmp/ipykernel_30/2794702383.py in ?(self, X)
  29.      24     def forward(self, X):
  30. ---> 25         output = self.dense(X)
  31.      26         return output

  33. /opt/conda/lib/python3.10/site-packages/torch/nn/modules/module.py in ?(self, *args, **kwargs)
  34.    1549     def _wrapped_call_impl(self, *args, **kwargs):
  35.    1550         if self._compiled_call_impl is not None:
  36.    1551             return self._compiled_call_impl(*args, **kwargs)  # type: ignore[misc]
  37.    1552         else:
  38. -> 1553             return self._call_impl(*args, **kwargs)

  40. /opt/conda/lib/python3.10/site-packages/torch/nn/modules/module.py in ?(self, *args, **kwargs)
  41.    1558         # this function, and just call forward.
  42.    1559         if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks or self._forward_pre_hooks
  43.    1560                 or _global_backward_pre_hooks or _global_backward_hooks
  44.    1561                 or _global_forward_hooks or _global_forward_pre_hooks):
  45. -> 1562             return forward_call(*args, **kwargs)
  46.    1563
  47.    1564         try:
  48.    1565             result = None

  50. /opt/conda/lib/python3.10/site-packages/torch/nn/modules/container.py in ?(self, input)
  51.     217     def forward(self, input):
  52.     218         for module in self:
  53. --> 219             input = module(input)
  54.     220         return input

  56. /opt/conda/lib/python3.10/site-packages/torch/nn/modules/module.py in ?(self, *args, **kwargs)
  57.    1549     def _wrapped_call_impl(self, *args, **kwargs):
  58.    1550         if self._compiled_call_impl is not None:
  59.    1551             return self._compiled_call_impl(*args, **kwargs)  # type: ignore[misc]
  60.    1552         else:
  61. -> 1553             return self._call_impl(*args, **kwargs)

  63. /opt/conda/lib/python3.10/site-packages/torch/nn/modules/module.py in ?(self, *args, **kwargs)
  64.    1558         # this function, and just call forward.
  65.    1559         if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks or self._forward_pre_hooks
  66.    1560                 or _global_backward_pre_hooks or _global_backward_hooks
  67.    1561                 or _global_forward_hooks or _global_forward_pre_hooks):
  68. -> 1562             return forward_call(*args, **kwargs)
  69.    1563
  70.    1564         try:
  71.    1565             result = None

  73. /opt/conda/lib/python3.10/site-packages/torch/nn/modules/flatten.py in ?(self, input)
  74.      49     def forward(self, input: Tensor) -> Tensor:
  75. ---> 50         return input.flatten(self.start_dim, self.end_dim)

  77. /opt/conda/lib/python3.10/site-packages/pandas/core/generic.py in ?(self, name)
  78.    6295             and name not in self._accessors
  79.    6296             and self._info_axis._can_hold_identifiers_and_holds_name(name)
  80.    6297         ):
  81.    6298             return self[name]
  82. -> 6299         return object.__getattribute__(self, name)

  84. AttributeError: 'DataFrame' object has no attribute 'flatten'
复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

FishC
发表于 2024-10-25 23:31:24 | 显示全部楼层
Terence888 发表于 2024-10-25 23:26
#tensor_test_x = torch.FloatTensor(X_test)

with ...


错误的原因是您尝试将一个 pandas DataFrame 对象传递给模型。但是模型期望输入的是 PyTorch 张量。您需要先将 DataFrame 转换为张量。

这里是修正后的代码示例：

  1. import torch
  2. import pandas as pd

  4. # 假设 X_test 是 pandas DataFrame
  5. X_test_tensor = torch.tensor(X_test.values, dtype=torch.float32)

  7. with torch.no_grad():
  8.     test_output = dnn_model(X_test_tensor)
  9.     # 将张量转换为 numpy 数组
  10.     test_output_numpy = test_output.numpy().flatten()
  11.     submission = pd.DataFrame({'PassengerId': X_test.index, 'SalePrice': test_output_numpy})
  12.     submission.to_csv('submission.csv', index=False)
复制代码


注意事项：
- 确保 `X_test` 转换为 PyTorch 张量前已去除可能的缺失值。
- 使用 `flatten()` 来将输出张量转换为一维，以符合输出格式要求。
- 使用 `X_test.index` 来填充 `PassengerId`，假设其代表唯一标识符。根据需要进行调整。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

Terence888
 楼主| 发表于 2024-10-26 12:11:11 | 显示全部楼层
FishC 发表于 2024-10-25 23:31
错误的原因是您尝试将一个 pandas DataFrame 对象传递给模型。但是模型期望输入的是 PyTorch 张量。您 ...
  1. #模型期望输入的是PyTorch 张量,先将 DataFrame 转换为张量
  2. X_test_tensor = torch.tensor(X_test.values, dtype=torch.float32)


  5. with torch.no_grad():
  6.     test_output = dnn_model(X_test_tensor)
  7.     test_output_numpy = test_output.numpy().flatten() # 将张量转换为 numpy 数组
  8.     submission = pd.DataFrame({'Id': X_test['Id'], 'SalePrice': test_output})
  9.     submission.to_csv('submission.csv', index=False)
复制代码

代码报错
  1. ---------------------------------------------------------------------------
  2. TypeError                                 Traceback (most recent call last)
  3. Cell In[25], line 2
  4.       1 #模型期望输入的是PyTorch 张量,先将 DataFrame 转换为张量
  5. ----> 2 X_test_tensor = torch.tensor(X_test.values, dtype=torch.float32)
  6.       5 with torch.no_grad():
  7.       6     test_output = dnn_model(X_test_tensor)

  9. TypeError: can't convert np.ndarray of type numpy.object_. The only supported types are: float64, float32, float16, complex64, complex128, int64, int32, int16, int8, uint64, uint32, uint16, uint8, and bool.
复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

FishC
发表于 2024-10-26 12:11:23 | 显示全部楼层
Terence888 发表于 2024-10-26 12:11
#模型期望输入的是PyTorch 张量,先将 DataFrame 转换 ...


此错误通常是因为 `X_test` 数据框中包含了一些非数值型数据，例如字符串或对象。为了避免此问题，可以先检查并确保 `X_test` 中所有列都为数值型。

以下是具体的解决方法：

1. **检查并转换非数值型数据**：确保所有数据列都为数值型。
2. **填写缺失值**：处理数据中的缺失值。

可以使用以下代码来进行预处理：

  1. import pandas as pd
  2. import torch

  4. # 确保所有列都是数值型数据
  5. X_test = X_test.apply(pd.to_numeric, errors='coerce').fillna(0)

  7. # 转换为 PyTorch 张量
  8. X_test_tensor = torch.tensor(X_test.values, dtype=torch.float32)

  10. with torch.no_grad():
  11.     test_output = dnn_model(X_test_tensor)
  12.     test_output_numpy = test_output.numpy().flatten() # 将张量转换为 numpy 数组
  13.    
  14.     # 假设 X_test 有一个索引可以作为 'Id'
  15.     submission = pd.DataFrame({'Id': X_test.index, 'SalePrice': test_output_numpy})
  16.     submission.to_csv('submission.csv', index=False)

  18. print("Submission file created successfully.")
复制代码


注意事项：
- `apply(pd.to_numeric, errors='coerce').fillna(0)` 将所有非数值型数据转换为 NaN 并用 0 填充。
- `X_test.index` 用在 `submission` 中作为 'Id'，假定这是合理的唯一标识符。如果 `X_test` 中确实需要特定的列作为 'Id'，应根据实际需要进行调整。

希望这些修改能解决您的问题！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

Terence888
 楼主| 发表于 2024-10-26 12:41:24 | 显示全部楼层
FishC 发表于 2024-10-26 12:11
此错误通常是因为 `X_test` 数据框中包含了一些非数值型数据，例如字符串或对象。为了避免此问题，可以 ...

如何观察array数组X_test是否有非数值型数据
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

FishC
发表于 2024-10-26 12:42:36 | 显示全部楼层
Terence888 发表于 2024-10-26 12:41
如何观察array数组X_test是否有非数值型数据


要检查 `X_test` 数组中是否有非数值型数据，可以使用以下方法：

1. **检查数据类型**：
   - 用 `dtypes` 查看每列的数据类型，确保是数值型。

  1. print(X_test.dtypes)
复制代码


2. **查找非数值型数据**：
   - 使用 `select_dtypes` 选择非数值型数据。

  1. non_numeric_columns = X_test.select_dtypes(exclude=[np.number]).columns
  2. print("Non-numeric columns:", non_numeric_columns)
复制代码


3. **查看示例值**：
   - 使用 `head()` 查看每列的前几个值，确认是否有异常。

  1. print(X_test.head())
复制代码


如果列出了非数值型列，您可以考虑使用以下方法将其转换为数值：

- **使用编码**：将分类数据转换为数值，例如用 `pd.get_dummies()`。
- **转化类型**：使用 `astype` 转换列的数据类型。

确认所有列为数值型后，再进行后续的张量转换操作。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

Terence888
 楼主| 发表于 2024-10-26 15:44:32 | 显示全部楼层
FishC 发表于 2024-10-26 12:42
要检查 `X_test` 数组中是否有非数值型数据，可以使用以下方法：

1. **检查数据类型**：

bool类型被识别为object类型怎么办
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

FishC
发表于 2024-10-26 15:44:39 | 显示全部楼层
Terence888 发表于 2024-10-26 15:44
bool类型被识别为object类型怎么办


如果布尔类型的列被识别为 `object` 类型，可以通过以下步骤将其转换为数值类型：

1. **使用 `astype` 转换为布尔型**：
   - 先将 `object` 类型转换为布尔类型。

  1. X_test['your_column_name'] = X_test['your_column_name'].astype(bool)
复制代码


2. **将布尔型转换为数值型**：
   - 将布尔型（`True`/`False`）转换为数值型（`1`/`0`）。

  1. X_test['your_column_name'] = X_test['your_column_name'].astype(int)
复制代码


3. **批量处理所有布尔类型的列**：
   - 找到所有 `object` 列并尝试转换。

  1. for col in X_test.columns:
  2.     if X_test[col].dtype == 'object':
  3.         X_test[col] = X_test[col].astype(bool).astype(int)
复制代码


通过这些步骤，所有布尔值列将被转换为数值型，确保后续的处理不会遇到数据类型问题。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

Terence888
 楼主| 发表于 2024-10-26 16:02:35 | 显示全部楼层
FishC 发表于 2024-10-26 15:44
如果布尔类型的列被识别为 `object` 类型，可以通过以下步骤将其转换为数值类型：

1. **使用 `astyp ...
  1. #模型期望输入的是PyTorch 张量,先将 DataFrame 转换为张量
  2. X_test_tensor = torch.tensor(X_test.values, dtype=torch.float32)

  4. with torch.no_grad():
  5.     test_output = dnn_model(X_test_tensor)
  6.     test_output_numpy = test_output.numpy().flatten() # 将张量转换为 numpy 数组
  7.     submission = pd.DataFrame({'Id': X_test['Id'], 'SalePrice': test_output})
  8.     #submission.to_csv('submission.csv', index=False)
复制代码


报错
  1. ---------------------------------------------------------------------------
  2. TypeError                                 Traceback (most recent call last)
  3. Cell In[78], line 2
  4.       1 #模型期望输入的是PyTorch 张量,先将 DataFrame 转换为张量
  5. ----> 2 X_test_tensor = torch.tensor(X_test.values, dtype=torch.float32)
  6.       4 with torch.no_grad():
  7.       5     test_output = dnn_model(X_test_tensor)

  9. TypeError: can't convert np.ndarray of type numpy.object_. The only supported types are: float64, float32, float16, complex64, complex128, int64, int32, int16, int8, uint64, uint32, uint16, uint8, and bool.
复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

FishC
发表于 2024-10-26 16:02:48 | 显示全部楼层
Terence888 发表于 2024-10-26 16:02
#模型期望输入的是PyTorch 张量,先将 DataFrame 转换 ...


出现这个错误的原因是数据框 `X_test` 仍然包含一些无法转换为数值型的数据。我们需要对 `X_test` 做进一步检查和转换。以下是具体步骤：

1. 检查 `X_test` 中的非数值型数据。
2. 将所有列转换为数值型，如果有需要，根据数据情况处理布尔型等列。

可以使用以下代码来确保 `X_test` 中的所有列都是数值型数据：

  1. import pandas as pd
  2. import numpy as np
  3. import torch

  5. # 假设 X_test 是你的 DataFrame

  7. # 1. 检查所有列的数据类型
  8. print(X_test.dtypes)

  10. # 2. 将所有object类型尝试转换为数值型，如果无法转换则用0替换
  11. X_test = X_test.apply(pd.to_numeric, errors='coerce').fillna(0)

  13. # 3. 再次检查数据类型，确保所有列都是数值型
  14. print(X_test.dtypes)

  16. # 4. 转换为 PyTorch 张量
  17. X_test_tensor = torch.tensor(X_test.values, dtype=torch.float32)

  19. # 5. 进行预测
  20. with torch.no_grad():
  21.     test_output = dnn_model(X_test_tensor)
  22.     test_output_numpy = test_output.numpy().flatten()  # 将张量转换为 numpy 数组
  23.    
  24.     # 假设 X_test 有一个 Id 列用于唯一标识，如果没有需要自行定义
  25.     submission = pd.DataFrame({'Id': X_test.index, 'SalePrice': test_output_numpy})
  26.     submission.to_csv('submission.csv', index=False)

  28. print("Submission file created successfully.")
复制代码


注意事项：

1. **处理缺失值**：使用 `fillna(0)` 将缺失值替换为 0。
2. **`Id` 列**：确保 `Id` 列存在并且能用于唯一标识每一行；如果没有，可以使用 `X_test.index` 作为标识符。

以上代码段将确保 `X_test` 中的所有列都是数值型数据，并能够正确转换为 PyTorch 张量进行预测。这样就不会再出现类型错误。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

下一页 »
12下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)

GMT+8, 2025-4-19 17:14

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表