torch.nn:
Containers: 神经网络骨架
Convolution Layers 卷积层
Pooling Layers 池化层
Normalization Layers 正则化层
Non-linear Activations (weighted sum, nonlinearity) 非线性激活
Loss Functions 损失函数
Containers
Module
import torch
from torch import nn
class Zrf(nn.Module):
def __init__(self):
super().__init__() # 继承父类
def forward(self, input):
output = input + 1
return output
zrf = Zrf()
x = torch.tensor(1.0)
output = zrf(x)
print(output)Sequential
cifar-10 module structure：
计算padding的公式：
import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.tensorboard import SummaryWriter
class Zrf(nn.Module):
def __init__(self):
super(Zrf, self).__init__()
# # padding=2 是根据输入输出的H，W计算出来的
# self.conv1 = Conv2d(3, 32, 5, padding=2)
# self.maxpool1 = MaxPool2d(2)
# self.conv2 = Conv2d(32, 32, 5 ,padding=2)
# self.maxpool2 = MaxPool2d(2)
# self.conv3 = Conv2d(32, 64, 5, padding=2)
# self.maxpool3 = MaxPool2d(2)
# self.flatten = Flatten() # 展平，与torch.flatten作用相同
# self.linear1 = Linear(1024, 64)
# self.linear2 = Linear(64, 10)
# Sequential 的作用
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.conv1(x)
# x = self.maxpool1(x)
# x = self.conv2(x)
# x = self.maxpool2(x)
# x = self.conv3(x)
# x = self.maxpool3(x)
# x = self.flatten(x)
# x = self.linear1(x)
# x = self.linear2(x)
x = self.model1(x)
return x
zrf = Zrf()
print(zrf)
input = torch.ones((64, 3, 32, 32))
output = zrf(input)
print(output.shape)
writer = SummaryWriter("logs_seq")
writer.add_graph(zrf, input)
writer.close()用tensorboard看网络结构
Convolution Layers
Conv2d
torch.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)
in_channels= : 输入图像的通道数
out_channels= ： 输出图象的通道数
kernel_size=3: 3x3的卷积核，会在训练过程中不断调整
stride: 卷积核滑动的步长，默认1
padding: 在图像的纵向和横向填充 ，填充的地方一般默认为0，这样卷积核可以划过更多地方
padding_mode=zeros: padding时的填充值
dilation: 卷积核的对应位，默认1
groups
bias：偏置
卷积过程：
经典vgg16的卷积过程：
推导padding等参数的公式：
import torch
import torchvision
from torch import nn
from torch.nn import Conv2d
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
dataset = torchvision.datasets.CIFAR10("../dataset_transform",train=False, transform=torchvision.transforms.ToTensor(), download=True)
dataloader = DataLoader(dataset, batch_size=64)
class Zrf(nn.Module):
def __init__(self):
super(Zrf, self).__init__()
self.conv1 = Conv2d(in_channels=3, out_channels=6, kernel_size=3, stride=1, padding=0)
def forward(self, x):
x = self.conv1(x)
return x
# 初始化网络
zrf = Zrf()
print(zrf)
writer = SummaryWriter("conv2d")
step = 0
for data in dataloader:
imgs, targets = data
output = zrf(imgs)
print(imgs.shape)
print(output.shape)
# torch.Size([64, 3, 32, 32])
writer.add_images("input_imgs", imgs, step)
# torch.Size([64, 6, 30, 30]) ---> [xxx, 3, 30, 30]
output = torch.reshape(output, (-1, 3, 30, 30))
writer.add_images("output_imgs", output, step)
step = step + 1
writer.close()
Pooling Layers
MaxPool2d
最大池化--->下采样(别称)
（池化层没有要优化的参数，只是形式上的卷积核）
kernel_size=3: 3x3的窗口，用来取最大值
stride: 窗口滑动的步长，默认值是kernel_size的大小
padding: 在图像的纵向和横向填充 ，填充的地方一般默认为0
dilation: 空洞卷积
return_indices: 通常来说不会用到
ceil_mode: 设置为True时，会使用ceil模式（不满3x3也取一个最大值）而不是floor模式（不满3x3就不取值 ）
一般理解------ceil：向上取整，floor模式：向下取整
为什么要进行最大池化？ 在保持数据特征的同时，减小数据量
import torch
import torchvision
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(root="../dataset_transform", download=True, train=False, 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))
# print(input.shape)
class Zrf(nn.Module):
def __init__(self):
super(Zrf, self).__init__()
self.maxpool1 = MaxPool2d(kernel_size=3)
def forward(self, x):
output = self.maxpool1(x)
return output
zrf = Zrf()
# output = zrf(input)
# print(output)
writer = SummaryWriter("log_maxpol")
step = 0
for data in dataloader:
imgs, targets = data
writer.add_images("max_before", imgs, step)
output = zrf(imgs)
writer.add_images("max_afteer", output, step)
step = step + 1
writer.close()
Non-linear Activations
Relu：大于0取原值，小于0取0
Sigmoid：常用激活函数
inplace参数
input = -1
Relu(input, inplace = True)
# 结果：input = 0
input = -1
output = Relu(input, inplace = False)
# 结果：input = -1, output = 0import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
input = torch.tensor([[1, -0.5],
[-1, 3]])
input = torch.reshape(input, (-1, 1, 2, 2))
# print(input.shape)
dataset = torchvision.datasets.CIFAR10(root="../dataset_transform", download=True, train=False, transform=torchvision.transforms.ToTensor())
dataloader = DataLoader(dataset, batch_size=64)
class Zrf(nn.Module):
def __init__(self):
super(Zrf, self).__init__()
# self.relu1 = nn.ReLU()
self.sigmoid1 = nn.Sigmoid()
def forward(self, input):
# output = self.relu1(input)
output = self.sigmoid1(input)
return output
# zrf = Zrf()
# output = zrf(input)
# print(output)
zrf = Zrf()
writer = SummaryWriter("log_sigmoid")
step = 0
for data in dataloader:
imgs, targets = data
writer.add_images("before_sigmoid", imgs, step)
output = zrf(imgs)
writer.add_images("after_sigmoid", output, step)
step = step + 1
writer.close()
线性层以及其他层介绍
Linear Layers
线性层，目的是变换特征维度，参数：in_features, out_features, bias (bool)
in_features：
out_features：
bias (bool)：偏置
计算过程中的权重k和偏置b要按照一定条件进行调整和优化
import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
dataset = torchvision.datasets.CIFAR10(root="dataset_transform", download=True, train=False, transform=torchvision.transforms.ToTensor())
dataloader = DataLoader(dataset, batch_size=64)
class Zrf(nn.Module):
def __init__(self):
super(Zrf, self).__init__()
# 196608是in_features，10是out_features
self.linear1 = nn.Linear(196608, 10)
def forward(self, input):
output = self.linear1(input)
return output
zrf = Zrf()
for data in dataloader:
imgs, targets = data
print(imgs.shape)
# output = torch.reshape(imgs, (1, 1, 1, -1))
# 与上面语句同功能 flatten 摊平 torch.flatten()
output = torch.flatten(imgs)
print(output.shape)
output = zrf(output)
print(output.shape)
Normalization Layers
正则化层：对输入进行正则化（注意：正则化不是归一化），有助于梯度下降，解决过拟合
num_feature(int): 输入图像的通道数层
affine(bool): 当设置为True时，该模块具有可学习的仿射参数，一般默认为True
Recurrent Layers
循环网络，多用于文字处理中
Transformers Layers
。。。21年大火
Dropout Layers
在训练过程中，会随机的把输入图像（tensor数据类型）中的元素以p的概率变成0
主要是为了防止过拟合
Sparse Layers
主要用于自然语言处理
Distance Functions
计算两个值之间的误差
Loss Functions
计算损失，让output不断靠近target（loss是越小越好）
1. 计算实际输出和目标之间的差距
2.为我们更新输出提供一定的依据（反向传播） : 对神经网络，或者说对卷积层来说，其中的每一个卷积核的参数就是我们需要调整的。根据grad梯度来调整。
L1Loss
MSELoss
平方差
CrossEntropyLoss 交叉熵损失
下面公式中，应该是ln，不是log
output：0.1预测是人的概率，0.2预测是狗的概率，0.3预测是猫的概率
import torch
from torch.nn import L1Loss, MSELoss, CrossEntropyLoss
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 = L1Loss(reduction='sum') # 默认是mean
result = loss(inputs, targets)
# 平方差损失
loss_mse = MSELoss()
result_mse = loss_mse(inputs, targets)
# 交叉熵损失
x = torch.tensor([0.1, 0.2, 0.3])
y = torch.tensor([1])
# 要注意输入的形状为（N，C），N是batch_size，C是预测结果的总类型数目
x = torch.reshape(x, (1, 3))
loss_cross = CrossEntropyLoss()
result_cross = loss_cross(x, y)
print(result_cross)
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
