深度学习VGG16网络构建（Pytorch代码从零到一精讲，帮助理解网络的参数定义）

📚博客主页：knighthood2001
✨公众号：认知up吧 （目前正在带领大家一起提升认知，感兴趣可以来围观一下）
🎃知识星球：【认知up吧|成长|副业】介绍
❤️感谢大家点赞👍🏻收藏⭐评论✍🏻，您的三连就是我持续更新的动力❤️
🙏笔者水平有限，欢迎各位大佬指点，相互学习进步！

vgg16网络架构

前言

很多时候，对于一些网络结构，我们总是会看到其对应的图片，但是代码部分，讲的人不是很多。

比如，下面这两张图片，就是讲解VGG16的博客或者视频中经常能够看到的。
在这里插入图片描述
下面这张图片的D类型是VGG16架构，E类型是VGG19
在这里插入图片描述
初次见到这种图片，其实不是特别清楚，就导致很多人对网络结构其实不是那么清楚。

比如，conv3-64是啥意思等等。

因此，我接下来打算使用pytorch代码进行讲解。尤其是对于构造网络时候的参数，需要一步一步计算后，才会有比较清晰的理解。

图片讲解

从上面两张图片，可以看出网络结构：
卷积层(+relu激活函数)
卷积层(+relu激活函数)
最大池化层
卷积层(+relu激活函数)
卷积层(+relu激活函数)
最大池化层
卷积层(+relu激活函数)
卷积层(+relu激活函数)
卷积层(+relu激活函数)
最大池化层
卷积层(+relu激活函数)
卷积层(+relu激活函数)
卷积层(+relu激活函数)
最大池化层
卷积层(+relu激活函数)
卷积层(+relu激活函数)
卷积层(+relu激活函数)
最大池化层
全连接层(+relu激活函数)
全连接层(+relu激活函数)
全连接层

除去最大池化层，刚好16层（relu激活函数不算层数）。

数据维度讲解（含代码）

搞清楚层数后，接着开始看数据维度。

对于VGG16这样的经典模型，其设计是基于224x224大小的输入图像的。这个尺寸不是随意确定的，而是经过仔细考虑和实验确定的。因此这里暂时先不考虑更改成其他数据。
首先，输入图像维度是224*224*3，图片大小是224*224，通道数是3。
输出图像维度是224*224*64，图片大小是224*224，通道数是64。

至于卷积核，说是3*3的（这个我也不知道从哪里看的，可能需要去看原作者的论文）。

至于padding：
在卷积神经网络中，padding（填充）是指在输入图像周围添加额外的像素，以便在进行卷积操作时可以保持输入和输出的尺寸相同或者更接近。padding='same'是一种常见的填充方式，它的含义是将输入的每一侧都填充足够的零值，以使输出与输入的尺寸相同。

通常图像大小的计算公式是，假设输入图像的大小为NxN，卷积核的大小为FxF，如果没有填充（padding=‘valid’），则输出图像的大小为(N-F+1)x(N-F+1)。而如果进行了填充（padding=‘same’），则在输入图像的周围填充了P个像素，使得输出图像的大小变为N+2P。

使用padding='same'填充时，通常选择填充的数量P，使得输出图像的大小与输入图像的大小相同。这样做有助于在卷积操作中保持输入输出尺寸的一致性，同时有助于减少信息丢失。

第一层

在224*224图像中，卷积核为3*3，如果没有在周围填充，那么最后的输出图像大小就是(224-3+1)*(224-3+1)=222*222，就和原来输入图像大小不相同了。

如果padding=1，则在224*224图像外围添加1个单位的行和列。最终图片就变成了226*226，在利用上面的公式，对于卷积核为3*3，最终输出图像大小就是(226-3+1)*(226-3+1)=224*224，和原始图片大小一样，保证了图像大小的一致性。
因此VGG16网络的第一层就是这样：

		self.conv1 = nn.Conv2d(3, 64, kernel_size=3, padding=1)self.relu1 = nn.ReLU(inplace=True)

注意，激活函数不会改变数据的维度。
数据维度变化：224*224*3->224*224*64

第二层

对于第二层，其图像大小就是第一层输出的图像大小，为224*224，其输入通道就是第一层的输出通道，为64，输出通道为64。因此第二层代码如下：

        self.conv2 = nn.Conv2d(64, 64, kernel_size=3, padding=1)self.relu2 = nn.ReLU(inplace=True)

数据维度变化：224*224*64->224*224*64

池化层1

接着，就到了一个最大池化层：

最大池化层（Max Pooling Layer）是卷积神经网络中常用的一种池化操作。在最大池化层中，通过在每个池化窗口中选择最大值来减小特征图的尺寸。最大池化层通常用于减少特征图的空间维度，从而降低模型的计算量，同时保留重要的特征。

最大池化层的工作原理如下：

  1. 首先，将输入特征图划分为不重叠的矩形区域（池化窗口）。
  2. 对于每个池化窗口，从窗口内提取出一个值，通常是窗口内的最大值（即最大池化）。
  3. 最终，输出的特征图尺寸减小，但保留了最显著的特征。

最大池化层具有以下几个重要的参数：

  • 池化窗口大小：确定了每次池化操作中提取的区域大小。
  • 步长（stride）：确定了池化窗口在输入特征图上滑动的步长。
  • 填充（padding）：可选参数，用于控制在特征图周围是否进行填充操作。

最大池化层通常用于卷积神经网络的不同层次，可以帮助网络在保持重要特征的同时降低维度，提高计算效率。

在VGG16中，最大池化层的池化窗口大小是2，步长也是2。且不会改变通道数。
由于池化窗口=2，因此如果步长是1的话，就在2*2的数据区域内选择1个最大值，然后以1为间隔平移。最后数据变化应该是数据维度变化：224*224*64->(224-2+1)*(224-2+1)*64也就是(223*223*64
但是如果池化窗口大小是2，步长也是2，那么每次移动2格子，刚好使得图像大小减半，使得数据维度变化：224*224*64->112*112*64

        self.max_pooling1 = nn.MaxPool2d(kernel_size=2, stride=2)

数据维度变化：224*224*64->112*112*64

第三层

经过最大池化层后，数据维度已经变成112*112*64，查看VGG16架构图，我们看到第三个卷积层，需要将其通道数变成128。并且图像大小不发生改变，因此这里当kernel_size=3时候padding=1。

上面的数据维度转换，我讲了很多，目的就是带着大家一起感受维度的变化，因为神经网络本质就是矩阵运算，一旦出现维度的不同，就会报错。

        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)self.relu3 = nn.ReLU(inplace=True)

数据维度变化：112*112*64->112*112*128

第四层

经过第三层时，数据维度已经变成112*112*128，查看VGG16架构图，我们看到第四个卷积层其通道数还是128。因此代码没什么变化，就是把输入通道数改成第三层的输出通道数，也就是128。

        self.conv4 = nn.Conv2d(128, 128, kernel_size=3, padding=1)self.relu4 = nn.ReLU(inplace=True)

数据维度变化：112*112*128->112*112*128

池化层2

经过第四层时，数据维度已经变成112*112*128，因此当经过kernel_size=2, stride=2的最大池化层时候，图片大小减半，通道数不变

        self.max_pooling2 = nn.MaxPool2d(kernel_size=2, stride=2)

数据维度变化：112*112*128->56*56*128

第五层

经过最大池化层后，数据维度已经变成56*56*128，查看VGG16架构图，我们看到第五个卷积层，需要将其通道数变成256。并且图像大小不发生改变，因此这里当kernel_size=3时候padding=1。

		self.conv5 = nn.Conv2d(128, 256, kernel_size=3, padding=1)self.relu5 = nn.ReLU(inplace=True)

数据维度变化：56*56*128->56*56*256

第六层~第七层

经过第五层时，数据维度已经变成56*56*256，查看VGG16架构图，我们看到第六个和第七个卷积层其通道数还是256。因此代码如下（这里我把两个层不单独讲了，大家也能看懂了吧）

        self.conv6 = nn.Conv2d(256, 256, kernel_size=3, padding=1)self.relu6 = nn.ReLU(inplace=True)self.conv7 = nn.Conv2d(256, 256, kernel_size=3, padding=1)self.relu7 = nn.ReLU(inplace=True)

数据维度变化：56*56*256->56*56*256->56*56*256

池化层3

经过第七层时，数据维度已经变成56*56*256，因此当经过kernel_size=2, stride=2的最大池化层时候，图片大小减半，通道数不变。

        self.max_pooling3 = nn.MaxPool2d(kernel_size=2, stride=2)

数据维度变化：56*56*256->28*28*256

剩余的卷积层和池化层

请允许我偷个懒，剩余的卷积层和池化层的代码如下：

        self.conv8 = nn.Conv2d(256, 512, kernel_size=3, padding=1)self.relu8 = nn.ReLU(inplace=True)self.conv9 = nn.Conv2d(512, 512, kernel_size=3, padding=1)self.relu9 = nn.ReLU(inplace=True)self.conv10 = nn.Conv2d(512, 512, kernel_size=3, padding=1)self.relu10 = nn.ReLU(inplace=True)self.max_pooling4 = nn.MaxPool2d(kernel_size=2, stride=2)self.conv11 = nn.Conv2d(512, 512, kernel_size=3, padding=1)self.relu11 = nn.ReLU(inplace=True)self.conv12 = nn.Conv2d(512, 512, kernel_size=3, padding=1)self.relu12 = nn.ReLU(inplace=True)self.conv13 = nn.Conv2d(512, 512, kernel_size=3, padding=1)self.relu13 = nn.ReLU(inplace=True)self.max_pooling5 = nn.MaxPool2d(kernel_size=2, stride=2)

卷积层中的kernel_size=3, padding=1，目的还是为了保证图片大小不会改变，最大池化层的kernel_size=2, stride=2，目的是为了让图片的宽高减半。
因此
第八层数据维度变化：28*28*256->28*28*512
第九层数据维度变化：28*28*512->28*28*512
第十层数据维度变化：28*28*512->28*28*512
池化层4数据维度变化：28*28*512->14*14*512
第十一层数据维度变化：14*14*512->14*14*512
第十二层数据维度变化：14*14*512->14*14*512
第十三层数据维度变化：14*14*512->14*14*512
池化层5数据维度变化：14*14*512->7*7*512

第十四层(全连接层)~第十六层

经过上面13层，数据维度已经变成7*7*512了，如果需要连接全连接层，就需要将数据展平。

        x = x.view(-1, 512*7*7)

上面的-1表示，会根据总的数据量和第二个占有的数据量大小，计算一个合适的值。

在 PyTorch 中，当你使用 .view() 函数对张量进行形状变换时，可以用 -1 来表示一个特殊的值，它表示该维度的大小由函数自动推断而来，以保证张量的总元素数不变。

具体来说，对于输入张量 x，如果你使用 x.view(-1, 512*7*7) 进行形状变换，其中 -1 的位置表示 PyTorch 应该根据其他维度和张量的总元素数来自动计算该维度的大小。

举个例子，假设输入张量 x 的形状是 (B, C, H, W)，其中 B 表示批量大小，C 表示通道数，H 表示高度，W 表示宽度。假设在这之前的处理中，已经得到了一个形状为 (B, 512, 7, 7) 的张量 x。如果使用 x.view(-1, 512*7*7)，PyTorch 将会自动计算出第一个维度的大小，以确保总元素数不变，也就是保证张量的批量大小 B 不变。

因此，x.view(-1, 512*7*7) 的作用是将输入张量 x 在第一个维度上重新调整为 -1 所代表的大小（由其他维度和张量的总元素数来确定），并且将后三个维度展平成一维。

因此，根据这一步，就将数据维度变成1*(512*7*7)=1*25088，当然这里的1，说的不太准确，准确来说应该是批数，因为卷积层的第一个参数是批数。下面我还是用1来表示吧，方便理解哈。

        # 全连接层部分self.fc1 = nn.Linear(512 * 7 * 7, 4096)self.relu14 = nn.ReLU(inplace=True)self.fc2 = nn.Linear(4096, 4096)self.relu15 = nn.ReLU(inplace=True)self.dropout = nn.Dropout(),self.fc3 = nn.Linear(4096, 1000)

全连接层1的数据维度变化：1*(512*7*7)=1*25088->1*4096

全连接层2的数据维度变化：1*4096->1*4096

全连接层3的数据维度变化：1*4096->1*1000

其中的nn.Dropout()现在还不需要了解，是正则化，用来防止过拟合的。

最后，如果输入数据是1*3*224*224，经过VGG16网络，输出就是1*1000；
如果输入数据是2*3*224*224，经过VGG16网络，输出就是2*1000。这就是我说的批数变化。

全部代码

不用nn.Sequential()

import torch
import torch.nn as nn
import numpy as np
# 定义VGG16网络类
class VGG16(nn.Module):def __init__(self):super(VGG16, self).__init__()# 卷积层部分self.conv1 = nn.Conv2d(3, 64, kernel_size=3, padding=1)self.relu1 = nn.ReLU(inplace=True)self.conv2 = nn.Conv2d(64, 64, kernel_size=3, padding=1)self.relu2 = nn.ReLU(inplace=True)self.max_pooling1 = nn.MaxPool2d(kernel_size=2, stride=2)self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)self.relu3 = nn.ReLU(inplace=True)self.conv4 = nn.Conv2d(128, 128, kernel_size=3, padding=1)self.relu4 = nn.ReLU(inplace=True)self.max_pooling2 = nn.MaxPool2d(kernel_size=2, stride=2)self.conv5 = nn.Conv2d(128, 256, kernel_size=3, padding=1)self.relu5 = nn.ReLU(inplace=True)self.conv6 = nn.Conv2d(256, 256, kernel_size=3, padding=1)self.relu6 = nn.ReLU(inplace=True)self.conv7 = nn.Conv2d(256, 256, kernel_size=3, padding=1)self.relu7 = nn.ReLU(inplace=True)self.max_pooling3 = nn.MaxPool2d(kernel_size=2, stride=2)self.conv8 = nn.Conv2d(256, 512, kernel_size=3, padding=1)self.relu8 = nn.ReLU(inplace=True)self.conv9 = nn.Conv2d(512, 512, kernel_size=3, padding=1)self.relu9 = nn.ReLU(inplace=True)self.conv10 = nn.Conv2d(512, 512, kernel_size=3, padding=1)self.relu10 = nn.ReLU(inplace=True)self.max_pooling4 = nn.MaxPool2d(kernel_size=2, stride=2)self.conv11 = nn.Conv2d(512, 512, kernel_size=3, padding=1)self.relu11 = nn.ReLU(inplace=True)self.conv12 = nn.Conv2d(512, 512, kernel_size=3, padding=1)self.relu12 = nn.ReLU(inplace=True)self.conv13 = nn.Conv2d(512, 512, kernel_size=3, padding=1)self.relu13 = nn.ReLU(inplace=True)self.max_pooling5 = nn.MaxPool2d(kernel_size=2, stride=2)# 全连接层部分self.fc1 = nn.Linear(512 * 7 * 7, 4096)self.relu14 = nn.ReLU(inplace=True)self.fc2 = nn.Linear(4096, 4096)self.relu15 = nn.ReLU(inplace=True)self.dropout = nn.Dropout(),self.fc3 = nn.Linear(4096, 1000)# 前向传播函数def forward(self, x):x = self.conv1(x)x = self.relu1(x)x = self.conv2(x)x = self.relu2(x)x = self.max_pooling1(x)x = self.conv3(x)x = self.relu3(x)x = self.conv4(x)x = self.relu4(x)x = self.max_pooling2(x)x = self.conv5(x)x = self.relu5(x)x = self.conv6(x)x = self.relu6(x)x = self.conv7(x)x = self.relu7(x)x = self.max_pooling3(x)x = self.conv8(x)x = self.relu8(x)x = self.conv9(x)x = self.relu9(x)x = self.conv10(x)x = self.relu10(x)x = self.max_pooling4(x)x = self.conv11(x)x = self.relu11(x)x = self.conv12(x)x = self.relu12(x)x = self.conv13(x)x = self.relu13(x)x = self.max_pooling5(x)print(x.shape)x = x.view(-1, 512*7*7)print(x.shape)x = self.fc1(x)x = self.relu14(x)x = self.fc2(x)x = self.relu15(x)x = self.fc3(x)return x# 生成随机的224x224x3大小的数据if __name__ == '__main__':random_data = np.random.rand(1, 3, 224, 224)  # 调整数据形状为 (batch_size, channels, height, width)random_data_tensor = torch.from_numpy(random_data.astype(np.float32))  # 将NumPy数组转换为PyTorch的Tensor类型，并确保数据类型为float32print("输入数据的数据维度", random_data_tensor.size())  # 检查数据形状是否正确# 创建VGG16网络实例vgg16 = VGG16()output = vgg16(random_data_tensor)print("输出数据维度", output.shape)print(output)

使用nn.Sequential()

看看上面的代码，是不是觉得光定义网络就要好多代码写。

import torch
import torch.nn as nn
import numpy as np
# 定义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.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 = torch.flatten(x, 1)x = self.classifier(x)return x# 生成随机的224x224x3大小的数据if __name__ == '__main__':random_data = np.random.rand(1, 3, 224, 224)  # 调整数据形状为 (batch_size, channels, height, width)random_data_tensor = torch.from_numpy(random_data.astype(np.float32))  # 将NumPy数组转换为PyTorch的Tensor类型，并确保数据类型为float32print("输入数据的数据维度", random_data_tensor.size())  # 检查数据形状是否正确# 创建VGG16网络实例vgg16 = VGG16()output = vgg16(random_data_tensor)print("输出数据维度", output.shape)print(output)

nn.Sequential() 是PyTorch 中的一个容器，用于按顺序地将多个神经网络层组合在一起，构建一个神经网络模型。通过nn.Sequential()，你可以方便地定义一个神经网络模型，按照你指定的顺序依次添加神经网络层。

torch.flatten(x, 1)的作用和我说的.view()一样，也是用来展平操作的。
这里的1，表示的就是[batch,通道数,高,宽]中的通道数所在的维度。

举个例子，假设输入张量 x 的形状为 (B, C, H, W)，其中 B 表示批量大小，C 表示通道数，H 表示高度，W 表示宽度。如果使用 torch.flatten(x, 1)，则函数会将输入张量在通道维度上（维度索引从0开始，因此通道维度索引为1）进行展平，结果将是一个形状为 (B, CHW) 的一维张量。

至于数据，你可以使用numpy随机生成一个符合条件的数据，但是喂到网络中之前，你需要将其类型转化为tensor格式，并确保数据类型为float32

运行一下

批数为1时：
在这里插入图片描述
批数为2时：
在这里插入图片描述

最后

希望我的讲解能够帮助大家入门神经网络的网络构建。

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

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

相关文章

Labview2024安装包（亲测可用）

Labview2024安装包（亲测可用）

目录 一、软件简介 二、软件下载 一、软件简介 LabVIEW是一种由美国国家仪器（NI）公司开发的程序开发环境，它显著区别于其他计算机语言，如C和BASIC。传统的计算机语言是基于文本的语言来产生代码，而LabVIEW则采用图形化…
阅读更多...
CERLAB无人机自主框架: 1-环境搭建

CERLAB无人机自主框架: 1-环境搭建

前言：更多更新文章详见我的个人博客主页【MGodmonkeyの世界】 描述：欢迎来到CERLAB无人机自主框架，这是一个用于自主无人飞行器 (UAV) 的多功能模块化框架。该框架包括不同的组件 (模拟器，感知，映射，规划和…
阅读更多...
Day23_学点儿JSON_定义、数据格式、和XML比较、插件

Day23_学点儿JSON_定义、数据格式、和XML比较、插件

1 JSON定义 定义&#xff1a;是一种轻量级的数据交换格式 JSON是JavaScript Object Notation缩写 特点&#xff1a; 易于程序员阅读和编写。易于计算机解析和生成。其实是javascript的子集&#xff1a;原生javascript支持JSON <script type"text/javascript">…
阅读更多...
B-树 B+树与数据库原理

B-树 B+树与数据库原理

B树 引入 概念和性质 插入分析 总结 B树 B*树&#xff08;了解&#xff09; 数据库原理 数据库与B树的关系
阅读更多...
【深度学习实战（10）】图像推理之预处理

【深度学习实战（10）】图像推理之预处理

一、预处理流程 在把一张图像送入模型进行推理时&#xff0c;需要先进行预处理&#xff0c;预处理流程包括&#xff1a; &#xff08;1&#xff09;读取图像 &#xff08;2&#xff09;尺寸调整&#xff0c;letter_box&#xff08;不失真&#xff09; &#xff08;3&#xff0…
阅读更多...
小红的排列构造（dp优化）

小红的排列构造（dp优化）

题目描述 小红拿到了一个长度为n的数组a&#xff0c;她希望你构造两个排列p和q&#xff0c;满足对于i∈[1,n],ai∈[1,n]pi或qi二选一。你能帮帮她吗&#xff1f;定义排列是一个长度为n的数组&#xff0c;其中1到n每个元素恰好出现1次。 输入描述:第一行输入一个正整数n&#…
阅读更多...
解析OceanBase v4.2 Oracle 语法兼容之 LOCK TABLE

解析OceanBase v4.2 Oracle 语法兼容之 LOCK TABLE

背景 在OceanBase V4.1及之前的版本中&#xff0c;尽管已经为Oracle租户兼容了LOCK TABLE相关的语法&#xff0c;包括单表锁定操作&#xff0c;和WAIT N&#xff0c; NOWAIT 关键字。但使用时还存在一些限制。例如&#xff1a;LOCK TABLE只能针对单表进行锁定&#xff0c;并不…
阅读更多...
URL GET +号后台接收成空格

URL GET +号后台接收成空格

问题&#xff1a;参数spdmwhbs001 其中包含URL特殊符号 如果用GET请求方式不做任何不处理那么浏览器自动将转为%20 请求链接为 details?spdmwhbs%20001&limitKcysType1 后台接收到的参数为 whbs 001 &#xff0c;自动将号转成空格了。 尝试解决&#xff08;失败&#…
阅读更多...
Redis中的事务(二)

Redis中的事务(二)

事务 事务的实现 执行事务 当一个处于事务状态的客户端向服务器发送EXEC命令时&#xff0c;这个EXEC命令将立即被服务器执行&#xff0c;服务器会遍历这个客户端的事务队列&#xff0c;执行队列中保存的所有命令&#xff0c;最后将执行命令所得的结果全部返回给客户端。 例…
阅读更多...
STM32学习和实践笔记（17）：STM32外部中断（EXTI）的整体介绍

STM32学习和实践笔记（17）：STM32外部中断（EXTI）的整体介绍

1.外部中断介绍 1.1 EXTI简介 STM32F10x外部中断/事件控制器&#xff08;EXTI&#xff09;包含多达 20 个用于产生事件/中断请求的边沿检测器。&#xff08;事件与中断的区别&#xff0c;可参看STM32---中断与事件的区别_中断和事件的区别-CSDN博客&#xff09; 具体有哪些&a…
阅读更多...
C语言结课实战项目_贪吃蛇小游戏

C语言结课实战项目_贪吃蛇小游戏

目录 最终实现效果&#xff1a; 实现基本的功能&#xff1a; 根据游戏进程解释代码&#xff1a; 游戏初始化&#xff1a; 首先进入游戏&#xff0c;我们应该将窗口名称改为 “贪吃蛇” 并将光标隐藏掉。再在中间打印游戏信息。 之后我们要把地图打印出来&#xff1a; 然后…
阅读更多...
【Qt】设置QT标准对话框为中文字体

【Qt】设置QT标准对话框为中文字体

设置QT标准对话框为中文字体 一、问题二、解决方法1、找到Qt内置的翻译文件 qt_zh_CN.qm2、在代码中加载该文件 一、问题 在Qt中我们使用的标准对话框都是英文&#xff0c;例如下面的 字体选择对话框&#xff0c;但是实际中我们需要构建的是中文对话框。 所以我们需要使用Qt官…
阅读更多...
js自动缩放页面，html自动缩放页面，大屏自动缩放页面，数字看板自动缩放页面，大数据看板自动缩放页面

js自动缩放页面，html自动缩放页面，大屏自动缩放页面，数字看板自动缩放页面，大数据看板自动缩放页面

js自动缩放页面&#xff0c;html自动缩放页面&#xff0c;大屏自动缩放页面&#xff0c;数字看板自动缩放页面&#xff0c;大数据看板自动缩放页面 由纯JS实现 html代码 <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8"…
阅读更多...
【数据结构】单链表的头节点与尾节点

【数据结构】单链表的头节点与尾节点

&#x1f388;个人主页&#xff1a;豌豆射手^ &#x1f389;欢迎 &#x1f44d;点赞✍评论⭐收藏 &#x1f917;收录专栏&#xff1a;数据结构 &#x1f91d;希望本文对您有所裨益&#xff0c;如有不足之处&#xff0c;欢迎在评论区提出指正&#xff0c;让我们共同学习、交流进…
阅读更多...
玄子Share-计算机网络参考模型

玄子Share-计算机网络参考模型

玄子Share-计算机网络参考模型 分层思想 利用七层参考模型&#xff0c;便于在网络通信过程中&#xff0c;快速的分析问题&#xff0c;定位问题并解决问题 将复杂的流程分解为几个功能相对单一的子过程 整个流程更加清晰&#xff0c;复杂问题简单化 更容易发现问题并针对性的…
阅读更多...
【Java开发指南 | 第十七篇】Java 方法

【Java开发指南 | 第十七篇】Java 方法

读者可订阅专栏&#xff1a;Java开发指南 |【CSDN秋说】 文章目录 简介语法实例构造方法 简介 Java中的方法是用来执行特定任务的一组语句&#xff0c;可以重复使用。它们包含在类或对象中&#xff0c;并通过调用来执行。 举个例子&#xff0c;println() 是一个方法&#xff…
阅读更多...
动态内存管理 柔性数组

动态内存管理 柔性数组

文章目录 动态内存函数 malloc freecallocrealloc 重新开辟空间realloc 也可以第一个参数为NULL&#xff0c;则是直接开辟内存&#xff0c;类似于malloc用法 常见的动态内存错误对空指针进行解引用操作对开辟的内存越界访问对非动态开辟的内存使用free释放使用free释放动态开辟…
阅读更多...
（四）相关性分析 学习简要笔记 #统计学 #CDA学习打卡

（四）相关性分析 学习简要笔记 #统计学 #CDA学习打卡

目录 一. 相关性分析简介 二. 相关性分析方法 1&#xff09;连续型变量vs连续型变量&#xff1a;Pearson/Spearman &#xff08;a&#xff09;Pearson &#xff08;b&#xff09;Spearman等级相关系数 2&#xff09;二分类变量&#xff08;自然&#xff09;vs连续型变量&…
阅读更多...
macos知名的清理软件 cleanmymac和腾讯柠檬哪个好 cleanmymacx有必要买吗

macos知名的清理软件 cleanmymac和腾讯柠檬哪个好 cleanmymacx有必要买吗

MacOS是一款优秀的操作系统&#xff0c;但是随着使用时间的增加&#xff0c;它也会产生一些不必要的垃圾文件&#xff0c;占用磁盘空间和内存资源&#xff0c;影响系统的性能和稳定性。为了保持MacOS的清洁和高效&#xff0c;我们需要使用一些专业的清理软件来定期扫描和清除这…
阅读更多...
【Golang】Gin教学-获取请求信息并返回

【Golang】Gin教学-获取请求信息并返回

安装Gin初始化Gin处理所有HTTP请求获取请求的URL和Method获取请求参数根据Content-Type判断请求数据类型处理JSON数据处理表单数据处理文件返回JSON响应启动服务完整代码测试 Gin是一个用Go&#xff08;又称Golang&#xff09;编写的HTTP Web框架&#xff0c;它具有高性能和简洁…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023