YOLOv8改进 | 模块缝合 | C2f 融合SCConv提升检测性能【CVPR2023】

news2024/9/20 0:59:56

秋招面试专栏推荐 ：深度学习算法工程师面试问题总结【百面算法工程师】——点击即可跳转

💡💡💡本专栏所有程序均经过测试，可成功执行💡💡💡

专栏目录 ：《YOLOv8改进有效涨点》专栏介绍 & 专栏目录 | 目前已有110+篇内容，内含各种Head检测头、损失函数Loss、Backbone、Neck、NMS等创新点改进——点击即可跳转

卷积神经网络（CNN）在计算机视觉任务中表现优异，但需大量计算资源。本文介绍了SCConv模块，通过减少空间和通道冗余来压缩CNN，提高效率。SCConv包含空间重构单元（SRU）和通道重构单元（CRU），分别减少空间和通道冗余。SCConv能降低模型复杂性和计算成本，同时提升性能。文章在介绍主要的原理后，将手把手教学如何进行模块的代码添加和修改，并将修改后的完整代码放在文章的最后，方便大家一键运行，小白也可轻松上手实践。以帮助您更好地学习深度学习目标检测YOLO系列的挑战。

专栏地址：YOLOv8改进——更新各种有效涨点方法——点击即可跳转  

目录

1. 原理

2. 将C2f_SCConv添加到yolov8网络中

2.1 C2f_SCConv代码实现

2.2 C2f_SCConv的神经网络模块代码解析

2.3 更改init.py文件

2.4 添加yaml文件

2.5 注册模块

2.6 执行程序

3. 完整代码分享

4. GFLOPs

5. 进阶

6. 总结

1. 原理

论文地址：SCConv: Spatial and Channel Reconstruction Convolution for Feature Redundancy——点击即可跳转

官方代码： 官方代码仓库——点击即可跳转

SCConv（空间和通道重构卷积）是一个卷积模块，减少卷积神经网络（CNN）中空间和通道维度的特征冗余。其主要目的是降低计算成本，在不牺牲性能的情况下改善特征表示。该模块由两个主要组件组成：

  1. 空间重构单元（SRU）： 该单元通过使用组归一化缩放因子将特征图分为信息量大的部分和信息量小的部分来解决空间冗余问题。它通过组合这两个部分来重构特征，以创建空间细化特征，减少冗余并增强空间特征表示。

  2. 通道重构单元（CRU）： 该单元通过将特征图分成两组并应用不同的卷积运算（如分组和点卷积）来处理通道冗余。然后，它自适应地融合转换后的特征，减少通道维度的冗余并提高特征提取效率。

同时，SRU 和 CRU 被依次应用，以减少空间和通道冗余。SCConv 可以集成到现有的 CNN 架构中，取代标准卷积，以提高性能，同时减少参数数量和 FLOP（浮点运算）。

2. 将C2f_SCConv添加到yolov8网络中

2.1 C2f_SCConv代码实现

关键步骤一: 将下面代码粘贴到在/ultralytics/ultralytics/nn/modules/block.py中，并在该文件的__all__中添加“C2f_SCConv”


class GroupBatchnorm2d(nn.Module):
    def __init__(self, c_num:int, 
                 group_num:int = 16, 
                 eps:float = 1e-10
                 ):
        super(GroupBatchnorm2d,self).__init__()
        assert c_num    >= group_num
        self.group_num  = group_num
        self.gamma      = nn.Parameter(torch.randn(c_num, 1, 1))
        self.beta       = nn.Parameter(torch.zeros(c_num, 1, 1))
        self.eps        = eps

    def forward(self, x):
        N, C, H, W  = x.size()
        x           = x.view(   N, self.group_num, -1   )
        mean        = x.mean(   dim = 2, keepdim = True )
        std         = x.std (   dim = 2, keepdim = True )
        x           = (x - mean) / (std+self.eps)
        x           = x.view(N, C, H, W)
        return x * self.gamma + self.beta

class SRU(nn.Module):
    def __init__(self,
                 oup_channels:int, 
                 group_num:int = 16,
                 gate_treshold:float = 0.5 
                 ):
        super().__init__()
        
        self.gn             = GroupBatchnorm2d( oup_channels, group_num = group_num )
        self.gate_treshold  = gate_treshold
        self.sigomid        = nn.Sigmoid()

    def forward(self,x):
        gn_x        = self.gn(x)
        w_gamma     = self.gn.gamma/sum(self.gn.gamma)
        reweigts    = self.sigomid( gn_x * w_gamma )
        # Gate
        info_mask   = reweigts>=self.gate_treshold
        noninfo_mask= reweigts<self.gate_treshold
        x_1         = info_mask * x
        x_2         = noninfo_mask * x
        x           = self.reconstruct(x_1,x_2)
        return x
    
    def reconstruct(self,x_1,x_2):
        x_11,x_12 = torch.split(x_1, x_1.size(1)//2, dim=1)
        x_21,x_22 = torch.split(x_2, x_2.size(1)//2, dim=1)
        return torch.cat([ x_11+x_22, x_12+x_21 ],dim=1)


class CRU(nn.Module):
    '''
    alpha: 0<alpha<1
    '''
    def __init__(self, 
                 op_channel:int,
                 alpha:float = 1/2,
                 squeeze_radio:int = 2 ,
                 group_size:int = 2,
                 group_kernel_size:int = 3,
                 ):
        super().__init__()
        self.up_channel     = up_channel   =   int(alpha*op_channel)
        self.low_channel    = low_channel  =   op_channel-up_channel
        self.squeeze1       = nn.Conv2d(up_channel,up_channel//squeeze_radio,kernel_size=1,bias=False)
        self.squeeze2       = nn.Conv2d(low_channel,low_channel//squeeze_radio,kernel_size=1,bias=False)
        #up
        self.GWC            = nn.Conv2d(up_channel//squeeze_radio, op_channel,kernel_size=group_kernel_size, stride=1,padding=group_kernel_size//2, groups = group_size)
        self.PWC1           = nn.Conv2d(up_channel//squeeze_radio, op_channel,kernel_size=1, bias=False)
        #low
        self.PWC2           = nn.Conv2d(low_channel//squeeze_radio, op_channel-low_channel//squeeze_radio,kernel_size=1, bias=False)
        self.advavg         = nn.AdaptiveAvgPool2d(1)

    def forward(self,x):
        # Split
        up,low  = torch.split(x,[self.up_channel,self.low_channel],dim=1)
        up,low  = self.squeeze1(up),self.squeeze2(low)
        # Transform
        Y1      = self.GWC(up) + self.PWC1(up)
        Y2      = torch.cat( [self.PWC2(low), low], dim= 1 )
        # Fuse
        out     = torch.cat( [Y1,Y2], dim= 1 )
        out     = F.softmax( self.advavg(out), dim=1 ) * out
        out1,out2 = torch.split(out,out.size(1)//2,dim=1)
        return out1+out2


class ScConv(nn.Module):
    # https://github.com/cheng-haha/ScConv/blob/main/ScConv.py
    def __init__(self,
                op_channel:int,
                group_num:int = 16,
                gate_treshold:float = 0.5,
                alpha:float = 1/2,
                squeeze_radio:int = 2 ,
                group_size:int = 2,
                group_kernel_size:int = 3,
                 ):
        super().__init__()
        self.SRU = SRU(op_channel, 
                       group_num            = group_num,  
                       gate_treshold        = gate_treshold)
        self.CRU = CRU(op_channel, 
                       alpha                = alpha, 
                       squeeze_radio        = squeeze_radio ,
                       group_size           = group_size ,
                       group_kernel_size    = group_kernel_size)
    
    def forward(self,x):
        x = self.SRU(x)
        x = self.CRU(x)
        return x

class Bottleneck_ScConv(Bottleneck):
    def __init__(self, c1, c2, shortcut=True, g=1, k=(3, 3), e=0.5):
        super().__init__(c1, c2, shortcut, g, k, e)
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, k[0], 1)
        self.cv2 = ScConv(c2)

class C3_ScConv(C3):
    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
        super().__init__(c1, c2, n, shortcut, g, e)
        c_ = int(c2 * e)  # hidden channels
        self.m = nn.Sequential(*(Bottleneck_ScConv(c_, c_, shortcut, g, k=((1, 1), (3, 3)), e=1.0) for _ in range(n)))

class C2f_ScConv(C2f):
    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
        super().__init__(c1, c2, n, shortcut, g, e)
        self.m = nn.ModuleList(Bottleneck_ScConv(self.c, self.c, shortcut, g, k=(3, 3), e=1.0) for _ in range(n))

2.2 C2f_SCConv的神经网络模块代码解析

C2f_ScConv 是一个自定义神经网络模块，它通过合并 ScConv 来扩展 C2f 架构，ScConv 是两个单元的组合：空间重构单元 (SRU) 和通道重构单元 (CRU)。

空间和通道重构 (ScConv)：

ScConv 模块集成了 SRU 和 CRU，以解决特征图中的空间和通道冗余。

  • SRU：使用组批量归一化 (GroupBatchnorm2d) 分离空间冗余特征，并通过门控机制重构信息和非信息部分。

  • CRU：将通道分为两部分（高信息通道和低信息通道），并应用轻量级卷积操作（分组和点卷积）来有效地转换和融合这些特征。

Bottleneck_ScConv: 在 C2f_ScConv 块中，每个瓶颈层都被 Bottleneck_ScConv 替换，后者使用 ScConv 作为其转换层的一部分。这为标准瓶颈结构添加了特征重构能力，增强了特征表示，同时减少了冗余。

C2f 结构: C2f_ScConv 块继承了 C2f 的核心结构，它使用模块列表 (self.m) 堆叠多个瓶颈层（现在使用 ScConv）。此设置允许模型以更精细的方式处理特征，利用 ScConv 提供的空间和通道优化。

C2f_ScConv 的主要目标是通过减少不必要的计算来改进特征学习，使其在保持或提高性能的同时更加高效。

2.3 更改init.py文件

关键步骤二：修改modules文件夹下的__init__.py文件，先导入函数    

然后在下面的__all__中声明函数

2.4 添加yaml文件

关键步骤三：在/ultralytics/ultralytics/cfg/models/v8下面新建文件yolov8_C2f_SCConv.yaml文件，粘贴下面的内容

  •  OD【目标检测】
# Ultralytics YOLO 🚀, AGPL-3.0 license
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect

# Parameters
nc: 80  # number of classes
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
  # [depth, width, max_channels]
  n: [0.33, 0.25, 1024]  # YOLOv8n summary: 225 layers,  3157200 parameters,  3157184 gradients,   8.9 GFLOPs
  s: [0.33, 0.50, 1024]  # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients,  28.8 GFLOPs
  m: [0.67, 0.75, 768]   # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients,  79.3 GFLOPs
  l: [1.00, 1.00, 512]   # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
  x: [1.00, 1.25, 512]   # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs

# YOLOv8.0n backbone
backbone:
  # [from, repeats, module, args]
  - [-1, 1, Conv, [64, 3, 2]]  # 0-P1/2
  - [-1, 1, Conv, [128, 3, 2]]  # 1-P2/4
  - [-1, 3, C2f_ScConv, [128, True]]
  - [-1, 1, Conv, [256, 3, 2]]  # 3-P3/8
  - [-1, 6, C2f_ScConv, [256, True]]
  - [-1, 1, Conv, [512, 3, 2]]  # 5-P4/16
  - [-1, 6, C2f_ScConv, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]]  # 7-P5/32
  - [-1, 3, C2f_ScConv, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]]  # 9

# YOLOv8.0n head
head:
  - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
  - [[-1, 6], 1, Concat, [1]]  # cat backbone P4
  - [-1, 3, C2f_ScConv, [512]]  # 12

  - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
  - [[-1, 4], 1, Concat, [1]]  # cat backbone P3
  - [-1, 3, C2f_ScConv, [256]]  # 15 (P3/8-small)

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 12], 1, Concat, [1]]  # cat head P4
  - [-1, 3, C2f_ScConv, [512]]  # 18 (P4/16-medium)

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 9], 1, Concat, [1]]  # cat head P5
  - [-1, 3, C2f_ScConv, [1024]]  # 21 (P5/32-large)

  - [[15, 18, 21], 1, Detect, [nc]]  # Detect(P3, P4, P5)
  • Seg【语义分割】
# Ultralytics YOLO 🚀, AGPL-3.0 license
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect

# Parameters
nc: 80  # number of classes
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
  # [depth, width, max_channels]
  n: [0.33, 0.25, 1024]  # YOLOv8n summary: 225 layers,  3157200 parameters,  3157184 gradients,   8.9 GFLOPs
  s: [0.33, 0.50, 1024]  # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients,  28.8 GFLOPs
  m: [0.67, 0.75, 768]   # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients,  79.3 GFLOPs
  l: [1.00, 1.00, 512]   # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
  x: [1.00, 1.25, 512]   # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs

# YOLOv8.0n backbone
backbone:
  # [from, repeats, module, args]
  - [-1, 1, Conv, [64, 3, 2]]  # 0-P1/2
  - [-1, 1, Conv, [128, 3, 2]]  # 1-P2/4
  - [-1, 3, C2f_ScConv, [128, True]]
  - [-1, 1, Conv, [256, 3, 2]]  # 3-P3/8
  - [-1, 6, C2f_ScConv, [256, True]]
  - [-1, 1, Conv, [512, 3, 2]]  # 5-P4/16
  - [-1, 6, C2f_ScConv, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]]  # 7-P5/32
  - [-1, 3, C2f_ScConv, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]]  # 9

# YOLOv8.0n head
head:
  - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
  - [[-1, 6], 1, Concat, [1]]  # cat backbone P4
  - [-1, 3, C2f_ScConv, [512]]  # 12

  - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
  - [[-1, 4], 1, Concat, [1]]  # cat backbone P3
  - [-1, 3, C2f_ScConv, [256]]  # 15 (P3/8-small)

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 12], 1, Concat, [1]]  # cat head P4
  - [-1, 3, C2f_ScConv, [512]]  # 18 (P4/16-medium)

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 9], 1, Concat, [1]]  # cat head P5
  - [-1, 3, C2f_ScConv, [1024]]  # 21 (P5/32-large)

  - [[15, 18, 21], 1, Segment, [nc, 32, 256]] # Segment(P3, P4, P5)

温馨提示：因为本文只是对yolov8基础上添加模块，如果要对yolov8n/l/m/x进行添加则只需要指定对应的depth_multiple 和 width_multiple。不明白的同学可以看这篇文章： yolov8yaml文件解读——点击即可跳转 

# YOLOv8n
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.25  # layer channel multiple
max_channels: 1024 # max_channels
 
# YOLOv8s
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.50  # layer channel multiple
max_channels: 1024 # max_channels
 
# YOLOv8l 
depth_multiple: 1.0  # model depth multiple
width_multiple: 1.0  # layer channel multiple
max_channels: 512 # max_channels
 
# YOLOv8m
depth_multiple: 0.67  # model depth multiple
width_multiple: 0.75  # layer channel multiple
max_channels: 768 # max_channels
 
# YOLOv8x
depth_multiple: 1.33  # model depth multiple
width_multiple: 1.25  # layer channel multiple
max_channels: 512 # max_channels

2.5 注册模块

关键步骤四：在task.py的parse_model函数中注册

2.6 执行程序

在train.py中，将model的参数路径设置为yolov8_C2f_SCConv.yaml的路径

建议大家写绝对路径，确保一定能找到 

from ultralytics import YOLO
import warnings
warnings.filterwarnings('ignore')
from pathlib import Path
 
if __name__ == '__main__':
 
 
    # 加载模型
    model = YOLO("ultralytics/cfg/v8/yolov8.yaml")  # 你要选择的模型yaml文件地址
    # Use the model
    results = model.train(data=r"你的数据集的yaml文件地址",
                          epochs=100, batch=16, imgsz=640, workers=4, name=Path(model.cfg).stem)  # 训练模型

  🚀运行程序，如果出现下面的内容则说明添加成功🚀 

                   from  n    params  module                                       arguments
  0                  -1  1       464  ultralytics.nn.modules.conv.Conv             [3, 16, 3, 2]
  1                  -1  1      4672  ultralytics.nn.modules.conv.Conv             [16, 32, 3, 2]
  2                  -1  1      5536  ultralytics.nn.modules.block.C2f_ScConv      [32, 32, 1, True]
  3                  -1  1     18560  ultralytics.nn.modules.conv.Conv             [32, 64, 3, 2]
  4                  -1  2     35008  ultralytics.nn.modules.block.C2f_ScConv      [64, 64, 2, True]
  5                  -1  1     73984  ultralytics.nn.modules.conv.Conv             [64, 128, 3, 2]
  6                  -1  2    138880  ultralytics.nn.modules.block.C2f_ScConv      [128, 128, 2, True]
  7                  -1  1    295424  ultralytics.nn.modules.conv.Conv             [128, 256, 3, 2]
  8                  -1  1    342656  ultralytics.nn.modules.block.C2f_ScConv      [256, 256, 1, True]
  9                  -1  1    164608  ultralytics.nn.modules.block.SPPF            [256, 256, 5]
 10                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']
 11             [-1, 6]  1         0  ultralytics.nn.modules.conv.Concat           [1]
 12                  -1  1    118848  ultralytics.nn.modules.block.C2f_ScConv      [384, 128, 1]
 13                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']
 14             [-1, 4]  1         0  ultralytics.nn.modules.conv.Concat           [1]
 15                  -1  1     29920  ultralytics.nn.modules.block.C2f_ScConv      [192, 64, 1]
 16                  -1  1     36992  ultralytics.nn.modules.conv.Conv             [64, 64, 3, 2]
 17            [-1, 12]  1         0  ultralytics.nn.modules.conv.Concat           [1]
 18                  -1  1     94272  ultralytics.nn.modules.block.C2f_ScConv      [192, 128, 1]
 19                  -1  1    147712  ultralytics.nn.modules.conv.Conv             [128, 128, 3, 2]
 20             [-1, 9]  1         0  ultralytics.nn.modules.conv.Concat           [1]
 21                  -1  1    375424  ultralytics.nn.modules.block.C2f_ScConv      [384, 256, 1]
 22        [15, 18, 21]  1    897664  ultralytics.nn.modules.head.Detect           [80, [64, 128, 256]]
YOLOv8_C2f_ScConv summary: 305 layers, 2780624 parameters, 2780608 gradients, 7.9 GFLOPs

3. 完整代码分享

https://pan.baidu.com/s/1ltsFj8LsgeseaVbvqY_GBw?pwd=cy7t

 提取码: cy7t 

4. GFLOPs

关于GFLOPs的计算方式可以查看：百面算法工程师 | 卷积基础知识——Convolution

未改进的YOLOv8nGFLOPs

img

改进后的GFLOPs

5. 进阶

可以与其他的注意力机制或者损失函数等结合，进一步提升检测效果

6. 总结

SCConv（空间与通道重建卷积）通过同时减少卷积神经网络（CNN）中的空间和通道冗余，提升计算效率和特征表达能力。SCConv模块由两部分组成：空间重建单元（SRU）和通道重建单元（CRU）。SRU通过基于权重的分离和重构操作，分离出空间冗余较少的特征，并通过交叉重构增强有信息的特征，同时抑制空间冗余。CRU采用“分割-变换-融合”的策略，先将特征图通道划分为两部分，再分别应用高效的卷积操作（如组卷积和点卷积），以减少通道冗余。最后，通过自适应融合机制结合两类特征，进一步提升特征表达能力。SCConv可以无缝嵌入各种现有的CNN架构，代替标准卷积操作，在减少模型参数和计算量的同时，提升性能，尤其适用于在资源受限环境下的模型部署。

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

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

相关文章

智能负载均衡：分布式缓存的高效能解决方案

智能负载均衡：分布式缓存的高效能解决方案

在当今快速发展的互联网时代&#xff0c;分布式缓存成为了提升网站性能和用户体验的关键技术。本文将深入探讨负载均衡算法在分布式缓存中的应用&#xff0c;分析各种算法的优缺点&#xff0c;并提供选择最佳算法的指导。通过实际案例&#xff0c;我们将展示如何通过智能的负载…
阅读更多...
2024 年塑造 SaaS 安全的 7 大趋势

2024 年塑造 SaaS 安全的 7 大趋势

在过去的几年里&#xff0c;SaaS已经发展成为企业IT的支柱。医疗实践、律师事务所和金融服务公司等服务企业几乎完全基于 SaaS。非服务企业&#xff08;包括制造商和零售商&#xff09;将大约 70% 的软件运行在云中。 这些应用程序包含大量数据&#xff0c;从最低敏感的一般公司…
阅读更多...
黑马点评25—原理—Redis网络模型

黑马点评25—原理—Redis网络模型

文章目录 原理篇-Redis网络模型1 用户空间和内核态空间2.网络模型-阻塞IO3 网络模型-非阻塞IO4 网络模型-IO多路复用5 网络模型-IO多路复用-select方式6 网络模型-IO多路复用模型-poll模式7 网络模型-IO多路复用模型-epoll函数8、网络模型-epoll中的ET和LT9 网络模型-基于epoll…
阅读更多...
wireshark打开时空白|没有接口，卸载重装可以解决

wireshark打开时空白|没有接口，卸载重装可以解决

解决方法&#xff1a;卸载wireshark,全选卸载干净&#xff0c;重新安装旧版的wireshark4.2.7, 甚至cmd下运行net start npf时显示服务名无效&#xff0c;但打开wireshark仍有多个接口 错误描述&#xff1a; 一开始下载的是wireshark的最新版&#xff0c;win11 x64 在安装wir…
阅读更多...
JAVA——方法

JAVA——方法

public static 返回值类型 方法名(参数){//方法体return 数据; } 一、定义与调用 public class demo9_12 {public static void main(String[] args) {// 调用myName();}//定义public static void myName(){System.out.println("Hello World");} } 运行 二、含参数…
阅读更多...
STM32G474之CALIB输出

STM32G474之CALIB输出

STM32G474之CALIB输出源是1Hz和512Hz的时钟源。通过测试输出波形&#xff0c;计算RTC输入时钟和理论值之间的误差&#xff0c;为“校准”服务的。 1、CALIB输出原理 2、CALIB输出测试程序 #include "RTC.h" #include "stdio.h" //getchar(),putchar(),s…
阅读更多...
蓝桥杯4. Fizz Buzz 经典问题

蓝桥杯4. Fizz Buzz 经典问题

题目描述 给定一个整数 NN&#xff0c;从 1 到 NN 按照下面的规则返回每个数&#xff1a; 如果这个数被 3 整除&#xff0c;返回 Fizz。如果这个数被 5 整除&#xff0c;返回 Buzz如果这个数能同时被 3 和 5 整除&#xff0c;返回 FizzBuzz。如果这个数既不能被 3 也不能被 5…
阅读更多...
智能医学（四）——Elsevier特刊推荐

智能医学（四）——Elsevier特刊推荐

特刊征稿 01 期刊名称&#xff1a; Information Sciences 特刊名称&#xff1a; Open-world Multi-modal Machine Learning for Uncertain Medicine and Healthcare Big Data Analysis 截止时间&#xff1a; 提交开放日期&#xff1a;2024 年 6 月 15 日 最终手稿提交截止…
阅读更多...
sass实现文字两侧横线

sass实现文字两侧横线

sass实现文字两侧横线 自我记录 mixin 的基本作用&#xff1a; 代码复用&#xff1a;把常用的样式封装在一起&#xff0c;不需要重复写相同的代码。参数化&#xff1a;可以通过参数动态生成样式&#xff0c;提高灵活性。逻辑处理&#xff1a;结合 Sass 的控制语句&#xff0…
阅读更多...
CAD 3dsmax maya等autodesk系列专用卸载修复工具AutoRemove,一键完全彻底卸载删除软件的专用卸载工具

CAD 3dsmax maya等autodesk系列专用卸载修复工具AutoRemove,一键完全彻底卸载删除软件的专用卸载工具

AutoRemove 是一款功能强大的软件卸载工具&#xff0c;专门设计用于彻底清除Autodesk系列软件&#xff0c;如AutoCAD、3ds Max、Revit、Maya、Inventor、Navisworks、civil 3d、sketchbook、Architecture、Electrical、Mechanical、、等&#xff0c;从您的系统中。它通过深度清…
阅读更多...
learn C++ NO.13——list

learn C++ NO.13——list

前言 本文将从list的使用&#xff0c;再到根据sgi库对于list实现作为参考模拟实现一下list。通过模拟实现来增加对它的理解。 介绍list list是一个由带头双向循环链表实现的STL容器&#xff0c;它提供常规时间内对数据进行插入和删除操作。 list在内存中存储不连续的空间存储…
阅读更多...
Kamailio-超强dispatcher负载均衡模块

Kamailio-超强dispatcher负载均衡模块

Kamailio 负载均衡的功能主要依靠 Dispatcher 模块完成&#xff0c;模块官方文档参看 为什么要引入负载均衡&#xff1f;如何使用&#xff1f; 引入和配置功能路由调用命令行指令 为什么要引入负载均衡&#xff1f; Q: 如果单台VOIP服务的性能不能满足业务需求了&#xff0…
阅读更多...
掌握ZooKeeper的二阶段提交及其优缺点

掌握ZooKeeper的二阶段提交及其优缺点

1. ZooKeeper的协议 1.1 ZAB协议 要深入学习ZooKeeper前&#xff0c;胡广认为我们要先学习ZooKeeper的核心理念&#xff0c;所有的ZooKeeper行为都是围绕这个核心来进行的。说了那么多&#xff0c;它就是——ZAB协议。 ZAB协议英文全称叫ZooKeeper Atomic Broadcast&#xf…
阅读更多...
TIDB的整体架构和主要功能

TIDB的整体架构和主要功能

1. 基础架构 PD &#xff1a;负责集群管理和调度。TiDB Server &#xff1a;负责 SQL 查询处理。TiKV/TiFlash&#xff1a;负责数据存储和事务处理。 1.1 PD (Placement Driver) Server 1.1.1 基础介绍 整个 TiDB 集群的元信息管理模块&#xff0c;负责存储每个 TiKV 节点实时…
阅读更多...
让我们聊一下小团队也可以用的敏捷开发

让我们聊一下小团队也可以用的敏捷开发

使用敏捷开发的团队往往需要寻找一个更佳的平衡点&#xff1a; 较少的团队成员&#xff1a;通常更容易沟通和协作&#xff0c;减少了协调成本。小团队&#xff08;如 5 到 9 人&#xff09;能够更灵活地适应变化&#xff0c;且管理和决策过程较为高效。 较多的团队成员&#x…
阅读更多...
喜报 | 知从科技荣获 “AutoSec 安全之星 - 优秀汽车软件供应链安全方案奖”

喜报 | 知从科技荣获 “AutoSec 安全之星 - 优秀汽车软件供应链安全方案奖”

近日&#xff0c;「AutoSec 2024第八届中国汽车网络安全周暨第五届智能汽车数据安全展」在上海盛大举行。本届大会由谈思实验室和谈思汽车主办、上海市车联网协会联合主办&#xff0c;以汽车“网络数据安全、软件安全、功能安全”为主题&#xff0c;设置了“31X”模式&#xff…
阅读更多...
Docker学习笔记-部署MySQL-命令解读

Docker学习笔记-部署MySQL-命令解读

部署MySQL 先停掉虚拟机中的MySQL&#xff0c;确保你的虚拟机已经安装Docker&#xff0c;且网络开通的情况下&#xff0c;在MobaXterm中执行下面命令即可安装MySQL。 docker run -d \--name mysql \-p 3306:3306 \-e TZAsia/Shanghai \-e MYSQL_ROOT_PASSWORD123456 \mysql …
阅读更多...
c++修炼之路之AVL树与红黑树

c++修炼之路之AVL树与红黑树

目录 一&#xff1a;AVL树 1.AVL树的概念 2.AVL树插入数据后平衡因子及更新的情况 3.AVL树节点的定义 4.AVL树的插入及旋转 二&#xff1a;红黑树 1.红黑树的概念及性质 2.红黑树节点的定义 3.红黑树的插入操作情况 4.红黑树与AVL树的比较 接下来的日子会顺顺利利…
阅读更多...
多方位实测运动耳机排行榜前十名，助你选出靠谱的运动耳机！

多方位实测运动耳机排行榜前十名，助你选出靠谱的运动耳机！

非常荣幸能与各位运动爱好者共聚本次的骨传导耳机知识分享&#xff01;作为一名深耕运动科技领域多年的专家&#xff0c;今天将主要跟大家分析一下市面上比较热门的骨传导耳机。骨传导耳机作为当下市面上非常新颖且有创意的耳机种类&#xff0c;相信有很多用户都想入手一款&…
阅读更多...
流片为啥那么重要？

流片为啥那么重要？

很多微电子与集成电路专业的学生、初入IC职场的工程师&#xff0c;以及电子/机械大类专业的同学&#xff0c;在进入芯片设计行业时&#xff0c;都或多或少听说了参与流片的重要性。 但是却并不是很清楚——流片到底有多重要&#xff1f;流片为什么重要&#xff1f; 研0的同学…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023