Pytorch损失函数、反向传播和优化器、Sequential使用

Pytorch_Sequential使用、损失函数、反向传播和优化器

文章目录

    • nn.Sequential
    • 搭建小实战
    • 损失函数与反向传播
    • 优化器

nn.Sequential

nn.Sequential是一个有序的容器，用于搭建神经网络的模块被按照被传入构造器的顺序添加到nn.Sequential()容器中。

在这里插入图片描述

在这里插入图片描述

import torch.nn  as nn
from collections import OrderedDict
# Using Sequential to create a small model. When `model` is run,
# input will first be passed to `Conv2d(1,20,5)`. The output of
# `Conv2d(1,20,5)` will be used as the input to the first
# `ReLU`; the output of the first `ReLU` will become the input
# for `Conv2d(20,64,5)`. Finally, the output of
# `Conv2d(20,64,5)` will be used as input to the second `ReLU`
model = nn.Sequential(
          nn.Conv2d(1,20,5),
          nn.ReLU(),
          nn.Conv2d(20,64,5),
          nn.ReLU()
        )

# Using Sequential with OrderedDict. This is functionally the
# same as the above code
model = nn.Sequential(OrderedDict([
          ('conv1', nn.Conv2d(1,20,5)),
          ('relu1', nn.ReLU()),
          ('conv2', nn.Conv2d(20,64,5)),
          ('relu2', nn.ReLU())
        ]))
print(model)

Sequential(
  (conv1): Conv2d(1, 20, kernel_size=(5, 5), stride=(1, 1))
  (relu1): ReLU()
  (conv2): Conv2d(20, 64, kernel_size=(5, 5), stride=(1, 1))
  (relu2): ReLU()
)

搭建小实战

还是以 C I F A R − 10 m o d e l CIFAR-10 model CIFAR−10model为例

在这里插入图片描述

  1. 输入图像是3通道的32×32的
  2. 先后经过卷积层(5×5的卷积核)
  3. 最大池化层(2×2的池化核)
  4. 卷积层(5×5的卷积核)
  5. 最大池化层(2×2的池化核)
  6. 卷积层(5×5的卷积核)
  7. 最大池化层(2×2的池化核)
  8. 拉直(flatten)
  9. 全连接层的处理，
  10. 最后输出的大小为10

基于以上的介绍，后续将利用Pytorch构建模型，实现 C I F A R − 10 m o d e l s t r u c t u r e CIFAR-10 \quad model \quad structure CIFAR−10modelstructure

参数说明：in_channels: int、out_channels: int,kernel_size: Union由input、特征图以及卷积核即可看出，而stride、padding需要通过公式计算得到。

特得到的具体的特征图尺寸的计算公式如下:
在这里插入图片描述

inputs : 3@32x32，3通道32x32的图片,5*5的kernel --> 特征图(Feature maps) : 32@32x32

即经过32个3@5x5的卷积层，输出尺寸没有变化（有x个卷积核即由x个卷积核，卷积核的通道数与输入的通道数相等）

由上述的计算公式来计算出 s t r i d e stride stride和 p a d d i n g padding padding

在这里插入图片描述

卷积层中的stride默认为1

池化层中的stride默认为kernel_size的大小

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

class BS(nn.Module):

    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(in_channels=3,
                               out_channels=32,
                               kernel_size=5,
                               stride=1,
                               padding=2)  #stride和padding计算得到
        self.maxpool1 = nn.MaxPool2d(kernel_size=2)
        self.conv2 = nn.Conv2d(in_channels=32,
                               out_channels=32,
                               kernel_size=5,
                               stride=1,
                               padding=2)
        self.maxpool2 = nn.MaxPool2d(kernel_size=2)
        self.conv3 = nn.Conv2d(in_channels=32,
                               out_channels=64,
                               kernel_size=5,
                               padding=2)
        self.maxpool3 = nn.MaxPool2d(kernel_size=2)
        self.flatten = nn.Flatten()  #变为63*4*4=1024
        self.linear1 = nn.Linear(in_features=1024, out_features=64)
        self.linear2 = nn.Linear(in_features=64, out_features=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)
        return x
    
bs = BS()
bs

BS(
  (conv1): Conv2d(3, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
  (maxpool1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
  (maxpool2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv3): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
  (maxpool3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (flatten): Flatten(start_dim=1, end_dim=-1)
  (linear1): Linear(in_features=1024, out_features=64, bias=True)
  (linear2): Linear(in_features=64, out_features=10, bias=True)
)

利用Sequential优化代码，并在tensorboard显示

.add_graph函数用于将PyTorch模型图添加到TensorBoard中。通过这个函数，您可以以可视化的方式展示模型的计算图，使其他人更容易理解您的模型结构和工作流程。

add_graph(model, input_to_model, strip_default_attributes=True)
  • model：要添加的PyTorch模型。
  • input_to_model：用于生成模型图的输入数据。
  • strip_default_attributes：是否删除模型中的默认属性，默认为True。
class BS(nn.Module):

    def __init__(self):
        super().__init__()
        self.model = nn.Sequential(
            nn.Conv2d(in_channels=3,
                               out_channels=32,
                               kernel_size=5,
                               stride=1,
                               padding=2),  #stride和padding计算得到
            nn.MaxPool2d(kernel_size=2),
            nn.Conv2d(in_channels=32,
                                   out_channels=32,
                                   kernel_size=5,
                                   stride=1,
                                   padding=2),
            nn.MaxPool2d(kernel_size=2),
            nn.Conv2d(in_channels=32,
                                   out_channels=64,
                                   kernel_size=5,
                                   padding=2),
            nn.MaxPool2d(kernel_size=2),
            nn.Flatten(),  #变为64*4*4=1024
            nn.Linear(in_features=1024, out_features=64),
            nn.Linear(in_features=64, out_features=10),
        )
    
    def forward(self,x):
        x = self.model(x)
        return x
    
bs = BS()
print(bs)

BS(
  (model): Sequential(
    (0): Conv2d(3, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (2): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (4): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (6): Flatten(start_dim=1, end_dim=-1)
    (7): Linear(in_features=1024, out_features=64, bias=True)
    (8): Linear(in_features=64, out_features=10, bias=True)
  )
)

# 在tensorboard中显示
input_ = torch.ones((64,3,32,32))
writer = SummaryWriter(".logs")
writer.add_graph(bs, input_)  # 定义的模型，数据
writer.close()

利用tensorboard可视化网络结构graph如下
在这里插入图片描述

损失函数与反向传播

计算模型目标输出和实际输出之间的误差。并通过反向传播算法更新模型的权重和参数，以减小预测输出和实际输出之间的误差。

  • 计算实际输出和目标输出之间的差距
  • 为更新输出提供一定依据(反向传播)

不同的模型用的损失函数一般也不一样。
在这里插入图片描述

平均绝对误差MAE Mean Absolute Error

torch.nn.L1Loss(size_average=None, reduce=None, reduction=‘mean’)

在这里插入图片描述

import torch
import torch.nn as nn
# 实例化
criterion1 = nn.L1Loss(reduction='mean')#mean
criterion2 = nn.L1Loss(reduction="sum")#sum
output = torch.tensor([1.0, 2.0, 3.0])#或dtype=torch.float32
target = torch.tensor([2.0, 2.0, 2.0])#或dtype=torch.float32
# 平均值损失值
loss = criterion1(output, target)
print(loss)  # 输出：tensor(0.6667)
# 误差和
loss1 = criterion2(output,target)
print(loss1) # tensor(2.)

tensor(0.6667)
tensor(2.)

loss = nn.L1Loss()
input = torch.randn(3, 5, requires_grad=True)
target = torch.randn(3, 5)
output = loss(input, target)
output.backward()
output

tensor(1.0721, grad_fn=<MeanBackward0>)

均方误差MSE Mean-Square Error
在这里插入图片描述

torch.nn.MSELoss(size_average=None, reduce=None, reduction=‘mean’)

在这里插入图片描述

import torch.nn as nn
# 实例化
criterion1 = nn.MSELoss(reduction='mean')
criterion2 = nn.MSELoss(reduction="sum")
output = torch.tensor([1, 2, 3],dtype=torch.float32)
target = torch.tensor([1, 2, 5],dtype=torch.float32)
# 平均值损失值
loss = criterion1(output, target)
print(loss)  # 输出：tensor(1.3333)
# 误差和
loss1 = criterion2(output,target)
print(loss1) # tensor(4.)

tensor(1.3333)
tensor(4.)

交叉熵损失 CrossEntropyLoss

torch.nn.CrossEntropyLoss(weight=None,size_average=None,ignore_index=-100,reduce=None,reduction='mean',label_smoothing=0.0)

当你有一个不平衡的训练集时，这是特别有用的
在这里插入图片描述

import torch
import torch.nn as nn

# 设置三分类问题，假设是人的概率是0.1，狗的概率是0.2，猫的概率是0.3
x = torch.tensor([0.1, 0.2, 0.3])
print(x)
y = torch.tensor([1]) # 设目标标签为1，即0.2狗对应的标签,目标标签张量y
x = torch.reshape(x, (1, 3))  # tensor([[0.1000, 0.2000, 0.3000]]),批次大小为1，分类数3，即为3分类
print(x)
print(y)
# 实例化对象
loss_cross = nn.CrossEntropyLoss()
# 计算结果
result_cross = loss_cross(x, y)
print(result_cross)

tensor([0.1000, 0.2000, 0.3000])
tensor([[0.1000, 0.2000, 0.3000]])
tensor([1])
tensor(1.1019)

import torch
import torchvision
from torch.utils.data import DataLoader

# 准备数据集
dataset = torchvision.datasets.CIFAR10(root="dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)
# 数据集加载器
dataloader = DataLoader(dataset, batch_size=1)
"""
输入图像是3通道的32×32的，
先后经过卷积层(5×5的卷积核)、
最大池化层(2×2的池化核)、
卷积层(5×5的卷积核)、
最大池化层(2×2的池化核)、
卷积层(5×5的卷积核)、
最大池化层(2×2的池化核)、
拉直、
全连接层的处理，
最后输出的大小为10
"""

# 搭建神经网络
class BS(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = nn.Sequential(
            nn.Conv2d(in_channels=3,
                      out_channels=32,
                      kernel_size=5,
                      stride=1,
                      padding=2),  #stride和padding计算得到
            nn.MaxPool2d(kernel_size=2),
            nn.Conv2d(in_channels=32,
                      out_channels=32,
                      kernel_size=5,
                      stride=1,
                      padding=2),
            nn.MaxPool2d(kernel_size=2),
            nn.Conv2d(in_channels=32,
                      out_channels=64,
                      kernel_size=5,
                      padding=2),
            nn.MaxPool2d(kernel_size=2),
            nn.Flatten(),  #变为64*4*4=1024
            nn.Linear(in_features=1024, out_features=64),
            nn.Linear(in_features=64, out_features=10),
        )

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


# 实例化
bs = BS()
loss = torch.nn.CrossEntropyLoss()
# 对每一张图片进行CrossEntropyLoss损失函数计算
# 使用损失函数loss计算预测结果和目标标签之间的交叉熵损失

for inputs,labels in dataloader:
    outputs = bs(inputs)
    result = loss(outputs,labels)
    print(result)



tensor(2.3497, grad_fn=<NllLossBackward0>)
tensor(2.2470, grad_fn=<NllLossBackward0>)
tensor(2.2408, grad_fn=<NllLossBackward0>)
tensor(2.2437, grad_fn=<NllLossBackward0>)
tensor(2.3121, grad_fn=<NllLossBackward0>)
........

优化器

优化器(Optimizer)是用于更新神经网络参数的工具

它根据计算得到的损失函数的梯度来调整模型的参数，以最小化损失函数并改善模型的性能

在这里插入图片描述
常见的优化器包括:SGD、Adam

optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

model.parameters()用于获取模型的可学习参数

learning rate,lr表示学习率，即每次参数更新的步长

在每个训练批次中，需要执行以下操作:

  1. 输入训练数据到模型中，进行前向传播

  2. 根据损失函数计算损失

  3. 调用优化器的zero_grad()方法清零之前的梯度

  4. 调用backward()方法进行反向传播，计算梯度

  5. 调用优化器的step()方法更新模型参数

伪代码如下(运行不了的)

import torch
import torch.optim as optim

# Step 1: 定义模型
model = ...
# Step 2: 定义优化器
optimizer = optim.SGD(model.parameters(), lr=0.01)
# Step 3: 定义损失函数
criterion = ...
# Step 4: 训练循环
for inputs, labels in dataloader:
    # 前向传播
    outputs = model(inputs)

    # 计算损失
    loss = criterion(outputs, labels)

    # 清零梯度
    optimizer.zero_grad()

    # 反向传播,得到梯度
    loss.backward()

    # 更新参数，根据梯度就行优化
    optimizer.step()

在上述模型代码中，SGD作为优化器，lr为0.01。同时根据具体任务选择适合的损失函数，例如torch.nn.CrossEntropyLoss、torch.nn.MSELoss等，以CIFRA10为例

import torch
import torch.optim as optim
import torchvision
from torch.utils.data import DataLoader

dataset = torchvision.datasets.CIFAR10(root="dataset", train=False, transform=torchvision.transforms.ToTensor(),download=True)
dataloader = DataLoader(dataset,batch_size=1)

class BS(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = nn.Sequential(
            nn.Conv2d(in_channels=3,
                      out_channels=32,
                      kernel_size=5,
                      stride=1,
                      padding=2),  #stride和padding计算得到
            nn.MaxPool2d(kernel_size=2),
            nn.Conv2d(in_channels=32,
                      out_channels=32,
                      kernel_size=5,
                      stride=1,
                      padding=2),
            nn.MaxPool2d(kernel_size=2),
            nn.Conv2d(in_channels=32,
                      out_channels=64,
                      kernel_size=5,
                      padding=2),
            nn.MaxPool2d(kernel_size=2),
            nn.Flatten(),  #变为64*4*4=1024
            nn.Linear(in_features=1024, out_features=64),
            nn.Linear(in_features=64, out_features=10),
        )

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


model = BS()  #定义model
optimizer = optim.SGD(model.parameters(), lr=0.01)  #定义优化器SGD
criterion = nn.CrossEntropyLoss()  #定义损失函数，交叉熵损失函数

'''循环一次，只对数据就行了一轮的学习'''
for inputs, labels in dataloader:
    # 前向传播
    outputs = model(inputs)
    # 计算损失
    loss = criterion(outputs, labels)
    # 清零梯度
    optimizer.zero_grad()
    # 反向传播
    loss.backward()
    # 更新参数
    optimizer.step()
    # 打印经过优化器后的结果
    print(loss)
    
"""训练循环20次"""
# for epoch in range(20):
#     running_loss = 0.0
#     for inputs, labels in dataloader:
#         # 前向传播
#         outputs = model(inputs)
#         # 计算损失
#         loss = criterion(outputs,labels)
#         # 清零梯度
#         optimizer.zero_grad()
#         # 反向传播
#         loss.backward()
#         # 更新参数
#         optimizer.step()
#         # 打印经过优化器后的结果
#         running_loss = running_loss + loss
#     print(running_loss)

Files already downloaded and verified
tensor(2.3942, grad_fn=<NllLossBackward0>)
tensor(2.2891, grad_fn=<NllLossBackward0>)
tensor(2.2345, grad_fn=<NllLossBackward0>)
tensor(2.2888, grad_fn=<NllLossBackward0>)
tensor(2.2786, grad_fn=<NllLossBackward0>)
........

在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

不可思议，才一周，阅读量就突破千万了

不可思议，才一周，阅读量就突破千万了

这段时间&#xff0c;我发布的文章阅读量看上去还算可以&#xff0c;但我知道&#xff0c;这并不是终点&#xff0c;而是起点。我深知&#xff0c;写作的道路永无止境&#xff0c;只有不断努力&#xff0c;才能在文字的海洋中游得更远。 在这条道路上&#xff0c;我始终坚持用心…
阅读更多...
学习率范围测试（LR Finder）脚本

学习率范围测试（LR Finder）脚本

简介 深度学习中的学习率是模型训练中至关重要的超参数之一。合适的学习率可以加速模型的收敛&#xff0c;提高训练效率&#xff0c;而不恰当的学习率可能导致训练过慢或者无法收敛。为了找到合适的学习率&#xff0c;LR Finder成为了一种强大的工具。 学习率范围测试&#x…
阅读更多...
springboot项目基本配置

springboot项目基本配置

接口入口日志 参数校验 业务逻辑执行 异常捕获-统一异常处理 统一数据返回体 接口返回日志 使用的是springboot2.x版本。 Mybatisplus 官网地址&#xff1a;https://baomidou.com/ 导入依赖 <dependency><groupId>com.baomidou</groupId><artifactId&g…
阅读更多...
前端工具nvm实现node自由

前端工具nvm实现node自由

node的自由之路 前言 大家使用vue框架开发的朋友可能会遇到首次运行公司项目环境的时候&#xff0c;会出现使用npm install命令安装依赖包的时候出现各种各样的问题&#xff0c;其中很重要的一个错误原因就是因为你的nodejs版本和当时搭建环境的版本不一致造成的。今天就来给…
阅读更多...
c语言-数据结构-栈和队列的实现和解析

c语言-数据结构-栈和队列的实现和解析

目录 一、栈 1、栈的概念 1.2 栈的结构 2、栈的创建及初始化 3、压栈操作 4、出栈操作 5、显示栈顶元素 6、显示栈空间内元素的总个数 7、释放栈空间 8、测试栈 二、队列 1、队列的概念 1.2 队列的结构 2、队列的创建及初始化 3、入队 4、出队 5、显示队头、队…
阅读更多...
creo之混合和扫描混合

creo之混合和扫描混合

案例一&#xff1a;杯子 步骤&#xff1a; 在top平面画一个草图圆角矩形&#xff1a; 然后形状–》混合 然后绘制新增的截面2&#xff1a; 用中心线将圆分割成八分&#xff0c;因为底部的圆角矩形是八份线段组成&#xff0c;所以我们要和他一样分成八份&#xff1a;先画中心线…
阅读更多...
详解Java：抽象类和接口

详解Java：抽象类和接口

前言&#xff1a;在前文中我们学习认知到了多态的使用和相关知识&#xff0c;算是打开了Java世界的大门&#xff0c;而本次要分享的抽象类和接口则是我们在面向对象编程中最常用的编程结构之一 目录 一.抽象类 abstract 抽象类特性 二.接口 语法规则 接口使用 接口特…
阅读更多...
第十七章jQuery中的事件与动画

第十七章jQuery中的事件与动画

一。常用事件&#xff1a; 1.鼠标事件&#xff1a; mouseover()&#xff1a;在鼠标进入内容后一直显示事件 mouseout()&#xff1a;在鼠标离开内容后一直显示事件 mouseenter()&#xff1a;在进入刹那间显示事件 mouseleave()&#xff1a;在退出刹那间显示事件 案例&#xf…
阅读更多...
windows系统升级powershell7

windows系统升级powershell7

利用winget在线升级脚本 REM --accept-package-agreements 接受包的所有许可协议 REM --accept-source-agreements 在源操作期间接受所有源协议 winget install Microsoft.PowerShell --accept-source-agreements 应该在路径C:\Program Files\PowerShel…
阅读更多...
功能案例 -- 拖拽上传文件,生成缩略图

功能案例 -- 拖拽上传文件,生成缩略图

直接看效果 实现代码 <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, initial-scale1.0"><title>拖拽上传文件</title>&l…
阅读更多...
两个序列（数论）

两个序列（数论）

两个序列 Problem:B Time Limit:1000ms Memory Limit:65535K Description Gugu 有两个长度无限长的序列A,BA0a^0/0!,A1a^1/1!,A2a^2/2!,A3a^3/3!…. B00, B1b^1/1!,B20,B3b^3/3!,B40, B5b^5/5! … Douge 看到这道这两个序列很觉得很麻烦&#xff0c;所以他想到一个好点子&…
阅读更多...
EMNLP 2023 | 基于知识图谱嵌入的关系感知集成学习算法

EMNLP 2023 | 基于知识图谱嵌入的关系感知集成学习算法

©PaperWeekly 原创 作者 | 黄鉦皓 单位 | 清华大学 研究方向 | 图神经网络 本文介绍《基于知识图谱嵌入的关系感知集成学习算法》&#xff08;Relation-aware Ensemble Learning for Knowledge Graph Embedding&#xff09;&#xff0c;该论文提出的 RelEns-DSC 方法针对…
阅读更多...
【Springboot】基于注解式开发Springboot-Vue3整合Mybatis-plus实现分页查询(一)——后端实现思路

【Springboot】基于注解式开发Springboot-Vue3整合Mybatis-plus实现分页查询(一)——后端实现思路

系列文章目录 基于注解式开发Springboot-Vue3整合Mybatis-plus实现分页查询(二&#xff09;——前端el-pagination实现 文章目录 系列文章目录系统版本实现功能操作步骤1. 新建Mybatis的全局分页配置文件2. 编写OrderMapper :继承Mybatis-plus提供的BaseMapper3. 编写OrderSer…
阅读更多...
Python---字典---dict

Python---字典---dict

1、为什么需要字典 如果想要存储一个人的信息&#xff0c;姓名&#xff1a;Tom&#xff0c;年龄&#xff1a;20周岁&#xff0c;性别&#xff1a;男&#xff0c;如何快速存储。 person [Tom, 20, 男] 在日常生活中&#xff0c;姓名、年龄以及性别同属于一个人的基本特征。 但…
阅读更多...
【哈夫曼树的构造】

【哈夫曼树的构造】

文章目录 如何构造哈夫曼树哈夫曼树构造算法的实现 如何构造哈夫曼树 哈夫曼算法口诀&#xff1a; 1.构造森林全是根&#xff1b;2.选用两小造新树&#xff1b; 3.删除两小添新人&#xff1b;4.重复2,3剩单根&#xff1b; 例&#xff1a;有4个新结点a,b,c,d&#xff0c;权值为…
阅读更多...
upload-labs关卡7(基于黑名单的空格绕过)通关思路

upload-labs关卡7(基于黑名单的空格绕过)通关思路

文章目录 前言一、回顾上一关知识点二、靶场第七关通关思路1、看源代码2、空格绕过3、检查文件是否成功上传 总结 前言 此文章只用于学习和反思巩固文件上传漏洞知识&#xff0c;禁止用于做非法攻击。注意靶场是可以练习的平台&#xff0c;不能随意去尚未授权的网站做渗透测试…
阅读更多...
【Python】二维码和条形码的识别

【Python】二维码和条形码的识别

我主要的问题就在于无法识别图片 注意事项&#xff1a; 1、从文件中加载图像的时候注意图片尽量用英文来命名&#xff0c;因为中文无法识别到图片 2、使用绝对地址的时候要用两个双斜杠&#xff0c;因为用一个会被识别为Unicode 转义&#xff0c;但是并没有后续的合法 Unico…
阅读更多...
matlab simulink PSO算法优化simulink的PID参数

matlab simulink PSO算法优化simulink的PID参数

1、内容简介 略 13-可以交流、咨询、答疑 PSO算法优化simulink的PID参数 2、内容说明 标准的PSO算法优化simulink的PID参数 PSO、粒子群算法、simulink参数优化 3、仿真分析 4、参考论文 略 链接&#xff1a;https://pan.baidu.com/s/1yQ1yDfk-_Qnq7tGpa23L7g 提取码&…
阅读更多...
docker安装RocketMQ

docker安装RocketMQ

1、RocketMQ基本概念 1.1 消息模型&#xff08;Message Model&#xff09; RocketMQ主要由Producer、Broker、Consumer三部分组成&#xff0c;其中Producer负责生产消息&#xff0c;Consumer负责消费消息&#xff0c;Broker负责存储消息。Broker在实际部署过程中对应一台服务…
阅读更多...
node实战——koa实现文件下载和图片/pdf/视频预览（node后端储备知识）

node实战——koa实现文件下载和图片/pdf/视频预览（node后端储备知识）

文章目录 ⭐前言⭐koa-send库实现下载⭐mime-types库实现图片预览&#x1f496; 渲染图片&#x1f496;渲染404&#x1f496;预览pdf&#x1f496;预览视频 ⭐总结⭐结束 ⭐前言 大家好&#xff0c;我是yma16&#xff0c;本文分享关于node实战——koa实现文件下载和图片预览。…
阅读更多...
最新文章

Copyright @ 2022~2023