在pytorch官网里的Docs可找到pytorch库的使用
目录
一、nn.Module的使用
在右侧可以找到pytorch.nn.Module的具体使用方法
在其中的Containers可以找到Module的使用例子
其中包含所有神经网络的模型
import torch.nn as nn
import torch.nn.functional as F
class Model(nn.Module): #定义神经网络名称，如例Model
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(1, 20, 5)
self.conv2 = nn.Conv2d(20, 20, 5)
def forward(self, x):
x = F.relu(self.conv1(x))
return F.relu(self.conv2(x))二、卷积层
Convolution Layers是卷积层的函数库
其中有一维、二维和三维的卷积操作
例如：二维卷积的参数设置
in_channels：输入通道（多数为3个通道RGB）
out_channels：输出通道
kernel_size：卷积核大小
stride：卷积核移动的步子大小
padding：填充层的大小
padding_mode：填充层模式
bias：偏置层
多数参数是默认的，
import torch.nn.functional as F
output = F.conv2d(in_channels, kernel_size, stride=1,
padding=0, dilation=1, groups=1,
bias=True, padding_mode='zeros',
device=None, dtype=None)
print(output)例：
import torch
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
dataset = torchvision.dataset.CIFAR10("../data",train=False,
transform=torchvision.transforms.totensor(),
download=True) #下载数据集并转成tensor类型
dataloader = DataLoader(dataset,batch_size=64) #加载数据集
class Model(nn.Module): #数据集卷积
def __init__(self):
super(Model,self).__init__()
self.conv1 = Conv2d(in_channel=3,out_channel=6,kernel_size=3,stride=1,padding=0)
def forward(self,x):
x = self.conv1(x)
return x
model = Module()
writer = SummaryWriter("../logs")
step = 0
for data in dataloader:
img,targets = data
output = model(img) #此时的输入数据的channel是3
writer.add_images("input",imgs,step)
torch.reshape(output,()) #为了使输出通道一致
writer.add_images("output",imgs,step)
step = step + 1
三、最大池化的使用
在Pooling Layer里可以看得到
例如，nn.MaxPool2d里的参数了解
其中：池化层的stride默认为kernel_size，使池化核采样不重合。
dilation：空洞池化（中间隔开采样）
ceil_mode：如果为true，向上采样；如果为false，则为floor_mode向下采样。
import torch
import torchvision.datasets
from torch import nn
from torch.nn import MaxPool2d
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
dataset = torchvision.datasets.CIFAR10("../data",train=False,download=True,
transform=torchvision.transforms.ToTensor())
dataloader = DataLoader(dataset,batch_size=64)
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]],dtype=torch.float32)
input = torch.reshape(input,(-1,1,5,5)) #最大池化需要四个参数（N、C、H、W）
class Luka(nn.Module): #进行最大池化
def __init__(self):
super(Luka,self).__init__()
self.maxpool1 = MaxPool2d(kernel_size=3,ceil_mode=False)
def forward(self,input):
output = self.maxpool1(input)
return output
luka = Luka()
writer = SummaryWriter("../los_maxpool")
step = 0
for data in dataloader:
imgs,targets = data
writer.add_images("input",imgs,step)
output = luka(imgs)
writer.add_images("output",output,step)
step = step + 1
writer.close()四、非线性激活
常见的非线性激活
import torch
from torch import nn
from torch.nn import ReLU
input = torch.tensor([[1,-0.5],
[-1,3]])
input = torch.reshape(input,(-1,1,2,2))
class Luka(nn.Module): #进行非线性激活
def __init__(self):
super(Luka,self).__init__()
self.relu1 = ReLU()
def forward(self,input):
output = self.relu1(input)
return output
luka = Luka()
output = luka(input)
print(output)五、线性层及其他层
正则化层
官网给的例子：
# With Learnable Parameters
m = nn.BatchNorm2d(100)
# Without Learnable Parameters
m = nn.BatchNorm2d(100, affine=False)
input = torch.randn(20, 100, 35, 45)
output = m(input)线性层
六、nn.sequential的使用
会使代码更加简洁（相比之前方法列的代码）
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear
class Luka(nn.Module):
def __init__(self):
super(Luka,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 x
luka = Luka()
print(luka)七、Loss Functions的使用
1.计算实际输出和目标之间的差距（损失函数）
2.为我们更新输出提供一定的依据（反向传播、梯度下降）
例如，平方差的损失函数
import torch
from torch import nn
inputs = torch.tensor([1,2,3],dtype=torch.float32)
targets = torch.tensor([1,2,5]),dtype=torch.float32)
inputs = torch.reshape(inputs,(1,1,1,3))
targets = torch.reshape(targets,(1,1,1,3))
loss = nn.MSELoss()
result = loss(inputs,targets)
print(result)八、优化器
根据梯度调整参数，以降低误差
for input, target in dataset:
optimizer.zero_grad() #使上一次的梯度清零
output = model(input)
loss = loss_fn(output, target)
loss.backward()
optimizer.step() #进行优化九、对pytorch里现有的网络模型进行修改
例如，使用VGG模型的VGG16
import torch
vgg16 = torchvision.models.vgg16(pretrained=True)VGG16在models包里面，其中pretrained（bool=Ture）认为数据集是否之前使训练集
添加、修改vgg16里的神经网络操作方法
vgg16.classifier.add_module('add_linear',nn.linear(1000,10)) #在最后添加线性层
vgg16.classifier[5] = nn.linear(1000,10) #在第五位修改成线性层十、网络模型的读取和保存
#保持方式1，模型结构+模型参数
torch.save(vgg16,"vgg16_method1.pth")
#对于保存方式1的加载方式
torch.load("vgg16_method1.pth")
#保存方式2，模型参数(以字典的数组形式)
torch.save(vgg16.state_dict(),"vgg16_method2.pth")
#对于保存方式2的加载方式
vgg16.load_state_dict(torch.load("vgg16_method2.pth"))
十一、完整的训练套路
import torch.optim
import torchvision
from torch.nn import MaxPool2d
from torch.utils.tensorboard import SummaryWriter
from models import *
# 准备数据集
from torch import nn
from torch.utils.data import DataLoader
train_data = torchvision.datasets.CIFAR10(root="../data",train=True,transform=torchvision.transforms.ToTensor(),
download=True)
test_data = torchvision.datasets.CIFAR10(root="../data",train=False,transform=torchvision.transforms.ToTensor(),
download=True)
# length 长度
train_data_size = len(train_data)
test_data_size = len(test_data)
print("训练数据集的长度为：{}".format(train_data_size))
print("测试数据集的长度为：{}".format(test_data_size))
# 利用DataLoader来加载数据集
train_data_dataloader = DataLoader(train_data,batch_size=64)
test_data_dataloader = DataLoader(test_data,batch_size=64)
# 创建网络模型
class Luka(nn.Module):
def __init__(self):
super(Luka,self).__init__()
self.maxpool1 = MaxPool2d(kernel_size=3,ceil_mode=False)
def forward(self,input):
output = self.maxpool1(input)
return output
luka = Luka()
# 损失函数
loss_fn = nn.CrossEntropyLoss()
# 优化器
learning_rate = 1e-2
optimizer = torch.optim.SGD(luka.parameters(),lr=learning_rate)
# 设置训练网络的一部分参数
# 记录训练次数
total_train_step = 0
# 记录测试次数
total_test_step = 0
# 训练的轮数
epoch = 10
# 添加tensorboard
writer = SummaryWriter("../log_train")
for i in range(epoch):
print("——————第{}轮训练开始——————".format(i+1))
# 训练步骤开始
luka.train()
for data in train_data_dataloader:
imgs,targets = data
outputs = luka(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("tarin_loss",loss.item(),total_train_step)
# 测试步骤开始
luka.eval()
total_test_loss = 0
total_accuracy = 0
with torch.no_grad():
for data in test_data_dataloader:
imgs,targets = data
outputs = luka(imgs)
loss = loss_fn(outputs,targets)
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("teat_accuracy",total_accuracy/test_data_size,total_test_step)
total_test_step = total_test_step + 1
torch.save(luka,"luka_{}.pth".format(i))
print("模型已保存")
writer.close()
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
