pytorch入门-神经网络

每天学一点q

于 2023-08-15 13:47:17 发布

阅读量526

点赞数 1

分类专栏： pytorch学习文章标签： pytorch 神经网络人工智能

本文链接：https://blog.csdn.net/weixin_47626556/article/details/132280497

版权

pytorch学习专栏收录该内容

8 篇文章 0 订阅

订阅专栏

神经网络的基本骨架

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)

卷积操作

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)

卷积层

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

最大池化

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()

非线性激活

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()

线性层及其他层介绍

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的使用

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()

每天学一点q

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
pytorch入门-神经网络

self.linear是类中的一个成员变量，它被赋值为一个Linear对象。Linear对象的构造函数需要两个参数：输入特征的大小和输出特征的大小。在这里，输入特征的大小为196608，输出特征的大小为10。#in_features 表示输入的特征维度大小，out_features 表示输出的特征维度大小。output = torch.flatten(imgs)#通过调用 torch.flatten 函数，可以将输入张量 imgs 展平成一个一维张量。
复制链接

扫一扫