动手学深度学习（pytorch土堆）-05-1神经网络

Neural network

以下是 torch.nn 库中各个组件的详细分类：

1. 容器 (Containers)

  • torch.nn.Sequential: 顺序容器，用于将层按顺序堆叠在一起。
  • torch.nn.ModuleList: 模块列表，用于存储多个子模块。
  • torch.nn.ModuleDict: 模块字典，用于存储以字典形式组织的子模块。

2. 卷积层 (Convolution Layers)

  • torch.nn.Conv1d: 1D 卷积层，适用于处理序列数据。
  • torch.nn.Conv2d: 2D 卷积层，常用于处理图像数据。
  • torch.nn.Conv3d: 3D 卷积层，用于处理三维数据，例如视频帧。

3. 池化层 (Pooling Layers)

  • torch.nn.MaxPool1d: 1D 最大池化层，用于序列数据。
  • torch.nn.MaxPool2d: 2D 最大池化层，用于图像数据。
  • torch.nn.AvgPool2d: 2D 平均池化层，用于图像数据。

4. 填充层 (Padding Layers)

  • torch.nn.ConstantPad1d: 1D 常数填充层。
  • torch.nn.ReflectionPad2d: 2D 反射填充层。
  • torch.nn.ReplicationPad2d: 2D 复制填充层。

5. 非线性激活 (Weighted Sum, Nonlinearity)

  • torch.nn.ReLU: Rectified Linear Unit 激活函数。
  • torch.nn.Sigmoid: Sigmoid 激活函数。
  • torch.nn.Tanh: Tanh 激活函数。

6. 非线性激活 (其他)

  • torch.nn.LeakyReLU: 带泄漏的 ReLU 激活函数。
  • torch.nn.PReLU: 参数化 ReLU 激活函数。

7. 归一化层 (Normalization Layers)

  • torch.nn.BatchNorm1d: 1D 批归一化层。
  • torch.nn.BatchNorm2d: 2D 批归一化层。
  • torch.nn.LayerNorm: 层归一化层。

8. 递归层 (Recurrent Layers)

  • torch.nn.RNN: 循环神经网络层。
  • torch.nn.LSTM: 长短期记忆网络层。
  • torch.nn.GRU: 门控循环单元层。

9. Transformer 层 (Transformer Layers)

  • torch.nn.Transformer: Transformer 模型的实现。
  • torch.nn.MultiheadAttention: 多头自注意力机制。

10. 线性层 (Linear Layers)

  • torch.nn.Linear: 全连接层。

11. Dropout 层 (Dropout Layers)

  • torch.nn.Dropout: Dropout 层，用于减少过拟合。
  • torch.nn.Dropout2d: 2D Dropout 层。

12. 稀疏层 (Sparse Layers)

  • torch.nn.Embedding: 嵌入层，用于处理稀疏数据（如词汇表中的词向量）。

13. 距离函数 (Distance Functions)

  • torch.nn.PairwiseDistance: 计算一对样本之间的距离。
  • torch.nn.CosineSimilarity: 计算余弦相似度。

14. 损失函数 (Loss Functions)

  • torch.nn.CrossEntropyLoss: 交叉熵损失函数。
  • torch.nn.MSELoss: 均方误差损失函数。
  • torch.nn.BCEWithLogitsLoss: 结合了 Sigmoid 激活和二元交叉熵损失的损失函数。

15. 视觉层 (Vision Layers)

  • torch.nn.Conv2d: 2D 卷积层。
  • torch.nn.MaxPool2d: 2D 最大池化层。
  • torch.nn.AdaptiveAvgPool2d: 自适应平均池化层。

16. Shuffle 层 (Shuffle Layers)

  • torch.nn.PixelShuffle: 像素重排层，用于超分辨率任务。

17. DataParallel 层 (多 GPU，分布式)

  • torch.nn.DataParallel: 用于多 GPU 训练的封装器。

18. 实用工具 (Utilities)

  • torch.nn.init: 权重初始化函数。
  • torch.nn.functional: 包含各种功能性操作（如激活函数、卷积操作等）。

19. 量化函数 (Quantized Functions)

  • torch.nn.quantized: 用于量化模型的模块和函数。

20. 惰性模块初始化 (Lazy Modules Initialization)

  • torch.nn.LazyLinear: 懒初始化的全连接层。
  • torch.nn.LazyConv2d: 懒初始化的卷积层。

这些组件共同构成了 PyTorch 的神经网络构建和训练的基础。

Model示例

在这段代码中，Model(nn.Module) 是一个类定义语法的部分，涉及到几个重要的 Python 和 PyTorch 语法和概念。具体说明如下：

类定义 (class 语法)

class Model(nn.Module):
  • class: 这是 Python 中定义类的关键字。
  • Model: 这是你定义的类的名称。
  • (nn.Module): 这是类的基类，表示 Model 继承自 nn.Module。

继承 (inheritance)

  • nn.Module: 是 PyTorch 提供的一个基类，用于所有神经网络模型的构建。它提供了基本的功能，如参数的注册、前向传播的定义等。通过继承 nn.Module，Model 类可以使用这些功能。

  • 继承的意义:

    • 继承 nn.Module 允许 Model 类拥有 nn.Module 的所有方法和属性。
    • 自定义的神经网络类需要继承自 nn.Module，并重写 forward 方法，定义前向传播的具体逻辑。

初始化 (__init__ 方法)

def __init__(self):super().__init__()self.conv1 = nn.Conv2d(1, 20, 5)self.conv2 = nn.Conv2d(20, 20, 5)
  • __init__: 是 Python 中的构造函数，用于初始化类的实例。在创建 Model 实例时，会调用这个方法来初始化网络层。
  • super().__init__(): 调用基类（nn.Module）的初始化方法，确保父类的初始化逻辑也被执行。
  • self.conv1 和 self.conv2: 这些是 Model 类的属性，定义了网络的卷积层。

前向传播 (forward 方法)

def forward(self, x):x = F.relu(self.conv1(x))return F.relu(self.conv2(x))
  • forward: 是一个必须重写的方法，用于定义数据如何通过网络传递。在这里，x 是输入数据，经过两个卷积层和 ReLU 激活函数后返回结果。
  • F.relu: 是 torch.nn.functional 中的 ReLU 激活函数。它在每个卷积层后应用，以引入非线性特征。

关键点总结

  • 继承: Model 继承自 nn.Module，使其具有构建神经网络的能力。
  • 初始化: 使用 __init__ 方法初始化网络层。
  • 前向传播: forward 方法定义了数据流经网络的过程。

这段代码展示了 PyTorch 中定义和实现自定义神经网络模型的基本方法。

Model示例

import torch
from torch import nn
import torch.nn.functional as Fclass xkk(nn.Module):def __init__(self):super().__init__()# self.conv1 = nn.Conv2d(1, 20, 5)# self.conv2 = nn.Conv2d(20, 20, 5)def forward(self, input):output=input+1return output
Xkk=xkk()
x=torch.tensor(1.0)
output=Xkk(x)#调用了模块的 __call__ 方法，而 __call__ 方法会自动执行 forward 函数。
print(output)

CONV2D
卷积
在这里插入图片描述

设置padding=1
在 PyTorch 的 conv2d 函数中，padding=1 是指在输入的边缘添加 1 层像素的填充（通常填充 0）。
填充的目的是保持输入的空间尺寸不变或者控制输出的尺寸
在这里插入图片描述

import torch
import torch.nn.functional as F
input=torch.tensor([[1,2,0,3,1],[0,1,2,3,1],[5,2,3,1,1],[1,2,1,0,0],[2,1,0,1,1]])
kernel=torch.tensor([[1,2,1],[0,1,0],[2,1,0]])
"""
在 PyTorch 中执行二维卷积时，输入数据和卷积核需要遵循特定的格式。将 input 和 kernel 张量分别重新调整为 (1, 1, 5, 5) 和 (1, 1, 3, 3) 
是为了符合 conv2d 函数的输入要求。
具体来说，conv2d 的输入和卷积核的张量格式是四维的，分别表示 [batch_size, channels, height, width]。每个维度的含义如下：
batch_size (批大小)：表示同时输入的样本数量。在这个例子中，只进行一次卷积，因此批大小为 1。
channels (通道数)：表示输入的通道数量，通常对于灰度图像为 1，对于彩色图像为 3（对应 RGB 三个通道）。这里输入和卷积核的通道数均为 1。
height (高度) 和 width (宽度)：表示输入图像的大小或卷积核的大小。
因此，input=torch.reshape(input,(1,1,5,5)) 将原始的 5x5 输入张量变为 (1, 1, 5, 5) 的四维张量，以符合 conv2d 函数的输入格式。
类似地，kernel=torch.reshape(kernel,(1,1,3,3)) 是将 3x3 的卷积核也调整为四维格式 (1, 1, 3, 3)。
"""
input=torch.reshape(input,(1,1,5,5))
kernel=torch.reshape(kernel,(1,1,3,3))
output=F.conv2d(input,kernel,stride=1)
print(output)
"""在 PyTorch 的 conv2d 函数中，padding=1 是指在输入的边缘添加 1 层像素的填充（通常填充 0）。
填充的目的是保持输入的空间尺寸不变或者控制输出的尺寸
"""
output2=F.conv2d(input,kernel,stride=1,padding=1)
print(output2)

神经网络-卷积层

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 （int） – 输入图像中的通道数

out_channels （int） – 卷积产生的通道数

kernel_size （int or tuple） – 卷积内核的大小

stride （int or tuple， optional） - 卷积的步幅。默认值：1

padding （int， tuple or str， optional） – 添加到 的所有四个边的填充 输入。默认值：0

padding_mode （str，可选） – 、 或 .违约：‘zeros’‘reflect’‘replicate’‘circular’‘zeros’

dilation （int 或 tuple，可选） – 内核元素之间的间距。默认值：1

groups （int， optional） – 来自输入的阻塞连接数 channels 设置为 output channels。默认值：1

bias （bool，可选） – 如果 ，则向 输出。违约：TrueTrue

import torch
import torch.nn.functional as F
import torchvision
from torch import nn
from torch.nn import Conv2d
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
writer=SummaryWriter("conv2")
dataset=torchvision.datasets.CIFAR10("./data_nn",train=False,transform=torchvision.transforms.ToTensor(),download=True )
dataloader=DataLoader(dataset,batch_size=64)
class xkkk(nn.Module):def __init__(self):super(xkkk,self).__init__()self.conv1=Conv2d(3,6,3,stride=1,padding=0)def forward(self, x):x=self.conv1(x)return x
XKK=xkkk()
i=0
for data in dataloader:imgs,targets=dataoutput=XKK(imgs)print(imgs.shape)print(output.shape)writer.add_images("input",imgs,1,i)output=torch.reshape(output,(-1,3,30,30))#torch.Size([64, 6, 30, 30])---->torch.Size([64, 3, 30 ,30])writer.add_images("output", output, 1, i)i=i+1

在这里插入图片描述池化层
torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
kernel_size （Union[int， Tuple[int， int]]） – 要达到最大值的窗口大小

stride （Union[int， Tuple[int， int]]） —— 窗口的步幅。默认值为kernel_size

padding （Union[int， Tuple[int， int]]） – 要在两侧添加的隐式负无穷大填充

dilation （Union[int， Tuple[int， int]]） – 控制窗口中元素步幅的参数

在这里插入图片描述

return_indices （bool） – 如果 ，将返回最大索引以及输出。 对以后有用True

ceil_mode （bool） – 当 True 时，将使用 ceil 而不是 floor 来计算输出形状
在这里插入图片描述

池化操作

池化（Pooling）是卷积神经网络（CNN）中的一种下采样操作，用于减少特征图的尺寸，同时保留关键信息。其主要目的是降低数据量和计算复杂度，防止过拟合，并且提高模型的鲁棒性。

常见的池化操作有以下两种：

  1. 最大池化（Max Pooling）：取池化窗口内的最大值。其作用是保留该区域内最显著的特征，常用于提取边缘和其他强特征。

    • 举例：如果一个2x2的池化窗口中的值是[1, 3, 2, 0]，最大池化会取值3。

  2. 平均池化（Average Pooling）：取池化窗口内所有值的平均值。这个操作可以平滑特征图，减缓最大池化可能导致的过于强调局部特征的问题。

    • 举例：对于一个2x2的窗口[1, 3, 2, 0]，平均池化会取值(1+3+2+0)/4 = 1.5。

常见的池化参数：

  • 池化窗口大小：窗口的大小决定了要处理的区域范围，通常为2x2或3x3。
  • 步长（stride）：每次移动窗口的距离。步长越大，池化后的特征图越小。

池化是无参操作，不会影响模型的可学习参数。

#ceil_mode （bool） =True 
import torch
from torch import nn
from torch.nn import MaxPool2dinput=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 xkkk(nn.Module):def __init__(self):super(xkkk,self).__init__()self.maxpool1=MaxPool2d(kernel_size=3,ceil_mode=True)def forward(self, x):output=self.maxpool1(x)return output
XKK=xkkk()
output=XKK(input)
print(output)
结果
tensor([[[[2., 3.],[5., 1.]]]])

#ceil_mode=False
import torch
from torch import nn
from torch.nn import MaxPool2dinput=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 xkkk(nn.Module):def __init__(self):super(xkkk,self).__init__()self.maxpool1=MaxPool2d(kernel_size=3,ceil_mode=False)def forward(self, x):output=self.maxpool1(x)return output
XKK=xkkk()
output=XKK(input)
print(output)
结果
tensor([[[[2.]]]])

对图片进行池化操作

import torch
import torchvision
from torch import nn
from torch.nn import MaxPool2d
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriterwriter=SummaryWriter("maxpool")
dataset=torchvision.datasets.CIFAR10("./data_nn",train=False,transform=torchvision.transforms.ToTensor(),download=True )
dataloader=DataLoader(dataset,batch_size=64)
class xkkk(nn.Module):def __init__(self):super(xkkk,self).__init__()self.maxpool1=MaxPool2d(kernel_size=3,ceil_mode=True)def forward(self, x):x=self.maxpool1(x)return x
XKK=xkkk()
i=0
for data in dataloader:imgs,targets=dataoutput=XKK(imgs)# print(imgs.shape)# print(output.shape)writer.add_images("input",imgs,i)# output=torch.reshape(output,(-1,3,30,30))#torch.Size([64, 6, 30, 30])---->torch.Size([64, 3, 30 ,30])writer.add_images("output", output, i)i=i+1writer.close()

在这里插入图片描述

RELU

ReLU（Rectified Linear Unit，线性整流函数）是深度神经网络中常用的激活函数。它的主要作用是引入非线性，从而使得神经网络能够学习复杂的模式和特征。

ReLU 的数学定义为：
[ f(x) = \max(0, x) ]
即：

  • 当 ( x > 0 ) 时，输出 ( x )；
  • 当 ( x \leq 0 ) 时，输出 0。

ReLU 的特点：

  1. 计算简单：相比于其他激活函数（如 Sigmoid 或 Tanh），ReLU 的计算非常简单，仅涉及判断和取值操作，加快了训练速度。
  2. 解决梯度消失问题：在深层网络中，Sigmoid 和 Tanh 激活函数容易导致梯度消失，而 ReLU 的正区间（ ( x > 0 ) ）不会出现这种问题，能够更好地传播梯度。
  3. 稀疏激活：由于 ReLU 的输出会将负值部分置为0，这会使得一部分神经元不被激活，从而产生稀疏性，有助于提高模型的效率和鲁棒性。

ReLU 的缺点：

  • 死亡ReLU（Dying ReLU）问题：如果输入的权重或偏置导致神经元的输出始终为负，那么 ReLU 的输出将一直为 0，导致该神经元不再对输入数据产生任何反应。这种现象会导致部分神经元“死亡”，从而影响模型的表现。

ReLU 的变种：

为了解决死亡 ReLU 的问题，出现了几种 ReLU 的变种：

  1. Leaky ReLU：在负区间引入一个小的斜率，使得负数也可以有小的非零输出。定义为：
    [ f(x) = \max(0.01x, x) ]

  2. Parametric ReLU（PReLU）：类似 Leaky ReLU，但负区间的斜率是一个可学习的参数。

  3. Exponential Linear Unit (ELU)：在负区间采用指数函数，使得其输出更加平滑。

import torch
from torch.nn import ReLU
import torch.nn
input=torch.tensor([[1,-0.5],[-1,3]]
)
input=torch.reshape(input,(-1,1,2,2))
class xkkk(torch.nn.Module):def __init__(self):super(xkkk,self).__init__()self.relu=ReLU()def forward(self, x):x=self.relu(x)return x
XKK=xkkk()
output=XKK(input)
print(output)
结果
tensor([[[[1., 0.],[0., 3.]]]])

sigmoid

Sigmoid函数（S形函数）是机器学习和神经网络中的一个常用激活函数。其特点是将任意实数输入转换为介于0和1之间的输出值，具有S形曲线的特性。

数学公式

Sigmoid函数的公式为：

[
\sigma(x) = \frac{1}{1 + e^{-x}}
]

其中，( e ) 是自然对数的底数，( x ) 是输入值。

特点

  1. 输出范围： Sigmoid函数将输入值压缩到0和1之间，这使得它特别适合用于二元分类问题，例如二分类的输出。

  2. S形曲线： Sigmoid函数的图形是光滑的S形曲线，当输入值为0时，输出为0.5。当输入值趋于正无穷时，输出接近1；当输入值趋于负无穷时，输出接近0。

  3. 平滑和可微性： Sigmoid函数是连续且可导的，导数可以用于梯度下降等优化算法中。

  4. 概率解释： 由于其输出值在(0, 1)之间，常用作表示某事件发生的概率，尤其在逻辑回归和二分类神经网络输出层中广泛应用。

缺点

  1. 梯度消失问题： 当输入值过大或过小时，Sigmoid函数的梯度会接近于零，这会导致神经网络训练过程中梯度更新很慢，从而影响模型的收敛速度。

  2. 非零中心输出： Sigmoid函数的输出值范围是(0, 1)，使得它是非零中心的，这可能会影响反向传播时的梯度计算效率，导致收敛较慢。

导数

Sigmoid函数的导数可以通过以下公式计算：

[
\sigma’(x) = \sigma(x) \cdot (1 - \sigma(x))
]

这意味着其导数与输出值有关，在反向传播中可以方便地计算。

应用场景

  1. 二元分类： 在逻辑回归模型和二元分类神经网络中，Sigmoid通常用于输出层，将模型的输出映射为概率值。
  2. 概率预测： 因为Sigmoid的输出在0和1之间，常用来表示事件发生的概率。

尽管在一些深度学习模型中，ReLU等激活函数逐渐取代了Sigmoid函数，但它在特定任务中仍然有着广泛的应用。

import torch
import torchvision
from torch.nn import ReLU, Sigmoid
import torch.nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriterwriter=SummaryWriter("sigmoid")
dataset=torchvision.datasets.CIFAR10("./data_nn",train=False,transform=torchvision.transforms.ToTensor(),download=True )
dataloader=DataLoader(dataset,batch_size=64)class xkkk(torch.nn.Module):def __init__(self):super(xkkk,self).__init__()self.sigmoid=Sigmoid()def forward(self, x):x=self.sigmoid(x)return x
XKK=xkkk()
i=0
for data in dataloader:imgs,targets=dataoutput=XKK(imgs)# print(imgs.shape)# print(output.shape)writer.add_images("input",imgs,i)# output=torch.reshape(output,(-1,3,30,30))#torch.Size([64, 6, 30, 30])---->torch.Size([64, 3, 30 ,30])writer.add_images("output", output, i)i=i+1writer.close()

在这里插入图片描述

线性层以及其它层介绍

import torch
import torchvision
from torch.nn import Linear
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriterdataset=torchvision.datasets.CIFAR10("./data_nn",train=False,transform=torchvision.transforms.ToTensor(),download=True )
dataloader=DataLoader(dataset,batch_size=64)class xkkk(torch.nn.Module):def __init__(self):super(xkkk,self).__init__()self.linear1=Linear(196608,10)def forward(self, x):output=self.linear1(x)return output
XKK=xkkk()
for data in dataloader:imgs,targets=dataprint(imgs.shape)# output=torch.reshape(imgs,(1,1,1,-1))output=torch.flatten(imgs)print(output.shape)output=XKK(output)print(output.shape)结果
.....
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
torch.Size([10])
torch.Size([64, 3, 32, 32])
torch.Size([196608])
.....

小型实战和Sequential

在 PyTorch 中，torch.nn.Sequential 是一个简单而强大的容器，它可以将多个层按照顺序组合成一个模型。这对于构建多层神经网络尤其有用，因为它允许将一系列的神经网络层按顺序堆叠起来，使得代码更加简洁。

Sequential 的定义与使用

1. 基本使用

可以将多个层按照顺序传递给 Sequential，然后 PyTorch 会自动将数据按顺序通过这些层。

import torch
import torch.nn as nn# 使用 Sequential 定义一个简单的神经网络
model = nn.Sequential(nn.Linear(10, 20),  # 线性层，将输入维度10映射到输出维度20nn.ReLU(),          # 激活函数ReLUnn.Linear(20, 1),   # 线性层，将输入维度20映射到输出维度1nn.Sigmoid()        # 激活函数Sigmoid
)# 打印模型结构
print(model)# 定义输入张量
input_tensor = torch.randn(1, 10)# 前向传播
output = model(input_tensor)
print(output)

在这个例子中，Sequential 包含了两个线性层和两个激活函数，数据会从输入传递到第一层，然后按顺序通过每一层，最终输出结果。

2. 命名层

如果需要给每一层命名，可以使用 OrderedDict 来实现。这样可以更方便地根据层的名字进行访问和操作。

from collections import OrderedDictmodel = nn.Sequential(OrderedDict([('fc1', nn.Linear(10, 20)),('relu1', nn.ReLU()),('fc2', nn.Linear(20, 1)),('sigmoid', nn.Sigmoid())
]))# 打印模型
print(model)# 可以通过名字访问某一层
print(model.fc1)
3. 动态构建

你也可以通过循环等方式动态地创建模型。例如，可以根据用户输入的层数来构建一个网络。

layers = []
input_size = 10
hidden_size = 20for i in range(3):  # 动态添加三层layers.append(nn.Linear(input_size, hidden_size))layers.append(nn.ReLU())input_size = hidden_size  # 下一层的输入是上一层的输出layers.append(nn.Linear(hidden_size, 1))
layers.append(nn.Sigmoid())# 使用 Sequential 构建模型
model = nn.Sequential(*layers)print(model)

Sequential 的特点

  • 简洁：可以轻松地按顺序堆叠层，适用于简单的网络结构。
  • 模块化：方便将复杂的模型模块化，每个部分的功能清晰且独立。
  • 灵活性较低：不适合有复杂控制流或多个输入/输出的模型。例如，Sequential 不适合具有分支或跳跃结构的网络。

适用场景

Sequential 适用于构建简单的前馈神经网络，如：

  • 全连接网络（MLP）
  • 卷积神经网络（CNN）
  • 自编码器

如果你的模型结构比较简单，Sequential 是一种非常高效和易用的方式来定义神经网络。

在这里插入图片描述

import torch
import torchvision
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriterclass xkkk(torch.nn.Module):def __init__(self):super(xkkk,self).__init__()# self.conv1=Conv2d(3,32,5,padding=2)# self.maxpool1=MaxPool2d(kernel_size=2)# self.conv2 = Conv2d(32, 32, 5, padding=2)# self.maxpool2 = MaxPool2d(kernel_size=2)# self.conv3 = Conv2d(32, 64, 5, padding=2)# self.maxpool3 = MaxPool2d(kernel_size=2)# self.flatten=Flatten()# self.linear1=Linear(1024,64)#1024=64*4*4# self.linear2=Linear(64,10)self.model1=torch.nn.Sequential(Conv2d(3, 32, 5, padding=2),MaxPool2d(kernel_size=2),Conv2d(32, 32, 5, padding=2),MaxPool2d(kernel_size=2),Conv2d(32, 64, 5, padding=2),MaxPool2d(kernel_size=2),Flatten(),Linear(1024, 64),  # 1024=64*4*4,Linear(64, 10))def forward(self, x):# output=self.conv1(x)# output=self.maxpool1(output)# output=self.conv2(output)# output=self.maxpool2(output)# output=self.conv3(output)# output=self.maxpool3(output)# output=self.flatten(output)# output=self.linear1(output)# output=self.linear2(output)output=self.model1(x)return output
XKK=xkkk()
print(XKK)
input=torch.ones(64,3,32,32)
writer=SummaryWriter("nn_sequential")
writer.add_graph(XKK,input)
writer.close()

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.xdnf.cn/news/1538000.html

如若内容造成侵权/违法违规/事实不符，请联系一条长河网进行投诉反馈，一经查实，立即删除！

相关文章

Pycharm出现Please specify a different SDK name报错，但是看不到重名环境解决方案

Pycharm出现Please specify a different SDK name报错，但是看不到重名环境解决方案

这句话的意思是出现了重名的环境 ，一般情况下删除重名的环境即可解决问题。做法如下图所示 1，点击右上角齿轮→settings（或者File→settings）进入Python Interpreter 2.点击这个沙漏按键，你会发现多了几个环境&#x…
阅读更多...
minio的最大优势--运维（五）

minio的最大优势--运维（五）

前言： 前面讲了minio的简介、场景、单机部署、集群部署等内容，现在简单来讲讲它的运维工具。 一、Minio客户端使用（这个中文文档没问题） 官方文档地址：https://docs.min.io/docs/minio-client-quickstart-guide.html…
阅读更多...
穿什么有这么重要？——装饰模式

穿什么有这么重要？——装饰模式

文章目录 穿什么有这么重要？——装饰模式穿什么有这么重要？小菜扮靓第一版小菜扮靓第二版装饰模式小菜扮靓第三版商场收银程序再升级简单工厂策略装饰模式实现装饰模式总结 穿什么有这么重要？——装饰模式 穿什么有这么重要？ 时…
阅读更多...
手写redis实现分布式锁详细教程，满足可续锁、可重入等分布式锁条件

手写redis实现分布式锁详细教程，满足可续锁、可重入等分布式锁条件

前言 本文将讨论的做一个高并发场景下避不开的话题，即redis分布式锁。比如在淘宝 的秒杀场景、热点新闻和热搜排行榜等。可见分布式锁是一个程序员面向高级的一门必修课，下面请跟着本篇文章好好学习。 redis分布式锁有哪些面试题 1.Redis做分布式的时…
阅读更多...
执着追求与匠心独运 朵拉朵尚2024欧洲溯源 深入德国巴斯夫

执着追求与匠心独运 朵拉朵尚2024欧洲溯源 深入德国巴斯夫

执着追求与匠心独运 朵拉朵尚2024欧洲溯源 深入德国巴斯夫 前不久，朵拉朵尚踏上了其2024年欧洲溯源之旅的第三站—德国巴斯夫，一场旨在深化护肤智慧、共谋新品未来的深度交流盛宴在此拉开帷幕。作为全球最大的化工公司，巴斯夫不仅以其卓越的…
阅读更多...
电脑录屏工具哪个好用？推荐新手几款实用工具介绍

电脑录屏工具哪个好用？推荐新手几款实用工具介绍

现在不管是录个教学视频教教别人，还是直播游戏给粉丝看，或者是展示你的产品，都得用到它。但是市面上的录屏软件多得让人眼花缭乱，新手可能一看就懵了。别急，今天我就给你介绍几个特别好用的电脑录屏工具，不…
阅读更多...
攻克大模型面试！RAG基础与应用痛点一网打尽！

攻克大模型面试！RAG基础与应用痛点一网打尽！

RAG相关理论知识与经验整理。 谈到大模型在各垂直领域中的应用，一定离不开RAG，本系列开始分享一些RAG相关使用经验，可以帮助大家在效果不理想的时候找到方向排查或者优化。 本系列以医疗领域为例，用面试题的形式讲解RAG相关知识…
阅读更多...
唤醒金融数据中台：我的数据驱动秘籍

唤醒金融数据中台：我的数据驱动秘籍

目录 一、明析业务痛点和机会点二、数据驱动精准化营销三、一体化数据平台——整合金融数据1. 数据整合与标准化2. 数据服务与共享3.业务体系集中化 四、强化金融数据安全，筑牢数据保护防线 在当今数字化时代的大潮中，数据无疑是金融行业最耀眼的财富。作…
阅读更多...
销售管理中的难题，你是否也深陷其中？

销售管理中的难题，你是否也深陷其中？

销售管理中的难题似乎总是让人头疼。从客户跟进不及时，到销售数据分析不足，再到团队沟通不畅，导致商机频频流失。销售目标总是难以达成，业绩压力越来越大，但解决方案却总是力不从心。面对这样的问题，你是不…
阅读更多...
Chainlit集成LlamaIndex并使用通义千问模型实现AI知识库检索网页对话应用增强版

Chainlit集成LlamaIndex并使用通义千问模型实现AI知识库检索网页对话应用增强版

前言 之前使用Chainlit集成LlamaIndex并使用通义千问大语言模型的API接口，实现一个基于文档文档的网页对话应用。 可以点击我的上一篇文章《Chainlit集成LlamaIndex并使用通义千问模型实现AI知识库检索网页对话应用》 查看。 本次针对上一次的代码功能进一步的完善…
阅读更多...
推动公平学习与身份归一化的视网膜神经疾病数据集

推动公平学习与身份归一化的视网膜神经疾病数据集

人工智能咨询培训老师叶梓 转载标明出处 在机器学习领域，公平性（也称为公正性或平等性）是一个日益受到关注的话题，它对于社会的福祉至关重要。然而，目前缺乏专门用于公平学习且包含成像数据的公共医学数据集&#xff…
阅读更多...
分苹果 - 华为OD统一考试(E卷)

分苹果 - 华为OD统一考试(E卷)

2024华为OD机试（E卷+D卷+C卷）最新题库【超值优惠】Java/Python/C++合集 题目描述 A 和 B 两个人要分苹果。A 希望按照他的计算规则得到平均分配的苹果，而 B 希望在满足 A 的条件下获得尽可能多的苹果量。 A 的计算规则是按照二进制加法进行，并不计算进位。例如，12 + 5 =…
阅读更多...
CAT1 DTU软硬件设计开源资料分析（TCP协议版本 ）

CAT1 DTU软硬件设计开源资料分析（TCP协议版本 ）

一、CAT1 DTU方案简介： 远程终端单元DTU，一种针对通信距离较长和工业现场环境恶劣而设计的具有模块化结构的、特殊的计算机测控单元，它将末端检测仪表和执行机构与远程控制中心相连接。 奇迹TCP DTU版本DTU，用于将远程现场的传感…
阅读更多...
VoIP协议

VoIP协议

VoIP协议是VoIP业务的规范标准。我们都知道VoIP业务有着压倒性的优势。随着网络应用的多元化和低成本化发展，VoIP业务直接冲击着传统通信市场，那么目前VoIP协议目前常用的协议,如H.323、SIP、MEGACO和MGCP。 H.248 H.248是定义网关控制协议的ITU建议书…
阅读更多...
分布式光伏发电站数据采集设备管理硬件解决方案

分布式光伏发电站数据采集设备管理硬件解决方案

随着全球能源结构的转型和可再生能源的快速发展，光伏发电作为重要的清洁能源之一，在能源市场中占据了越来越重要的位置。AcrelCoud-1200分布式光伏运维云平台通过监测光伏站点的逆变器设备，气象设备以及摄像头设备，帮助用户管理分…
阅读更多...
【Linux系统编程】第二十弹---进程优先级 命令行参数 环境变量

【Linux系统编程】第二十弹---进程优先级 命令行参数 环境变量

✨个人主页： 熬夜学编程的小林 💗系列专栏： 【C语言详解】 【数据结构详解】【C详解】【Linux系统编程】 目录 1、进程优先级 2.1、什么是优先级 2.2、优先级的描述 2.3、优先级与权限的关系 2.4、为什么要有优先级 2.5、Linux优先级的…
阅读更多...
某oa命令执行漏洞挖掘思路

某oa命令执行漏洞挖掘思路

《网安面试指南》http://mp.weixin.qq.com/s?__bizMzkwNjY1Mzc0Nw&mid2247484339&idx1&sn356300f169de74e7a778b04bfbbbd0ab&chksmc0e47aeff793f3f9a5f7abcfa57695e8944e52bca2de2c7a3eb1aecb3c1e6b9cb6abe509d51f&scene21#wechat_redirect 《Java代码审…
阅读更多...
图像修复（Inpainting）技术的前沿模型与数据集资源汇总

图像修复（Inpainting）技术的前沿模型与数据集资源汇总

图像修复（Image Inpainting）是一种计算机视觉技术，旨在填补图像中的缺失区域或去除图像中的不需要部分，使其看起来自然且无明显痕迹。其目标是根据图像的上下文信息和周围像素来推断和重建缺失区域的内容，以生成逼真且…
阅读更多...
《机器学习》周志华-CH7（贝叶斯分类）

《机器学习》周志华-CH7（贝叶斯分类）

7.1贝叶斯决策论 对分类任务而言，在所有相关概率已知的理想情形下，贝叶斯决策论考虑如何基于这些概率核误判损失来选择最优的类别标记。 R ( x i ∣ x ) ∑ j 1 N λ i j P ( c j ∣ x ) \begin{equation} R(x_{i}|x)\sum_{j1}^{N}\lambda_{ij}P(c_{j}…
阅读更多...
DTMF2str集成工具

DTMF2str集成工具

DTMF2str 项目地址： baicaiyihao/DTMF2str: DTMF解码并转换为字符串 (github.com) 用于CTF中misc DTMF题中，方便ctfer解题。 注：工具根据现有的一些题型进行编写的，如果有无法解出的题型可以提issus后续进行完善。 工具功能&a…
阅读更多...
最新文章

Copyright @ 2022~2023