神经网络的基本骨架
python
复制代码
import torch
from torch import nn #nn模块是PyTorch中用于构建神经网络模型的核心模块。它提供了各种类和函数，可以帮助你定义和训练神经网络。
class Tudui(nn.Module):
def __init__(self):
super(Tudui, self).__init__() #调用 super(Tudui, self).__init__() 初始化父类 nn.Module，这样我们才能正常使用神经网络模块的功能。
def forward(self,input):
output = input + 1 #在 forward 方法中，定义了模型的前向传播过程。输入 input 加上 1，并将结果作为输出返回。
return output
tudui = Tudui()
x = torch.tensor(1.0)
output = tudui(x)
print(output)
卷积操作
python
复制代码
import torch
import torch.nn.functional as F #torch.nn.functional模块提供了一系列的函数，用于构建神经网络的各种操作，如激活函数、损失函数、池化操作等。
# torch.tensor是PyTorch中的一个类，用于创建多维数组或张量。它是使用PyTorch进行科学计算和深度学习的核心数据结构之一。
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]])
#input是一个张量，通过调用torch.reshape(input, (1, 1, 5, 5))将其形状重塑为(1, 1, 5, 5)。这意味着原先的张量形状为(5, 5)，重塑后的张量形状为(1, 1, 5, 5)。
input = torch.reshape(input, (1, 1, 5, 5))
kernel = torch.reshape(kernel, (1, 1, 3, 3))
output = F.conv2d(input, kernel, stride=1) #conv2d函数接收三个参数：input、kernel和stride。它执行了一个二维卷积操作，将输入张量input与卷积核张量kernel进行卷积运算，并返回卷积结果。stride参数指定了卷积操作的步幅，默认为1。
print(output)
output2 = F.conv2d(input, kernel, stride=2)
print(output2)
output3 = F.conv2d(input, kernel, stride=1, padding=1)#padding参数用于在输入张量的周围添加零填充（zero-padding），以控制输出的尺寸。通过在输入的周围添加零值像素，可以保持输出具有与输入相同的空间尺寸。
print(output3)
卷积层
python
复制代码
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(r"D:\PyCharm\learn_torch\dataset", train=False, transform=torchvision.transforms.ToTensor(),
download=True)#加载CIFAR-10数据集。
#DataLoader类主要用于将数据集分割成小批量数据并提供数据加载的功能。它接收两个主要参数：dataset和batch_size。
# dataset参数是一个数据集对象，可以是之前加载的CIFAR-10数据集 (torchvision.datasets.CIFAR10) 或其他自定义的数据集对象。
# batch_size参数指定了每个小批量数据的样本数量。在这个例子中，batch_size被设置为64，表示每个小批量数据中包含64个样本。
dataLoader = DataLoader(dataset, batch_size=64)
class Tudui(nn.Module):
def __init__(self):
super(Tudui, self).__init__()
#Conv2d 类需要指定一些参数来定义卷积层的属性：
# in_channels：输入张量的通道数，这里为 3，表示输入是 RGB 彩色图像，具有 3 个通道。
# out_channels：输出张量的通道数，这里为 6，表示输出将包含 6 个通道。
# kernel_size：卷积核的大小，这里为 3，表示卷积核的宽度和高度都为 3。
# stride：卷积的步幅大小，这里为 1，表示每次卷积的滑动步幅为 1。
# padding：零填充的大小，这里为 0，表示不对输入进行零填充。
self.conv1 = Conv2d(in_channels=3,out_channels=6,kernel_size=3,stride=1,padding=0)
#forward(self, x) 是模型类中的方法，用于定义模型的前向传播过程。在该方法中，输入张量 x 经过模型的各个层（如卷积层、池化层、全连接层等）进行计算，并返回最终的输出结果。
# x = self.conv1(x)
# x = torch.relu(x)
# x = x.view(x.size(0), -1)
# x = self.fc1(x)
def forward(self,x):
x = self.conv1(x) #这行代码将输入张量 x 通过卷积层 conv1 进行卷积操作，更新 x 的值为卷积操作的结果。
return x
tudui = Tudui()
write = SummaryWriter(r"../logs")#创建了一个 SummaryWriter 对象，用于将训练过程中的数据写入到指定的日志目录中。
step = 0
for data in dataLoader:
#这行代码将 data 数据拆分为 imgs 和 target 两个部分。
# 假设 data 是一个包含图像和标签的数据集，在进行训练或测试时，常常需要将数据拆分为图像和对应的标签。这样可以方便地对图像进行处理和输入模型，同时获取对应 的标签用于计算损失或评估模型性能。
# imgs 表示图像数据，target 表示对应的标签数据，可能是一个类别标签、一个数字标签或者其他形式的标签。
imgs, target = data
output = tudui(imgs)#将图像数据 imgs 作为输入传递给名为 tudui 的函数（或模型），并将输出结果赋值给变量 output。
print(imgs.shape)
print(output.shape)
#torch.Size([64, 3, 32, 32])
write.add_images("input", imgs, step)
#torch.Size([64, 6, 30, 30])
output = torch.reshape(output, (-1, 3, 30, 30))
#这行代码将名称为 "input" 的图像数据 imgs 添加到 SummaryWriter 对象中，用于生成可视化的输入图像。
# 在使用 TensorBoard 进行可视化时，可以通过 SummaryWriter 对象的 add_images 方法将图像数据写入到日志文件中，以便后续在 TensorBoard 中展示和分 析。
# 第一个参数是图像的名称，可以是任意字符串，用于在
# TensorBoard
# 中标识不同的图像。
# 第二个参数是图像数据，在这里是
# imgs
# 变量，可能是一个张量或数组，表示一批图像数据。图像数据的形状通常是[batch_size, channels, height, width]。
# 第三个参数是步数 / 迭代次数，用于在
# TensorBoard
# 中确定图像数据对应的时间或步数。这个参数是可选的，如果不提供，则默认使用
# SummaryWriter
对象的全局步数。
write.add_images("output",output, step)
step = step + 1
最大池化
python
复制代码
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(r"../dataset", 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)#指定了数据的类型为 torch.float32，这意味着张量中的元素将被解释为 32 位浮点数。
# 第一个维度（-1）：将根据其他维度确定，以使得重塑后的总元素数量与原始张量保持一致。
# 第二个维度（1）：表示每个批次中的通道数为 1。
# 第三个维度（5）：表示每个图像的高度为 5。
# 第四个维度（5）：表示每个图像的宽度为 5。
input = torch.reshape(input, (-1, 1, 5, 5))
print(input.shape)
class Tudui(nn.Module):
def __init__(self):
super(Tudui, self).__init__()
#池化操作是深度学习中常用的一种操作，用于减小特征图的空间尺寸，从而降低模型参数量和计算量，并提取出更显著的特征。
# kernel_size = 3：池化窗口的大小为 3x3。这意味着在进行池化操作时，将以3x3的窗口滑动在输入特征图上，每次选取窗口内的最大值作为输出。
# ceil_mode = False：在默认情况下，当输入特征图的大小除以池化窗口的大小时存在小数部分时，输出特征图的大小将向下取整。即输入特征图大小与输出特征图 大小之间存在下取整关系。设为False表示不进行这种向上取整操作。
self.maxpool = MaxPool2d(kernel_size=3, ceil_mode=False)
def forward(self, input):
output = self.maxpool(input)
return output
tudui = Tudui()
# output = tudui(input)
# print(output)
write = SummaryWriter(r"../logs--maxpool")
step = 0
for data in dataloader:
imgs, target = data
write.add_images("input",imgs,step)
output = tudui(imgs)
write.add_images("output", output, step)
step = step + 1
write.close()
非线性激活
python
复制代码
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 SummaryWriter
input = torch.tensor([[1, -0.5],
[-1, 3]])
output = torch.reshape(input, (-1, 1, 2, 2))
print(output.shape)
dataset = torchvision.datasets.CIFAR10("../dataset", train=False, download=True,
transform=torchvision.transforms.ToTensor())
datalodar = DataLoader(dataset, batch_size=64)
class Tudui(nn.Module):
def __init__(self):
super(Tudui, self).__init__()
self.relu1 = ReLU() # ReLU（Rectified Linear Unit）是深度学习中常用的一种非线性激活函数。它的作用是在神经网络的模型中引入非线性映射，以增强模型的表达能力。
self.sigmoid1 = Sigmoid() # Sigmoid激活函数是一种常用的非线性激活函数，用于在神经网络中引入非线性变换。它的输出范围在 (0, 1) 之间，将输入值映射到概率形式的输出。
def forward(self, input):
output = self.sigmoid1(input)
return output
tudui = Tudui()
writer = SummaryWriter("../log_relu")
step = 0
for data in datalodar:
imgs, target = data
writer.add_images("input", imgs, global_step=step)
output = tudui(imgs)
writer.add_images("output", imgs, global_step=step)
step = step + 1
writer.close()
线性层及其他层介绍
python
复制代码
import torch
import torchvision
from torch import nn
from torch.nn import Linear
from torch.utils.data import DataLoader
dataset = torchvision.datasets.CIFAR10("../dataset",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.linear是类中的一个成员变量，它被赋值为一个Linear对象。Linear对象的构造函数需要两个参数：输入特征的大小和输出特征的大小。在这里，输入特征的大小为196608，输出特征的大小为10。
#linear = Linear(in_features, out_features)
# output = linear(input)
#in_features 表示输入的特征维度大小，out_features 表示输出的特征维度大小。
self.linear = Linear(196608,10)
def forward(self,input):
output = self.linear(input)
return output
tudui = Tudui()
for data in dataloader:
imgs, targets = data
print(imgs.shape)
# output = torch.reshape(imgs, (1, 1, 1, -1))
output = torch.flatten(imgs)#通过调用 torch.flatten 函数，可以将输入张量 imgs 展平成一个一维张量。展平后的张量 output 中的元素顺序与原始张量保持一致，只是维度形状变为一维。
print(output.shape)
output = tudui(output)
print(output.shape)
神经网络搭建和Sequential的使用
python
复制代码
import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
from torch.utils.tensorboard import SummaryWriter
class Tudui(nn.Module):
def __init__(self):
super(Tudui, self).__init__()
# 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()
# self.linear1 = Linear(1024, 64)
# self.linear2 = Linear(64, 10)
# 这个模型使用了Sequential模型，并依次添加了多个层来构建网络结构。每个层的作用如下：
# Conv2d(3, 32, 5, padding=2)：卷积层，输入通道数为3，输出通道数为32，卷积核大小为5x5，填充为2。
# MaxPool2d(2)：池化层，池化核大小为2x2。
# Conv2d(32, 32, 5, padding=2)：卷积层，输入通道数为32，输出通道数为32，卷积核大小为5x5，填充为2。
# MaxPool2d(2)：池化层，池化核大小为2x2。
# Conv2d(32, 64, 5, padding=2)：卷积层，输入通道数为32，输出通道数为64，卷积核大小为5x5，填充为2。
# MaxPool2d(2)：池化层，池化核大小为2x2。
# Flatten()：展平层，用于将多维的输入数据展平为一维。
# Linear(1024, 64)：全连接层，输入维度为1024，输出维度为64。
# Linear(64, 10)：全连接层，输入维度为64，输出维度为10。
self.modul1 = 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.modul1(x)
return x
tudui = 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()