P29_利用GUP训练（一）

1.方法1：调用.cuda()方法

（1）找到网络模型、数据（输入、标注）和损失函数，然后调用其.cuda()方法：

①网络模型如dyl模型：dyl.cuda()，②数据（输入、标注）即：imgs = imgs.cuda()，targets = targets.cuda()，③损失函数即loss_fn.cuda()

点击查看代码

#5.创建网络模型
dyl = Dyl()
dyl = dyl.cuda()

#6.创建损失函数（交叉熵）
loss_fn = nn.CrossEntropyLoss()
loss_fn = loss_fn.cuda()

#训练步骤和测试步骤中的imgs,targets = data
imgs = imgs.cuda()
targets = targets.cuda()

（2）其中更好的写法是：加上if torch.cuda.is.available():

点击查看代码

#例如模型加上if torch.cuda.is.available():
if torch.cuda.is.available():
	dyl = dyl.cuda()

使用这种方法很麻烦，但是可以看到gpu跑出来真的很快：

2.使用Google Colab（前提是能访问Google）

（1）需要登录谷歌账号

和jupyter很像，
发现gpu不能用：

打开“修改-笔记本设置-把硬件改成gpu"

（2）在Google Colab运行P29_train_gpu_1.py

点击查看代码

import torch
import torchvision
from torch.utils.tensorboard import SummaryWriter

#1.准备数据集
#1.1训练数据集
from torch import nn
from torch.utils.data import DataLoader

train_data = torchvision.datasets.CIFAR10("./dataset",train=True,transform=torchvision.transforms.ToTensor(),
                                          download=True)
#1.2测试数据集
test_data = torchvision.datasets.CIFAR10("./dataset",train=False,transform=torchvision.transforms.ToTensor(),
                                          download=True)

#2.查看训练/测试数据集有多少张：len()
train_data_size = len(train_data)
test_data_size = len(test_data)
#打印：python中格式化字符串的一种写法
#如果train_data_size=10，则打印输出：训练数据集的长度为：10
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.搭建神经网络
#（由于CIFAR10有10个类别，则网络为10分类的网络）:CIFAR10模型结构
class Dyl(nn.Module):
    def __init__(self):
        super(Dyl, self).__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3,32,5,1,2) ,   #padding为2，之前计算过
            nn.MaxPool2d(2),
            nn.Conv2d(32,32,5,1,2),
            nn.MaxPool2d(2),
            nn.Conv2d(32,64,5,1,2),
            nn.MaxPool2d(2),
            nn.Flatten(),
            nn.Linear(1024,64),
            nn.Linear(64,10)
        )
    def forward(self, x):
        x = self.model(x)
        return x
#一般会把以上模型单独保存在一个py文件里面：P26_model.py
#注意：model文件和该train.py要在同一文件夹下

#5.创建网络模型
dyl = Dyl()
dyl = dyl.cuda()

#6.创建损失函数（交叉熵）
loss_fn = nn.CrossEntropyLoss()
loss_fn = loss_fn.cuda()

#7.定义优化器
#learning_rate = 0.01
#1e-2=1*(10)^(-2)=1/100=0.01
learning_rate = 1e-2
optimizer = torch.optim.SGD(dyl.parameters(),lr = learning_rate)

#8.设置训练网络的一些参数
#8.1用total_train_step记录训练的次数
total_train_step = 0
#8.2用total_test_step记录测试的次数
total_test_step = 0
#8.3用epoch记录训练轮次，训练10轮
epoch = 10

#10.添加tensorboard
writer = SummaryWriter("logs_train")

for i in range(epoch):
    print("第{}轮训练开始".format(i+1))

    #8.4训练步骤开始：
    dyl.train()
    #从训练的dataloader去取数据：
    for data in train_dataloader:
        imgs,targets = data
        imgs = imgs.cuda()
        targets = targets.cuda()
        outputs = dyl(imgs)
        loss = loss_fn(outputs,targets)

        #优化器优化模型
        #优化器梯度清零
        optimizer.zero_grad()
        #损失反向传播：得到每一个参数节点的梯度
        loss.backward()
        #调用优化器的step:对其中每个参数进行优化
        optimizer.step()

        total_train_step = total_train_step + 1
        if total_train_step % 100 == 0:
            #print("训练次数：{}，loss:{}".format(total_train_step,loss))
            print("训练次数：{}，loss:{}".format(total_train_step,loss.item()))
            writer.add_scalar("train_loss",loss.item(),total_train_step)

    #9.测试步骤开始：
    dyl.eval()
    total_test_loss = 0

    #11.计算整体正确率
    total_accuracy = 0
    with torch.no_grad(): #梯度没有了，能保证不会对其进行调优
        for data in test_dataloader:
            imgs,targets = data
            imgs = imgs.cuda()
            targets = targets.cuda()
            outputs = dyl(imgs)
            loss = loss_fn(outputs,targets)
            # total_test_loss = total_test_loss + loss
            #由于total_test_loss初始化为0，是个int类型，而loss是tensor数据类型，使用loss.item()
            total_test_loss = total_test_loss + loss.item()
            accuracy = (outputs.argmax(1) == targets ).sum()
            total_accuracy = total_accuracy + accuracy
    print("整体测试集上的loss为:{}".format(total_test_loss))
    #整体测试集上的正确率 = 总共预测对的数据/测试数据集上的个数
    print("整体测试集上的正确率为：{}".format(total_accuracy/test_data_size))

    writer.add_scalar("test_loss",total_test_loss,total_test_step)
    writer.add_scalar("test_accuracy",total_accuracy/test_data_size,total_test_step)
    total_test_step = total_test_step + 1

    #11.保存模型(保存每一轮训练的结果）
    torch.save(dyl,"dyl_{}.pth".format(i))
    #torch.save(dyl.state_dict(),"dyl_{}.pth".format(i))
    print("模型已保存")

writer.close()

运行如下，仅用时1分钟：

点击查看代码

100%|██████████| 170M/170M [00:03<00:00, 48.9MB/s]
训练数据集的长度为：50000
训练测试集的长度为：10000
第1轮训练开始
训练次数：100，loss:2.2890524864196777
训练次数：200，loss:2.2805564403533936
训练次数：300，loss:2.259554862976074
训练次数：400，loss:2.1806514263153076
训练次数：500，loss:2.0599446296691895
训练次数：600，loss:2.014772415161133
训练次数：700，loss:2.000741481781006
整体测试集上的loss为:315.0673141479492
整体测试集上的正确率为：0.28360000252723694
模型已保存
第2轮训练开始
训练次数：800，loss:1.8652737140655518
训练次数：900，loss:1.834112286567688
训练次数：1000，loss:1.8954215049743652
训练次数：1100，loss:1.971741795539856
训练次数：1200，loss:1.7018647193908691
训练次数：1300，loss:1.641083002090454
训练次数：1400，loss:1.7378132343292236
训练次数：1500，loss:1.8231093883514404
整体测试集上的loss为:298.4915977716446
整体测试集上的正确率为：0.32339999079704285
模型已保存
第3轮训练开始
训练次数：1600，loss:1.7254525423049927
训练次数：1700，loss:1.657171607017517
训练次数：1800，loss:1.9478938579559326
训练次数：1900，loss:1.706923246383667
训练次数：2000，loss:1.8814713954925537
训练次数：2100，loss:1.500960111618042
训练次数：2200，loss:1.4777264595031738
训练次数：2300，loss:1.7960994243621826
整体测试集上的loss为:259.3301887512207
整体测试集上的正确率为：0.406499981880188
模型已保存
第4轮训练开始
训练次数：2400，loss:1.729522705078125
训练次数：2500，loss:1.3426584005355835
训练次数：2600，loss:1.6002354621887207
训练次数：2700，loss:1.684340238571167
训练次数：2800，loss:1.4967888593673706
训练次数：2900，loss:1.5782129764556885
训练次数：3000，loss:1.359269618988037
训练次数：3100，loss:1.5283527374267578
整体测试集上的loss为:242.99408984184265
整体测试集上的正确率为：0.43959999084472656
模型已保存
第5轮训练开始
训练次数：3200，loss:1.3664240837097168
训练次数：3300，loss:1.4924986362457275
训练次数：3400，loss:1.4467047452926636
训练次数：3500，loss:1.5090128183364868
训练次数：3600，loss:1.5577365159988403
训练次数：3700，loss:1.3685413599014282
训练次数：3800，loss:1.2862745523452759
训练次数：3900，loss:1.4254090785980225
整体测试集上的loss为:239.26388657093048
整体测试集上的正确率为：0.44509997963905334
模型已保存
第6轮训练开始
训练次数：4000，loss:1.3754222393035889
训练次数：4100，loss:1.4235591888427734
训练次数：4200，loss:1.5399119853973389
训练次数：4300，loss:1.2159309387207031
训练次数：4400，loss:1.138811469078064
训练次数：4500，loss:1.3563718795776367
训练次数：4600，loss:1.4215106964111328
整体测试集上的loss为:231.33142125606537
整体测试集上的正确率为：0.4651999771595001
模型已保存
第7轮训练开始
训练次数：4700，loss:1.3076436519622803
训练次数：4800，loss:1.5358412265777588
训练次数：4900，loss:1.3899439573287964
训练次数：5000，loss:1.3983232975006104
训练次数：5100，loss:0.9627978801727295
训练次数：5200，loss:1.317246675491333
训练次数：5300，loss:1.1845314502716064
训练次数：5400，loss:1.3754074573516846
整体测试集上的loss为:220.0756711959839
整体测试集上的正确率为：0.4975999891757965
模型已保存
第8轮训练开始
训练次数：5500，loss:1.2074824571609497
训练次数：5600，loss:1.2270691394805908
训练次数：5700，loss:1.221336841583252
训练次数：5800，loss:1.2056835889816284
训练次数：5900，loss:1.3447682857513428
训练次数：6000，loss:1.4489622116088867
训练次数：6100，loss:1.0195748805999756
训练次数：6200，loss:1.0643141269683838
整体测试集上的loss为:208.24758577346802
整体测试集上的正确率为：0.5264999866485596
模型已保存
第9轮训练开始
训练次数：6300，loss:1.385869026184082
训练次数：6400，loss:1.0935404300689697
训练次数：6500，loss:1.5920482873916626
训练次数：6600，loss:1.1219077110290527
训练次数：6700，loss:1.1198220252990723
训练次数：6800，loss:1.1673028469085693
训练次数：6900，loss:1.1212191581726074
训练次数：7000，loss:0.9083971977233887
整体测试集上的loss为:199.67288333177567
整体测试集上的正确率为：0.5457000136375427
模型已保存
第10轮训练开始
训练次数：7100，loss:1.2265293598175049
训练次数：7200，loss:1.0468568801879883
训练次数：7300，loss:1.1133828163146973
训练次数：7400，loss:0.8650857210159302
训练次数：7500，loss:1.2117706537246704
训练次数：7600，loss:1.2019312381744385
训练次数：7700，loss:0.8399395942687988
训练次数：7800，loss:1.2381956577301025
整体测试集上的loss为:194.8076994419098
整体测试集上的正确率为：0.5564999580383301
模型已保存