pytorch学习笔记--nn.Module、nn.Sequential的搭建模型、损失函数、反向传播和训练器

nn.Module、nn.Sequential的搭建模型、损失函数和训练器


nn.Module和nn.equential都是pytorch中container的方法,用于保存深度学习层信息,即容器、模型

一、nn.Module

#使用nn.Module模块构建一个LeNet
import torch
import torch.nn as nn
import torch.nn.functional as fun

class LeNet(nn.Module):
	#初始化即创建模型包含的层
	def __init__(self):
		super(LeNet, self).__init__()
		self.Conv2D1 = nn.Conv2d(in_channels=3,out_channels=6,kernel_size=5,stride=1,padding=0)
		self.activation1 = fun.sigmoid
		self.Maxpool2d1 = nn.MaxPool2d(kernel_size=2,stride=2,padding=0)
		self.Conv2D2 = nn.Conv2d(in_channels=6,out_channels=16,kernel_size=5,stride=1,padding=0)
		self.activation2 = fun.sigmoid
		self.Maxpool2d2 = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
		self.flatten = nn.Flatten()
		self.linear1 = nn.Linear(in_features=400,out_features=120)
		self.activation3 = fun.sigmoid
		self.linear2 = nn.Linear(in_features=120,out_features=84)
		self.activation4 = fun.sigmoid
		self.linear3 = nn.Linear(in_features=84,out_features=10)
	#前向计算
	def forward(self,x):
		x = self.Conv2D1(x)
		x = self.activation1(x)
		x = self.Maxpool2d1(x)
		x = self.Conv2D2(x)
		x = self.activation2(x)
		x = self.Maxpool2d2(x)
		x = self.flatten(x)
		x = self.linear1(x)
		x = self.activation3(x)
		x = self.linear2(x)
		x = self.activation4(x)
		x = self.linear3(x)
		return x

if __name__ == '__main__':
	input = torch.ones((64,3,32,32))
	test = LeNet()
	output = test(input)
	print(output.shape)

输入一个batch_size 64,3通道,32*32像素的图片后
输出:

torch.Size([64, 10])

二、nn.Sequential

#使用nn.equential模块构建一个LeNet
import torch
import torch.nn as nn

LeNet = nn.Sequential(
		nn.Conv2d(in_channels=3,out_channels=6,kernel_size=5,stride=1,padding=0),
		nn.Sigmoid(),
		nn.MaxPool2d(kernel_size=2,stride=2,padding=0),
		nn.Conv2d(in_channels=6,out_channels=16,kernel_size=5,stride=1,padding=0),
		nn.Sigmoid(),
		nn.MaxPool2d(kernel_size=2, stride=2, padding=0),
		nn.Flatten(),
		nn.Linear(in_features=400,out_features=120),
		nn.Sigmoid(),
		nn.Linear(in_features=120,out_features=84),
		nn.Sigmoid(),
		nn.Linear(in_features=84,out_features=10),
)
if __name__ == '__main__':
	input = torch.ones((64,3,32,32),dtype=torch.float32)
	for layer in LeNet:
		input = layer(input)
		print(layer.__class__.__name__, 'output shape: \t', input.shape)

输出:

Conv2d output shape: 	 torch.Size([64, 6, 28, 28])
Sigmoid output shape: 	 torch.Size([64, 6, 28, 28])
MaxPool2d output shape: 	 torch.Size([64, 6, 14, 14])
Conv2d output shape: 	 torch.Size([64, 16, 10, 10])
Sigmoid output shape: 	 torch.Size([64, 16, 10, 10])
MaxPool2d output shape: 	 torch.Size([64, 16, 5, 5])
Flatten output shape: 	 torch.Size([64, 400])
Linear output shape: 	 torch.Size([64, 120])
Sigmoid output shape: 	 torch.Size([64, 120])
Linear output shape: 	 torch.Size([64, 84])
Sigmoid output shape: 	 torch.Size([64, 84])
Linear output shape: 	 torch.Size([64, 10])

模型.add_module(layer)可以往模型里添加层

三、损失函数、反向传播和优化器

损失函数都包含在torch.nn库中,Loss Functions官方文档

损失函数作用
nn.L1Loss平均绝对误差
nn.MSELoss均方误差
nn.CrossEntropyLosssoftmax和交叉熵误差的组合

常用的就是nn.CrossEntropyLoss
得到Loss之后,计算细节都保存在了loss赋值的变量中,对该变量进行loss_value.backward()即可完成反向传播,反向梯度信息都保存在了变量中。

使用优化器即可根据梯度信息而更新权重和偏置,优化器一般用SGD。torch.optim官方文档

from torch import nn,optim
from torchvision import datasets,transforms as tf
from torch.utils.data import DataLoader


#读取数据
train_datas = datasets.CIFAR10(root='./dataset',transform=tf.ToTensor(),train=True,download=True)
test_datas = datasets.CIFAR10(root='./dataset',transform=tf.ToTensor(),train=False,download=True)
train_iter = DataLoader(dataset=train_datas,batch_size=64,shuffle=True,num_workers=0,drop_last=True)

#创建模型
LeNet = nn.Sequential(
		nn.Conv2d(in_channels=3,out_channels=6,kernel_size=5,stride=1,padding=0),
		nn.Sigmoid(),
		nn.MaxPool2d(kernel_size=2,stride=2,padding=0),
		nn.Conv2d(in_channels=6,out_channels=16,kernel_size=5,stride=1,padding=0),
		nn.Sigmoid(),
		nn.MaxPool2d(kernel_size=2, stride=2, padding=0),
		nn.Flatten(),
		nn.Linear(in_features=400,out_features=120),
		nn.Sigmoid(),
		nn.Linear(in_features=120,out_features=84),
		nn.Sigmoid(),
		nn.Linear(in_features=84,out_features=10),
)

loss = nn.CrossEntropyLoss()
train_model = LeNet
optimer = optim.SGD(train_model.parameters(),lr=0.9)
for epoch in range(3):
	loss_all = 0.0
	for data in train_iter:
		img,label = data
		y_hat = train_model(img)
		l = loss(y_hat,label)
		optimer.zero_grad()
		l.backward()
		optimer.step()
		loss_all += l
	print(loss_all)

损失函数、反向传播和优化器的使用按以下步骤:
〇设置损失函数和优化器
①得出loss
②训练器保存的梯度清零
③反向传播得到梯度
④训练器step()命令进行训练
结果:损失确实在减小

tensor(1805.3182, grad_fn=<AddBackward0>)
tensor(1801.2908, grad_fn=<AddBackward0>)
tensor(1800.9563, grad_fn=<AddBackward0>)
  • 0
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
pytorch 是一个高效的深度学习框架,其中nn.modulelist 和 nn.sequential是常用的模块。这两种模块都可以用于创建深度学习网络,并且能够实现自动求导。nn.sequential 是一个有序的容,其中每个模块按照传入的顺序依次进行计算。nn.modulelist 是一个无序的容,其中每个模块都可以以列表的形式存储,且没有特定的计算顺序。 nn.sequential 模块的优点是简单易用,并且可以通过一行代码构建和训练网络。例如,要创建一个简单的两层全连接神经网络,可以如下代码实现: ``` model = nn.Sequential(nn.Linear(784, 64), nn.ReLU(), nn.Linear(64, 10), nn.Softmax(dim=1)) ``` 这会定义一个两个全连接层网络以及 ReLU 和softmax 激活函数,输入大小为 784(MNIST 图像大小) ,输出大小为 10(10 个数字)。 nn.modulelist 是一个更加灵活的容,可以在其中添加任意的子模块。要使用 nn.modulelist,需要先创建一个空的 nn.modulelist,然后手动向其中添加子模块。例如,可以这样创建一个相同的两层全连接网络: ``` model = nn.ModuleList([ nn.Linear(784, 64), nn.ReLU(), nn.Linear(64, 10), nn.Softmax(dim=1) ]) ``` 需要注意的是,nn.modulelist 中的子模块顺序可能会影响计算结果,因为没有特定的训练顺序。因此,在使用 nn.modulelist 时应该尽量保证顺序的准确性。 综上所述,nn.sequentialnn.modulelist 都是常用的容,用于组织神经网络中的子模块,它们在不同场景下具有各自的优势。在简单的前向计算中,nn.sequential 更加容易使用;在需要更好的灵活性时,nn.modulelist 可以更好地实现目标。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值