土堆原视频

文章目录

• 前言
• • Jupyter的使用
  • • ESC 命令模式
    • 双击 编辑模式
  • dir和help使用
  • [Pytorch中Tensor Variable Parameter以及求导运算](https://blog.csdn.net/qq_42283621/article/details/124921414)
  • 激活函数与Pytorch
  • 损失函数和Pytorch
• (重要)完整的训练套路
• TensorBoard
• Transforms
• Dataset
• DataLoader
• Module
• • F.conv2d vs. nn.Conv2D
  • Sequential
• 预训练模型的训练和使用
• 模型的保存和加载
• • 方式一
  • • 官方模型
    • 自定义模型
    • 应用训练好的模型
  • 方式二（官方推荐）
  • • 应用训练好的模型
• 使用CUDA

前言 Jupyter的使用 ESC 命令模式
A 前插入cell
B 后插入cell
DD 刪除cell
M/Y 单元格变为markdowm/code
双击 编辑模式
markdown的换行需要两个空格加一个回车
运行：Ctrl+Enter Alt+Enter Shift+Enter
dir和help使用 dir可以看到包里有什么（若包里面的变量均包含下划线，那么它是一个函数)
help可以看到函数的官方解释文档b

dir(torch.cuda)help(torch.cuda.is_available)from torch.utils.data import Dataset Dataset??

Pytorch中Tensor Variable Parameter以及求导运算 【深度学习|（小土堆）PyTorch深度学习】包含optim的优化
激活函数与Pytorch 损失函数和Pytorch (重要)完整的训练套路 nn.Module.train()和nn.Module.eval()的作用
.train()之后进入训练模式，例如Dropout、BatchNorm等操作将为训练模式
.eval()之后进行评估模式，例如Dropout、BatchNorm等操作将为评估模式（评估就是测试）
如果模型中没有这些层，那么使用.train()/.eval()和不使用的效果相同
例如：

# dropout将x各分量的值以概率p置为0，对于没有置为0的分量除以(1-p)（这样做的目的是通过增大没有被drop的分量从而寻求尽量不改变x的均值） import torch from torch import nnclass MyNet(nn.Module): def __init__(self, input_size, num_classes): super(MyNet, self).__init__() self.fc1 = nn.Linear(input_size, num_classes)# 输入层到输出层 self.dropout = nn.Dropout(p=0.5)# dropout训练def forward(self, x): out = self.dropout(x) print('dropout层的输出:', out) out = self.fc1(out) return outinput_size = 10 num_classes = 5 model = MyNet(input_size, num_classes)x = torch.arange(0, 10).reshape(-1).float() print('输入向量', x) print()model.train() print("训练模式下:", model(x)) print()model.eval() print("测试模式下:", model(x)) print()# 输入向量 tensor([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.]) # # dropout层的输出: tensor([ 0.,2.,0.,6.,8.,0., 12., 14., 16., 18.]) # 训练模式下: tensor([-4.0742, 11.8426,6.4491, -5.8407,4.6627], grad_fn=) # # dropout层的输出: tensor([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.]) # 测试模式下: tensor([-3.2385,5.7172,3.9615, -1.8763,2.2566], grad_fn=)

# model.pyfrom torch import nn# 搭建神经网络 class Tudui(nn.Module): def __init__(self): super(Tudui, self).__init__() self.model = nn.Sequential( nn.Conv2d(3, 32, 5, 1, 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(64*4*4, 64), nn.Linear(64, 10) )def forward(self, x): x = self.model(x) return x

import torch import torchvision from torch.utils.tensorboard import SummaryWriter from model import * from torch import nn from torch.utils.data import DataLoader# 下载数据集 train_data = https://www.it610.com/article/torchvision.datasets.CIFAR10(root="../data", train=True, transform=torchvision.transforms.ToTensor(), download=True) test_data = https://www.it610.com/article/torchvision.datasets.CIFAR10(root="../data", train=False, transform=torchvision.transforms.ToTensor(), download=True)# 数据集长度 train_data_size = len(train_data) test_data_size = len(test_data) print("训练数据集的长度为：{}".format(train_data_size)) print("测试数据集的长度为：{}".format(test_data_size))# 加载数据集 train_dataloader = DataLoader(train_data, batch_size=64) test_dataloader = DataLoader(test_data, batch_size=64)# 创建网络模型 tudui = Tudui()# 损失函数 loss_fn = nn.CrossEntropyLoss()# 优化器 optimizer = torch.optim.SGD(tudui.parameters(), lr=1e-2)# 添加tensorboard writer = SummaryWriter("../logs_train")total_train_step = 0 total_test_step = 0 epoch = 10for i in range(epoch): print("-------第 {} 轮训练开始-------".format(i+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: print("训练次数：{}, Loss: {}".format(total_train_step, loss.item())) writer.add_scalar("train_loss", loss.item(), total_train_step)# 测试步骤开始 tudui.eval() total_test_loss = 0 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() accuracy = (outputs.argmax(1) == targets).sum() total_accuracy = total_accuracy + accuracyprint("整体测试集上的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 + 1torch.save(tudui.state_dict(), "tudui_{}.pth".format(i)) print("模型已保存")writer.close()

TensorBoard （重要）opencv PIL SummaryWriter读写图片的形状和顺序

from torch.utils.tensorboard import SummaryWriter from PIL import Image import numpy as np# 定义 writer = SummaryWriter("logs")# 写入标量 for i in range(100): writer.add_scalar("y = x ** 2 + 1", i ** 2 + 1, i) writer.add_scalar("y = x", i, i)# 写入图片（可以是特征图） writer.add_image("img", np.array(Image.open(r"hymenoptera\train\ants\0013035.jpg")), 1, dataformats="HWC") writer.add_image("img", np.array(Image.open(r"hymenoptera\train\ants\5650366_e22b7e1065.jpg")), 2, dataformats="HWC")# 关闭 writer.close()# 在Terminal中使用命令 tensorboard --logdir=??? [--port=???] 打开 # 例如默认端口6006 tensorboard --logdir=logs #指定端口6007 tensorboard --logdir=logs --port=6007

# 从tensorboard文件中读取数据from tensorboard.backend.event_processing import event_accumulator# 加载日志 参数为存储日志文件的文件夹 ea = event_accumulator.EventAccumulator("logs") ea.Reload()# 获取日志中所有 标量表 的title keys = ea.scalars.Keys()# 根据title获取 表量表 scalarsTable = ea.scalars.Items(keys[0])# 打印前3条数据 print(scalarsTable[0:3]) # [ScalarEvent(wall_time=1653532538.0441616, step=0, value=https://www.it610.com/article/1.0), # ScalarEvent(wall_time=1653532539.0454786, step=1, value=2.0), # ScalarEvent(wall_time=1653532540.0469015, step=2, value=5.0)]# 打印前3条数据 的step value for i in scalarsTable[0:3]: print(i.step, i.value) # 0 1.0 # 1 2.0 # 2 5.0

Transforms （重要）opencv PIL SummaryWriter读写图片的形状和顺序

from PIL import Image import numpy as np from torch.utils.tensorboard import SummaryWriter from torchvision import transformswriter = SummaryWriter("logs")# ToTensor img_path = "hymenoptera/train/ants/0013035.jpg" trans_totensor = transforms.ToTensor()img1 = Image.open(img_path)img_tensor1 = trans_totensor(img1) writer.add_image("ToTensor", img_tensor1, 1)img_tensor2 = trans_totensor(np.array(img1)) writer.add_image("ToTensor", img_tensor2, 2)# Normalize 不同的channel分别 减均值除以方差 trans_norm = transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]) img_norm = trans_norm(img_tensor1) writer.add_image("Normalize", img_norm, 1)# Resize 改变图片形状 trans_resize = transforms.Resize((512, 512)) img_resize = trans_resize(img1) img_tensor = trans_totensor(img_resize) writer.add_image("Resize", img_tensor, 1)# Compose trans_pose = transforms.Compose([transforms.Resize((512, 512)), transforms.ToTensor()]) img_tensor = trans_pose(img1) writer.add_image("Compose", img_tensor, 1)# RandomCrop 在图片上随机裁剪指定大小 trans_pose2 = transforms.Compose([transforms.RandomCrop((500, 1000)), transforms.ToTensor()]) for i in range(10): img_crop = trans_pose2(img1) writer.add_image("RandomCrop", img_crop, i)writer.close()

Dataset

import torch from torch.utils.data import Dataset, DataLoader from PIL import Image import os from torchvision import transforms from torch.utils.tensorboard import SummaryWriter# 以hymenoptera数据集为例 ans标签0 bees标签1 class MyData(Dataset):def __init__(self, data_path, train=False, transform=None, target_transform=None): super(MyData, self).__init__()self.transform = transform self.target_transform = target_transform self.inputs = [] self.labels = [] if train: ants = os.listdir(data_path + "/train/ants") bees = os.listdir(data_path + "/train/bees") for i in ants: self.inputs.append(os.path.join(data_path, "train/ants", i)) self.labels.append(0) for i in bees: self.inputs.append(os.path.join(data_path, "train/bees", i)) self.labels.append(1) else: ants = os.listdir(data_path + "/val/ants") bees = os.listdir(data_path + "/val/bees") for i in ants: self.inputs.append(os.path.join(data_path, "val/ants", i)) self.labels.append(0) for i in bees: self.inputs.append(os.path.join(data_path, "val/bees", i)) self.labels.append(1)def __getitem__(self, idx): img_name = self.inputs[idx] label = self.labels[idx] img = Image.open(img_name)# 某些非jpg png例如jif的模式不是RGB，需转换为RGB if img.mode != "RGB": img = img.convert("RGB")if self.transform is not None: img = self.transform(img)if self.target_transform is not None: label = self.target_transform(label)return img, labeldef __len__(self): assert self.inputs.__len__() == self.labels.__len__() return len(self.inputs)dataset_transform = transforms.Compose([transforms.Resize((512, 512)), transforms.ToTensor()])def one_hot(x, class_count=2): return torch.eye(class_count)[x, :]train_loader = DataLoader(dataset=MyData("hymenoptera", True, transform=dataset_transform, target_transform=one_hot), batch_size=64, shuffle=True, num_workers=0, drop_last=True) test_loader = DataLoader(dataset=MyData("hymenoptera", False, transform=dataset_transform, target_transform=one_hot), batch_size=64, shuffle=True, num_workers=0, drop_last=True)writer = SummaryWriter("logs")for i, data in enumerate(train_loader): inputs, labels = data writer.add_images("train", inputs, i)for i, data in enumerate(test_loader): inputs, labels = data writer.add_images("test", inputs, i)writer.close()

DataLoader

import torch.nn.functional from torch.utils.data import DataLoader from torchvision import transforms, datasetsdataset_transform = transforms.Compose([transforms.ToTensor()])def one_hot(x, class_count=10): return torch.eye(class_count)[x, :]test_set = datasets.CIFAR10(root="./dataset", train=False, transform=dataset_transform, target_transform=one_hot, download=True)# 数据集 batch_size 是否打乱顺序 工作线程数 抛弃最后一个不全的batch test_loader = DataLoader(dataset=test_set, batch_size=64, shuffle=True, num_workers=0, drop_last=True)for i in test_loader: passnext(iter(test_loader))

Module F.conv2d vs. nn.Conv2D F.conv2d，需要自己定义和初始化weight和bias的Tensor传入
nn.Conv2d，只需要指定配置参数即可，故该种较为常用

import torch from torch.nn.parameter import Parameter from torch import nn from torch.nn import functional as Fclass Net(nn.Module):def __init__(self): super(Net, self).__init__()# out_channels, in_channels, kH, kW self.weight = Parameter(torch.randn(6, 3, 5, 5)) # out_channels self.bias = Parameter(torch.zeros(6))def forward(self, x): x = F.conv2d(x, self.weight, self.bias, stride=(2, 3), padding=(4, 6)) return x# minibatch, in_channels, iH, iW input = torch.randn(64, 3, 256, 256)net = Net() output = net(input) # torch.Size([64, 6, 130, 88]) print(output.shape)print(output)

import torch from torch.nn.parameter import Parameter from torch import nn from torch.nn import functional as Fclass Net(nn.Module):def __init__(self): super(Net, self).__init__()# out_channels, in_channels, kH, kW self.weight = Parameter(torch.randn(6, 3, 5, 5)) # out_channels self.bias = Parameter(torch.zeros(6))def forward(self, x): x = F.conv2d(x, self.weight, self.bias, stride=(2, 3), padding=(4, 6)) return x# minibatch, in_channels, iH, iW input = torch.randn(64, 3, 256, 256)net = Net() output = net(input) # torch.Size([64, 6, 130, 88]) print(output.shape)print(output)

Sequential

from torch import nn from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential from torch.utils.tensorboard import SummaryWriterclass Tudui(nn.Module): def __init__(self): super(Tudui, self).__init__()self.model1 = Sequential( Conv2d(3, 32, 5, padding=2), MaxPool2d(2), Conv2d(32, 32, 5, padding=2), MaxPool2d(2), Conv2d(32, 64, 5, padding=2), MaxPool2d(2), Flatten(), Linear(1024, 64), Linear(64, 10) )def forward(self, x): x = self.model1(x) return xtudui = Tudui() input = torch.ones((64, 3, 32, 32)) output = tudui(input)

预训练模型的训练和使用

import torchvision from torch import nn# 仅加载模型，不加载参数 vgg16_false = torchvision.models.vgg16(pretrained=False) # 加载模型，同时加载预训练的参数，并且显示参数的下载进度 vgg16_true = torchvision.models.vgg16(pretrained=True, progress=True)# vgg16_false和vgg16_true除了一个为初始化参数，一个为预训练的参数，其他没有任何区别# 打印模型结构 # print(vgg16_true) # VGG( #... #(classifier): Sequential( #(0): Linear(in_features=25088, out_features=4096, bias=True) #(1): ReLU(inplace=True) #(2): Dropout(p=0.5, inplace=False) #(3): Linear(in_features=4096, out_features=4096, bias=True) #(4): ReLU(inplace=True) #(5): Dropout(p=0.5, inplace=False) #(6): Linear(in_features=4096, out_features=1000, bias=True) #) # )# 1. 添加结构# 1.1 最外层添加 线性层 # vgg16_true.add_module('add_linear', nn.Linear(1000, 10)) # print(vgg16_true) # VGG( #... #(classifier): Sequential( #(0): Linear(in_features=25088, out_features=4096, bias=True) #(1): ReLU(inplace=True) #(2): Dropout(p=0.5, inplace=False) #(3): Linear(in_features=4096, out_features=4096, bias=True) #(4): ReLU(inplace=True) #(5): Dropout(p=0.5, inplace=False) #(6): Linear(in_features=4096, out_features=1000, bias=True) #) #(add_linear): Linear(in_features=1000, out_features=10, bias=True) # )# 1.2 在(classifier)中添加 线性层 # vgg16_true.classifier.add_module('add_linear', nn.Linear(1000, 10)) # print(vgg16_true) # VGG( #... #(classifier): Sequential( #(0): Linear(in_features=25088, out_features=4096, bias=True) #(1): ReLU(inplace=True) #(2): Dropout(p=0.5, inplace=False) #(3): Linear(in_features=4096, out_features=4096, bias=True) #(4): ReLU(inplace=True) #(5): Dropout(p=0.5, inplace=False) #(6): Linear(in_features=4096, out_features=1000, bias=True) #(add_linear): Linear(in_features=1000, out_features=10, bias=True) #) # )# 2. 修改结构# vgg16_true.classifier[6] = nn.Linear(4096, 10) # print(vgg16_true) # VGG( #... #(classifier): Sequential( #(0): Linear(in_features=25088, out_features=4096, bias=True) #(1): ReLU(inplace=True) #(2): Dropout(p=0.5, inplace=False) #(3): Linear(in_features=4096, out_features=4096, bias=True) #(4): ReLU(inplace=True) #(5): Dropout(p=0.5, inplace=False) #(6): Linear(in_features=4096, out_features=10, bias=True) 该行发生了改变 #) # )# 3. 删除结构# 将要删除的层改为Identity层（恒等变换，输入即输出，该层没有任何参数） # vgg16_true.classifier[4] = nn.Identity() # vgg16_true.classifier[5] = nn.Identity() # print(vgg16_true) # VGG( #... #(classifier): Sequential( #(0): Linear(in_features=25088, out_features=4096, bias=True) #(1): ReLU(inplace=True) #(2): Dropout(p=0.5, inplace=False) #(3): Linear(in_features=4096, out_features=4096, bias=True) #(4): Identity() #(5): Identity() #(6): Linear(in_features=4096, out_features=1000, bias=True) #) # )

模型的保存和加载 方式一 保存 模型结构+模型参数
陷阱：对于自己的所定义的模型，需要能够找到模型的定义（在load()所在文件中 或者 import 模型定义文件）
官方模型

import torch import torchvisionvgg16 = torchvision.models.vgg16(pretrained=False) torch.save(vgg16, "vgg16_method1.pth")

import torchmodel = torch.load("vgg16_method1.pth") print(model) # VGG( #... #(classifier): Sequential( #(0): Linear(in_features=25088, out_features=4096, bias=True) #(1): ReLU(inplace=True) #(2): Dropout(p=0.5, inplace=False) #(3): Linear(in_features=4096, out_features=4096, bias=True) #(4): ReLU(inplace=True) #(5): Dropout(p=0.5, inplace=False) #(6): Linear(in_features=4096, out_features=1000, bias=True) #) # )

自定义模型

import torch from torch import nnclass Net(nn.Module): def __init__(self): super(Net, self).__init__() self.conv1 = nn.Conv2d(3, 64, kernel_size=3)def forward(self, x): x = self.conv1(x) return xnet = Net() torch.save(net, "net_method1.pth")

import torch from torch import nn# model = torch.load("net_method1.pth") # AttributeError: Can't get attribute 'Net' on class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.conv1 = nn.Conv2d(3, 64, kernel_size=3)def forward(self, x): x = self.conv1(x) return xmodel = torch.load("net_method1.pth") print(model) # Net( #(conv1): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1)) # )

应用训练好的模型

# 以这种方式，无论保存时模型是在cpu/gpu上，我们均可以将其加载到cpu/gpu上import torch from torch import nnclass MyNet(nn.Module): def __init__(self): super(MyNet, self).__init__()self.fc = nn.Linear(100, 10)def forward(self, input): output = self.fc(input) return outputdata = https://www.it610.com/article/torch.randn(64, 100)# 情况1：模型在cpu上保存，在cpu上加载，data在cpu上 # model = torch.load("MyNet_10_cpu.pth") # print(torch.argmax(model(data), dim=1))# 情况2：模型在gpu上保存，在gpu上加载，data在cpu上，将data移入gpu # model = torch.load("MyNet_10_gpu.pth") # print(torch.argmax(model(data.cuda()), dim=1))# 情况3：模型在gpu上保存，在gpu上加载，data在cpu上，将模型移入cpu # 方式1 # model = torch.load("MyNet_10_gpu.pth") # model = model.cpu() # print(torch.argmax(model(data), dim=1)) # 方式2 加载时映射到cpu # model = torch.load("MyNet_10_gpu.pth", map_location=torch.device('cpu')) # print(torch.argmax(model(data), dim=1))

方式二（官方推荐） 推荐的原因是因为其保存的文件比较小
仅保存参数（以字典的方式，不保存模型）

import torch import torchvisionvgg16 = torchvision.models.vgg16(pretrained=False)torch.save(vgg16.state_dict(), "vgg16_method2.pth")

import torch import torchvisionvgg16 = torchvision.models.vgg16(pretrained=False)vgg16.load_state_dict(torch.load("vgg16_method2.pth"))

应用训练好的模型

# 以这种方式，无论保存时模型是在cpu/gpu上，我们均可以将其加载到cpu/gpu上import torch from torch import nnclass MyNet(nn.Module): def __init__(self): super(MyNet, self).__init__()self.fc = nn.Linear(100, 10)def forward(self, input): output = self.fc(input) return outputdata = https://www.it610.com/article/torch.randn(64, 100)# model = MyNet() # model.load_state_dict(torch.load("MyNet_10_cpu.pth")) # print(torch.argmax(model(data), dim=1))# model = MyNet() # model.load_state_dict(torch.load("MyNet_10_gpu.pth")) # print(torch.argmax(model(data), dim=1))# model = MyNet().cuda() # model.load_state_dict(torch.load("MyNet_10_cpu.pth")) # print(torch.argmax(model(data.cuda()), dim=1))# model = MyNet().cuda() # model.load_state_dict(torch.load("MyNet_10_gpu.pth")) # print(torch.argmax(model(data.cuda()), dim=1))

使用CUDA

1. 需要转移到cuda上的部分包括：网络模型；数据（输入，标注）；
   nn.CrossEntropyLoss()和F.cross_entropy()，因为不包含任何的参数，故不用移动到cuda
   
2. 特别注意事项
   

   # LayerNorm包含参数Parameter，但成员变量self.layerNorm将其参数和MyNet模型绑定在了一起 # 故随着myNet.cuda()，self.layerNorm的参数自动到cuda上 class MyNet(nn.Module): def __init__(self): super(MyNet, self).__init__()self.fc = nn.Linear(100, 10) self.layerNorm = nn.LayerNorm(10)def forward(self, input): output = self.fc(input) return self.layerNorm(output)# 如果不是成员变量，则LayerNorm的参数不会随着myNet.cuda()移动到cuda上，需要手动移动 class MyNet(nn.Module): def __init__(self): super(MyNet, self).__init__()self.fc = nn.Linear(100, 10)def forward(self, input): output = self.fc(input) return nn.LayerNorm(10).cuda()(output)# 普通的tensor，无论是否为成员变量均不可能和模型绑定在一起，故需要手动.cuda() # 对于Parameter类型，则可以通过成员变量绑定在模型上，不用手动.cuda() # 此处有一个特例，若tensor是一个标量则不用管 class MyNet(nn.Module): def __init__(self): super(MyNet, self).__init__()self.fc = nn.Linear(100, 10)def forward(self, input): w = torch.randn(64, 10) output = self.fc(input) return output * w.cuda()class MyNet(nn.Module): def __init__(self): super(MyNet, self).__init__()self.fc = nn.Linear(100, 10) self.w = torch.randn(64, 10).cuda()def forward(self, input): output = self.fc(input) return output * self.wclass MyNet(nn.Module): def __init__(self): super(MyNet, self).__init__()self.fc = nn.Linear(100, 10) self.w = Parameter(torch.randn(64, 10))def forward(self, input): output = self.fc(input) return output * self.w

   
   
3. 转移到cuda上有两种方式
   

   # 方式1 myNet = MyNet() # 默认在cpu上if torch.cuda.is_available(): myNet = myNet.cuda() # 转移到cuda# 方式2 device = torch.device("cpu") if torch.cuda.is_available(): device = torch.device("cuda")myNet = MyNet().to(device)

   
   

   import torch from torch import nnclass MyNet(nn.Module): def __init__(self): super(MyNet, self).__init__()self.fc = nn.Linear(100, 10)def forward(self, input): output = self.fc(input) return outputdata_train = torch.randn(64, 100) label_train = torch.randint(0, 10, (64,)) data_test = torch.randn(16, 100) label_test = torch.randint(0, 10, (16,))myNet = MyNet() loss_fn = nn.CrossEntropyLoss() optimizer = torch.optim.SGD(myNet.parameters(), lr=1e-2)if torch.cuda.is_available(): myNet = myNet.cuda()epoch = 10 for i in range(epoch): print("-------第 {} 轮训练开始-------".format(i + 1))myNet.train() if torch.cuda.is_available(): data_train = data_train.cuda() label_train = label_train.cuda() out = myNet(data_train) loss = loss_fn(out, label_train)optimizer.zero_grad() loss.backward() optimizer.step()print("train loss:{}".format(loss.item()))if i == epoch - 1: myNet.eval() with torch.no_grad(): if torch.cuda.is_available(): data_test = data_test.cuda() label_test = label_test.cuda() out = myNet(data_test) loss = loss_fn(out, label_test) accuracy = (out.argmax(1) == label_test).sum() / len(label_test) print("\ntest loss:{}, test accuracy:{}".format(loss.item(), accuracy))on_device = "cpu" if torch.cuda.is_available(): on_device = "gpu" torch.save(myNet.state_dict(), "MyNet_{}_{}.pth".format(epoch, on_device)) print("模型已保存 MyNet_{}_{}.pth".format(epoch, on_device))

   
   

推荐阅读

• 

  《封神演义》中龙吉原是天庭公主,被封为红鸾星后,她的地位究竟是升还是降？
• 

  沙海原著中有张日山吗
• 

  js中数组对象转换为字符串，js将数组转换成对象
• 

  Win10专业版UAC窗口提示框点不了是怎么解决？
• 

  健康码变黄多久能变回来绿色
• 

  三华李种植管理技术，树苗什么时候种植好
• 

  贵州青酒价格表 贵州青酒浓香型口感怎么样
• 

  理查德|不知道有没有小伙伴和我一样，每次临近新年
• 

  肺癌|肺癌患者不可不知的5大转移部位及处理方法！
• 

  什么材质的奶锅好 什么材质的奶锅好用
• 

  身柱的定位在哪里
• 

  两高故意延误投递邮件罪的相关司法解释是什么
• 

  佳能ts9020清零软件下载
• 

  梦见跟别人打架 梦见跟别人打架的寓意
• 

  焦晃老师演过刘启、玄烨、弘历三位皇帝的角色,你认为哪个角色扮演的最好？
• 

  43399游戏盒下载的游戏在那个盘里
• 

  开发程序员 涨工资幅度，一般程序员每年工资涨幅多少是合理的
• 

  笔记--STM32时钟系统简单总结
• 

  我爱阅读手抄报 我爱阅读手抄报内容模版
• 

  王者荣耀破绽是什么意思

• python题库|python二级考试第一套选择题
• 人脸识别|yolov5人脸识别(yolov5-facenet-svm)
• Python基础语法2（函数）
• 各专栏目录|pytorch 学习笔记目录
• YOLOv5解析|YOLOv5解析 | 第二篇（用YOLOv5训练自己的数据集（超级详细完整版））
• 算法|工程详细记录（超准确人脸检测(带关键点)YOLO5Face C++）
• 机器视觉算法|batch size对训练的影响
• 《告别Bug》|成功解决（WARNING: There was an error checking the latest version of pip.）
• 《告别Bug》|成功解决（TypeError: the JSON object must be str, bytes or bytearray, not dict）