神经网络的搭建与各层分析

news2024/11/16 3:43:32

为什么去西藏的人都会感觉很治愈

拉萨的老中医是这么说的

缺氧脑子短路，很多事想不起来，就会感觉很幸福

一、卷积层

解释：卷积层通过卷积操作对输入数据进行处理。它使用一组可学习的滤波器（也称为卷积核或特征检测器），将滤波器与输入数据进行逐元素的乘法累加操作，从而生成输出特征图。这种滤波器的操作类似于图像处理中的卷积操作，因此得名卷积层。

主要作用：

  1. 特征提取：卷积层通过滤波器的卷积操作，可以有效地提取输入数据中的局部特征。滤波器可以学习到不同的特征，例如边缘、纹理、形状等，这些特征对于图像识别和分类等任务非常重要。

  2. 参数共享：卷积层的滤波器在整个输入数据上共享参数。这意味着在不同位置上使用相同的滤波器，从而减少了需要学习的参数数量。这种参数共享的特性使得卷积层具有一定的平移不变性，即对于输入数据的平移操作具有不变性。

  3. 减少参数数量：相比全连接层（每个神经元与上一层的所有神经元相连），卷积层的参数数量较少。这是因为卷积层的滤波器在空间上共享参数，并且每个滤波器只与输入数据的局部区域进行卷积操作。这种参数共享和局部连接的方式大大减少了需要学习的参数数量，提高了模型的效率和泛化能力。

  4. 空间结构保持：卷积层在进行卷积操作时，保持了输入数据的空间结构。这意味着输出特征图的每个元素对应于输入数据的相应局部区域，从而保留了输入数据的空间信息。这对于图像处理任务非常重要，因为图像中的相邻像素之间存在一定的关联性。

使用示例：

 代码示例：

import torch
import torch.nn.functional as F

# 模拟图像
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]])
# 模拟卷积核
kernal = torch.tensor([[1, 2, 1],
                       [0, 1, 0],
                       [2, 1, 0]])

# 参数结构转化
input = torch.reshape(input, (1, 1, 5, 5))
kernal = torch.reshape(kernal, (1, 1, 3, 3))

print(input.shape)
print(kernal.shape)

# 输入经过卷积操作
output = F.conv2d(input, kernal, stride=2, padding=1)
print(output)

输出

torch.Size([1, 1, 5, 5])
torch.Size([1, 1, 3, 3])
tensor([[[[ 1,  4,  8],
          [ 7, 16,  8],
          [14,  9,  4]]]])

图片数据集经过卷积层输出：

import torch
import torchvision
from torch.utils.data import DataLoader
from torch.nn import Conv2d
from torch import nn
from torch.utils.tensorboard import SummaryWriter

# 加载数据集并加载到神经网络中
dataset = torchvision.datasets.CIFAR10("./cifar10", train=False, transform=torchvision.transforms.ToTensor(),
                                       download=False)
dataloader = DataLoader(dataset, batch_size=64)


class Lh(nn.Module):
    def __init__(self):
        super(Lh, self).__init__()
        self.conv1 = Conv2d(3, 6, 3, 1)

    def forward(self, x):
        x = self.conv1(x)
        return x


lh = Lh()

writer = SummaryWriter("logs")
step = 0
for data in dataloader:
    imgs, targets = data
    output = lh(imgs)
    writer.add_images("input", imgs, step)

    output = torch.reshape(output, (-1, 3, 30, 30))
    writer.add_images("output", output, step)

    step += 1

通过tensorboard展示

 二、最大池化层

解释：它将输入数据划分为不重叠的矩形区域（通常是2x2的窗口），然后在每个区域中选择最大值作为输出。这样，最大池化层通过取每个区域中的最大值来减少数据的维度。

主要作用：

  1. 特征减少：最大池化层可以减少输入数据的空间尺寸，从而降低了模型的计算复杂度。通过减少特征图的尺寸，最大池化层能够在保留重要特征的同时，减少需要处理的数据量，提高模型的效率。

  2. 平移不变性：最大池化层具有一定的平移不变性，即对于输入数据的平移操作具有不变性。这是因为在最大池化操作中，只选择每个区域中的最大值，而不考虑其位置信息。这种平移不变性使得神经网络对于输入数据的位置变化具有一定的鲁棒性。

  3. 特征提取：最大池化层可以帮助提取输入数据中的主要特征。通过选择每个区域中的最大值作为输出，最大池化层能够保留输入数据中的重要特征，并且对于噪声和不重要的细节具有一定的鲁棒性。

最大池化层在神经网络中起到了减少数据维度、提取关键特征和增强模型的鲁棒性等作用（简单来说就是把1080p的视频变成720p的）。它通常与卷积层交替使用，帮助神经网络有效地处理输入数据，提高模型的性能和泛化能力。

 使用示例：

import torch
from torch.nn import MaxPool2d
from torch import nn
import torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10('./cifar10', train=False, transform=torchvision.transforms.ToTensor(),
                                       download=False)
dataloader = DataLoader(dataset, 64, False)

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


class Lh(nn.Module):
    def __init__(self):
        super(Lh, self).__init__()
        self.maxpool = MaxPool2d(kernel_size=3, ceil_mode=True)

    def forward(self, x):
        x = self.maxpool(x)
        return x


lh = Lh()

writer = SummaryWriter("logs")
step = 0
for data in dataloader:
    imgs, tagerts = data
    writer.add_images("input", imgs, step)
    output = lh(imgs)
    writer.add_images("output", output, step)
    step += 1

writer.close()

使用torchboard打卡

三、非线性激活函数

解释：神经网络的非线性激活函数是在神经网络的每个神经元上引入非线性变换的函数。它的作用是为神经网络引入非线性能力，从而使网络能够学习和表示更加复杂的函数关系。

主要作用：

  1. 引入非线性：线性变换的组合只能表示线性关系，而神经网络的层级结构和参数学习能力使其具备了更强大的函数逼近能力。非线性激活函数的引入打破了线性关系的限制，使得神经网络可以学习和表示非线性的函数关系，从而更好地适应复杂的数据模式。

  2. 增强模型的表达能力：非线性激活函数可以增强神经网络的表达能力，使其能够学习和表示更加复杂的特征和模式。通过引入非线性变换，激活函数可以对输入信号进行非线性映射，从而提取和表示更多种类的特征，帮助网络更好地理解输入数据。

  3. 解决分类问题的非线性可分性：在处理分类问题时，输入数据通常是非线性可分的。非线性激活函数可以帮助神经网络学习并表示类别之间的非线性边界，从而提高分类准确性。例如，常用的激活函数如ReLU、Sigmoid和Tanh等都是非线性的，它们可以帮助神经网络学习并表示复杂的决策边界。

  4. 缓解梯度消失问题：在深层神经网络中，反向传播算法需要通过链式法则计算梯度并更新参数。线性激活函数（如恒等映射）会导致梯度的乘积变得非常小，从而导致梯度消失问题。而非线性激活函数可以通过引入非线性变换，使得梯度能够在网络中传播并保持较大的幅度，从而缓解了梯度消失问题，有助于更好地训练深层网络。

 使用示例：

import torch
import torchvision.datasets
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, 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))

dataset = torchvision.datasets.CIFAR10("./cifar10", False, transform=torchvision.transforms.ToTensor())
dataloader = DataLoader(dataset, 64)


class Lh(nn.Module):
    def __init__(self):
        super(Lh, self).__init__()
        self.relu1 = ReLU()
        self.sigmoid = Sigmoid()

    def forward(self, input):
        return self.sigmoid(input)


lh = Lh()

step = 0
writer = SummaryWriter("logs")

for data in dataloader:
    imgs, targets = data
    writer.add_images("input", imgs, step)
    output = lh(imgs)
    writer.add_images("output", output, step)
    step += 1

writer.close()

print("end")

使用torchboard打开

四、其它层与神经网络模型

查看pytorch的官方文档可以看到，神经网络中不同层及其使用

你可以创建自己的神经网络，然后自由搭配里面的网络层进行模型的训练。但是一般情况下我们不用手动去一层一层构建，因为官网提供了很多已经搭配好的神经网络模型，这些模型的训练效果都非常不错，我们只需要选择构建好的模型使用即可。

如 torchvision.models

五、神经网络搭建小实战

crfar10 model structure

根据上图，以input为 3@32 * 32为例，可更据公式计算pandding

代码示例：

from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential
import torch

class Lh(nn.Module):
    def __init__(self):
        super(Lh, self).__init__()
        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.model1(x)
        return x

lh = Lh()
input = torch.ones((64,3,32,32))
print(input.shape)
output = lh(input)
print(output.shape)

可以使用tensorboard绘制神经网络流程图

writer = SummaryWriter('logs')
writer.add_graph(lh, input)
writer.close()

六、损失函数

损失函数用于衡量模型的预测输出与真实标签之间的差异，并且在训练过程中用于优化模型的参数。

常用的损失函数及其简单使用方法：

1. 均方误差损失（Mean Squared Error, MSE）：
均方误差损失函数用于回归问题，计算预测值与真实值之间的平均平方差。它可以通过torch.nn.MSELoss()来创建。

import torch
import torch.nn as nn

loss_fn = nn.MSELoss()

predictions = torch.tensor([0.5, 0.8, 1.2])
targets = torch.tensor([1.0, 1.0, 1.0])

loss = loss_fn(predictions, targets)
print(loss)

2. 交叉熵损失（Cross Entropy Loss）：
交叉熵损失函数常用于分类问题，特别是多分类问题。它计算预测概率分布与真实标签之间的交叉熵。在PyTorch中，可以使用torch.nn.CrossEntropyLoss()来创建交叉熵损失函数。

import torch
import torch.nn as nn

loss_fn = nn.CrossEntropyLoss()

predictions = torch.tensor([[0.2, 0.3, 0.5], [0.8, 0.1, 0.1]])
targets = torch.tensor([2, 0])  # 真实标签

loss = loss_fn(predictions, targets)
print(loss)

3. 二分类交叉熵损失（Binary Cross Entropy Loss）：
二分类交叉熵损失函数适用于二分类问题，计算预测概率与真实标签之间的交叉熵。在PyTorch中，可以使用torch.nn.BCELoss()来创建二分类交叉熵损失函数。

import torch
import torch.nn as nn

loss_fn = nn.BCELoss()

predictions = torch.tensor([0.2, 0.8])
targets = torch.tensor([0.0, 1.0])  # 真实标签

loss = loss_fn(predictions, targets)
print(loss)

将损失函数运用到前面的神经网络模型中：

import torchvision
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear
from torch.utils.data import DataLoader

dataset = torchvision.datasets.CIFAR10('./cifar10', False, transform=torchvision.transforms.ToTensor())
dataloader = DataLoader(dataset, batch_size=64)

class Lh(nn.Module):
    def __init__(self):
        super(Lh, self).__init__()
        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.model1(x)
        return x

loss = nn.CrossEntropyLoss()
lh=Lh()
for data in dataloader:
    imgs, targets = data
    outputs = lh(imgs)
    result_loss = loss(outputs, targets)
    result_loss.backward()
    print(result_loss)

七、优化器

优化器用于更新模型的参数以最小化损失函数。

常用的优化器及其简单使用方法：

1. 随机梯度下降（Stochastic Gradient Descent, SGD）：
随机梯度下降是最基本的优化算法之一，它通过计算损失函数关于参数的梯度来更新参数。在PyTorch中，可以使用torch.optim.SGD来创建SGD优化器。

import torch
import torch.optim as optim

model = MyModel()  # 自定义模型

optimizer = optim.SGD(model.parameters(), lr=0.01)

# 在训练循环中使用优化器
optimizer.zero_grad()  # 清零梯度
loss = compute_loss()  # 计算损失
loss.backward()  # 反向传播计算梯度
optimizer.step()  # 更新参数

2. Adam优化器：
Adam是一种自适应学习率优化算法，它结合了动量（momentum）和自适应学习率调整。在PyTorch中，可以使用torch.optim.Adam来创建Adam优化器。

import torch
import torch.optim as optim

model = MyModel()  # 自定义模型

optimizer = optim.Adam(model.parameters(), lr=0.001)

# 在训练循环中使用优化器
optimizer.zero_grad()  # 清零梯度
loss = compute_loss()  # 计算损失
loss.backward()  # 反向传播计算梯度
optimizer.step()  # 更新参数

3. 其他优化器：
PyTorch还提供了其他优化器，如Adagrad、RMSprop等。这些优化器都可以在torch.optim模块中找到，并使用类似的方式进行使用。

结合前面的神经网络模型代码示例：

import torchvision
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear
from torch.utils.data import DataLoader
import torch


dataset = torchvision.datasets.CIFAR10('./cifar10', False, transform=torchvision.transforms.ToTensor())
dataloader = DataLoader(dataset, batch_size=64)


class Lh(nn.Module):
    def __init__(self):
        super(Lh, self).__init__()
        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.model1(x)
        return x

loss = nn.CrossEntropyLoss()
lh=Lh()
optis = torch.optim.SGD(lh.parameters(), lr=0.1)

for epoch in range(10):
    running_loss = 0
    for data in dataloader:
        imgs, targets = data
        outputs = lh(imgs)
        result_loss = loss(outputs, targets)

        optis.zero_grad()
        result_loss.backward() # 设置对应的梯度
        optis.step()
        running_loss += result_loss
    print(running_loss)

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

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

相关文章

hive通过外表整合es，超详细过程。

hive通过外表整合es，超详细过程。

参考官网 Apache Hive integration | Elasticsearch for Apache Hadoop [7.17] | Elastic 官网的介绍很简单，我看了很多博客，写的也很简单，但是我搞了半天才勉强成功，分享下，免得各位多走弯路。 环境准备 官网也很…
阅读更多...
论文研读｜生成式文本隐写发展综述

论文研读｜生成式文本隐写发展综述

前言：最近接触了文本隐写这一研究领域，大概率以后深入这个方向开展研究，以下是本人近日对该领域研究现状的调研总结，以及生成式文本隐写代表性工作的相关介绍，便于厘清生成式文本隐写的发展脉络以及探寻未来研究空间。…
阅读更多...
Go学习第三天

Go学习第三天

map的三种声明定义方式 声明map后，一定要make开辟空间，否则会报越界且不能使用 package mainimport "fmt"func main() {// 第一种声明方式// 声明myMap1是一种map类型 key是string value是stringvar myMap1 map[string]string// 判断一下map在…
阅读更多...
接口请求（get、post、head等）详解

接口请求（get、post、head等）详解

一．接口请求的六种常见方式： 1、Get 向特定资源发出请求（请求指定页面信息，并返回实体主体） 2、Post 向指定资源提交数据进行处理请求（提交表单、上传文件），又可能导致新的资源的建…
阅读更多...
【高光谱图像的去噪算法】通过全变异最小化对受激拉曼光谱图像进行去噪研究（Matlab代码实现）

【高光谱图像的去噪算法】通过全变异最小化对受激拉曼光谱图像进行去噪研究（Matlab代码实现）

💥💥💞💞欢迎来到本博客❤️❤️💥💥 🏆博主优势：🌞🌞🌞博客内容尽量做到思维缜密，逻辑清晰，为了方便读者。 ⛳️座右铭&a…
阅读更多...
HCIP 交换综合实验--企业三层架构

HCIP 交换综合实验--企业三层架构

题目 1、内网IP地址使用172.16.0.0/26分配 2、SW1和SW2之间互为备份 3、VRRP/STP/VLAN/Eth-trunk均使用 4、所有PC均通过DHCP获取IP地址 5、ISP只能配置IP地址 6、所有电脑可以正常访问ISP路由器环回 实验步骤 第一步、规划IP地址 R1-R2：100.1.1.0/24 R2-LSW1…
阅读更多...
【远程桌面软件NoMachine】

【远程桌面软件NoMachine】

Remote Access for Everybody 特色：快速、安全、跨平台、免费且简单易用，尤其是在带宽低、速率慢的网络环境下，NoMachine仍能保持良好的性能。 官网地址为：https://www.nomachine.com/
阅读更多...
c++--简单多状态动态规划问题

c++--简单多状态动态规划问题

PS:以下代码均为C实现 1.按摩师 力扣 一个有名的按摩师会收到源源不断的预约请求，每个预约都可以选择接或不接。在每次预约服务之间要有休息时间，因此她不能接受相邻的预约。给定一个预约请求序列，替按摩师找到最优的预约集合（总…
阅读更多...
【JAVA】正则表达式是啥？

【JAVA】正则表达式是啥？

个人主页：【😊个人主页】 系列专栏：【❤️初识JAVA】 文章目录 前言正则表达式正则表达式语法正则表达式的特点捕获组实例 前言 如果我们想要判断给定的字符串是否符合正则表达式的过滤逻辑（称作“匹配”）&#xff0c…
阅读更多...
2023华数杯数学建模C题思路 - 母亲身心健康对婴儿成长的影响

2023华数杯数学建模C题思路 - 母亲身心健康对婴儿成长的影响

# 1 赛题 C 题 母亲身心健康对婴儿成长的影响 母亲是婴儿生命中最重要的人之一，她不仅为婴儿提供营养物质和身体保护， 还为婴儿提供情感支持和安全感。母亲心理健康状态的不良状况，如抑郁、焦虑、 压力等，可能会对婴儿的认知、情…
阅读更多...
搭建 Vite + Vue3 + Pinia + Element Plus 项目。

搭建 Vite + Vue3 + Pinia + Element Plus 项目。

一、基础项目搭建： 开发工具推荐 VS Code 开发，配合插件如下： 插件名功能TypeScript Vue Plugin (Volar)用于 TypeScript 的 Vue 插件Vue Language Features (Volar)Vue3.0 语法支持 1. 创建项目 可以通过附加的命令行选项直接指定项目名…
阅读更多...
第20节 R语言医学分析:某保险医疗事故赔偿因素分析

第20节 R语言医学分析:某保险医疗事故赔偿因素分析

文章目录 某保险医疗事故赔偿因素分析源码源文件下载某保险医疗事故赔偿因素分析 我们分析数据集“诉讼”的第一个方法是确定样本数量、变量类型、缩放/编码约定（如果有）用于验证数据清理。 接下来，数据集看起来很干净，没有缺失值，并且对于分类变量，将编码约定替换为实际…
阅读更多...
LeetCode 热题 100 JavaScript--543. 二叉树的直径

LeetCode 热题 100 JavaScript--543. 二叉树的直径

给你一棵二叉树的根节点，返回该树的 直径 。 二叉树的 直径 是指树中任意两个节点之间最长路径的 长度 。这条路径可能经过也可能不经过根节点 root 。 两节点之间路径的 长度 由它们之间边数表示。 var diameterOfBinaryTree function(root) {var maxDiameter…
阅读更多...
leetcode每日一练-第88题-合并两个有序数组

leetcode每日一练-第88题-合并两个有序数组

一、解题方法 先合并&#xff0c;再排序 二、code class Solution { public:void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {for(int i0;i<n;i){nums1[mi]nums2[i];//将 nums2 中的元素逐个复制到 nums1 的尾部}sort(nums1.beg…
阅读更多...
基于遗传算法的试题组卷（一）

基于遗传算法的试题组卷（一）

基于遗传算法的试题组卷 IT企业每年都会在春季和秋季举行校园招聘&#xff0c;对于个性化定制的试卷需求量很大&#xff0c;如何组出又好又快的定制化试题对于IT企业非常重要。组卷技术主要针对知识点覆盖率&#xff0c;题型&#xff0c;难度系数&#xff0c;试题数量等一些试题…
阅读更多...
为什么感觉 C/C++ 不火了？

为什么感觉 C/C++ 不火了？

首先C和C是两个非常不一样的编程语言。 C语言在系统开发领域地位非常稳固&#xff0c;几乎没有替代产品。应用层开发近年来略微有被Rust取代的迹象。 C由于支持的编程范式过多&#xff0c;导致不同水平的人写出来的代码质量差异太大&#xff0c;这给软件的稳健性带来了很大的…
阅读更多...
C高级_第二讲_shell指令和shell脚本_递归练习

C高级_第二讲_shell指令和shell脚本_递归练习

思维导图 递归实现&#xff0c;输入一个数&#xff0c;输出这个数的每一位 int funh(int num){if(0 num){return 0;}else{funh(num/10);printf("%d\n", num%10);} }int main(int argc, const char *argv[]) {puts("请输入一个数");int num 0;scanf(&quo…
阅读更多...
C++11中的内存模型

C++11中的内存模型

一、几种关系术语 1.1、sequenced-before sequenced-before用于表示同一个线程中&#xff0c;两个操作上的先后顺序&#xff0c;这个顺序是非对称、可以进行传递的关系。 它不仅仅表示两个操作之间的先后顺序&#xff0c;还表示了操作结果之间的可见性关系。两个操作A和操作…
阅读更多...
《长安的荔枝》阅读笔记

《长安的荔枝》阅读笔记

《长安的荔枝》阅读笔记 2023年6月9号在杭州的小屋读完&#xff0c;作者以“一骑红尘妃子笑”的典故&#xff0c;想象拓展出来的荔枝使李善德&#xff0c;为了皇帝要求在贵妃寿辰&#xff0c;六月一号那天要吃到10斤的荔枝。需要从广州运送到长安即如今的西安。本来以为这个差事…
阅读更多...
SequenceDiagram 查看代码时序图的利器，做技术方案必备！

SequenceDiagram 查看代码时序图的利器，做技术方案必备！

前言 “ 无论是快速了解业务流程&#xff0c;还是快速的熟悉系统的业务代码逻辑&#xff0c;以及各个类和方法等的调用关系&#xff0c;时序图无疑是其中一种不可获取的简便快捷的方式。一起来了解下&#xff0c;IDEA如何快速生成时序图吧。” 工作中&#xff0c;经常需要绘制…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023