CNN——VGG

news2024/11/29 6:31:01

1.VGG简介

        论文下载地址：https://arxiv.org/pdf/1409.1556.pdf 

        VGGNet 是由牛津大学视觉几何小组（Visual Geometry Group, VGG）提出的一种深层卷积网络结构，他们以 7.32% 的错误率赢得了 2014 年 ILSVRC 分类任务的亚军（冠军由 GoogLeNet 以 6.65% 的错误率夺得）和 25.32% 的错误率夺得定位任务（Localization）的第一名（GoogLeNet 错误率为 26.44%）。 

        VGG通过vgg块的堆积，VGG19最高让网络达到了16 个卷积层和 3 个全连接层，共计 19 层网络（池化层不带参数，一般不算一层）。这也导致参数量非常的多，模型比较臃肿（第一个全连接层占了非常大一部分）

        包括VGG11，VGG13，VGG16和VGG19，性能依次提升，最常用的是VGG16。

核心点：

  1. 全部使用3×3步长为1的小卷积核。3×3卷积核是最小的能够表示上下左右中心的尺寸。

                        

         假设输入为5×5，使用2次3×3卷积后最终得到1×1的特征图，那么这个1×1的特征图的感受野为5×5。这和直接使用一个5×5卷积核得到1×1的特征图是一样的。也就是说2次3×3卷积可以代替一次5×5卷积同时，2次3×3卷积的参数更少（2×3×3=18<5×5=25）而且会经过两次激活函数进行非线性变换，学习能力会更好。同样的3次3×3卷积可以替代一次7×7的卷积。

        此外步长为1可以不会丢失信息

        2.相同的vgg块堆叠

        3.深度深，且成功证明深度增加可以提高网络性能

2.VGG网络结构详解

        这里以最常用的VGG16为例子。VGG11，VGG13，VGG19都是根据上面的表使用不同的卷积个数。

vgg_block包括若干个3×3卷积（padding=1，stride=1）+激活+2×2池化（padding=0，stride=2）,第一个卷积将通道数翻倍

  • 3×3卷积，padding=1，stride=1，output=(input-3+2×1)/1+1=input，特征图尺寸不变
  • 2×2池化，padding=0，stride=2，output=(input-2)/2+1=1/2input，特征图尺寸减半

1.输入层。224×224×3，RGB图

2.vgg_block1

操作填充步长输入通道数输出通道数输出特征图尺寸
3×3卷积11364224×224
Relu激活//6464224×224
3×3卷积116464224×224
Relu激活//6464224×224
2×2最大池化026464112×112

2.vgg_block2

操作填充步长输入通道数输出通道数输出特征图尺寸
3×3卷积1164128112×112
Relu激活//128128112×112
3×3卷积11128128112×112
Relu激活//128128112×112
2×2最大池化0212812856×56

3.vgg_block3

        从这个块开始卷积变成3次

操作填充步长输入通道数输出通道数输出特征图尺寸
3×3卷积1112825656×56
Relu激活//25625656×56
3×3卷积1125625656×56
Relu激活//25625656×56
3×3卷积1125625656×56
Relu激活//25625656×56
2×2最大池化0225625628×28

4.vgg_block4

操作填充步长输入通道数输出通道数输出特征图尺寸
3×3卷积1125651228×28
Relu激活//51251228×28
3×3卷积1151251228×28
Relu激活//51251228×28
3×3卷积1151251228×28
Relu激活//51251228×28
2×2最大池化0251251214×14

 4.vgg_block5

操作填充步长输入通道数输出通道数输出特征图尺寸
3×3卷积1151251214×14
Relu激活//51251214×14
3×3卷积1151251214×14
Relu激活//51251214×14
3×3卷积1151251214×14
Relu激活//51251214×14
2×2最大池化025125127×7

6.向量化

        flatten，7×7×512(25,088) ->> 1×1×25,088

7.全连接FC1

        1×1×25,088 ->>1×1×4096

8.全连接FC2

        1×1×4096 ->> 1×1×4096

9.全连接FC3（Softmax）

        1×1×4096 ->> 1×1×1000

3.VGGPytorch实现

3.1 手动实现VGG

# 定义VGG块
def vgg_block(num_convs, in_channels, out_channels):
    layers = []  # 初始化一个空列表用于存放层（卷积层和ReLU激活函数）
    for _ in range(num_convs):  # 循环创建指定数量的卷积层和ReLU激活函数
        layers.append(nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1))  # 添加一个卷积层
        layers.append(nn.ReLU(inplace=True))  # 添加一个ReLU激活函数，并在原地执行节省内存
        in_channels = out_channels  # 更新输入通道数为输出通道数，以便下一层使用
    layers.append(nn.MaxPool2d(kernel_size=2, stride=2))  # 添加一个最大池化层
    return nn.Sequential(*layers)  # 返回一个由这些层组成的Sequential模型

# 定义VGG网络
class VGG(nn.Module):
    def __init__(self, cfg, num_classes=1000):
        super(VGG, self).__init__()
        self.conv_layers = self._make_layers(cfg)  # 创建VGG的卷积层部分
        self.fc_layers = nn.Sequential(  # 创建VGG的全连接层部分
            nn.Linear(512 * 7 * 7, 4096),  # 全连接层1
            nn.ReLU(inplace=True),  # ReLU激活函数
            nn.Dropout(),  # Dropout层用于防止过拟合
            nn.Linear(4096, 4096),  # 全连接层2
            nn.ReLU(inplace=True),  # ReLU激活函数
            nn.Dropout(),  # Dropout层用于防止过拟合
            nn.Linear(4096, num_classes)  # 全连接层3，输出类别数
        )
        self.flatten = nn.Flatten()

    def forward(self, x):
        x = self.conv_layers(x)  # 卷积层部分
        x = self.flatten(x)  # 将特征张量展平以输入全连接层
        x = self.fc_layers(x)  # 全连接层部分
        return x

    def _make_layers(self, cfg):
        layers = []  # 初始化一个空列表用于存放VGG的层
        in_channels = 3  # 输入通道数为RGB图像的3通道
        for num_convs, out_channels in cfg:
            layers.append(vgg_block(num_convs, in_channels, out_channels))  # 添加VGG块
            in_channels = out_channels  # 更新输入通道数为输出通道数，以便下一层使用
        return nn.Sequential(*layers)  # 返回一个由VGG块组成的Sequential模型

# 不同版本的VGG配置
cfgs = {
    'VGG11': [(1, 64), (1, 128), (2, 256), (2, 512), (2, 512)],  # VGG11的卷积层配置
    'VGG13': [(2, 64), (2, 128), (2, 256), (2, 512), (2, 512)],  # VGG13的卷积层配置
    'VGG16': [(2, 64), (2, 128), (3, 256), (3, 512), (3, 512)],  # VGG16的卷积层配置
    'VGG19': [(2, 64), (2, 128), (4, 256), (4, 512), (4, 512)]   # VGG19的卷积层配置
}

# 实例化不同版本的VGG
def get_vgg(model_name, num_classes=1000):
    cfg = cfgs[model_name]  # 获取指定版本的VGG配置
    model = VGG(cfg, num_classes)  # 根据配置创建相应版本的VGG模型
    return model  # 返回指定版本的VGG模型

# 实例化不同版本的VGG示例
# vgg11 = get_vgg('VGG11')
# vgg13 = get_vgg('VGG13')
vgg16 = get_vgg('VGG16') # 修改分类数目，vgg16 = get_vgg('VGG16',num_classes=10)
# vgg19 = get_vgg('VGG19')

summary(vgg16.to(device), (3, 224, 224))

 3.2 手动实现VGG16简易版

        还有一个简单易懂的实现方式，如VGG16实现如下。但这种方式如果网络比较深代码就比较冗长了，而且一次只能实现一种模型

# 定义VGG16模型结构
class VGG16(nn.Module):
    def __init__(self, num_classes=1000):
        super(VGG16, self).__init__()
        # 特征层
        self.features = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(64, 128, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(128, 128, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(128, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(256, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )
        
        self.flatten = nn.Flatten()
        
        # 分类层 
        self.classifier = nn.Sequential(
            nn.Linear(512 * 7 * 7, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(4096, num_classes),
        )

    def forward(self, x):
        x = self.features(x)
        x = self.flatten(x)
        x = self.classifier(x)
        return x

  3.2 使用Pytorch自带的VGG

        官方文档：VGG — Torchvision 0.16 documentation (pytorch.org)。Pytorch官方实现了VGG，并且还附带有在ImageNet上预训练权重

        可以看到还有bn版本可选，即在卷积后增加使用了batch-normalization批量归一化。下面是使用的示例：

# 初始化预训练的vgg16模型
modelPre = models.vgg16(weights='DEFAULT')
summary(modelPre.to(device), (3, 224, 224))

        weights='DEFAULT'会默认使用最新最好的权重，或者直接指明weights='IMAGENET1K_V1'，什么模型有什么权重可以直接去官方文档中查看就好。

        除了加入了全局平均池化层之外，其他和我们自己实现的是一样的。全局平均池化层可以支持任意输入尺寸，无论31输出什么尺寸，全部变成7×7

4.VGG在CIFAR-10简单实践 

        所需库

import torch
import torch.nn as nn
from torchsummary import summary
import torch.optim as optim
import torchvision.datasets as datasets
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
from tqdm import tqdm
from torchvision import models
import matplotlib.pyplot as plt

1.修改网络结构

        CIFAR-10输入尺寸为32×32，为了适应该数据集，需要简单修改一下第一层全连接层的输入参数。根据网络结构，尺寸会减半5次，对于224×224来说会降到7，则会降低到1。

        将nn.Linear(512 * 7 * 7, 4096)修改为nn.Linear(512 * 1 * 1, 4096)

# 定义VGG16模型结构
class VGG16(nn.Module):
    def __init__(self, num_classes=1000):
        super(VGG16, self).__init__()
        # 特征层
        self.features = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 64, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(64, 128, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(128, 128, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(128, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(256, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )
        
        self.flatten = nn.Flatten()
        
        # 分类层 
        self.classifier = nn.Sequential(
            #nn.Linear(512 * 7 * 7, 4096),
            nn.Linear(512 * 1 * 1, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(4096, 4096),
            nn.ReLU(inplace=True),
            nn.Dropout(),
            nn.Linear(4096, num_classes),
        )

    def forward(self, x):
        x = self.features(x)
        x = self.flatten(x)
        x = self.classifier(x)
        return x

# 打印模型结构
model = VGG16(num_classes=10).to(device)
summary(model, (3, 32, 32))

2.读取数据集

# 数据预处理
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
])

# 加载CIFAR-10数据集
train_dataset = datasets.CIFAR10(root='./dataset', train=True, download=True, transform=transform)
test_dataset = datasets.CIFAR10(root='./dataset', train=False, download=True, transform=transform)

# 数据加载器
train_dataloader = DataLoader(train_dataset, batch_size=128, shuffle=True)
test_dataloader = DataLoader(test_dataset, batch_size=128, shuffle=False)

3.使用GPU

device = 'cuda' if torch.cuda.is_available() else 'cpu'

4.模型训练

def train(model, lr, epochs, train_dataloader, device, save_path):
    # 将模型放入GPU
    model = model.to(device)
    # 使用交叉熵损失函数
    loss_fn = nn.CrossEntropyLoss().to(device)
    # SGD
    optimizer = torch.optim.SGD(model.parameters(), lr=lr, weight_decay=5e-4, momentum=0.9)
    # 记录训练与验证数据
    train_losses = []
    train_accuracies = []
    # 开始迭代   
    for epoch in range(epochs):   
        # 切换训练模式
        model.train()  
        # 记录变量
        train_loss = 0.0
        correct_train = 0
        total_train = 0
        # 读取训练数据并使用 tqdm 显示进度条
        for i, (inputs, targets) in tqdm(enumerate(train_dataloader), total=len(train_dataloader), desc=f"Epoch {epoch+1}/{epochs}", unit='batch'):
            # 训练数据移入GPU
            inputs = inputs.to(device)
            targets = targets.to(device)
            # 模型预测
            outputs = model(inputs)
            # 计算损失
            loss = loss_fn(outputs, targets)
            # 梯度清零
            optimizer.zero_grad()
            # 反向传播
            loss.backward()
            # 使用优化器优化参数
            optimizer.step()
            # 记录损失
            train_loss += loss.item()
            # 计算训练正确个数
            _, predicted = torch.max(outputs, 1)
            total_train += targets.size(0)
            correct_train += (predicted == targets).sum().item()
        # 计算训练正确率并记录
        train_loss /= len(train_dataloader)
        train_accuracy = correct_train / total_train
        train_losses.append(train_loss)
        train_accuracies.append(train_accuracy)
        # 输出训练信息
        print(f"Epoch [{epoch + 1}/{epochs}] - Train Loss: {train_loss:.4f}, Train Acc: {train_accuracy:.4f}")
    # 绘制损失和正确率曲线
    plt.figure(figsize=(10, 5))
    plt.subplot(1, 2, 1)
    plt.plot(range(epochs), train_losses, label='Training Loss')
    plt.xlabel('Epoch')
    plt.ylabel('Loss')
    plt.legend()
    plt.subplot(1, 2, 2)
    plt.plot(range(epochs), train_accuracies, label='Accuracy')
    plt.xlabel('Epoch')
    plt.ylabel('Accuracy')
    plt.legend()
    plt.tight_layout()
    plt.show()
    torch.save(model.state_dict(), save_path)
model = VGG16(num_classes=10)
lr = 0.01 
epochs = 10
save_path = './modelWeight/VGG16_CIFAR10'
train(model,lr,epochs,train_dataloader,device,save_path)

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

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

相关文章

MindSpore Serving与TGI框架 の 对比

MindSpore Serving与TGI框架 の 对比

一、MindSpore Serving MindSpore Serving是一款轻量级、高性能的服务工具&#xff0c;帮助用户在生产环境中高效部署在线推理服务。 使用MindSpore完成模型训练>导出MindSpore模型&#xff0c;即可使用MindSpore Serving创建该模型的推理服务。 MindSpore Serving包含以…
阅读更多...
C# 2中的一些小特性

C# 2中的一些小特性

一、局部类型 在C#当中有这样一个关键字partial 用来声明类&#xff0c;结构&#xff0c;接口分为多个部分来声明。使用场景可以一部分类中写实例方法&#xff0c;一部分写属性&#xff0c;我在实际工作测试中就是将属性与实际方法是分开的。相互之间的成员互相通用。 举个例子…
阅读更多...
【普中开发板】基于51单片机的篮球计分器液晶LCD1602显示( proteus仿真+程序+设计报告+讲解视频）

【普中开发板】基于51单片机的篮球计分器液晶LCD1602显示( proteus仿真+程序+设计报告+讲解视频）

基于普中开发板51单片机的篮球计分器液晶LCD1602显示 1.主要功能&#xff1a;讲解视频&#xff1a;2.仿真3. 程序代码4. 设计报告5. 设计资料内容清单&&下载链接资料下载链接&#xff08;可点击&#xff09;&#xff1a; 基于51单片机的篮球计分器液晶LCD1602显示 ( pr…
阅读更多...
【水浸传感器】软硬件一体水浸监测整套方案远程监测解决各种环境漏水问题

【水浸传感器】软硬件一体水浸监测整套方案远程监测解决各种环境漏水问题

一、痛点分析 在工业生产中&#xff0c;水浸传感器可以安装在数据中心、半导体厂房、输油管道、车间仓库、变电室等易发生水浸的区域。一旦检测到漏水情况&#xff0c;立即发出信号反馈。然而&#xff0c;水浸传感器分散在各个地点&#xff0c;导致管理不集中、不便捷&#xf…
阅读更多...
关于TypeScript Interface你需要知道的10件事

关于TypeScript Interface你需要知道的10件事

TypeScript接口的10种使用场景——可能只有20%的web开发人员完全掌握它们 TypeScript中的接口是一个非常灵活的概念。除了抽象类的部分行为外&#xff0c;它还经常用于描述“对象的形状”。 必需的属性 在定义接口时&#xff0c;需要使用 interface 关键字: interface Use…
阅读更多...
流量困境下，2024年餐饮商家的直播带货生意到底怎么做？

流量困境下，2024年餐饮商家的直播带货生意到底怎么做？

据官方数据显示&#xff0c;截至2023年2月&#xff0c;抖音生活服务餐饮商家直播间数量达到43万&#xff0c;2023年7月&#xff0c;抖音生活服务餐饮行业自播商家数较1月增长134%。可以说&#xff0c;直播带货已经成为餐饮商家的常态化的线上营销模式&#xff0c;也成为各大餐饮…
阅读更多...
SwiftUI之深入解析ContentUnavailableView的实战应用

SwiftUI之深入解析ContentUnavailableView的实战应用

一、基本用法 SwiftUI 引入了新的 ContentUnavailableView 类型&#xff0c;允许在应用程序中展示空状态、错误状态或任何其他内容不可用的状态。那么&#xff0c;如何使用 ContentUnavailableView 引导用户浏览应用程序中的空状态呢&#xff1f;首先看看 ContentUnavailableV…
阅读更多...
redis服务迁移数据工具--RDM

redis服务迁移数据工具--RDM

一、背景&#xff1a; 在日常的运维工作经常遇见各种数据迁移工作&#xff0c;例如mysql数据库迁移、redis数据库迁移、minio数据迁移等等工作。这里介绍一下redis数据库的迁移过程。 二、迁移思路&#xff1a; redis服务/集群的数据迁移思路是需要新建一个配置、密码一样的re…
阅读更多...
NX/UG二次开发—C\C++开发单个DLL支持多版本NX一种方法

NX/UG二次开发—C\C++开发单个DLL支持多版本NX一种方法

1、去除附加包含目录下的NX相关的lib文件&#xff1a; 2、从对应的dll导出ufun函数和NXopen函数&#xff1a; libufun.dll; libufun_cam.dll; libufun_cae.dll; libufun_die.dll; libufun_vdac.dll; libufun_weld.dll; libugopenint.dll; libugopenint_cae.dll; libugopenint_…
阅读更多...
感知与认知的碰撞，大模型时代的智能文档处理范式

感知与认知的碰撞，大模型时代的智能文档处理范式

目录 0 写在前面1 GPT4-V&#xff1a;拓宽文档认知边界2 大语言模型的文档感知缺陷3 大一统文档图像处理范式3.1 像素级OCR任务3.2 OCR大一统模型3.3 长文档理解与应用 4 总结抽奖福利 0 写在前面 由中国图象图形学学会青年工作委员会发起的第十九届中国图象图形学学会青年科学…
阅读更多...
Java重修第一天—学习数组

Java重修第一天—学习数组

1. 认识数组 建议1.5倍速学习&#xff0c;并且关闭弹幕。 数组的定义&#xff1a;数组是一个容器&#xff0c;用来存储一批同种类型的数据。 下述图&#xff1a;是生成数字数组和字符串数组。 为什么有了变量还需要定义数组呢&#xff1f;为了解决在某些场景下&#xff0c;变…
阅读更多...
chromium在中文用户名下无法编译的问题

chromium在中文用户名下无法编译的问题

新电脑没有太注意&#xff0c;起用户名的时候用了中文。 在编译chromium104的代码时&#xff0c;因为环境变量有中文导致编译失败&#xff1a; 因为我的电脑默认是使用gbk编码&#xff0c;而不是utf-8编码。 这个问题有三种解决办法&#xff1a; &#xff08;一&#xff09;把…
阅读更多...
【Spark精讲】Spark on Hive性能优化

【Spark精讲】Spark on Hive性能优化

目录 第一章 1.1 集群配置概述 1.2 集群规划概述 第二章 Yarn配置 2.1 Yarn配置说明 yarn.nodemanager.resource.memory-mb yarn.nodemanager.resource.cpu-vcores yarn.scheduler.maximum-allocation-mb yarn.scheduler.minimum-allocation-mb 第三章 Spark的配置说…
阅读更多...
在Ubuntu22.04上部署Stable Diffusion

在Ubuntu22.04上部署Stable Diffusion

在AI绘画软件领域Stable-Diffusion&#xff08;简称SD&#xff09;在开源领域绝对是不二之选&#xff0c;他的插件方式可以让此软件具有更多的功能&#xff0c;开发者社群为此提供了大量免费高质量的外接预训练模型&#xff08;fine-tune&#xff09;和插件&#xff0c;并持续维…
阅读更多...
深耕汽车检测设备领域，引领行业技术革新

深耕汽车检测设备领域，引领行业技术革新

在汽车工业飞速发展的今天&#xff0c;汽车检测技术作为保障车辆安全、提升维修效率的重要手段&#xff0c;日益受到行业内外的高度关注。康士柏汽车检测线设备厂家&#xff0c;作为这一领域的佼佼者&#xff0c;凭借其深厚的技术积累和卓越的产品品质&#xff0c;正引领着行业…
阅读更多...
傅里叶级数、傅里叶变换、小波变换、离散余弦变换的理解

傅里叶级数、傅里叶变换、小波变换、离散余弦变换的理解

目录 1. 傅里叶级数2.傅里叶变换 1. 傅里叶级数 功能&#xff1a;能把任意周期性函数展开成一系列正弦、余弦函数的和。 公式&#xff1a; f ( x ) a 0 2 ∑ n 1 ∞ ( a n cos ⁡ ( 2 π n x T ) b n sin ⁡ ( 2 π n x T ) ) 傅里叶系数 a n 2 T ∫ x 0 x 0 T f ( x )…
阅读更多...
即时设计：一键查看设计稿与页面差异，让设计师的工作更便捷高效

即时设计：一键查看设计稿与页面差异，让设计师的工作更便捷高效

设计稿走查 在设计工作中&#xff0c;对设计稿和实际页面进行对比是必不可少的环节。然而&#xff0c;传统的对比方式往往耗时耗力&#xff0c;无法精确测量差异。为了解决这个问题&#xff0c;我们推出了一款强大的工具&#xff0c;它可以通过图片对比&#xff0c;轻松查看设…
阅读更多...
【ESP32接入语言大模型之通义千问】

【ESP32接入语言大模型之通义千问】

1. 通义千问 讲解视频&#xff1a; ESP32接入语言大模型之通义千问 随着人工智能技术的不断发展&#xff0c;自然语言处理领域也得到了广泛的关注和应用。通义千问由阿里云开发&#xff0c;目标是帮助用户获得准确、有用的信息&#xff0c;解决他们的问题和困惑&#xff0c;也…
阅读更多...
Debian12使用Xshell连接失败解决办法详细

Debian12使用Xshell连接失败解决办法详细

1、Debian开启ssh服务 sudo apt update -y sudo apt install ssh2、编辑配置文件 # 安装vim sudo apt install vimvim /etc/ssh/sshd_config3、将#PermitRootLogin prohibit-password的注释去掉&#xff0c;设置为yes 4、将#PasswordAuthentication no的注释去掉&#xff0c;…
阅读更多...
爬虫工具（tkinter+scrapy+pyinstaller）

爬虫工具（tkinter+scrapy+pyinstaller）

需求介绍输入&#xff1a;关键字文件&#xff0c;每一行数据为一爬取单元。若一行存在多个and关系的关键字 &#xff0c;则用|隔开处理&#xff1a;爬取访问6个网站的推送&#xff0c;获取推送内容的标题&#xff0c;发布时间&#xff0c;来源&#xff0c;正文第一段&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023