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

鱼C论坛

 找回密码
 立即注册
鱼C论坛»论坛 › 编程语言专区 › Python交流 › 如何修改代码使用gpu的cuda来运行
返回列表 发新帖
查看: 406|回复: 3

如何修改代码使用gpu的cuda来运行

[复制链接]
Terence888
发表于 2024-10-27 16:14:47 | 显示全部楼层 |阅读模式

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

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

x
  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

  8. #定义神经网络模型


  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,1024)
  17.         self.hidden_layer4 = nn.Linear(1024,1024)
  18.         self.output_layer = nn.Linear(1024,1)
  19.         self.dropout = nn.Dropout(p=0.5)
  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.gelu(self.hidden_layer1(inputs))
  28.         layer1_out = self.dropout(layer1_out)
  29.         layer2_out = torch.nn.functional.gelu(self.hidden_layer2(layer1_out))
  30.         layer2_out = self.dropout(layer2_out)
  31.         layer3_out = torch.nn.functional.gelu(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.         return output

  38. # 设置超参数
  39. k = 5
  40. batch_size = 128
  41. num_epochs = 1000
  42. weight_decay = 0

  44. #初始化模型和优化器
  45. dnn_model = SimpleNN()
  46. optimizer = optim.AdamW(dnn_model.parameters(),lr=0.0001,weight_decay=weight_decay) #定义优化器


  49. #k折交叉验证选取训练集与验证集
  50. def get_k_fold_data(k, i, X, y):
  51.     assert k > 1
  52.     fold_size = len(X) // k
  53.     X_train, y_train = None, None
  54.     for j in range(k):
  55.         start = j * fold_size
  56.         end = (j + 1) * fold_size
  57.         if j == i:
  58.             X_valid, y_valid = X.iloc[start:end], y.iloc[start:end]
  59.         elif X_train is None:
  60.             X_train, y_train = X.iloc[start:end], y.iloc[start:end]
  61.         else:
  62.             X_train = pd.concat([X_train, X.iloc[start:end]], ignore_index=True)
  63.             y_train = pd.concat([y_train, y.iloc[start:end]], ignore_index=True)
  64.     return X_train, y_train, X_valid, y_valid




  69. #初始化列表
  70. train_ls, valid_ls = [], []

  72. for i in range(k):
  73.     X_train, y_train, X_valid, y_valid = get_k_fold_data(k, i, X, y)
  74.     print(f'FOLD {i}')
  75.     print('--------------------------------')
  76.    

  78.     #将DataFrame数据转换为NumPy数组，然后再转换为PyTorch张量
  79.     X_train = torch.tensor(X_train.astype(np.float32).values, dtype=torch.float32)
  80.     y_train = torch.tensor(y_train.astype(np.float32).values, dtype=torch.float32)
  81.     X_valid = torch.tensor(X_valid.astype(np.float32).values, dtype=torch.float32)
  82.     y_valid = torch.tensor(y_valid.astype(np.float32).values, dtype=torch.float32)
  83.    
  84.     #创建数据集
  85.     train_ds = data.TensorDataset(X_train, y_train)
  86.     valid_ds = data.TensorDataset(X_valid, y_valid)

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

  104.             train_loss += train_l.item() * len(tensor_x)
  105.             
  106.         train_loss /= len(train_ds) #每次迭代平均损失
  107.         
  108.         if epoch % 200 == 0:
  109.             print('Loss: {}  Epoch:{}'.format(train_loss, epoch))
  110.             #print(train_l)
  111.         
  112.         
  113.         with torch.no_grad():
  114.             valid_loss = 0
  115.             
  116.             for tensor_x, tensor_y in valid_iter:
  117.                 tensor_x = tensor_x.float()
  118.                 tensor_y = tensor_y.float().reshape(-1, 1)
  119.                 pre_valid = dnn_model(tensor_x)
  120.                 valid_l = MSLE_loss(pre_valid, tensor_y)
  121.                 valid_loss += valid_l.item() * len(tensor_x)
  122.                   
  123.             valid_loss /= len(valid_ds)
  124.                   
  125.             if epoch % 200 == 0:
  126.                 print('Valid Loss: {}  Epoch:{}'.format(valid_loss, epoch))
  127.                 #print(valid_l)
  128.         
  129.       #将每折的损失添加到列表中
  130.     train_ls.append(train_loss)
  131.     valid_ls.append(valid_loss)

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


迭代次数太多cpu跑不动了， 要怎么修改用gpu跑
小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

FishC
发表于 2024-10-27 16:15:04 | 显示全部楼层
为了让你的代码在GPU上运行，主要需要以下几个步骤：

1. **检查是否有可用的GPU**。
2. **将模型移到GPU上**。
3. **将输入数据和目标数据移到GPU上**。

下面是修改后的代码示例：

  1. import torch
  2. import torch.nn as nn
  3. from torch.utils import data
  4. from torch.utils.data import Dataset, DataLoader
  5. from torch import optim

  7. # 检查GPU是否可用
  8. device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

  10. # 定义神经网络模型

  12. class SimpleNN(nn.Module):
  13.     def __init__(self):
  14.         super(SimpleNN, self).__init__()
  15.         self.hidden_layer1 = nn.Linear(154, 1024)
  16.         self.hidden_layer2 = nn.Linear(1024, 1024)
  17.         self.hidden_layer3 = nn.Linear(1024, 1024)
  18.         self.hidden_layer4 = nn.Linear(1024, 1024)
  19.         self.output_layer = nn.Linear(1024, 1)
  20.         self.dropout = nn.Dropout(p=0.5)
  21.         nn.init.xavier_uniform_(self.hidden_layer1.weight)
  22.         nn.init.xavier_uniform_(self.hidden_layer2.weight)
  23.         nn.init.xavier_uniform_(self.hidden_layer3.weight)
  24.         nn.init.xavier_uniform_(self.hidden_layer4.weight)
  25.         nn.init.xavier_uniform_(self.output_layer.weight)

  27.     def forward(self, x):
  28.         inputs = x
  29.         layer1_out = torch.nn.functional.gelu(self.hidden_layer1(inputs))
  30.         layer1_out = self.dropout(layer1_out)
  31.         layer2_out = torch.nn.functional.gelu(self.hidden_layer2(layer1_out))
  32.         layer2_out = self.dropout(layer2_out)
  33.         layer3_out = torch.nn.functional.gelu(self.hidden_layer3(layer2_out))
  34.         layer3_out = self.dropout(layer3_out)
  35.         layer4_out = torch.nn.functional.gelu(self.hidden_layer4(layer3_out))
  36.         layer4_out = self.dropout(layer4_out)
  37.         output = torch.relu(self.output_layer(layer4_out))
  38.         return output

  40. # 设置超参数
  41. k = 5
  42. batch_size = 128
  43. num_epochs = 1000
  44. weight_decay = 0

  46. # 初始化模型和优化器
  47. dnn_model = SimpleNN().to(device)  # 将模型移到GPU上
  48. optimizer = optim.AdamW(dnn_model.parameters(), lr=0.0001, weight_decay=weight_decay)  # 定义优化器

  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, y.iloc
  60.         elif X_train is None:
  61.             X_train, y_train = X.iloc, y.iloc
  62.         else:
  63.             X_train = pd.concat([X_train, X.iloc], ignore_index=True)
  64.             y_train = pd.concat([y_train, y.iloc], ignore_index=True)
  65.     return X_train, y_train, X_valid, y_valid

  67. # 初始化列表
  68. train_ls, valid_ls = [], []

  70. for i in range(k):
  71.     X_train, y_train, X_valid, y_valid = get_k_fold_data(k, i, X, y)
  72.     print(f'FOLD {i}')
  73.     print('--------------------------------')
  74.    
  75.     # 将DataFrame数据转换为NumPy数组，然后再转换为PyTorch张量，并且移动到GPU上
  76.     X_train = torch.tensor(X_train.astype(np.float32).values, dtype=torch.float32).to(device)
  77.     y_train = torch.tensor(y_train.astype(np.float32).values, dtype=torch.float32).to(device)
  78.     X_valid = torch.tensor(X_valid.astype(np.float32).values, dtype=torch.float32).to(device)
  79.     y_valid = torch.tensor(y_valid.astype(np.float32).values, dtype=torch.float32).to(device)
  80.    
  81.     # 创建数据集
  82.     train_ds = data.TensorDataset(X_train, y_train)
  83.     valid_ds = data.TensorDataset(X_valid, y_valid)

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

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

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


**注意**：
1. 在初始化模型时，使用 `.to(device)` 将模型移动到指定的设备（GPU）。
2. 在将数据转换为PyTorch张量后，也使用 `.to(device)` 将数据移动到GPU。
3. 确保你的计算环境中已经安装了CUDA驱动和相关的工具包。

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

使用道具 举报

Terence888
 楼主| 发表于 2024-10-27 16:37:49 | 显示全部楼层
FishC 发表于 2024-10-27 16:15
为了让你的代码在GPU上运行，主要需要以下几个步骤：

1. **检查是否有可用的GPU**。

转换成gpu代码报错
  1. ---------------------------------------------------------------------------
  2. RuntimeError                              Traceback (most recent call last)
  3. Cell In[32], line 96
  4.      94 for epoch in range(num_epochs):
  5.      95     train_loss = 0
  6. ---> 96     for tensor_x, tensor_y in train_iter:#训练集执行梯度更新
  7.      97         tensor_x = tensor_x.float()
  8.      98         tensor_y = tensor_y.float().reshape(-1, 1)

  10. File /opt/conda/lib/python3.10/site-packages/torch/utils/data/dataloader.py:630, in _BaseDataLoaderIter.__next__(self)
  11.     627 if self._sampler_iter is None:
  12.     628     # TODO(https://github.com/pytorch/pytorch/issues/76750)
  13.     629     self._reset()  # type: ignore[call-arg]
  14. --> 630 data = self._next_data()
  15.     631 self._num_yielded += 1
  16.     632 if self._dataset_kind == _DatasetKind.Iterable and \
  17.     633         self._IterableDataset_len_called is not None and \
  18.     634         self._num_yielded > self._IterableDataset_len_called:

  20. File /opt/conda/lib/python3.10/site-packages/torch/utils/data/dataloader.py:1344, in _MultiProcessingDataLoaderIter._next_data(self)
  21.    1342 else:
  22.    1343     del self._task_info[idx]
  23. -> 1344     return self._process_data(data)

  25. File /opt/conda/lib/python3.10/site-packages/torch/utils/data/dataloader.py:1370, in _MultiProcessingDataLoaderIter._process_data(self, data)
  26.    1368 self._try_put_index()
  27.    1369 if isinstance(data, ExceptionWrapper):
  28. -> 1370     data.reraise()
  29.    1371 return data

  31. File /opt/conda/lib/python3.10/site-packages/torch/_utils.py:706, in ExceptionWrapper.reraise(self)
  32.     702 except TypeError:
  33.     703     # If the exception takes multiple arguments, don't try to
  34.     704     # instantiate since we don't know how to
  35.     705     raise RuntimeError(msg) from None
  36. --> 706 raise exception

  38. RuntimeError: Caught RuntimeError in DataLoader worker process 0.
  39. Original Traceback (most recent call last):
  40.   File "/opt/conda/lib/python3.10/site-packages/torch/utils/data/_utils/worker.py", line 309, in _worker_loop
  41.     data = fetcher.fetch(index)  # type: ignore[possibly-undefined]
  42.   File "/opt/conda/lib/python3.10/site-packages/torch/utils/data/_utils/fetch.py", line 52, in fetch
  43.     data = [self.dataset[idx] for idx in possibly_batched_index]
  44.   File "/opt/conda/lib/python3.10/site-packages/torch/utils/data/_utils/fetch.py", line 52, in <listcomp>
  45.     data = [self.dataset[idx] for idx in possibly_batched_index]
  46.   File "/opt/conda/lib/python3.10/site-packages/torch/utils/data/dataset.py", line 211, in __getitem__
  47.     return tuple(tensor[index] for tensor in self.tensors)
  48.   File "/opt/conda/lib/python3.10/site-packages/torch/utils/data/dataset.py", line 211, in <genexpr>
  49.     return tuple(tensor[index] for tensor in self.tensors)
  50. RuntimeError: CUDA error: initialization error
  51. CUDA kernel errors might be asynchronously reported at some other API call, so the stacktrace below might be incorrect.
  52. For debugging consider passing CUDA_LAUNCH_BLOCKING=1
  53. Compile with `TORCH_USE_CUDA_DSA` to enable device-side assertions.
复制代码


----------------------------------以下是源代码
  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

  8. #定义神经网络模型


  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,1024)
  17.         self.hidden_layer4 = nn.Linear(1024,1024)
  18.         self.output_layer = nn.Linear(1024,1)
  19.         self.dropout = nn.Dropout(p=0.5)
  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.gelu(self.hidden_layer1(inputs))
  28.         layer1_out = self.dropout(layer1_out)
  29.         layer2_out = torch.nn.functional.gelu(self.hidden_layer2(layer1_out))
  30.         layer2_out = self.dropout(layer2_out)
  31.         layer3_out = torch.nn.functional.gelu(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.         return output

  38. # 设置超参数
  39. k = 5
  40. batch_size = 128
  41. num_epochs = 1000
  42. weight_decay = 0

  44. #初始化模型和优化器
  45. dnn_model = SimpleNN().to(device)  # 将模型移到GPU上
  46. optimizer = optim.AdamW(dnn_model.parameters(),lr=0.0001,weight_decay=weight_decay) #定义优化器


  49. #k折交叉验证选取训练集与验证集
  50. def get_k_fold_data(k, i, X, y):
  51.     assert k > 1
  52.     fold_size = len(X) // k
  53.     X_train, y_train = None, None
  54.     for j in range(k):
  55.         start = j * fold_size
  56.         end = (j + 1) * fold_size
  57.         if j == i:
  58.             X_valid, y_valid = X.iloc[start:end], y.iloc[start:end]
  59.         elif X_train is None:
  60.             X_train, y_train = X.iloc[start:end], y.iloc[start:end]
  61.         else:
  62.             X_train = pd.concat([X_train, X.iloc[start:end]], ignore_index=True)
  63.             y_train = pd.concat([y_train, y.iloc[start:end]], ignore_index=True)
  64.     return X_train, y_train, X_valid, y_valid




  69. #初始化列表
  70. train_ls, valid_ls = [], []

  72. for i in range(k):
  73.     X_train, y_train, X_valid, y_valid = get_k_fold_data(k, i, X, y)
  74.     print(f'FOLD {i}')
  75.     print('--------------------------------')
  76.    

  78.     # 将DataFrame数据转换为NumPy数组，然后再转换为PyTorch张量，并且移动到GPU上
  79.     X_train = torch.tensor(X_train.astype(np.float32).values, dtype=torch.float32).to(device)
  80.     y_train = torch.tensor(y_train.astype(np.float32).values, dtype=torch.float32).to(device)
  81.     X_valid = torch.tensor(X_valid.astype(np.float32).values, dtype=torch.float32).to(device)
  82.     y_valid = torch.tensor(y_valid.astype(np.float32).values, dtype=torch.float32).to(device)
  83.    
  84.    
  85.     #创建数据集
  86.     train_ds = data.TensorDataset(X_train, y_train)
  87.     valid_ds = data.TensorDataset(X_valid, y_valid)

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

  105.             train_loss += train_l.item() * len(tensor_x)
  106.             
  107.         train_loss /= len(train_ds) #每次迭代平均损失
  108.         
  109.         if epoch % 200 == 0:
  110.             print('Loss: {}  Epoch:{}'.format(train_loss, epoch))
  111.             #print(train_l)
  112.         
  113.         
  114.         with torch.no_grad():
  115.             valid_loss = 0
  116.             
  117.             for tensor_x, tensor_y in valid_iter:
  118.                 tensor_x = tensor_x.float()
  119.                 tensor_y = tensor_y.float().reshape(-1, 1)
  120.                 pre_valid = dnn_model(tensor_x)
  121.                 valid_l = MSLE_loss(pre_valid, tensor_y)
  122.                 valid_loss += valid_l.item() * len(tensor_x)
  123.                   
  124.             valid_loss /= len(valid_ds)
  125.                   
  126.             if epoch % 200 == 0:
  127.                 print('Valid Loss: {}  Epoch:{}'.format(valid_loss, epoch))
  128.                 #print(valid_l)
  129.         
  130.       #将每折的损失添加到列表中
  131.     train_ls.append(train_loss)
  132.     valid_ls.append(valid_loss)

  134.         
  135. print('Training Ended')
  136. print('Train Average Loss: {} Valid Average Loss: {}'.format(np.mean(train_ls),np.mean(valid_ls)))
复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

FishC
发表于 2024-10-27 16:52:11 | 显示全部楼层
Terence888 发表于 2024-10-27 16:37
转换成gpu代码报错--------------------------------- ...


好的，让我们一步一步来分析和解决这个问题。

### 问题分析
错误信息显示一个 `CUDA error: initialization error`。这通常不是代码本身的问题，而是由于环境或并行处理引起的。在你的代码里，我们使用 `num_workers` 参数，并行处理数据加载，可能导致CUDA初始化错误。

### 解决方案
1. 确保你的代码中正确处理了设备选择和数据移动。
2. 在数据加载器中设置 `num_workers=0` 以避免多进程数据加载的问题，特别是在调试时。

### 修改后的代码
下面是修改后的代码，你可以按照这个示例来运行：

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

  9. # 检查GPU是否可用
  10. device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

  12. # 定义神经网络模型
  13. class SimpleNN(nn.Module):
  14.     def __init__(self):
  15.         super(SimpleNN, self).__init__()
  16.         self.hidden_layer1 = nn.Linear(154, 1024)
  17.         self.hidden_layer2 = nn.Linear(1024, 1024)
  18.         self.hidden_layer3 = nn.Linear(1024, 1024)
  19.         self.hidden_layer4 = nn.Linear(1024, 1024)
  20.         self.output_layer = nn.Linear(1024, 1)
  21.         self.dropout = nn.Dropout(p=0.5)
  22.         nn.init.xavier_uniform_(self.hidden_layer1.weight)
  23.         nn.init.xavier_uniform_(self.hidden_layer2.weight)
  24.         nn.init.xavier_uniform_(self.hidden_layer3.weight)
  25.         nn.init.xavier_uniform_(self.hidden_layer4.weight)
  26.         nn.init.xavier_uniform_(self.output_layer.weight)

  28.     def forward(self, x):
  29.         inputs = x
  30.         layer1_out = torch.nn.functional.gelu(self.hidden_layer1(inputs))
  31.         layer1_out = self.dropout(layer1_out)
  32.         layer2_out = torch.nn.functional.gelu(self.hidden_layer2(layer1_out))
  33.         layer2_out = self.dropout(layer2_out)
  34.         layer3_out = torch.nn.functional.gelu(self.hidden_layer3(layer2_out))
  35.         layer3_out = self.dropout(layer3_out)
  36.         layer4_out = torch.nn.functional.gelu(self.hidden_layer4(layer3_out))
  37.         layer4_out = self.dropout(layer4_out)
  38.         output = torch.relu(self.output_layer(layer4_out))
  39.         return output

  41. # 设置超参数
  42. k = 5
  43. batch_size = 128
  44. num_epochs = 1000
  45. weight_decay = 0
  46. learning_rate = 0.0001

  48. # 初始化模型和优化器
  49. dnn_model = SimpleNN().to(device)
  50. optimizer = optim.AdamW(dnn_model.parameters(), lr=learning_rate, weight_decay=weight_decay)

  52. # k折交叉验证选取训练集与验证集
  53. def get_k_fold_data(k, i, X, y):
  54.     assert k > 1
  55.     fold_size = len(X) // k
  56.     X_train, y_train = None, None
  57.     for j in range(k):
  58.         start = j * fold_size
  59.         end = (j + 1) * fold_size
  60.         X_part, y_part = X[start:end], y[start:end]
  61.         if j == i:
  62.             X_valid, y_valid = X_part, y_part
  63.         elif X_train is None:
  64.             X_train, y_train = X_part, y_part
  65.         else:
  66.             X_train = pd.concat([X_train, X_part], ignore_index=True)
  67.             y_train = pd.concat([y_train, y_part], ignore_index=True)
  68.     return X_train, y_train, X_valid, y_valid

  70. # 初始化列表
  71. train_ls, valid_ls = [], []

  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.     # 将DataFrame数据转换为NumPy数组，然后再转换为PyTorch张量，并且移动到GPU上
  79.     X_train = torch.tensor(X_train.astype(np.float32).values, dtype=torch.float32).to(device)
  80.     y_train = torch.tensor(y_train.astype(np.float32).values, dtype=torch.float32).to(device)
  81.     X_valid = torch.tensor(X_valid.astype(np.float32).values, dtype=torch.float32).to(device)
  82.     y_valid = torch.tensor(y_valid.astype(np.float32).values, dtype=torch.float32).to(device)
  83.    
  84.     # 创建数据集
  85.     train_ds = data.TensorDataset(X_train, y_train)
  86.     valid_ds = data.TensorDataset(X_valid, y_valid)

  88.     # 获取一个数据迭代器
  89.     train_iter = DataLoader(dataset=train_ds, batch_size=batch_size, shuffle=True, num_workers=0)
  90.     valid_iter = DataLoader(dataset=valid_ds, batch_size=batch_size, shuffle=False, num_workers=0)
  91.    
  92.     # 开始迭代
  93.     for epoch in range(num_epochs):
  94.         train_loss = 0
  95.         for tensor_x, tensor_y in train_iter:  # 训练集执行梯度更新
  96.             tensor_x = tensor_x.float()
  97.             tensor_y = tensor_y.float().reshape(-1, 1)
  98.             optimizer.zero_grad()  # 梯度清零
  99.             pre_train = dnn_model(tensor_x)
  100.             train_l = MSLE_loss(pre_train, tensor_y)  # 损失应避免与全局变量loss重名
  101.             train_l.backward()  # 前向传播
  102.             optimizer.step()  # 梯度下降

  104.             train_loss += train_l.item() * len(tensor_x)
  105.         
  106.         train_loss /= len(train_ds)  # 每次迭代平均损失
  107.         
  108.         if epoch % 200 == 0:
  109.             print('Loss: {}  Epoch: {}'.format(train_loss, epoch))
  110.         
  111.         with torch.no_grad():
  112.             valid_loss = 0
  113.             for tensor_x, tensor_y in valid_iter:
  114.                 tensor_x = tensor_x.float()
  115.                 tensor_y = tensor_y.float().reshape(-1, 1)
  116.                 pre_valid = dnn_model(tensor_x)
  117.                 valid_l = MSLE_loss(pre_valid, tensor_y)
  118.                 valid_loss += valid_l.item() * len(tensor_x)
  119.             
  120.             valid_loss /= len(valid_ds)
  121.             
  122.             if epoch % 200 == 0:
  123.                 print('Valid Loss: {}  Epoch: {}'.format(valid_loss, epoch))
  124.         
  125.     # 将每折的损失添加到列表中
  126.     train_ls.append(train_loss)
  127.     valid_ls.append(valid_loss)

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


### 关键点
1. 将数据加载器的 `num_workers` 参数设置为 `0` 以避免 CUDA 初始化错误。
2. 确保所有的张量和模型都正确地移动到 GPU 上： `tensor.to(device)` 和 `model.to(device)`。
3. 确保所有的计算都在 GPU 上进行，包含损失计算和优化器步骤。

### 注意
- `MSLE_loss` 需要在代码中定义，这个示例假设你已经定义了这个函数。
- 确保你的计算环境中有足够的 GPU 资源，否则可能仍然会遇到运行时错误。

通过上述修改，你应该能够成功地在 GPU 上运行你的深度神经网络模型。

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

使用道具 举报

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

本版积分规则

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

GMT+8, 2025-4-18 16:47

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

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