pytorch入门-神经网络

神经网络的基本骨架

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()
相关推荐
mit6.82425 分钟前
[Agent开发平台] 后端的后端 | MySQL | Redis | RQ | idgen | ObjectStorage
人工智能·python
GIOTTO情1 小时前
媒介宣发的技术革命:Infoseek如何用AI重构企业传播全链路
大数据·人工智能·重构
阿里云大数据AI技术1 小时前
云栖实录 | 从多模态数据到 Physical AI,PAI 助力客户快速启动 Physical AI 实践
人工智能
小关会打代码1 小时前
计算机视觉进阶教学之颜色识别
人工智能·计算机视觉
IT小哥哥呀1 小时前
基于深度学习的数字图像分类实验与分析
人工智能·深度学习·分类
机器之心2 小时前
VAE时代终结?谢赛宁团队「RAE」登场,表征自编码器或成DiT训练新基石
人工智能·openai
机器之心2 小时前
Sutton判定「LLM是死胡同」后,新访谈揭示AI困境
人工智能·openai
大模型真好玩2 小时前
低代码Agent开发框架使用指南(四)—Coze大模型和插件参数配置最佳实践
人工智能·agent·coze
jerryinwuhan2 小时前
基于大语言模型(LLM)的城市时间、空间与情感交织分析:面向智能城市的情感动态预测与空间优化
人工智能·语言模型·自然语言处理
落雪财神意2 小时前
股指10月想法
大数据·人工智能·金融·区块链·期股