卷积是如何计算的

使用代码,看卷积是如何计算的。

torch.nn
torch.nn.functional

srtide 的用法,代表卷积核的步幅

在这里插入图片描述
在这里插入图片描述

import torch
import torch.nn.functional as F
#  这个是输入的一个二维矩阵
input = torch.tensor([[1,2,0,3,1],[0,1,2,3,1],[1,2,1,0,0],[5,2,3,1,1],[2,1,0,1,1]])kernel = torch.tensor([[1,2,1],[0,1,0],[2,1,0]])# 尺寸变化,5*5 ,3*3
input = torch.reshape(input, (1,1,5,5))
kernel  = torch.reshape(kernel, (1,1,3,3))print(input.shape)
print(kernel.shape)
# stride 代表每次移动的次数或者步幅
output = F.conv2d(input, kernel, stride=1)
print(output)output2 = F.conv2d(input, kernel, stride=2)
print(output2)output3 = F.conv2d(input, kernel, stride=1,padding=1)
print(output3)

在这里插入图片描述在这里插入图片描述
在这里插入图片描述

padding 的用法为1的时候,代表把之前的矩阵四周拓展一个像素,

卷积层的使用

图片的一般都是二维矩阵,都使用CONV2D,1D 和3D用的较少

CLASStorch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', device=None, dtype=None)[SOURCE

in_channels 输入的通道数
out_channels 输出的通道数
kernel_size 卷积核的大小
stride=1 卷积核的步幅大小
padding =0 对原始数据的一个填充数
dilation =1 卷积核的对应位
groups =1
bias =True 对卷积后的数是否加减一个数
padding_mode=‘zeros’

Parameters:
输入的通道数
in_channels (int) – Number of channels in the input image
输出的通道数 当等于2,就会出现2个卷积核,就会有两个输出
out_channels (int) – Number of channels produced by the convolution
卷积核的大小例如设置为3, 卷积核就是3*3,训练过程中不断的调整。
kernel_size (int or tuple) – Size of the convolving kernel
卷积核移动的步幅
stride (int or tuple, optional) – Stride of the convolution. Default: 1
填充
padding (int, tuple or str, optional) – Padding added to all four sides of the input. Default: 0
填充的地方设置为0
padding_mode (str, optional) – 'zeros', 'reflect', 'replicate' or 'circular'. Default: 'zeros'dilation (int or tuple, optional) – Spacing between kernel elements. Default: 1groups (int, optional) – Number of blocked connections from input channels to output channels. Default: 1
偏置
bias (bool, optional) – If True, adds a learnable bias to the output. Default: True

在这里插入图片描述

动图,蓝色部分为输入图像,青色部分为输出图像

卷积层,

池化层
最常用的nn.MaxPool2d

torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
kernel_size (Union[int, Tuple[int, int]]) – the size of the window to take a max overstride (Union[int, Tuple[int, int]]) – the stride of the window. Default value is kernel_sizepadding (Union[int, Tuple[int, int]]) – Implicit negative infinity padding to be added on both sidesdilation (Union[int, Tuple[int, int]]) – a parameter that controls the stride of elements in the windowreturn_indices (bool) – if True, will return the max indices along with the outputs. Useful for torch.nn.MaxUnpool2d laterceil_mode (bool) – when True, will use ceil instead of floor to compute the output shape

在这里插入图片描述
cell_mode 为True的时候,要保留最大的值,当cell_mode为False的时候,不保留最大值。

import torch
import torchvision
from torch import nn
from torch.nn import MaxPool2d
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriterdataset = torchvision.datasets.CIFAR10("../data", train=False, download=True,transform=torchvision.transforms.ToTensor())dataloader = DataLoader(dataset, batch_size=64)class Tudui(nn.Module):def __init__(self):super(Tudui, self).__init__()self.maxpool1 = MaxPool2d(kernel_size=3, ceil_mode=False)def forward(self, input):output = self.maxpool1(input)return outputtudui = Tudui()writer = SummaryWriter("../logs_maxpool")
step = 0
for data in dataloader:imgs, targets = datawriter.add_images("input", imgs, step)output = tudui(imgs)writer.add_images("output", output, step)step = step + 1writer.close()

为什么池化的作用,保留输入的一个特征,同时把数据量减小,数据量减小了,训练的更快
经过一层卷积之后,来一层池化,然后再来一次非线性激活。

非线性激活层,RELU

import torch
import torchvision
from torch import nn
from torch.nn import ReLU, Sigmoid
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriterinput = torch.tensor([[1, -0.5],[-1, 3]])input = torch.reshape(input, (-1, 1, 2, 2))
print(input.shape)dataset = torchvision.datasets.CIFAR10("../data", train=False, download=True,transform=torchvision.transforms.ToTensor())dataloader = DataLoader(dataset, batch_size=64)class Tudui(nn.Module):def __init__(self):super(Tudui, self).__init__()self.relu1 = ReLU()self.sigmoid1 = Sigmoid()def forward(self, input):output = self.sigmoid1(input)return outputtudui = Tudui()writer = SummaryWriter("../logs_relu")
step = 0
for data in dataloader:imgs, targets = datawriter.add_images("input", imgs, global_step=step)output = tudui(imgs)writer.add_images("output", output, step)step += 1writer.close()

非线性变换的主要目的就是网络中引入一些非线性特征,非线性越多,才会训练出符合各种曲线,各种特征的一个模型,

正则化层

线性层

import torch
import torchvision
from torch import nn
from torch.nn import Linear
from torch.utils.data import DataLoaderdataset = torchvision.datasets.CIFAR10("../data", train=False, transform=torchvision.transforms.ToTensor(),download=True)dataloader = DataLoader(dataset, batch_size=64)class Tudui(nn.Module):def __init__(self):super(Tudui, self).__init__()self.linear1 = Linear(196608, 10)def forward(self, input):output = self.linear1(input)return outputtudui = Tudui()for data in dataloader:imgs, targets = dataprint(imgs.shape)output = torch.flatten(imgs)print(output.shape)output = tudui(output)print(output.shape)

Sequential

CIFAR 10 model 结构, 的网络结构
在这里插入图片描述

在这里插入图片描述

import torch
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()
print(tudui)
input = torch.ones((64, 3, 32, 32))
output = tudui(input)
print(output.shape)writer = SummaryWriter("../logs_seq")
writer.add_graph(tudui, input)
writer.close()

损失函数与反向传播
3.1 计算实际输出和目标之间的差距(损失函数)
3.2 为更新输出提供一定的依据(反向传播) grad 梯度下降
当使用反向传播的时候,每个节点,或者每个要更新的参数,都会求出一个对应的梯度,然后对参数进行优化,最终达到Loss降低的目的, 梯度下降
在这里插入图片描述

误差Loss 越小越好

Loss Function用于分析实际输出与目标之间的差距。

1、L1Loss

2、MSELoss 平方差

3、CrossEntropyLoss(交叉熵损失)
当训练分类问题的时候,
在这里插入图片描述
-0.2+ln(exp(0.1)+exp(0.2)+exp(0.3))

# Loss Function:(CrossEntropyLoss)https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html#torch.nn.CrossEntropyLoss
import torch
from torch import nnx = torch.tensor([0.1, 0.2, 0.3])
y = torch.tensor([1])
x = torch.reshape(x, (1, 3))
loss_cross = nn.CrossEntropyLoss()result_cross = loss_cross(x, y)
print(result_cross)   # tensor(1.1019)

运行结果

tensor(1.1019)Process finished with exit code 0

3.4交叉熵在神经网络的运用

import torch
from torch import nn
import torchvision# 准备数据集:
from torch.utils.data import DataLoaderdataset = torchvision.datasets.CIFAR10("./7dataset", train=False, download=True,transform=torchvision.transforms.ToTensor())
dataloader = DataLoader(dataset, batch_size=1, drop_last=True)# 搭建神经网络:
class Model(nn.Module):def __init__(self):super(Model, self).__init__()self.model1 = nn.Sequential(nn.Conv2d(3, 32, 5, padding=2),nn.MaxPool2d(2),nn.Conv2d(32, 32, 5, padding=2),nn.MaxPool2d(2),nn.Conv2d(32, 64, 5, padding=2),nn.MaxPool2d(2),nn.Flatten(),nn.Linear(1024, 64),nn.Linear(64, 10))def forward(self, x):x = self.model1(x)return xif __name__ == "__main__":loss = nn.CrossEntropyLoss()model_1 = Model()for data in dataloader:imgs, targets = dataoutputs = model_1(imgs)result_loss = loss(outputs, targets)print(result_loss)   # 计算神经网络输出与实际的误差# 反向传播,梯度下降result_loss.backward()   # 能够生成梯度print("ok")

优化器
反向传播可以求出每个需要调节的参数,每个参数对应的梯度,有了梯度就可以利用优化器,这个优化器对参数进行调整,以达到整体误差降低的目的。
Torch.optim
设置

# 官方文档:https://pytorch.org/docs/stable/optim.html
# lr(learning rate):学习速率
import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoaderdataset = torchvision.datasets.CIFAR10("../7. dataset", train=False, transform=torchvision.transforms.ToTensor(),download=True)dataloader = DataLoader(dataset, batch_size=1, drop_last=True)class Model(nn.Module):def __init__(self):super(Model, self).__init__()self.model1 = nn.Sequential(nn.Conv2d(3, 32, 5, padding=2),nn.MaxPool2d(2),nn.Conv2d(32, 32, 5, padding=2),nn.MaxPool2d(2),nn.Conv2d(32, 64, 5, padding=2),nn.MaxPool2d(2),nn.Flatten(),nn.Linear(1024, 64),nn.Linear(64, 10))def forward(self, x):x = self.model1(x)return xloss = nn.CrossEntropyLoss()
model_1 = Model()# 1. 设置优化器:(设置随机梯度下降优化器)
optim = torch.optim.SGD(model_1.parameters(), lr=0.01)  # lr不能设置得太大或太小,太大模型会不稳定,太小模型训练会很慢(推荐开始选择较大的lr,后面选择较小的lr)for epcoh in range(5):   # 循环几次就是尽行几轮学习running_loss = 0.0   # 保存整体误差总和for data in dataloader:  # 仅进行了一轮的学习imgs, targets = dataoutputs = model_1(imgs)result_loss = loss(outputs, targets)optim.zero_grad()  # 2. 调用优化器,让网络中的每一个参数的梯度置零result_loss.backward()  # 反向传播,求出每一个节点的梯度optim.step()  # 3. 调用优化器,对每一个参数进行调优# print(result_loss)running_loss += result_loss   # 整体误差总和print(running_loss)

现有网络模型的使用
安装scipy
卸载了
pip uninstall scipy

pip install scipy
下载数据集ImageNet,数据集太大了

  1. 加载VGG模型
  2. pretrained=False
# 文档:https://arxiv.org/abs/1409.1556
# 官方地址:https://pytorch.org/vision/stable/models.html#classification
# 常用 VGG16 或 VGG19
# 需要安装scipy模块:pip install scipy
import torchvision.datasets# train_data = torchvision.datasets.ImageNet("../19. dataset_image_net", split="train", download=True,
#                                            transform=torchvision.transforms.ToTensor())
# 由于ImageNet的训练数据集不被公开访问了,所以不能这样下载了(该数据集有140多G,太大了)vgg16_false = torchvision.models.vgg16(pretrained=False)   # 加载网络模型,不会下载(等同于前面我们写的Model()网络架构) 参数是默认的参数
# vgg16_true = torchvision.models.vgg16(pretrained=True)   # 会从网上下载网络模型,参数是已经被训练好的参数
print(vgg16_false)
  1. pretrained=True
# 文档:https://arxiv.org/abs/1409.1556
# 官方地址:https://pytorch.org/vision/stable/models.html#classification
# 常用 VGG16 或 VGG19
# 需要安装scipy模块:pip install scipy
import torchvision.datasets# train_data = torchvision.datasets.ImageNet("../19. dataset", split="train", download=True,
#                                            transform=torchvision.transforms.ToTensor())
# 由于ImageNet的训练数据集不被公开访问了,所以不能这样下载了(该数据集有140多G,太大了)# vgg16_false = torchvision.models.vgg16(pretrained=False)   # 加载网络模型,不会下载(等同于前面我们写的Model()网络架构) 参数是默认的参数
vgg16_true = torchvision.models.vgg16(pretrained=True)   # 会从网上下载网络模型,参数是已经被训练好的参数
# Downloading: "https://download.pytorch.org/models/vgg16-397923af.pth" to C:\Users\lv/.cache\torch\hub\checkpoints\vgg16-397923af.pth# print(vgg16_false)
print(vgg16_true)

运行结果,从运行结果中可以看出,最后的结果可以看出,也是分类的模型,

D:\Anaconda\envs\pytorch\python.exe "C:/Users/lv/Desktop/Pytorch/1. Pytorch的使用(第一次)/src/19. VGG模型_pretrained(现有网络模型的使用).py"
Downloading: "https://download.pytorch.org/models/vgg16-397923af.pth" to C:\Users\lv/.cache\torch\hub\checkpoints\vgg16-397923af.pth
100.0%
VGG((features): Sequential((0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(1): ReLU(inplace=True)(2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(3): ReLU(inplace=True)(4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(6): ReLU(inplace=True)(7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(8): ReLU(inplace=True)(9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(11): ReLU(inplace=True)(12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(13): ReLU(inplace=True)(14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(15): ReLU(inplace=True)(16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(18): ReLU(inplace=True)(19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(20): ReLU(inplace=True)(21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(22): ReLU(inplace=True)(23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(25): ReLU(inplace=True)(26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(27): ReLU(inplace=True)(28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(29): ReLU(inplace=True)(30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False))(avgpool): AdaptiveAvgPool2d(output_size=(7, 7))(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))
)Process finished with exit code 0

一般情况使用vgg16作为一个前置的网络结构,在vgg16后面加一些网络特征,去实现一个功能。
2. 修改VGG网络模型

# 文档:https://arxiv.org/abs/1409.1556
# 官方地址:https://pytorch.org/vision/stable/models.html#classification
# 常用 VGG16 或 VGG19
# 需要安装scipy模块:pip install scipy
import torchvision.datasets
from torch import nn# train_data = torchvision.datasets.ImageNet("../19. dataset", split="train", download=True,
#                                            transform=torchvision.transforms.ToTensor())
# 由于ImageNet的训练数据集不被公开访问了,所以不能这样下载了(该数据集有140多G,太大了)vgg16_false = torchvision.models.vgg16(pretrained=False)   # 加载网络模型,不会下载(等同于前面我们写的Model()网络架构) 参数是默认的参数
vgg16_true = torchvision.models.vgg16(pretrained=True)   # 会从网上下载网络模型,参数是已经被训练好的参数
# Downloading: "https://download.pytorch.org/models/vgg16-397923af.pth" to C:\Users\lv/.cache\torch\hub\checkpoints\vgg16-397923af.pth# print(vgg16_false)
# print(vgg16_true)train_data = torchvision.datasets.CIFAR10("../19. dataset", train=True, transform=torchvision.transforms.ToTensor(), download=True)
# 添加操作:
vgg16_true.add_module('add_linear1', nn.Linear(1000, 10))   # 添加一个线性层(添加在最后面)
# print(vgg16_true)
vgg16_true.classifier.add_module("add_linear2", nn.Linear(1000, 10))  # 添加到classifier里面
print(vgg16_true)print(vgg16_false)
# 修改操作:
vgg16_false.classifier[6] = nn.Linear(in_features=4096, out_features=10)
print(vgg16_false)

运行结果

D:\Anaconda\envs\pytorch\python.exe "C:/Users/lv/Desktop/Pytorch/1. Pytorch的使用(第一次)/src/19. VGG模型_pretrained(现有网络模型的使用).py"
Files already downloaded and verified
VGG((features): Sequential((0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(1): ReLU(inplace=True)(2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(3): ReLU(inplace=True)(4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(6): ReLU(inplace=True)(7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(8): ReLU(inplace=True)(9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(11): ReLU(inplace=True)(12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(13): ReLU(inplace=True)(14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(15): ReLU(inplace=True)(16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(18): ReLU(inplace=True)(19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(20): ReLU(inplace=True)(21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(22): ReLU(inplace=True)(23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(25): ReLU(inplace=True)(26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(27): ReLU(inplace=True)(28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(29): ReLU(inplace=True)(30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False))(avgpool): AdaptiveAvgPool2d(output_size=(7, 7))(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_linear2): Linear(in_features=1000, out_features=10, bias=True))(add_linear1): Linear(in_features=1000, out_features=10, bias=True)
)
VGG((features): Sequential((0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(1): ReLU(inplace=True)(2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(3): ReLU(inplace=True)(4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(6): ReLU(inplace=True)(7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(8): ReLU(inplace=True)(9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(11): ReLU(inplace=True)(12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(13): ReLU(inplace=True)(14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(15): ReLU(inplace=True)(16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(18): ReLU(inplace=True)(19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(20): ReLU(inplace=True)(21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(22): ReLU(inplace=True)(23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(25): ReLU(inplace=True)(26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(27): ReLU(inplace=True)(28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(29): ReLU(inplace=True)(30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False))(avgpool): AdaptiveAvgPool2d(output_size=(7, 7))(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))
)
VGG((features): Sequential((0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(1): ReLU(inplace=True)(2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(3): ReLU(inplace=True)(4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(6): ReLU(inplace=True)(7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(8): ReLU(inplace=True)(9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(11): ReLU(inplace=True)(12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(13): ReLU(inplace=True)(14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(15): ReLU(inplace=True)(16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(18): ReLU(inplace=True)(19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(20): ReLU(inplace=True)(21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(22): ReLU(inplace=True)(23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)(24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(25): ReLU(inplace=True)(26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(27): ReLU(inplace=True)(28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(29): ReLU(inplace=True)(30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False))(avgpool): AdaptiveAvgPool2d(output_size=(7, 7))(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))
)Process finished with exit code 0

模型的保存
模型的加载
完整的模型训练套路-GPU训练
完整的模型验证套路
在看下github上

模型的保存,有两种方式

import torch
import torchvisionvgg16 = torchvision.models.vgg16(pretrained=False)# 保存方式1,保存模型结构+模型参数
torch.save(vgg16, "vgg16_method1.pth")# 保存方式2  模型参数 官方推荐
torch.save(vgg16.state_dict(), "vgg16_method2.pth")

模型加载也有对应的两种方式

import torch# 方式一,保存方式1,加载模型
model = torch.load("vgg16_method1.pth")
# print(model)# 方式二,加载模型
model = torch.load("vgg16_method2.pth")print(model)

完整的模型验证套路

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/bicheng/45107.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Javascript[ECMAScript] 新特性—1

背景 JS1.1(1997) 第一版基于Netscape Navigator 3.0中实现的JAVASCRIPT 1.1 JS1.2(1999) 基于Netscape Navigator 4.0中实现的JavaScript 1.2。添加了正则表达式、更好的字符串处理、新的控制语句、Try/Catch异常处理、更严格…

推荐3个提升工作效率的实用电脑工具

PearOCR PearOCR是一款基于网络的光学字符识别(OCR)工具,旨在通过先进的图像处理和机器学习技术,快速、准确地从图片中提取文字。该工具的所有功能完全免费,这主要得益于其所有文件都在本地进行识别,不需要…

Python数据分析~~美食排行榜

目录 1.模块的导入和路径的选择 2.访问前面五行数据 3.按照条件进行筛选 4.获取店铺评分里面的最高分 5.打印对应的店铺的名字 1.模块的导入和路径的选择 # 导入pandas模块,简称为pd import pandas as pd # 使用read_csv()函数 # TODO 读取路径"/Users/fe…

完美解决:MySQL8报错:Public Key Retrieval is not allowed

在配置数据源的时候直接将属性allowPublicKeyRetrieval设置为true即可 &AutoReconnecttrue

使用getopt处理参数

文章目录 使用getopt处理参数1. shift 命令1.1 删除一个参数1.2 删除多个参数1.3 多次执行 shift 参数1.4 参数解析示例1.5 优化处理1.6 问题处理 2. getopt 命令2.1 常用参数及示例2.2 脚本参数优化示例2.3 参数校验 3. 示例展示4. eval 命令4.1 示例示例 1示例 2示例 3示例 4…

数学中的无穷小与物理学中的微元

数学中的无穷小与物理学中的微元 flyfish 数学中的直线和物理中的线比较下就容易理解了 数学中的直线: 数学中的直线是一种理想化的抽象概念,具有无限延伸且没有厚度或宽度。 直线的定义不依赖于物理性质,仅依赖于几何性质。它是一个一维对…

33 IRF配置思路

IRF配置思路网络括谱图 主 Ten-GigabitEthernet 1/0/49 Ten-GigabitEthernet 1/0/50 Ten-GigabitEthernet 1/0/51 备 Ten-GigabitEthernet 2/0/49 Ten-GigabitEthernet 2/0/50 Ten-GigabitEthernet 2/0/51 思路 主 1 利用console线进入设备的命令行页面去更改…

在安卓中使用FFmpeg录制摄像头的视频并保存到本地MP4文件

在移动应用开发中,有时需要利用设备的摄像头录制视频,并且希望在录制过程中能够精确控制视频的质量、格式和时长。FFmpeg作为一个强大的多媒体处理工具,提供了广泛的功能和选项,能够帮助我们实现这样的需求。 添加依赖 在安卓平台…

【C语言】C语言-身份证管理系统(源码+注释)【独一无二】

👉博__主👈:米码收割机 👉技__能👈:C/Python语言 👉公众号👈:测试开发自动化【获取源码商业合作】 👉荣__誉👈:阿里云博客专家博主、5…

关于.NETCORE站点程序部署到nginx上无法访问静态文件和无法正确生成文件的问题解决过程。

我的netcore6项目,部署到IIS的时候,生成报告时,需要获取公司LOGO图片放到PDF报告文件中,这时候访问静态图片没有问题。 然后还有生成邀请二维码图片,这时候动态创建图片路径和图片也没有问题,可以在站点的…

funasr最新更新GPU版本安装避坑

#当前安装过程没有cpu版本顺利 1.个人在自己的电脑上安装ubantu系统,以便使用本身的显卡功能(本人显卡NVIDIA GeForce RTX 4060)(这里需要注意,更新里面有附加驱动安装驱动会导致黑屏,小伙伴不要心急重装系统,可以ctr…

Python爬虫教程第4篇-使用BeautifulSoup解析html

文章目录 Beautiful Soup简介安装Beautiful Soup快速开始如何使用Beautiful Soup中的对象TagNameAttributes多值属性 NavigableStringBeautifulSoupComment 遍历文档树子节点tag名字.contents 和 .children.descendants.strings 和 stripped_strings 父节点.parent.parents 兄弟…

git批量删除本地包含某字符串的特定分支

git批量删除本地包含某字符串的特定分支 git branch -a | grep 分支中包含的字符串 | xargs git branch -D git删除本地分支_git查看删除本地分支-CSDN博客文章浏览阅读989次。git branch -d <分支名>可以通过: git branch 查看所有本地分支及其名字&#xff0c;然后删…

JavaScript(9)——作用域的一些问题

如果在函数内部&#xff0c;变量没有声明直接赋值&#xff0c;也会当做全局变量看。强烈不推荐&#xff01;&#xff01; function op() {num 80}op()console.log(num) 在不同作用域下&#xff0c;可能存在变量命名冲突的情况&#xff1a; let num 10 function fn(){let num…

Spring-Spring、IoC、DI、注解开发

1、Spring是什么 Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器(框架)。 Spring整体架构 Spring优点&#xff1a; Spring属于低侵入设计。IOC将对象之间的依赖关系交给Spring,降低组件之间的耦合&#xff0c;实现各个层之间的解耦&#xff0c;让我们更专注于业务…

代码随想三刷单调栈篇1

代码随想三刷单调栈篇1 739. 每日温度题目代码 496. 下一个更大元素 I题目代码 503. 下一个更大元素 II题目代码 42. 接雨水题目代码 84. 柱状图中最大的矩形题目代码 739. 每日温度 题目 链接 代码 class Solution {public int[] dailyTemperatures(int[] temperatures) {…

python库识别图像中人物的个数

要在Python中识别图像中的人物数量&#xff0c;可以使用OpenCV库来进行图像处理和特征提取&#xff0c;然后使用深度学习模型&#xff08;如YOLO、SSD或Faster R-CNN&#xff09;来识别物体。以下是一个简化的例子&#xff0c;使用OpenCV和预训练的YOLO模型来识别图像中的物体数…

5G中的RedCap

5G中的RedCap&#xff1a;降低能力的重要性和实现方式 随着5G技术的推广和普及&#xff0c;设备和终端的多样化使得网络能力的管理变得更加复杂和关键。RedCap&#xff08;Reduced Capability&#xff09;作为一个重要的概念&#xff0c;旨在解决设备能力差异对网络服务和用户…

WSGI 服务器教程:`write` 方法解析

Python WSGI 服务器教程&#xff1a;write 方法解析 在本文中&#xff0c;我们将详细解析一个用于 WSGI 服务器的 write 方法。这个方法负责处理 HTTP 响应&#xff0c;包括设置响应头和发送响应数据。我们将逐行解释该方法的工作原理&#xff0c;并提供一些背景知识&#xff…

【北京迅为】《i.MX8MM嵌入式Linux开发指南》-第一篇 嵌入式Linux入门篇-第十三章 Linux连接档

i.MX8MM处理器采用了先进的14LPCFinFET工艺&#xff0c;提供更快的速度和更高的电源效率;四核Cortex-A53&#xff0c;单核Cortex-M4&#xff0c;多达五个内核 &#xff0c;主频高达1.8GHz&#xff0c;2G DDR4内存、8G EMMC存储。千兆工业级以太网、MIPI-DSI、USB HOST、WIFI/BT…