30-31 利用GPU训练
一、第一种方法
1.找到能够调用.cuda（）的位置
- 网络模型
- 数据（输入，标注）
- 损失函数
2.计算训练的时间
- 在CPU运行速度
代码：
点击查看代码
import torch
import torchvision
# 13. 计算时间
import time
from torch.utils.tensorboard import SummaryWriter
# 1. 准备数据集
from torch import nn
from torch.utils.data import DataLoader
train_data=torchvision.datasets.CIFAR10(root="./CIFAR10_dataset",train=True,transform=torchvision.transforms.ToTensor(),download=True) #注意ToTensor的括号不能忘，不让模型无法调用
test_data=torchvision.datasets.CIFAR10(root="./CIFAR10_dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
# 2. 计算训练集和测试集的长度
train_data_size=len(train_data)
test_data_size=len(test_data)
# 2.1 输出训练集和测试集的长度
'''
训练数据集的长度为：50000
测试数据集的长度为：10000
'''
print("训练数据集的长度为：{}".format(train_data_size))
print("测试数据集的长度为：{}".format(test_data_size))
# 3. 利用DataLoader来加载数据集
train_dataloader=DataLoader(train_data,batch_size=64)
test_dataloader=DataLoader(test_data,batch_size=64)
# 4. 搭建神经网络
class Tudui(nn.Module):
def __init__(self):
super(Tudui, self).__init__()
self.model1=nn.Sequential(
nn.Conv2d(3, 32, 5, stride=1,padding=2), # in_channel 3;out_channel 32;kernel 5;padding需要计算（一般不会太大）
nn.MaxPool2d(2), # kennel_Size=2
nn.Conv2d(32, 32, 5,stride=1,padding=2),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 5,stride=1, padding=2),
nn.MaxPool2d(2),
nn.Flatten(), # 展平 ：可以把后面的删掉 获得输出的大小
nn.Linear(64*4*4, 64), # 看上一层的大小64*4*4=1024 ，可以看到是1024
nn.Linear(64, 10) # 输入大小 64 输出大小 10
)
def forward(self,x):
x=self.model1(x)
return x
# 5.创建网络模型
tudui=Tudui()
# 6.损失函数
loss_fn=nn.CrossEntropyLoss() #交叉熵
# 7.优化器
# 1e-2=1*(10)*(-2)=1/100=0.01
learning_rate=1e-2
optimizer=torch.optim.SGD(tudui.parameters(),lr=learning_rate)
# 8.设置训练网络的一些参数
total_train_step=0 #记录训练的次数
total_test_step=0 #记录测试的次数
epoch=10 #训练的轮数
# 9. 添加tensorboard
writer=SummaryWriter("./logs_27")
# 13.1 开始时间
start_time=time.time()
for i in range(epoch):
print("------第{}轮训练开始-------".format(i+1))
# 8.1 训练步骤开始
tudui.train()
for data in train_dataloader:
imgs, targets = data
outputs = tudui(imgs)
loss = loss_fn(outputs, targets)
# 优化器优化模型
optimizer.zero_grad()
loss.backward()
optimizer.step()
#训练次数
total_train_step=total_train_step+1
#限制输出的次数
if total_train_step%100==0: #当训练次数为 100 200 时训练输出
# 13.2 结束时间
end_time=time.time()
# 13.3 输出总共需要的时间
print(end_time-start_time)
print("训练次数：{}，loss:{}".format(total_train_step,loss.item()))#loss tensor类型， loss.item() 数字类型
# 9.1 训练的效果
writer.add_scalar("train_loss",loss.item(),total_train_step)
# 8.2 测试步骤开始
'''
判断训练的结果如何
'''
tudui.eval()
total_test_loss=0 #整体的loss
total_accuracy=0 #整体正确率
with torch.no_grad(): #不再进行梯度更新，也就是不进行优化，单纯的测试
for data in test_dataloader:
imgs,targets=data
outputs=tudui(imgs)
loss=loss_fn(outputs,targets) #计算测试集上的误差（一部分数据）
total_test_loss=total_test_loss + loss.item() #计算整体测试集上的loss
# 11.计算正确率
accuracy=(outputs.argmax(1)==targets).sum()
total_accuracy+=accuracy
print("整体测试集上的loss:{}".format(total_test_loss))
# 11.1 输出准确率
print("整体测试集上的正确率:{}".format(total_accuracy/test_data_size))
# 9.2 测试的效果
writer.add_scalar("test_loss",total_test_loss,total_test_step)
# 11.2 添加显示正确率
writer.add_scalar("test_accuracy",total_accuracy/test_data_size,total_test_step)
total_test_step=total_test_step + 1 #测试完一次就+1，不让图像不会变化
# 10. 模型保存
'''
存放每一轮保存的结果
'''
torch.save(tudui,"tudui_{}.pth".format(i))
print("模型已保存")
# 9.3 关闭writer
writer.close()
运行结果
点击查看代码
Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./CIFAR10_dataset/cifar-10-python.tar.gz
170499072/? [00:03<00:00, 51354686.99it/s]
Extracting ./CIFAR10_dataset/cifar-10-python.tar.gz to ./CIFAR10_dataset
Files already downloaded and verified
训练数据集的长度为：50000
测试数据集的长度为：10000
------第1轮训练开始-------
11.110987186431885
训练次数：100，loss:2.2877604961395264
22.01622247695923
训练次数：200，loss:2.2849936485290527
32.905092000961304
训练次数：300，loss:2.2703661918640137
43.75894856452942
训练次数：400，loss:2.2159266471862793
54.58061337471008
训练次数：500，loss:2.1416776180267334
65.39709186553955
训练次数：600，loss:2.0643601417541504
76.2299473285675
训练次数：700，loss:1.9848488569259644
整体测试集上的loss:312.2365174293518
整体测试集上的正确率:0.28209999203681946
模型已保存
------第2轮训练开始-------
95.73316836357117
训练次数：800，loss:1.8631683588027954
106.56938028335571
训练次数：900，loss:1.8136553764343262
117.3673300743103
训练次数：1000，loss:1.915215253829956
128.19729018211365
训练次数：1100，loss:1.9833741188049316
139.0181097984314
训练次数：1200，loss:1.6905808448791504
149.85367798805237
训练次数：1300，loss:1.629398226737976
160.67061710357666
训练次数：1400，loss:1.7097036838531494
171.5266809463501
训练次数：1500，loss:1.7631858587265015
整体测试集上的loss:297.0589954853058
整体测试集上的正确率:0.32010000944137573
模型已保存
------第3轮训练开始-------
191.06091499328613
训练次数：1600，loss:1.707668662071228
201.981027841568
训练次数：1700，loss:1.6452357769012451
212.8516628742218
训练次数：1800，loss:1.9550222158432007
223.75627636909485
训练次数：1900，loss:1.6798380613327026
234.6314036846161
训练次数：2000，loss:1.9116848707199097
245.548077583313
训练次数：2100，loss:1.4848814010620117
256.40956473350525
训练次数：2200，loss:1.4536629915237427
267.30272603034973
训练次数：2300，loss:1.786560297012329
整体测试集上的loss:261.26172029972076
整体测试集上的正确率:0.3970000147819519
模型已保存
------第4轮训练开始-------
286.85681414604187
训练次数：2400，loss:1.7242145538330078
297.7175645828247
训练次数：2500，loss:1.3175177574157715
308.64505910873413
训练次数：2600，loss:1.606272578239441
319.58935928344727
训练次数：2700，loss:1.6576868295669556
330.47361755371094
训练次数：2800，loss:1.4555641412734985
341.3601791858673
训练次数：2900，loss:1.5828633308410645
352.24713039398193
训练次数：3000，loss:1.3251534700393677
363.1433353424072
训练次数：3100，loss:1.5461094379425049
整体测试集上的loss:251.17172074317932
整体测试集上的正确率:0.41990000009536743
模型已保存
------第5轮训练开始-------
382.7338662147522
训练次数：3200，loss:1.3294955492019653
393.5845491886139
训练次数：3300，loss:1.4597337245941162
404.45455741882324
训练次数：3400，loss:1.4898042678833008
415.293363571167
训练次数：3500，loss:1.5291085243225098
426.17122054100037
训练次数：3600，loss:1.5570412874221802
437.08485531806946
训练次数：3700，loss:1.294222354888916
447.9350402355194
训练次数：3800，loss:1.2661834955215454
458.80909299850464
训练次数：3900，loss:1.4822486639022827
整体测试集上的loss:239.8183652162552
整体测试集上的正确率:0.44440001249313354
模型已保存
------第6轮训练开始-------
478.3040735721588
训练次数：4000，loss:1.3907177448272705
489.2052643299103
训练次数：4100，loss:1.4482570886611938
500.0663561820984
训练次数：4200，loss:1.585627794265747
510.9110174179077
训练次数：4300，loss:1.2001267671585083
521.7662646770477
训练次数：4400，loss:1.0922006368637085
532.5904085636139
训练次数：4500，loss:1.3374173641204834
543.4123511314392
训练次数：4600，loss:1.4145660400390625
整体测试集上的loss:231.92839086055756
整体测试集上的正确率:0.4611999988555908
模型已保存
------第7轮训练开始-------
562.9477961063385
训练次数：4700，loss:1.3356484174728394
573.7838807106018
训练次数：4800，loss:1.5377393960952759
584.6722838878632
训练次数：4900，loss:1.400399088859558
595.5435521602631
训练次数：5000，loss:1.4183498620986938
606.4164087772369
训练次数：5100，loss:0.9900897145271301
617.2879509925842
训练次数：5200，loss:1.2673202753067017
628.1238553524017
训练次数：5300，loss:1.178088903427124
638.9806408882141
训练次数：5400，loss:1.3776136636734009
整体测试集上的loss:227.1547429561615
整体测试集上的正确率:0.4796999990940094
模型已保存
------第8轮训练开始-------
658.4881916046143
训练次数：5500，loss:1.255350947380066
669.3180439472198
训练次数：5600，loss:1.1750385761260986
680.1810879707336
训练次数：5700，loss:1.2195059061050415
690.9893569946289
训练次数：5800，loss:1.2203878164291382
701.83780169487
训练次数：5900，loss:1.3593213558197021
712.6908051967621
训练次数：6000，loss:1.5081361532211304
723.5127925872803
训练次数：6100，loss:1.0833954811096191
734.3284862041473
训练次数：6200，loss:1.0904277563095093
整体测试集上的loss:222.00016403198242
整体测试集上的正确率:0.4966999888420105
模型已保存
------第9轮训练开始-------
753.840104341507
训练次数：6300，loss:1.4123660326004028
764.6953125
训练次数：6400，loss:1.1005157232284546
775.505446434021
训练次数：6500，loss:1.51044762134552
786.3773076534271
训练次数：6600，loss:1.0844604969024658
797.2431457042694
训练次数：6700，loss:1.0497959852218628
808.145026922226
训练次数：6800，loss:1.2178071737289429
818.9774401187897
训练次数：6900，loss:1.0795538425445557
829.8596458435059
训练次数：7000，loss:0.9014005661010742
整体测试集上的loss:215.3285013437271
整体测试集上的正确率:0.5152999758720398
模型已保存
------第10轮训练开始-------
849.4030301570892
训练次数：7100，loss:1.129699468612671
860.2384145259857
训练次数：7200，loss:0.927510142326355
871.0975918769836
训练次数：7300，loss:1.1657779216766357
881.9566361904144
训练次数：7400，loss:0.8315598368644714
892.8183481693268
训练次数：7500，loss:1.2595139741897583
903.6350629329681
训练次数：7600，loss:1.2293405532836914
914.4600555896759
训练次数：7700，loss:0.823930561542511
925.3196330070496
训练次数：7800，loss:1.2183678150177002
整体测试集上的loss:208.68356120586395
整体测试集上的正确率:0.5336999893188477
模型已保存
- 在GPU运行速度
可以在colab运行，每周30h
修改->笔记本设置->选择GPU
执行以下代码：
点击查看代码
import torch
import torchvision
# 13. 计算时间
import time
from torch.utils.tensorboard import SummaryWriter
# 1. 准备数据集
from torch import nn
from torch.utils.data import DataLoader
train_data=torchvision.datasets.CIFAR10(root="./CIFAR10_dataset",train=True,transform=torchvision.transforms.ToTensor(),download=True) #注意ToTensor的括号不能忘，不让模型无法调用
test_data=torchvision.datasets.CIFAR10(root="./CIFAR10_dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
# 2. 计算训练集和测试集的长度
train_data_size=len(train_data)
test_data_size=len(test_data)
# 2.1 输出训练集和测试集的长度
'''
训练数据集的长度为：50000
测试数据集的长度为：10000
'''
print("训练数据集的长度为：{}".format(train_data_size))
print("测试数据集的长度为：{}".format(test_data_size))
# 3. 利用DataLoader来加载数据集
train_dataloader=DataLoader(train_data,batch_size=64)
test_dataloader=DataLoader(test_data,batch_size=64)
# 4. 搭建神经网络
class Tudui(nn.Module):
def __init__(self):
super(Tudui, self).__init__()
self.model1=nn.Sequential(
nn.Conv2d(3, 32, 5, stride=1,padding=2), # in_channel 3;out_channel 32;kernel 5;padding需要计算（一般不会太大）
nn.MaxPool2d(2), # kennel_Size=2
nn.Conv2d(32, 32, 5,stride=1,padding=2),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 5,stride=1, padding=2),
nn.MaxPool2d(2),
nn.Flatten(), # 展平 ：可以把后面的删掉 获得输出的大小
nn.Linear(64*4*4, 64), # 看上一层的大小64*4*4=1024 ，可以看到是1024
nn.Linear(64, 10) # 输入大小 64 输出大小 10
)
def forward(self,x):
x=self.model1(x)
return x
# 5.创建网络模型
tudui=Tudui()
# 12.1 模型调用cuda
# if torch.cuda.is_available():#没有GPU就用CPU
tudui=tudui.cuda()
# 6.损失函数
loss_fn=nn.CrossEntropyLoss() #交叉熵
# 12.2 损失函数调用cuda
# if torch.cuda.is_available():
loss_fn=loss_fn.cuda()
# 7.优化器
# 1e-2=1*(10)*(-2)=1/100=0.01
learning_rate=1e-2
optimizer=torch.optim.SGD(tudui.parameters(),lr=learning_rate)
# 8.设置训练网络的一些参数
total_train_step=0 #记录训练的次数
total_test_step=0 #记录测试的次数
epoch=10 #训练的轮数
# 9. 添加tensorboard
writer=SummaryWriter("./logs_27")
# 13.1 开始时间
start_time=time.time()
for i in range(epoch):
print("------第{}轮训练开始-------".format(i+1))
# 8.1 训练步骤开始
tudui.train()
for data in train_dataloader:
imgs, targets = data
# 12.3 训练数据添加.cuda
# if torch.cuda.is_available() :
imgs=imgs.cuda()
targets=targets.cuda()
outputs = tudui(imgs)
loss = loss_fn(outputs, targets)
# 优化器优化模型
optimizer.zero_grad()
loss.backward()
optimizer.step()
#训练次数
total_train_step=total_train_step+1
#限制输出的次数
if total_train_step%100==0: #当训练次数为 100 200 时训练输出
# 13.2 结束时间
end_time = time.time()
# 13.3 输出总共需要的时间
print(end_time - start_time)
print("训练次数：{}，loss:{}".format(total_train_step,loss.item()))#loss tensor类型， loss.item() 数字类型
# 9.1 训练的效果
writer.add_scalar("train_loss",loss.item(),total_train_step)
# 8.2 测试步骤开始
'''
判断训练的结果如何
'''
tudui.eval()
total_test_loss=0 #整体的loss
total_accuracy=0 #整体正确率
with torch.no_grad(): #不再进行梯度更新，也就是不进行优化，单纯的测试
for data in test_dataloader:
imgs,targets=data
# 12.4 测试数据添加.cuda
# if torch.cuda.is_available() :
imgs = imgs.cuda()
targets = targets.cuda()
outputs=tudui(imgs)
loss=loss_fn(outputs,targets) #计算测试集上的误差（一部分数据）
total_test_loss=total_test_loss + loss.item() #计算整体测试集上的loss
# 11.计算正确率
accuracy=(outputs.argmax(1)==targets).sum()
total_accuracy+=accuracy
print("整体测试集上的loss:{}".format(total_test_loss))
# 11.1 输出准确率
print("整体测试集上的正确率:{}".format(total_accuracy/test_data_size))
# 9.2 测试的效果
writer.add_scalar("test_loss",total_test_loss,total_test_step)
# 11.2 添加显示正确率
writer.add_scalar("test_accuracy",total_accuracy/test_data_size,total_test_step)
total_test_step=total_test_step + 1 #测试完一次就+1，不让图像不会变化
# 10. 模型保存
'''
存放每一轮保存的结果
'''
torch.save(tudui,"tudui_{}.pth".format(i))
print("模型已保存")
# 9.3 关闭writer
writer.close()
运行结果：
点击查看代码
训练数据集的长度为：50000
测试数据集的长度为：10000
------第1轮训练开始-------
4.33272910118103
训练次数：100，loss:2.2884974479675293
5.493952512741089
训练次数：200，loss:2.281789779663086
6.413592100143433
训练次数：300，loss:2.2716212272644043
7.30815863609314
训练次数：400，loss:2.2252750396728516
8.214631795883179
训练次数：500，loss:2.092320680618286
9.104838132858276
训练次数：600，loss:2.0375611782073975
10.00234079360962
训练次数：700，loss:2.012112617492676
整体测试集上的loss:313.2297248840332
整体测试集上的正确率:0.28509998321533203
模型已保存
------第2轮训练开始-------
12.371474981307983
训练次数：800，loss:1.8864545822143555
13.280489683151245
训练次数：900，loss:1.870816946029663
14.181978225708008
训练次数：1000，loss:1.9185900688171387
15.075580835342407
训练次数：1100，loss:1.9517053365707397
15.980042934417725
训练次数：1200，loss:1.6900173425674438
16.911458253860474
训练次数：1300，loss:1.6750991344451904
17.81891131401062
训练次数：1400，loss:1.7436320781707764
18.733550310134888
训练次数：1500，loss:1.811186671257019
整体测试集上的loss:288.15271389484406
整体测试集上的正确率:0.34119999408721924
模型已保存
------第3轮训练开始-------
20.92395305633545
训练次数：1600，loss:1.77822744846344
21.847413778305054
训练次数：1700，loss:1.655598521232605
22.78502058982849
训练次数：1800，loss:1.9148616790771484
23.688599348068237
训练次数：1900，loss:1.7271881103515625
24.588708639144897
训练次数：2000，loss:1.8844763040542603
25.49996304512024
训练次数：2100，loss:1.5405311584472656
26.680898904800415
训练次数：2200，loss:1.4970617294311523
27.771580696105957
训练次数：2300，loss:1.7908413410186768
整体测试集上的loss:265.59271264076233
整体测试集上的正确率:0.38509997725486755
模型已保存
------第4轮训练开始-------
29.94524621963501
训练次数：2400，loss:1.6934089660644531
30.865198135375977
训练次数：2500，loss:1.363931655883789
31.763295650482178
训练次数：2600，loss:1.5953984260559082
32.67670917510986
训练次数：2700，loss:1.6671370267868042
33.571396827697754
训练次数：2800，loss:1.4739454984664917
34.468915700912476
训练次数：2900，loss:1.5968403816223145
35.377769231796265
训练次数：3000，loss:1.3682552576065063
36.28901982307434
训练次数：3100，loss:1.5051652193069458
整体测试集上的loss:262.48951256275177
整体测试集上的正确率:0.39559999108314514
模型已保存
------第5轮训练开始-------
38.50037908554077
训练次数：3200，loss:1.36240816116333
39.39479875564575
训练次数：3300，loss:1.457019567489624
40.28350615501404
训练次数：3400，loss:1.4686907529830933
41.185163736343384
训练次数：3500，loss:1.549347996711731
42.10871362686157
训练次数：3600，loss:1.5798014402389526
43.264132499694824
训练次数：3700，loss:1.363492727279663
44.163246154785156
训练次数：3800，loss:1.2952622175216675
45.06690216064453
训练次数：3900，loss:1.449944257736206
整体测试集上的loss:260.5120462179184
整体测试集上的正确率:0.4099999964237213
模型已保存
------第6轮训练开始-------
47.25864911079407
训练次数：4000，loss:1.4141969680786133
48.160966873168945
训练次数：4100，loss:1.4095240831375122
49.100165128707886
训练次数：4200，loss:1.5366352796554565
50.25661325454712
训练次数：4300，loss:1.227867841720581
51.15277934074402
训练次数：4400，loss:1.154367446899414
52.340696573257446
训练次数：4500，loss:1.384210467338562
53.255535364151
训练次数：4600，loss:1.4147766828536987
整体测试集上的loss:248.26019895076752
整体测试集上的正确率:0.43609997630119324
模型已保存
------第7轮训练开始-------
55.41539120674133
训练次数：4700，loss:1.3197097778320312
56.33135747909546
训练次数：4800，loss:1.5068280696868896
57.23777985572815
训练次数：4900，loss:1.3645864725112915
58.16762137413025
训练次数：5000，loss:1.3748646974563599
59.07088613510132
训练次数：5100，loss:0.999653160572052
59.98392128944397
训练次数：5200，loss:1.3277932405471802
60.89016318321228
训练次数：5300，loss:1.1706973314285278
61.82019829750061
训练次数：5400，loss:1.3529413938522339
整体测试集上的loss:230.41336357593536
整体测试集上的正确率:0.4745999872684479
模型已保存
------第8轮训练开始-------
64.00623440742493
训练次数：5500，loss:1.2114841938018799
64.91326403617859
训练次数：5600，loss:1.192514419555664
65.81842613220215
训练次数：5700，loss:1.251175880432129
66.98505425453186
训练次数：5800，loss:1.24003005027771
67.89593315124512
训练次数：5900，loss:1.3413259983062744
68.82185506820679
训练次数：6000，loss:1.4932656288146973
69.74867939949036
训练次数：6100，loss:1.0106247663497925
70.67207860946655
训练次数：6200，loss:1.136347770690918
整体测试集上的loss:213.7305462360382
整体测试集上的正确率:0.5126999616622925
模型已保存
------第9轮训练开始-------
73.09997987747192
训练次数：6300，loss:1.4074432849884033
74.06448864936829
训练次数：6400，loss:1.1067496538162231
75.49039149284363
训练次数：6500，loss:1.571216344833374
76.73335886001587
训练次数：6600，loss:1.1042038202285767
77.68112564086914
训练次数：6700，loss:1.0891891717910767
78.60149669647217
训练次数：6800，loss:1.163199782371521
79.51327633857727
训练次数：6900，loss:1.0899041891098022
80.45919966697693
训练次数：7000，loss:0.9244132041931152
整体测试集上的loss:201.28431105613708
整体测试集上的正确率:0.5447999835014343
模型已保存
------第10轮训练开始-------
82.65863108634949
训练次数：7100，loss:1.2787412405014038
83.56685018539429
训练次数：7200，loss:0.9970508813858032
84.47589230537415
训练次数：7300，loss:1.075785756111145
85.37683248519897
训练次数：7400，loss:0.8845826387405396
86.2892529964447
训练次数：7500，loss:1.1827806234359741
87.18609189987183
训练次数：7600，loss:1.2525413036346436
88.12955236434937
训练次数：7700，loss:0.8950385451316833
89.03755688667297
训练次数：7800，loss:1.2916812896728516
整体测试集上的loss:191.76686906814575
整体测试集上的正确率:0.56659996509552
模型已保存
colab提供的GPU:
3. 用自己的GPU跑
部分运行结果：
点击查看代码
Files already downloaded and verified
Files already downloaded and verified
训练数据集的长度为：50000
测试数据集的长度为：10000
------第1轮训练开始-------
19.179653882980347
训练次数：100，loss:2.2851109504699707
26.198033094406128
训练次数：200，loss:2.284975528717041
31.406862258911133
训练次数：300，loss:2.256366491317749
35.1027147769928
训练次数：400，loss:2.1797103881835938
39.66706681251526
训练次数：500，loss:2.0768096446990967
45.883233070373535
训练次数：600，loss:2.067444086074829
51.83834958076477
训练次数：700，loss:2.0041518211364746
整体测试集上的loss:314.1395843029022
整体测试集上的正确率:0.28329998254776
模型已保存
版本太低，升级cuda
问题：Key already registered with the same priority: GroupSpatialSoftmax
二、第二种方法(常用)
1.基本方法
.to(device)
torch.device("cpu")
torch.device("cuda")
torch.device("cuda:0") #指定不同的gpu
torch.device("cuda:1")
常用语句：
device=torch.device("cuda" if torch.cuda.is_available() else "cpu")
模型和损失函数可以不重新赋值，直接调用也行
2.CPU版本
点击查看代码
import torch
import torchvision
# 13. 计算时间
import time
from torch.utils.tensorboard import SummaryWriter
from torch import nn
from torch.utils.data import DataLoader
# 12.定义训练的设备
device=torch.device("cpu")
# 1. 准备数据集
train_data=torchvision.datasets.CIFAR10(root="./CIFAR10_dataset",train=True,transform=torchvision.transforms.ToTensor(),download=True) #注意ToTensor的括号不能忘，不让模型无法调用
test_data=torchvision.datasets.CIFAR10(root="./CIFAR10_dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
# 2. 计算训练集和测试集的长度
train_data_size=len(train_data)
test_data_size=len(test_data)
# 2.1 输出训练集和测试集的长度
'''
训练数据集的长度为：50000
测试数据集的长度为：10000
'''
print("训练数据集的长度为：{}".format(train_data_size))
print("测试数据集的长度为：{}".format(test_data_size))
# 3. 利用DataLoader来加载数据集
train_dataloader=DataLoader(train_data,batch_size=64)
test_dataloader=DataLoader(test_data,batch_size=64)
# 4. 搭建神经网络
class Tudui(nn.Module):
def __init__(self):
super(Tudui, self).__init__()
self.model1=nn.Sequential(
nn.Conv2d(3, 32, 5, stride=1,padding=2), # in_channel 3;out_channel 32;kernel 5;padding需要计算（一般不会太大）
nn.MaxPool2d(2), # kennel_Size=2
nn.Conv2d(32, 32, 5,stride=1,padding=2),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 5,stride=1, padding=2),
nn.MaxPool2d(2),
nn.Flatten(), # 展平 ：可以把后面的删掉 获得输出的大小
nn.Linear(64*4*4, 64), # 看上一层的大小64*4*4=1024 ，可以看到是1024
nn.Linear(64, 10) # 输入大小 64 输出大小 10
)
def forward(self,x):
x=self.model1(x)
return x
# 5.创建网络模型
tudui=Tudui()
# 12.1 模型指定设备
tudui=tudui.to(device)
# 6.损失函数
loss_fn=nn.CrossEntropyLoss() #交叉熵
# 12.2 损失函数指定设备
loss_fn=loss_fn.to(device)
# 7.优化器
# 1e-2=1*(10)*(-2)=1/100=0.01
learning_rate=1e-2
optimizer=torch.optim.SGD(tudui.parameters(),lr=learning_rate)
# 8.设置训练网络的一些参数
total_train_step=0 #记录训练的次数
total_test_step=0 #记录测试的次数
epoch=10 #训练的轮数
# 9. 添加tensorboard
writer=SummaryWriter("./logs_27")
# 13.1 开始时间
start_time=time.time()
for i in range(epoch):
print("------第{}轮训练开始-------".format(i+1))
# 8.1 训练步骤开始
tudui.train()
for data in train_dataloader:
imgs, targets = data
# 12.3 训练数据指定设备
imgs=imgs.to(device)
targets=targets.to(device)
outputs = tudui(imgs)
loss = loss_fn(outputs,targets)
# 优化器优化模型
optimizer.zero_grad()
loss.backward()
optimizer.step()
#训练次数
total_train_step=total_train_step+1
#限制输出的次数
if total_train_step%100==0: #当训练次数为 100 200 时训练输出
# 13.2 结束时间
end_time=time.time()
# 13.3 输出总共需要的时间
print(end_time-start_time)
print("训练次数：{}，loss:{}".format(total_train_step,loss.item()))#loss tensor类型， loss.item() 数字类型
# 9.1 训练的效果
writer.add_scalar("train_loss",loss.item(),total_train_step)
# 8.2 测试步骤开始
'''
判断训练的结果如何
'''
tudui.eval()
total_test_loss=0 #整体的loss
total_accuracy=0 #整体正确率
with torch.no_grad(): #不再进行梯度更新，也就是不进行优化，单纯的测试
for data in test_dataloader:
imgs,targets=data
# 12.4 训练数据指定设备
imgs=imgs.to(device)
targets=targets.to(device)
outputs=tudui(imgs)
loss=loss_fn(outputs,targets) #计算测试集上的误差（一部分数据）
total_test_loss=total_test_loss + loss.item() #计算整体测试集上的loss
# 11.计算正确率
accuracy=(outputs.argmax(1)==targets).sum()
total_accuracy+=accuracy
print("整体测试集上的loss:{}".format(total_test_loss))
# 11.1 输出准确率
print("整体测试集上的正确率:{}".format(total_accuracy/test_data_size))
# 9.2 测试的效果
writer.add_scalar("test_loss",total_test_loss,total_test_step)
# 11.2 添加显示正确率
writer.add_scalar("test_accuracy",total_accuracy/test_data_size,total_test_step)
total_test_step=total_test_step + 1 #测试完一次就+1，不让图像不会变化
# 10. 模型保存
'''
存放每一轮保存的结果
'''
torch.save(tudui,"tudui_{}.pth".format(i))
print("模型已保存")
# 9.3 关闭writer
writer.close()
3.GPU版本
点击查看代码
import torch
import torchvision
# 13. 计算时间
import time
from torch.utils.tensorboard import SummaryWriter
from torch import nn
from torch.utils.data import DataLoader
# 12.定义训练的设备
device=torch.device("cuda")
# 1. 准备数据集
train_data=torchvision.datasets.CIFAR10(root="./CIFAR10_dataset",train=True,transform=torchvision.transforms.ToTensor(),download=True) #注意ToTensor的括号不能忘，不让模型无法调用
test_data=torchvision.datasets.CIFAR10(root="./CIFAR10_dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
# 2. 计算训练集和测试集的长度
train_data_size=len(train_data)
test_data_size=len(test_data)
# 2.1 输出训练集和测试集的长度
'''
训练数据集的长度为：50000
测试数据集的长度为：10000
'''
print("训练数据集的长度为：{}".format(train_data_size))
print("测试数据集的长度为：{}".format(test_data_size))
# 3. 利用DataLoader来加载数据集
train_dataloader=DataLoader(train_data,batch_size=64)
test_dataloader=DataLoader(test_data,batch_size=64)
# 4. 搭建神经网络
class Tudui(nn.Module):
def __init__(self):
super(Tudui, self).__init__()
self.model1=nn.Sequential(
nn.Conv2d(3, 32, 5, stride=1,padding=2), # in_channel 3;out_channel 32;kernel 5;padding需要计算（一般不会太大）
nn.MaxPool2d(2), # kennel_Size=2
nn.Conv2d(32, 32, 5,stride=1,padding=2),
nn.MaxPool2d(2),
nn.Conv2d(32, 64, 5,stride=1, padding=2),
nn.MaxPool2d(2),
nn.Flatten(), # 展平 ：可以把后面的删掉 获得输出的大小
nn.Linear(64*4*4, 64), # 看上一层的大小64*4*4=1024 ，可以看到是1024
nn.Linear(64, 10) # 输入大小 64 输出大小 10
)
def forward(self,x):
x=self.model1(x)
return x
# 5.创建网络模型
tudui=Tudui()
# 12.1 模型指定设备
tudui=tudui.to(device)
# 6.损失函数
loss_fn=nn.CrossEntropyLoss() #交叉熵
# 12.2 损失函数指定设备
loss_fn=loss_fn.to(device)
# 7.优化器
# 1e-2=1*(10)*(-2)=1/100=0.01
learning_rate=1e-2
optimizer=torch.optim.SGD(tudui.parameters(),lr=learning_rate)
# 8.设置训练网络的一些参数
total_train_step=0 #记录训练的次数
total_test_step=0 #记录测试的次数
epoch=10 #训练的轮数
# 9. 添加tensorboard
writer=SummaryWriter("./logs_27")
# 13.1 开始时间
start_time=time.time()
for i in range(epoch):
print("------第{}轮训练开始-------".format(i+1))
# 8.1 训练步骤开始
tudui.train()
for data in train_dataloader:
imgs, targets = data
# 12.3 训练数据指定设备
imgs=imgs.to(device)
targets=targets.to(device)
outputs = tudui(imgs)
loss = loss_fn(outputs,targets)
# 优化器优化模型
optimizer.zero_grad()
loss.backward()
optimizer.step()
#训练次数
total_train_step=total_train_step+1
#限制输出的次数
if total_train_step%100==0: #当训练次数为 100 200 时训练输出
# 13.2 结束时间
end_time=time.time()
# 13.3 输出总共需要的时间
print(end_time-start_time)
print("训练次数：{}，loss:{}".format(total_train_step,loss.item()))#loss tensor类型， loss.item() 数字类型
# 9.1 训练的效果
writer.add_scalar("train_loss",loss.item(),total_train_step)
# 8.2 测试步骤开始
'''
判断训练的结果如何
'''
tudui.eval()
total_test_loss=0 #整体的loss
total_accuracy=0 #整体正确率
with torch.no_grad(): #不再进行梯度更新，也就是不进行优化，单纯的测试
for data in test_dataloader:
imgs,targets=data
# 12.4 训练数据指定设备
imgs=imgs.to(device)
targets=targets.to(device)
outputs=tudui(imgs)
loss=loss_fn(outputs,targets) #计算测试集上的误差（一部分数据）
total_test_loss=total_test_loss + loss.item() #计算整体测试集上的loss
# 11.计算正确率
accuracy=(outputs.argmax(1)==targets).sum()
total_accuracy+=accuracy
print("整体测试集上的loss:{}".format(total_test_loss))
# 11.1 输出准确率
print("整体测试集上的正确率:{}".format(total_accuracy/test_data_size))
# 9.2 测试的效果
writer.add_scalar("test_loss",total_test_loss,total_test_step)
# 11.2 添加显示正确率
writer.add_scalar("test_accuracy",total_accuracy/test_data_size,total_test_step)
total_test_step=total_test_step + 1 #测试完一次就+1，不让图像不会变化
# 10. 模型保存
'''
存放每一轮保存的结果
'''
torch.save(tudui,"tudui_{}.pth".format(i))
print("模型已保存")
# 9.3 关闭writer
writer.close()
浙公网安备 33010602011771号