神经网络-Inception

news2025/1/2 22:16:34

Inception网络是由Google开发的一种深度卷积神经网络架构，旨在解决计算机视觉领域中的图像分类和物体识别任务。

Inception网络最初在2014年被提出，并在ImageNet图像分类挑战赛上取得了很好的结果。其设计灵感来自于模块化的思想，将不同尺度和不同层级的滤波器并行应用于输入，然后将它们的输出在通道维度上拼接在一起，形成了一个多分支的结构。这种并行使用不同卷积核尺寸的方式可以捕捉到不同尺度的图像特征，提高了网络对输入图像的理解能力。

Inception网络的演变版本包括Inception-V2、Inception-V3、Inception-V4和Inception-ResNet等。这些版本在原始Inception网络的基础上进行了改进，提升了性能和效果。

Inception网络在计算机视觉领域广泛应用，被用于图像分类、目标检测、图像生成等任务。它的设计思想和结构对深度学习模型的发展和优化有着重要的影响和贡献。

Inception介绍

Inception模块是Inception架构的核心组件，它由多个并行的分支组成。每个分支都使用不同大小的卷积核进行卷积操作，例如1×1、3×3和5×5的卷积核。这样做的目的是让网络能够同时学习到局部和全局的特征，并且能够适应不同尺度的目标。此外，为了减少参数数量和计算复杂度，每个分支都会在输入前使用1×1的卷积核进行降维处理。

除了卷积层之外，Inception模块还包括池化层。池化层可以帮助减小特征图的空间尺寸，从而提高计算效率和减少过拟合的风险。作者建议在每个阶段中添加一个替代的并行池化路径，使得模型能够更好地捕捉空间信息。

整个Inception网络由多个堆叠的Inception模块构成，模块之间通过卷积层进行连接。最后的全局平均池化层将特征图转换为向量表示，并通过全连接层进行分类或回归等任务。

随着网络的深入，模型需要更多的感受野来理解更复杂的图像特征。较小的卷积核（如1×1和3×3）能够捕捉局部特征，而较大的卷积核（如5×5）则能够捕捉更广阔的上下文信息。因此，在高层次的特征表示中，作者提出使用更多的3×3和5×5卷积核来覆盖更大范围的特征，并适应数据中更高层次的抽象特征。这样做有助于提高网络对不同尺度和抽象级别的特征的表示能力。

下图是一个Inception结构拆解示意：

上图左侧是最原始的Inception结构，包含了1*1、3*3、5*5以及max pooling，使用多个5×5的卷积核可以捕捉到更广泛的特征，但是这会导致计算成本增加。特别是当在具有大量滤波器的卷积层上使用较多的5×5卷积时，计算量更加昂贵。

而且，一旦添加了池化单元，它们的输出滤波器数量与前一层的滤波器数量相等，这就意味着从卷积层到池化层的输出数量会增加。而当将池化层的输出与卷积层的输出合并时，会导致每个阶段之间输出数量的不可避免增加。

这种架构虽然可能能够覆盖最佳的稀疏结构，但是效率非常低下。随着网络的深入，输出数量会逐渐增加，从而导致计算量的剧增。这会对网络的计算性能和效率造成困扰，因为需要处理大量的输出数据。

如何保证模型效果的同时，降低计算量？

为了降低计算量，我们引入了1×1卷积操作。1×1卷积是一种特殊的卷积操作，它使用只有一个像素大小的卷积核。与传统的卷积核相比，它的尺寸非常小。通过应用1×1卷积，我们可以将输入信号从高维空间投影到低维空间，即减少信号的维度。这样做可以减少计算量，因为在低维空间中进行卷积计算要比在高维空间中更快速。

在Inception方法中，1×1卷积操作被放置在耗时的3×3和5×5卷积操作之前。通过降低信号的维度，我们可以减少需要进行的计算量。此外，为了增强模型的表达能力，我们在降维卷积后引入修正线性激活函数。这个激活函数可以让模型更好地学习特征，在处理图像时取得更好的效果。（也就是上图的b）

总结起来，我们的方法利用1×1卷积操作将信号从高维空间投影到低维空间，以降低计算量。同时，我们引入修正线性激活函数增强模型表达能力。这样的设计策略可以提高计算效率，并在处理复杂图像任务时获得更好的结果。

总结：

在Inception网络中，核心组件是称为Inception模块的构建块。一个Inception模块由多个并行的子路径组成，每个子路径具有不同大小的卷积核和不同的滤波器数量。这样可以让网络同时学习到不同尺度和层次的特征。例如，一个子路径可能使用小的卷积核来捕捉细节特征，而另一个子路径可能使用大的卷积核来捕捉整体结构。

为了提高计算效率，Inception模块还会使用降维操作，即先使用较少的滤波器数量进行卷积，然后再使用更多的滤波器进行卷积。这样可以减少网络的参数数量和计算量，同时保持较好的表达能力。

此外，Inception网络还会通过插入步长为2的最大池化层来减小输入数据的尺寸，从而进一步降低计算复杂度。最大池化层可以将输入数据划分为不重叠的区域，并从每个区域中选择最大值作为输出。这样可以降低数据的维度，同时保留重要的特征信息。

总体来说，Inception网络通过模块化的设计、不同尺度特征的并行处理和降维操作来提高图像处理任务的性能和效率。它能够从图像中学习到更丰富的特征表示，并在保持计算效率的同时提高准确性。

GoogLeNet

在GoogLeNet中，利用Inception结构进行了设计，下面我们将具体介绍，如何应用Inception：

在GooLeNet中，网络结构大致可以分为6个部分，其中第一部分、第二部分、第六部分是我们常见的卷积层等方法使用，第3~5，均是采用了上述介绍的Inception结构，每个部分中采用的数量不同，比如第三部分采用了2个Inception结构；第四部分采用了5个Inception结构；第五部分采用了2个Inception结构。

下图是GooLeNet整体的网络结构，下面我们将针对每部分进行介绍。

  • 第一部分、第二部分

    • 第一部分构成：conv 7*7 -》max pool 3*3 -》LRN

    • 第二部分构成：conv 1*1 -》 conv 3*3 -》 LRN -》 max pool 3*3

具体参数计算如下：

均属于常规网络设计。

  • 第三部分

    • 第三部分构成：Inception(3a)->Inception(3b)->max pool

  • 第四部分

    • 第四部分构成：Inception(4a)->Inception(4b)->Inception(4c)->Inception(4d)->Inception(4e)->MaxPool

其中在Inception(4b) 和Inception(4e) 又接了两个辅助分类器。

  • 第五部分

    • 第五部分构成：Inception(5a)->Inception(5b)-average pool

  • 第六部分

    • 第六部分构成：FC->softmax

代码示例

根据上文介绍，Inception结构如下所示，根据下图我们进行网络定义。

 

import torch
import torch.nn as nn


# 定义 Inception 模块
class Inception(nn.Module):
    def __init__(self, in_channels, ch1x1, ch3x3red, ch3x3, ch5x5red, ch5x5, pool_proj):
        super(Inception, self).__init__()
        
        # 1x1 卷积分支
        self.branch1 = nn.Sequential(
            nn.Conv2d(in_channels, ch1x1, kernel_size=1),
            nn.ReLU(inplace=True)
        )
        
        # 1x1 卷积后接 3x3 卷积分支
        self.branch2 = nn.Sequential(
            nn.Conv2d(in_channels, ch3x3red, kernel_size=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(ch3x3red, ch3x3, kernel_size=3, padding=1),
            nn.ReLU(inplace=True)
        )
        
        # 1x1 卷积后接 5x5 卷积分支
        self.branch3 = nn.Sequential(
            nn.Conv2d(in_channels, ch5x5red, kernel_size=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(ch5x5red, ch5x5, kernel_size=5, padding=2),
            nn.ReLU(inplace=True)
        )
        
        # 3x3 最大池化后接 1x1 卷积分支
        self.branch4 = nn.Sequential(
            nn.MaxPool2d(kernel_size=3, stride=1, padding=1),
            nn.Conv2d(in_channels, pool_proj, kernel_size=1),
            nn.ReLU(inplace=True)
        )
        
    def forward(self, x):
        branch1 = self.branch1(x)
        branch2 = self.branch2(x)
        branch3 = self.branch3(x)
        branch4 = self.branch4(x)
        
        outputs = [branch1, branch2, branch3, branch4]
        return torch.cat(outputs, 1)
 

 

  •  
    定义GoogleNet网络
     
 

# 定义 GoogleNet
class GoogleNet(nn.Module):
    def __init__(self, num_classes=1000):
        super(GoogleNet, self).__init__()
        
        # 第一个卷积和池化层
        self.conv1 = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3),  # 输入通道数为3，输出通道数为64，卷积核大小为7x7，步长为2，填充为3
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1)  # 池化层，使用最大池化，池化核大小为3x3，步长为2，填充为1
        )
        
        # 第二个卷积和池化层
        self.conv2 = nn.Sequential(
            nn.Conv2d(64, 64, kernel_size=1),  # 输入通道数为64，输出通道数为64，卷积核大小为1x1，不改变特征图的大小
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 192, kernel_size=3, padding=1),  # 输入通道数为64，输出通道数为192，卷积核大小为3x3，填充为1
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2, padding=1)  # 池化层，使用最大池化，池化核大小为3x3，步长为2，填充为1
        )
        
        # Inception 模块
        self.inception3a = Inception(192, 64, 96, 128, 16, 32, 32)
        self.inception3b = Inception(256, 128, 128, 192, 32, 96, 64)
        
        self.inception4a = Inception(480, 192, 96, 208, 16, 48, 64)
        self.inception4b = Inception(512, 160, 112, 224, 24, 64, 64)
        self.inception4c = Inception(512, 128, 128, 256, 24, 64, 64)
        self.inception4d = Inception(512, 112, 144, 288, 32, 64, 64)
        self.inception4e = Inception(528, 256, 160, 320, 32, 128, 128)
        
        self.inception5a = Inception(832, 256, 160, 320, 32, 128, 128)
        self.inception5b = Inception(832, 384, 192, 384, 48, 128, 128)
        
        # 最后的全局平均池化、dropout、全连接层
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))  # 全局平均池化层，将特征图大小池化为1x1
        self.dropout = nn.Dropout(0.4)  # Dropout层，防止过拟合，丢弃概率为0.4
        self.fc = nn.Linear(1024, num_classes)  # 全连接层，输入大小为1024，输出大小为类别数
        
    def forward(self, x):
        x = self.conv1(x)  # 第一个卷积和池化层
        x = self.conv2(x)  # 第二个卷积和池化层
        x = self.inception3a(x)  # Inception 模块
        x = self.inception3b(x)  # Inception 模块
        x = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)(x)  # 池化层，使用最大池化，池化核大小为3x3，步长为2，填充为1
        
        x = self.inception4a(x)  # Inception 模块
        x = self.inception4b(x)  # Inception 模块
        x = self.inception4c(x)  # Inception 模块
        x = self.inception4d(x)  # Inception 模块
        x = self.inception4e(x)  # Inception 模块
        x = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)(x)  # 池化层，使用最大池化，池化核大小为3x3，步长为2，填充为1
        
        x = self.inception5a(x)  # Inception 模块
        x = self.inception5b(x)  # Inception 模块
        
        x = self.avgpool(x)  # 全局平均池化层
        x = torch.flatten(x, 1)  # 平铺特征图
        x = self.dropout(x)  # Dropout层
        x = self.fc(x)  # 全连接层
        
        return x
 

最终model输出如下：
 

GoogleNet(
  (conv1): Sequential(
    (0): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3))
    (1): ReLU(inplace=True)
    (2): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  )
  (conv2): Sequential(
    (0): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))
    (1): ReLU(inplace=True)
    (2): Conv2d(64, 192, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (3): ReLU(inplace=True)
    (4): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  )
  (inception3a): Inception(
    (branch1): Sequential(
      (0): Conv2d(192, 64, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
    )
    (branch2): Sequential(
      (0): Conv2d(192, 96, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
      (2): Conv2d(96, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (3): ReLU(inplace=True)
    )
    (branch3): Sequential(
      (0): Conv2d(192, 16, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
      (2): Conv2d(16, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
      (3): ReLU(inplace=True)
    )
    (branch4): Sequential(
      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)
      (1): Conv2d(192, 32, kernel_size=(1, 1), stride=(1, 1))
      (2): ReLU(inplace=True)
    )
  )
  (inception3b): Inception(
    (branch1): Sequential(
      (0): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
    )
    (branch2): Sequential(
      (0): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
      (2): Conv2d(128, 192, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (3): ReLU(inplace=True)
    )
    (branch3): Sequential(
      (0): Conv2d(256, 32, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
      (2): Conv2d(32, 96, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
      (3): ReLU(inplace=True)
    )
    (branch4): Sequential(
      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)
      (1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1))
      (2): ReLU(inplace=True)
    )
  )
  (inception4a): Inception(
    (branch1): Sequential(
      (0): Conv2d(480, 192, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
    )
    (branch2): Sequential(
      (0): Conv2d(480, 96, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
      (2): Conv2d(96, 208, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (3): ReLU(inplace=True)
    )
    (branch3): Sequential(
      (0): Conv2d(480, 16, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
      (2): Conv2d(16, 48, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
      (3): ReLU(inplace=True)
    )
    (branch4): Sequential(
      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)
      (1): Conv2d(480, 64, kernel_size=(1, 1), stride=(1, 1))
      (2): ReLU(inplace=True)
    )
  )
  (inception4b): Inception(
    (branch1): Sequential(
      (0): Conv2d(512, 160, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
    )
    (branch2): Sequential(
      (0): Conv2d(512, 112, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
      (2): Conv2d(112, 224, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (3): ReLU(inplace=True)
    )
    (branch3): Sequential(
      (0): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
      (2): Conv2d(24, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
      (3): ReLU(inplace=True)
    )
    (branch4): Sequential(
      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)
      (1): Conv2d(512, 64, kernel_size=(1, 1), stride=(1, 1))
      (2): ReLU(inplace=True)
    )
  )
  (inception4c): Inception(
    (branch1): Sequential(
      (0): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
    )
    (branch2): Sequential(
      (0): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
      (2): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (3): ReLU(inplace=True)
    )
    (branch3): Sequential(
      (0): Conv2d(512, 24, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
      (2): Conv2d(24, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
      (3): ReLU(inplace=True)
    )
    (branch4): Sequential(
      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)
      (1): Conv2d(512, 64, kernel_size=(1, 1), stride=(1, 1))
      (2): ReLU(inplace=True)
    )
  )
  (inception4d): Inception(
    (branch1): Sequential(
      (0): Conv2d(512, 112, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
    )
    (branch2): Sequential(
      (0): Conv2d(512, 144, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
      (2): Conv2d(144, 288, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (3): ReLU(inplace=True)
    )
    (branch3): Sequential(
      (0): Conv2d(512, 32, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
      (2): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
      (3): ReLU(inplace=True)
    )
    (branch4): Sequential(
      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)
      (1): Conv2d(512, 64, kernel_size=(1, 1), stride=(1, 1))
      (2): ReLU(inplace=True)
    )
  )
  (inception4e): Inception(
    (branch1): Sequential(
      (0): Conv2d(528, 256, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
    )
    (branch2): Sequential(
      (0): Conv2d(528, 160, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
      (2): Conv2d(160, 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (3): ReLU(inplace=True)
    )
    (branch3): Sequential(
      (0): Conv2d(528, 32, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
      (2): Conv2d(32, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
      (3): ReLU(inplace=True)
    )
    (branch4): Sequential(
      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)
      (1): Conv2d(528, 128, kernel_size=(1, 1), stride=(1, 1))
      (2): ReLU(inplace=True)
    )
  )
  (inception5a): Inception(
    (branch1): Sequential(
      (0): Conv2d(832, 256, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
    )
    (branch2): Sequential(
      (0): Conv2d(832, 160, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
      (2): Conv2d(160, 320, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (3): ReLU(inplace=True)
    )
    (branch3): Sequential(
      (0): Conv2d(832, 32, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
      (2): Conv2d(32, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
      (3): ReLU(inplace=True)
    )
    (branch4): Sequential(
      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)
      (1): Conv2d(832, 128, kernel_size=(1, 1), stride=(1, 1))
      (2): ReLU(inplace=True)
    )
  )
  (inception5b): Inception(
    (branch1): Sequential(
      (0): Conv2d(832, 384, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
    )
    (branch2): Sequential(
      (0): Conv2d(832, 192, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
      (2): Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      (3): ReLU(inplace=True)
    )
    (branch3): Sequential(
      (0): Conv2d(832, 48, kernel_size=(1, 1), stride=(1, 1))
      (1): ReLU(inplace=True)
      (2): Conv2d(48, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
      (3): ReLU(inplace=True)
    )
    (branch4): Sequential(
      (0): MaxPool2d(kernel_size=3, stride=1, padding=1, dilation=1, ceil_mode=False)
      (1): Conv2d(832, 128, kernel_size=(1, 1), stride=(1, 1))
      (2): ReLU(inplace=True)
    )
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
  (dropout): Dropout(p=0.4, inplace=False)
  (fc): Linear(in_features=1024, out_features=1000, bias=True)
)
 


                

        

            

            

            

              

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

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

            
            

              
            

          


            
相关文章

          
            
                  

                    

                      

                        

                          
                            js给dom分页
                        

                      

                      

                        

                          js给dom分页
                        

                        

                          减少js操作dom 
js引擎与渲染引擎相互独立, 
js操作dom过程开销大操作到了dom层面会触发渲染树的变化,触发回流与重绘开销大 
让js给dom分压 
js处理完操作后,最后给dom 
缓存变量 
let container  document.getElementById(container)
let content  
for(let count0;count<…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            深度学习——神经网络中前向传播、反向传播与梯度计算原理
                        

                      

                      

                        

                          深度学习——神经网络中前向传播、反向传播与梯度计算原理
                        

                        

                          一、前向传播 
1.1 概念 
神经网络的前向传播&#xff08;Forward Propagation&#xff09;就像是一个数据处理的流水线。从输入层开始&#xff0c;按照网络的层次结构&#xff0c;每一层的神经元接收上一层神经元的输出作为自己的输入&#xff0c;经过线性变换&#xff08;加权…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            秒鲨后端之MyBatis【2】默认的类型别名、MyBatis的增删改查、idea中设置文件的配置模板、MyBatis获取参数值的两种方式、特殊SQL的执行
                        

                      

                      

                        

                          秒鲨后端之MyBatis【2】默认的类型别名、MyBatis的增删改查、idea中设置文件的配置模板、MyBatis获取参数值的两种方式、特殊SQL的执行
                        

                        

                          别忘了请点个赞收藏关注支持一下博主喵&#xff01;&#xff01;&#xff01;! ! ! 下篇更新&#xff1a; 秒鲨后端之MyBatis【3】自定义映射resultMap、动态SQL、MyBatis的缓存、MyBatis的逆向工程、分页插件。 
默认的类型别名 MyBatis的增删改查 
添加 
<!--int insertUs…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            瑞芯微全新芯片平台RK3506优势详解，高集成低功耗，为工业而生 触觉智能测评
                        

                      

                      

                        

                          瑞芯微全新芯片平台RK3506优势详解，高集成低功耗，为工业而生 触觉智能测评
                        

                        

                          RK3506是瑞芯微Rockchip在2024年第四季度全新推出的Arm嵌入式芯片平台&#xff0c;三核Cortex-A7单核Cortex-M0多核异构设计&#xff0c;CPU频率达1.5Ghz, M0 MCU为200Mhz。 而RK3506芯片平台下的工业级芯片型号RK3506J&#xff0c;具备-40-85℃的工业宽温性能、发热量小&#…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            AIOps平台的功能对比：如何选择适合的解决方案？
                        

                      

                      

                        

                          AIOps平台的功能对比：如何选择适合的解决方案？
                        

                        

                          定义与概念 AIOps&#xff0c;即人工智能运维&#xff08;Artificial Intelligence for IT Operations&#xff09;&#xff0c;是将人工智能技术应用于 IT 运维领域&#xff0c;以实现自动化、智能化的运维管理。它通过整合大数据、机器学习等先进技术&#xff0c;对海量运维数…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            Python + 深度学习从 0 到 1（03 / 99）
                        

                      

                      

                        

                          Python + 深度学习从 0 到 1（03 / 99）
                        

                        

                          希望对你有帮助呀&#xff01;&#xff01;&#x1f49c;&#x1f49c; 如有更好理解的思路&#xff0c;欢迎大家留言补充 ~ 一起加油叭 &#x1f4a6; 欢迎关注、订阅专栏 【深度学习从 0 到 1】谢谢你的支持&#xff01; ⭐ 神经网络的数据表示 – 张量 你可能对矩阵很熟悉&a…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            Lumos学习王佩丰Excel第二十三讲：饼图美化与PPT图表
                        

                      

                      

                        

                          Lumos学习王佩丰Excel第二十三讲：饼图美化与PPT图表
                        

                        

                          一、双坐标柱形图的补充知识 
1、主次坐标设置 2、主次坐标柱形避让&#xff08;通过增加两个系列&#xff0c;挤压使得两个柱形挨在一起&#xff09; 
增加两个系列 将一个系列设置成主坐标轴&#xff0c;另一个设成次坐标轴 调整系列位置 二、饼图美化 
1、饼图美化常见设置 …
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            基于Vue+SSM+SpringCloudAlibaba书籍管理系统
                        

                      

                      

                        

                          基于Vue+SSM+SpringCloudAlibaba书籍管理系统
                        

                        

                          功能要求 
一、登录功能&#xff08;http://localhost:8080/#/login&#xff09; 
输入账号和密码(admin/admin)进行登录&#xff1a; 
如果密码错误&#xff0c;给出提示信息 
如果密码正确&#xff0c;跳转到主页 账号或密码错误&#xff1a; 账号密码正确&#xff1a;跳转到…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            【优先算法】滑动窗口 --（结合例题讲解解题思路）（C++）
                        

                      

                      

                        

                          【优先算法】滑动窗口 --（结合例题讲解解题思路）（C++）
                        

                        

                          目录 ​编辑 
1.什么是滑动窗口&#xff1f; 2. 滑动窗口例题 2.1 例题1&#xff1a;长度最小的子数组 2.1.1 解题思路 2.1.2 方法一&#xff1a;暴力枚举出所有的子数组的和 2.1.3 方法二&#xff1a;使用 “同向双指针” 也就是滑动窗口来进行优化 2.2 例题2&#xff1a;无重…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            VS Code 从命令行启动
                        

                      

                      

                        

                          VS Code 从命令行启动
                        

                        

                          在 VS Code 中&#xff0c;code 命令允许你在命令行中快速打开文件、文件夹或新窗口。 
安装 
原本地址&#xff1a;https://code.visualstudio.com/docs/setup/mac 使用 
使用 code 命令 打开文件&#xff1a;你可以通过在命令行输入 code 文件名 来直接打开一个文件。 打开文…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            微服务-配置管理
                        

                      

                      

                        

                          微服务-配置管理
                        

                        

                          文章目录 1.什么是配置管理2.配置共享添加共享配置拉取共享配置 3.配置热更新添加配置到Nacos配置热更新 4.动态路由监听Nacos配置变更 1.什么是配置管理 
到目前为止我们已经解决了微服务相关的几个问题&#xff1a; 
微服务远程调用微服务注册、发现微服务请求路由、负载均衡…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            ArrayList 和LinkedList的区别比较
                        

                      

                      

                        

                          ArrayList 和LinkedList的区别比较
                        

                        

                          前言 
‌ArrayList和LinkedList的主要区别在于它们的底层数据结构、性能特点以及适用场景。‌ArrayList和LinkedList从名字分析&#xff0c;他们一个是Array&#xff08;动态数组&#xff09;的数据结构&#xff0c;一个是Linked&#xff08;链表&#xff09;的数据结构&#x…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            MySQL--》如何在SQL中巧妙运用函数与约束，优化数据处理与验证？
                        

                      

                      

                        

                          MySQL--》如何在SQL中巧妙运用函数与约束，优化数据处理与验证？
                        

                        

                          目录 
函数使用 
字符串函数 
数值函数 
日期函数 
流程函数 
约束 
外键约束 
约束规则 函数使用 
函数是指一段可以直接被另一段程序调用的程序或代码&#xff0c;在mysql当中有许多常见的内置函数&#xff0c;接下来开始对这些内置函数及其作用进行简单的讲解和使用&#xf…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            一文大白话讲清楚CSS盒子模型和块级格式化上下文（BFC）
                        

                      

                      

                        

                          一文大白话讲清楚CSS盒子模型和块级格式化上下文（BFC）
                        

                        

                          一文大白话讲清楚CSS盒子模型和块级格式化上下文&#xff08;BFC&#xff09; 
1.啥是个CSS盒子 
鞋盒你家总有吧&#xff0c;方方正正&#xff0c;有长度有高度。css盒子跟这个八九不离十当我们编写html页面时&#xff0c;写了很多的元素&#xff0c;比如"div",&quo…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            Docker 快速搭建 GBase 8s数据库服务
                        

                      

                      

                        

                          Docker 快速搭建 GBase 8s数据库服务
                        

                        

                          1.查看Gbase 8s镜像版本 
可以去到docker hub网站搜索&#xff1a;gbase8s  
liaosnet/gbase8s如果无法访问到该网站&#xff0c;可以通过docker search搜索
docker search gbase8s2.拉取Gbase 8s镜像 
以下演示的版本是目前官网最新版本Gbase8sV8.8_3.5.1 
docker pull liaosn…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            密钥登录服务器
                        

                      

                      

                        

                          密钥登录服务器
                        

                        

                          1. 生成 SSH 密钥对 
如果您还没有生成密钥对&#xff0c;可以使用以下命令生成&#xff1a; ssh-keygen 在 root 用户的家目录中生成了一个 .ssh 的隐藏目录&#xff0c;内含两个密钥文件&#xff1a;id_rsa 为私钥&#xff0c;id_rsa.pub 为公钥。 
在提示时&#xff0c;您可…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            王佩丰24节Excel学习笔记——第二十讲：图表基础
                        

                      

                      

                        

                          王佩丰24节Excel学习笔记——第二十讲：图表基础
                        

                        

                          【以 Excel2010 系列学习&#xff0c;用 Office LTSC 专业增强版 2021 实践】 【本章技巧】 
课件图片有问题&#xff0c;不能随隐藏熟悉各个图表小部件的功能&#xff0c;需要修改都是选中右键进行更改。 一、认识图表中的元素 图表标题&#xff1a;主坐标&#xff08;横坐标&…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            华为交换机配置本地端口流量镜像
                        

                      

                      

                        

                          华为交换机配置本地端口流量镜像
                        

                        

                          端口镜像&#xff08;Port Mirroring&#xff09;是网络监控的一种重要技术&#xff0c;通过复制流经特定端口的报文&#xff0c;并将其传送到指定的观察端口&#xff0c;以便对网络流量进行分析和监控。下面将详细介绍如何在华为交换机上配置本地端口镜像&#xff0c;以N:1镜像…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            IDEA设置作者信息 日期等
                        

                      

                      

                        

                          IDEA设置作者信息 日期等
                        

                        

                          file -> setting 或 ctrl  alt  s找到如下 然后添加注释即可  可以直接编辑5处的文字&#xff0c;在 author 后放自己的名字即可 
/*** author 你的名字* date ${DATE} ${TIME})*/当然 整体不止这些 &#xff0c;看下面的描述中&#xff0c;还有很多其他选项  
也可以 4 
这…
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
                  

                    

                      

                        

                          
                            【stm32can】
                        

                      

                      

                        

                          【stm32can】
                        

                        

                          can时钟 can波特率计算&#xff08;位同步内容&#xff09; 
ss是固定的1tq&#xff0c; pts&#xff0c;pbs1&#xff0c;pbs2是用户设定值  同步时间段的理解有误&#xff1f; 原文出处 
数据帧 遥控帧
                        

                        

                          阅读更多...
                        

                      

                    

                  

                  
       
      
        

        

          

            



                
                
                

            

          

          

            



              
推荐文章

              
            

          


          

            


                
                
                
            

          

          

            

              
最新文章

              
            

          

          

            

            
            
            
            

          

        

      

    

    

      

        

                    Copyright @ 2022~2023