CNN——VGG

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)

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

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

相关文章

2023-2024 年广东省职业院校技能大赛高职组 “软件测试”赛项竞赛规程

2023-2024 年广东省职业院校技能大赛高职组 “软件测试”赛项竞赛规程

2023-2024 年广东省职业院校技能大赛&#xff08;高职组&#xff09; “软件测试”赛项竞赛规程 一、赛项信息 赛项名称&#xff1a;软件测试 赛项编号&#xff1a;GZ034 赛项组别&#xff1a;高职组 二、竞赛目标 软件是新一代信息技术的灵魂&#xff0c;是数字经济发展的基础…
阅读更多...
Java 泛型深入解析

Java 泛型深入解析

Java 中的泛型是一种强大的编程特性&#xff0c;允许我们编写更加通用和类型安全的代码。本篇博客将深入探讨 Java 泛型的各个方面&#xff0c;包括泛型类、泛型方法、泛型接口以及泛型通配符。 1. 泛型类 首先&#xff0c;让我们看一个简单的泛型类的例子。在下面的代码中&a…
阅读更多...
云原生架构未来发展趋势，探索容器技术未来的发展趋势

云原生架构未来发展趋势，探索容器技术未来的发展趋势

云原生架构未来发展趋势&#xff0c;探索容器技术未来的发展趋势 云原生架构未来发展趋势容器技术发展趋势无处不在的计算催生新一代容器实现深入分布式云&#xff08;从多云/混合云&#xff0c;到分布式云&#xff09;云原生操作系统Kubernetes已经成为云时代的操作系统从无状…
阅读更多...
【开源】基于JAVA语言的高校宿舍调配管理系统

【开源】基于JAVA语言的高校宿舍调配管理系统

目录 一、摘要1.1 项目介绍1.2 项目录屏 二、功能需求2.1 学生端2.2 宿管2.3 老师端 三、系统展示四、核心代码4.1 查询单条个人习惯4.2 查询我的室友4.3 查询宿舍4.4 查询指定性别全部宿舍4.5 初次分配宿舍 五、免责说明 一、摘要 1.1 项目介绍 基于JAVAVueSpringBootMySQL的…
阅读更多...
10+免费图片素材/壁纸网站，搭一些图片处理工具，快收藏！

10+免费图片素材/壁纸网站，搭一些图片处理工具，快收藏！

划到最后“阅读原文”——领取工具包&#xff08;超过1000工具&#xff0c;免费素材网站分享和行业报告&#xff09; Hi&#xff0c;我是胡猛夫~&#xff0c;专注于分享各类价值网站、高效工具&#xff01; 更多资源&#xff0c;更多内容&#xff0c;欢迎交流&#xff01;公 号…
阅读更多...
计算机网络（10）：下一代因特网

计算机网络（10）：下一代因特网

下一代网际协议 IPv6(IPng) 解决IP地址耗尽的措施 要解决IP地址耗尽的问题&#xff0c;可以采用以下三个措施&#xff1a; (1)采用无分类编址CIDR&#xff0c;使IP地址的分配更加合理。 (2)采用网络地址转换NAT方法&#xff0c;可节省许多全球IP地址。 (3)采用具有更大地址空…
阅读更多...
chromium在中文用户名下无法编译的问题

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

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

synchronized锁的底层原理

synchronized 锁是 Java 中用于实现线程同步的关键字。它提供了一种简单而有效的方式来确保多个线程之间的互斥访问。底层原理可以通过 Java 的内存模型和对象监视器锁&#xff08;Monitor Lock&#xff09;来理解。 Monitor结构如下&#xff1a; 在 Java 的内存模型中&#x…
阅读更多...
微服务注册中心之Eureka

微服务注册中心之Eureka

微服务注册中心之Eureka eureka 搭建集群 版本说明 Spring Boot 2.1.7.RELEASE spring-cloud-starter-netflix-eureka-server Finchley.SR2 spring-boot-starter-security 2.1.7.RELEASE pom.xml 文件 <?xml version"1.0" encoding"UTF-8"?> &l…
阅读更多...
水稻潜在产量估算解决方案

水稻潜在产量估算解决方案

1.背景与技术路线 统计资料表明&#xff0c;尽管我国粮食单产已由 50 年代初期的 1.2t/ha 增加到如今的 5.2t/h&#xff0c;粮食产量增加了 4 倍&#xff0c;但我国人口的增长速度与气候变化导致的农业生产的不确定性&#xff0c; 在水稻收获指数保持稳定的情况下&#xff0c;…
阅读更多...
2397. 被列覆盖的最多行数

2397. 被列覆盖的最多行数

给你一个下标从 0 开始、大小为 m x n 的二进制矩阵 matrix &#xff1b;另给你一个整数 numSelect&#xff0c;表示你必须从 matrix 中选择的 不同 列的数量。 如果一行中所有的 1 都被你选中的列所覆盖&#xff0c;则认为这一行被 覆盖 了。 形式上&#xff0c;假设 s {c1…
阅读更多...
LRU的设计与实现（算法村第五关黄金挑战）

LRU的设计与实现（算法村第五关黄金挑战）

146. LRU 缓存 - 力扣&#xff08;LeetCode&#xff09; 请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类&#xff1a; LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存int get(int key) 如果关键字 key 存在于缓存…
阅读更多...
[Javaweb/LayUI/上机考试作业/开源]学生/图书/课程/仓库等管理系统六合一基础功能通用模板

[Javaweb/LayUI/上机考试作业/开源]学生/图书/课程/仓库等管理系统六合一基础功能通用模板

展示 考试要求 给定用户表和六张图书/教师/顾客/仓库....的表&#xff08;随机给每人抽选&#xff09;&#xff0c;要求实现用户登录注册&#xff0c;异步更新&#xff0c;对物品增删改查&#xff0c;精确/模糊查询等。 环境 tomcat 9 mysql 8 java 17 项目结构 项目类图 写前…
阅读更多...
DBA技术栈（二）：MySQL 存储引擎

DBA技术栈（二）：MySQL 存储引擎

2.1 MySQL存储引擎概述 上个业余的图&#xff1a; MyISAM 存储引擎是 MySQL 默认的存储引擎&#xff0c;也是目前 MySQL 使用最为广泛的存储引擎之一。他的前身就是我们在 MySQL 发展历程中所提到的 ISAM&#xff0c;是 ISAM 的升级版本。在 MySQL最开始发行的时候是 ISAM 存…
阅读更多...
大模型应用实践：AIGC探索之旅

大模型应用实践：AIGC探索之旅

随着OpenAI推出ChatGPT&#xff0c;AIGC迎来了前所未有的发展机遇。大模型技术已经不仅仅是技术趋势&#xff0c;而是深刻地塑造着我们交流、工作和思考的方式。 本文介绍了笔者理解的大模型和AIGC的密切联系&#xff0c;从历史沿革到实际应用案例&#xff0c;再到面临的技术挑…
阅读更多...
[足式机器人]Part2 Dr. CAN学习笔记-动态系统建模与分析 Ch02-4 拉普拉斯变换（Laplace）传递函数、微分方程

[足式机器人]Part2 Dr. CAN学习笔记-动态系统建模与分析 Ch02-4 拉普拉斯变换（Laplace）传递函数、微分方程

本文仅供学习使用 本文参考&#xff1a; B站&#xff1a;DR_CAN Dr. CAN学习笔记-动态系统建模与分析 Ch02-4 拉普拉斯变换&#xff08;Laplace&#xff09;传递函数、微分方程 1. Laplace Transform 拉式变换2. 收敛域&#xff08;ROC&#xff09;与逆变换&#xff08;ILT&…
阅读更多...
初学者SkyWalking详细使用文档

初学者SkyWalking详细使用文档

SkyWalking使用文档 下载地址&#xff1a;https://skywalking.apache.org/downloads/ 主要下载&#xff1a;skywalking apm&#xff08;tar&#xff09; 、agents(tar) 解压&#xff1a; &#xff08;可选操作&#xff09;&#xff1a; ​ apache-skywalking-apm-bin --&g…
阅读更多...
【鸿蒙】安装DevEco Studio运行HarmonyOS第一个APP(小白必看)

【鸿蒙】安装DevEco Studio运行HarmonyOS第一个APP(小白必看)

文章目录 前言一、DevEco Studio是什么&#xff1f;二、DevEco Studio安装运行1. 下载DevEco Studio2. 安装DevEco Studio3. 启动DevEco Studio4. 运行APP5. 修改代码 三、DevEco Studio调试注意事项总结 前言 鸿蒙OS是华为公司开发的一款基于微内核、耗时10年、4000多名研发人…
阅读更多...
Lazada商品详情API（lazada.item_get）进行商品的实时更新

Lazada商品详情API（lazada.item_get）进行商品的实时更新

一、引言 在数字时代&#xff0c;电商平台如Lazada成为了商品交易的重要场所。为了保持竞争力&#xff0c;实时更新商品信息变得至关重要。Lazada提供的商品详情API&#xff08;lazada.item_get&#xff09;为开发者提供了一个高效的方式来获取并更新商品数据。本文将深入探讨…
阅读更多...
“华为杯”杭州电子科技大学2023新生编程大赛---树

“华为杯”杭州电子科技大学2023新生编程大赛---树

题目链接 Problem Description 给定一棵包含 n 个节点的带边权的树&#xff0c;树是一个无环的无向联通图。定义 xordist(u,v) 为节点 u 到 v 的简单路径上所有边权值的异或和。 有 q 次询问&#xff0c;每次给出 l r x&#xff0c;求 ∑rilxordist(i,x) 的值。 Input 测试…
阅读更多...
最新文章

Copyright @ 2022~2023