YOLOv8改进 | 融合改进 | C2f融合Faster模块提升检测速度【完整代码 + 主要代码解析】

news2024/11/15 14:04:20

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

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

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

为了加速神经网络，通常减少浮点运算（FLOPs），但FLOPs降低并不总是等同于延迟降低。这是因为运算效率低，尤其是深度可分离卷积频繁内存访问。本文介绍一种部分卷积（PConv）以高效提取特征，减少冗余计算和内存访问。基于PConv，构建了FasterNet神经网络，它在多种设备上运行更快，且机会不影响视觉任务的准确性。文章在介绍主要的原理后，将手把手教学如何进行模块的代码添加和修改，并将修改后的完整代码放在文章的最后，方便大家一键运行，小白也可轻松上手实践。以帮助您更好地学习深度学习目标检测YOLO系列的挑战。

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

目录

1. 原理

2. 将C2f_Faster添加到yolov8网络中

2.1 C2f_Faster 代码实现

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

2.3 更改init.py文件

2.4 添加yaml文件

2.5 注册模块

2.6 执行程序

3. 完整代码分享

4. GFLOPs

5. 进阶

6. 总结

1. 原理

论文地址：Run, Don’t Walk: Chasing Higher FLOPS for Faster Neural Networks——点击即可跳转

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

FasterNet 神经网络，主要侧重于提高计算速度（FLOPS - 每秒浮点运算次数），同时保持浮点运算 (FLOP) 数量较低。核心思想是，由于许多现有方法的内存访问效率低下和 FLOPS 较低，减少 FLOP 并不总是意味着降低延迟或提高性能。

关键概念和创新

  1. FLOP 与 FLOPS：

  • 加速神经网络的传统方法侧重于降低 FLOP，这衡量了计算复杂度。然而，这并不一定会降低延迟，因为它忽略了实际的计算速度，即 FLOPS。

  • FLOPS 表示每秒可以执行多少次浮点运算，并直接影响网络的实际速度。作者认为，仅仅减少 FLOP 而不考虑 FLOPS 在某些情况下甚至可能会增加延迟。

内存访问瓶颈：

  • 许多现有运算符，如深度卷积 (DWConv)，都存在频繁内存访问的问题，这会降低整体计算速度。尽管这些运算符在 FLOP 方面很高效，但它们通常会导致较低的 FLOPS，从而增加延迟。

部分卷积 (PConv)：

  • 为了解决这些低效率问题，本文提出了一种称为部分卷积 (PConv) 的新运算符。PConv 通过将卷积滤波器仅应用于部分输入通道，而其余通道保持不变，从而减少了计算冗余。这种方法减少了 FLOP 并增加了 FLOPS，从而缩短了执行时间。

  • PConv 能够有效地提取空间特征，同时减少内存访问，这是提高 CPU 和 GPU 等设备的实际处理速度的关键因素。

FasterNet：

  • FasterNet 以 PConv 为基础，是一个新的神经网络系列，旨在在不牺牲准确性的情况下在各种设备上普遍更快。例如，较小的变体 FasterNet-T0 比 MobileViT-XXS 等竞争模型更快、更准确。

  • FasterNet 的设计考虑了实际部署，确保它在各种硬件配置（包括 GPU、CPU 和 ARM 处理器）上都能表现良好。

结论

FasterNet 代表了神经网络架构的进步，它解决了计算复杂度 (FLOP) 和实际计算速度 (FLOPS) 问题。通过引入 PConv 并强调高效的内存访问，它在不同设备上实现了更快的性能，同时与现有模型相比保持甚至提高了准确性。

2. 将C2f_Faster添加到yolov8网络中

2.1 C2f_Faster 代码实现

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

   
from timm.models.layers import DropPath
class Partial_conv3(nn.Module):
    def __init__(self, dim, n_div=4, forward='split_cat'):
        super().__init__()
        self.dim_conv3 = dim // n_div
        self.dim_untouched = dim - self.dim_conv3
        self.partial_conv3 = nn.Conv2d(self.dim_conv3, self.dim_conv3, 3, 1, 1, bias=False)

        if forward == 'slicing':
            self.forward = self.forward_slicing
        elif forward == 'split_cat':
            self.forward = self.forward_split_cat
        else:
            raise NotImplementedError

    def forward_slicing(self, x):
        # only for inference
        x = x.clone()   # !!! Keep the original input intact for the residual connection later
        x[:, :self.dim_conv3, :, :] = self.partial_conv3(x[:, :self.dim_conv3, :, :])
        return x

    def forward_split_cat(self, x):
        # for training/inference
        x1, x2 = torch.split(x, [self.dim_conv3, self.dim_untouched], dim=1)
        x1 = self.partial_conv3(x1)
        x = torch.cat((x1, x2), 1)
        return x

class Faster_Block(nn.Module):
    def __init__(self,
                 inc,
                 dim,
                 n_div=4,
                 mlp_ratio=2,
                 drop_path=0.1,
                 layer_scale_init_value=0.0,
                 pconv_fw_type='split_cat'
                 ):
        super().__init__()
        self.dim = dim
        self.mlp_ratio = mlp_ratio
        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
        self.n_div = n_div

        mlp_hidden_dim = int(dim * mlp_ratio)

        mlp_layer = [
            Conv(dim, mlp_hidden_dim, 1),
            nn.Conv2d(mlp_hidden_dim, dim, 1, bias=False)
        ]

        self.mlp = nn.Sequential(*mlp_layer)

        self.spatial_mixing = Partial_conv3(
            dim,
            n_div,
            pconv_fw_type
        )
        
        self.adjust_channel = None
        if inc != dim:
            self.adjust_channel = Conv(inc, dim, 1)

        if layer_scale_init_value > 0:
            self.layer_scale = nn.Parameter(layer_scale_init_value * torch.ones((dim)), requires_grad=True)
            self.forward = self.forward_layer_scale
        else:
            self.forward = self.forward

    def forward(self, x):
        if self.adjust_channel is not None:
            x = self.adjust_channel(x)
        shortcut = x
        x = self.spatial_mixing(x)
        x = shortcut + self.drop_path(self.mlp(x))
        return x

    def forward_layer_scale(self, x):
        shortcut = x
        x = self.spatial_mixing(x)
        x = shortcut + self.drop_path(
            self.layer_scale.unsqueeze(-1).unsqueeze(-1) * self.mlp(x))
        return x

class C3_Faster(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(*(Faster_Block(c_, c_) for _ in range(n)))

class C2f_Faster(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(Faster_Block(self.c, self.c) for _ in range(n))

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

1. 初始化与参数设定 (__init__ 方法):

  • 输入参数:

    • inc: 输入特征图的通道数。

    • dim: 模块中间层的通道数（也即输出的通道数）。

    • n_div: 部分卷积(Partial_conv3)的分割因子，用于控制部分卷积操作的分组数。

    • mlp_ratio: MLP层的宽度倍率，决定了中间层的隐藏通道数。

    • drop_path: DropPath概率，决定了跳跃连接中随机失活的比例。

    • layer_scale_init_value: 层级缩放因子初始值，控制了残差连接中输出的缩放比例。

    • pconv_fw_type: 部分卷积的前向传播类型。

  • 内部层:

    • mlp: 包含两个1x1卷积层的MLP层，用于通道之间的特征变换。

    • spatial_mixing: 使用Partial_conv3实现的部分卷积层，用于空间信息混合。

    • adjust_channel: 当输入通道数inc与模块的通道数dim不一致时，用于调整通道数的一层1x1卷积。

2. 前向传播 (forward 方法):

  • 通道调整:

    • 如果输入通道数不等于目标通道数dim，则通过adjust_channel调整输入通道数。

  • 部分卷积 (spatial_mixing):

    • 将输入特征图通过Partial_conv3进行部分卷积操作，这一步通过分割因子n_div将输入通道分为若干组，并对每组执行卷积操作。此步骤提取空间特征，同时减少了计算量。

  • MLP与残差连接:

    • 将部分卷积后的特征图输入到MLP层，进行通道间的特征变换。

    • 使用残差连接将输入的快捷路径(shortcut)与MLP的输出相加，这有助于在训练过程中稳定梯度传递。

    • 如果启用了DropPath，则在加和之前随机失活一部分路径，以增加模型的鲁棒性。

3. 层级缩放 (forward_layer_scale 方法):

  • 作用:

    • 如果layer_scale_init_value大于0，使用层级缩放因子调整残差连接的输出权重。

    • 在计算MLP输出时，残差连接中的输出会乘以一个可学习的缩放因子（layer_scale），以更好地控制不同层之间的特征信息。

  • 步骤:

    • layer_scale参数会按通道展开（使用unsqueeze），与MLP输出相乘，之后再加到输入的快捷路径(shortcut)上。

总结

Faster_Block通过结合部分卷积和MLP层，在保持高效特征提取的同时减少了计算量和内存访问。残差连接确保了信息的有效传递，而可选的层级缩放提供了额外的模型灵活性，有助于提高训练和推理的稳定性与效率。

2.3 更改init.py文件

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

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

2.4 添加yaml文件

关键步骤三：在/ultralytics/ultralytics/cfg/models/v8下面新建文件yolov8_C2f_Faster.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_Faster, [128, True]]
  - [-1, 1, Conv, [256, 3, 2]]  # 3-P3/8
  - [-1, 6, C2f_Faster, [256, True]]
  - [-1, 1, Conv, [512, 3, 2]]  # 5-P4/16
  - [-1, 6, C2f_Faster, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]]  # 7-P5/32
  - [-1, 3, C2f_Faster, [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_Faster, [512]]  # 12

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

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

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 9], 1, Concat, [1]]  # cat head P5
  - [-1, 3, C2f_Faster, [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_Faster, [128, True]]
  - [-1, 1, Conv, [256, 3, 2]]  # 3-P3/8
  - [-1, 6, C2f_Faster, [256, True]]
  - [-1, 1, Conv, [512, 3, 2]]  # 5-P4/16
  - [-1, 6, C2f_Faster, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]]  # 7-P5/32
  - [-1, 3, C2f_Faster, [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_Faster, [512]]  # 12

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

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

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 9], 1, Concat, [1]]  # cat head P5
  - [-1, 3, C2f_Faster, [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_Faster.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      3920  ultralytics.nn.modules.block.C2f_Faster      [32, 32, 1, True]
  3                  -1  1     18560  ultralytics.nn.modules.conv.Conv             [32, 64, 3, 2]
  4                  -1  2     22144  ultralytics.nn.modules.block.C2f_Faster      [64, 64, 2, True]
  5                  -1  1     73984  ultralytics.nn.modules.conv.Conv             [64, 128, 3, 2]
  6                  -1  2     87552  ultralytics.nn.modules.block.C2f_Faster      [128, 128, 2, True]
  7                  -1  1    295424  ultralytics.nn.modules.conv.Conv             [128, 256, 3, 2]
  8                  -1  1    240128  ultralytics.nn.modules.block.C2f_Faster      [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     93184  ultralytics.nn.modules.block.C2f_Faster      [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     23488  ultralytics.nn.modules.block.C2f_Faster      [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     68608  ultralytics.nn.modules.block.C2f_Faster      [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    272896  ultralytics.nn.modules.block.C2f_Faster      [384, 256, 1]
 22        [15, 18, 21]  1    897664  ultralytics.nn.modules.head.Detect           [80, [64, 128, 256]]
YOLOv8_c2f_faster summary: 245 layers, 2452000 parameters, 2451984 gradients, 7.1 GFLOPs

3. 完整代码分享

https://pan.baidu.com/s/1MtbUlIK6Qdso2lwSfQMgvg?pwd=1bgi

 提取码: 1bgi 

4. GFLOPs

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

未改进的YOLOv8nGFLOPs

img

改进后的GFLOPs

5. 进阶

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

6. 总结

FasterNet的主要工作原理在于通过优化神经网络的计算效率来提高实际运行速度（FLOPS），而不仅仅是减少浮点运算次数（FLOPs）。传统方法常通过减少FLOPs来降低计算复杂度，但这并不总能带来实际延迟的减少，主要因为频繁的内存访问限制了实际计算速度。为了解决这一问题，FasterNet引入了部分卷积（PConv）这一新型操作符，通过仅对部分输入通道进行卷积操作，减少了冗余计算和内存访问需求，同时保持高效的空间特征提取能力。基于PConv，FasterNet设计了一系列神经网络，在各种设备上实现了显著更快的运行速度，并在图像分类等任务中保持了较高的准确性。总的来说，FasterNet通过兼顾FLOPs和FLOPS，达到了更低的延迟和更高的吞吐量，适用于GPU、CPU和ARM处理器等多种硬件平台。

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

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

相关文章

conda环境安装与删除

conda环境安装与删除

安装 1.cmd安装 conda create -n xxxxx(名字) python3.8 进入虚拟环境 activate xxxxx(名字) 查看虚拟环境的库 pip list 退出虚拟环境 deactivate 2.pycharm直接创建 对一个项目右下角： 可以使用现有环境，也可以创建新环境 删除 在cmd中输入&…
阅读更多...
大模型在安全领域的十大应用场景及实现路径

大模型在安全领域的十大应用场景及实现路径

作为网络安全及AI的双重爱好者，笔者也一直在关注大模型在安全领域的相关应用，从目前市面上看到的产品来说，相关的结合还在一个较为早期的阶段，很多产品能力也是为了大模型而大模型，并未真正发挥其价值。 在去年上一篇相…
阅读更多...
lvgl 滚轮roller 选项循环设置

lvgl 滚轮roller 选项循环设置

lvgl 中可以通过设置滚轮的属性使所有选项循环出现，对于时间、日期之类的组件非常实用。 lv_roller_set_options(lv_obj_t * obj, const char * options, lv_roller_mode_t mode)； 这个函数的最后一个参数有两个值： LV_ROLLER_MODE_NORMAL…
阅读更多...
大模型面经——Langchain总结

大模型面经——Langchain总结

本篇介绍Langchain相关面试题。 本次将会分为上下两个部分，本篇章将会介绍前三个问题，下一次在将后三个问题补充完毕。 以下是一个快捷目录： 什么是 LangChain? LangChain 包含哪些部分？ LangChain 中 Chat Message History …
阅读更多...
49、Python之模块和包：模块导入对命名空间的影响

49、Python之模块和包：模块导入对命名空间的影响

引言 前面文章中，关于Python解释器在模块导入行为背后所执行的操作，已经做了深入的介绍。本文打算在此基础上，结合实际代码案例，进行进一步的补充说明。同时，比较看似只是微小的导入方式的改变，可能会导致…
阅读更多...
「ComfyUI」生图修图神器，自定义调节颜色光暗，更生动更强对比度生图技巧分享！

「ComfyUI」生图修图神器，自定义调节颜色光暗，更生动更强对比度生图技巧分享！

前言 ‍‍‍‍‍前 言 今天再给小伙伴们分享一个简单又实用生图神器插件，可以调整整个图像的光暗变化以及颜色变化。 原理的话，我们也简单来说下，我们在使用 VAE 将图像编码为潜在噪声时，VAE 解码的值通常在一定范围内&#xf…
阅读更多...
在Mac上打开UE4Editor

在Mac上打开UE4Editor

编译MacEditor 使用如下命令在Mac机器上编译Mac的UE4Editor： ${EnginePath}/Engine/Build/BatchFiles/Mac/Build.sh ${ProjectName}Editor Mac Development ${ProjectPath} -buildubt -buildscw -waitmutex -log${ClientPath}/Saved/Logs/${ProjectName}Editor.log…
阅读更多...
SpringBoot集成kafka-自定义拦截器(可以在拦截器中做记录日志、安全检查等操作)

SpringBoot集成kafka-自定义拦截器(可以在拦截器中做记录日志、安全检查等操作)

TOC 1、kafka配置类 kafka配置类添加Configuration注解，springboot启动后会自动读取该配置类；由于在application.yml文件中我们找不到kafak拦截器相关的配置项，因此需要自定义拦截器；消费者相关配置方法中添加自定义拦截器配置&a…
阅读更多...
FORTIFY: FD_ISSET: file descriptor 1024 ＞= FD_SETSIZE 128 记录

FORTIFY: FD_ISSET: file descriptor 1024 ＞= FD_SETSIZE 128 记录

问题 在开发过程中，遇到一个问题，即使用FD_ISSET时，当文件描述符数量超过1023，导致netd进程出现crash。通过代码和log分析，发现这是由于内核限制导致的数组越界问题。 总结：FD_ISSET(sock, &read_fds)…
阅读更多...
【日记】这个月花了好多钱（1317 字）

【日记】这个月花了好多钱（1317 字）

正文 这几天都好热。热到人不想动，只想睡觉。 今天写文章发现自己有个很显著的特点，就是在有个框架之后，具体细节完全没有预设。我只能像马尔可夫链一样，形成一个比较窄的窗口，接着这个窗口里的情节往下写，…
阅读更多...
.NET Razor类库 - 生成NuGet包

.NET Razor类库 - 生成NuGet包

上一篇讲了Razor类库组件化：https://blog.csdn.net/CsethCRM/article/details/141558974 本篇说一下Razor类库生成NuGet包 1.右键Razor类库项目 - 属性 2. 输入Nuget 包信息 点击 左侧菜单 包 在生成操作期间 创建包文件 打勾 版本号 我们输入 2023.1.0 作者 Xxx…
阅读更多...
外卖霸王餐项目是什么？怎么搭建属于自己的外卖霸王餐小程序 ？

外卖霸王餐项目是什么？怎么搭建属于自己的外卖霸王餐小程序 ？

前言： 外卖霸王餐项目是一种结合了优惠促销与推广合作的商业模式，主要针对外卖行业。这个项目的核心是通过提供低于市场价的外卖餐品（通常是半价或者更大折扣）来吸引新用户尝试，并通过用户的口碑传播来增加餐厅的知名…
阅读更多...
降本高达30%，磁集成是电源企业的福音吗？

降本高达30%，磁集成是电源企业的福音吗？

导语 为什么说磁集成将会是大功率电源产品趋势?因为终端价格战越来越激烈，只有磁集成才能同时解决电源企业的三大核心竞争需求。 终端持续“卷”价格 储能价格正式步入0.5元时代。从价格战的角度来看，储能领域自2023年起就已经进入“0.5元/Wh时代”&…
阅读更多...
集群 NAT（地址转换）、TUN（IP隧道）、DR（直接路由）

集群 NAT（地址转换）、TUN（IP隧道）、DR（直接路由）

一、企业群集应用概述 1、群集的含义 ①、Cluster、集群、群集 ②、由多台主机构成，但对外只表现为一个整体，只提供一个访问入口（域名与IP地址），相当于一台大型计算机。 2、问题 ①、互联网应用中，随着站…
阅读更多...
composer常用命令列表和实践使用、服务器lnmp环境自动化部署脚本及netstat命令常用选项笔记-及state各值的意义

composer常用命令列表和实践使用、服务器lnmp环境自动化部署脚本及netstat命令常用选项笔记-及state各值的意义

一、composer常用命令列表和实践使用 1. composer常用的命令列表如下： #. composer install 命令（composer.lock与composer.json） 如果当前目录下存在composer.lock文件，则从此文件读取依赖版本，否则就读取compose…
阅读更多...
计算机毕业设计选题推荐-社区康养管理系统-Java/Python项目实战

计算机毕业设计选题推荐-社区康养管理系统-Java/Python项目实战

✨作者主页：IT研究室✨ 个人简介：曾从事计算机专业培训教学，擅长Java、Python、微信小程序、Golang、安卓Android等项目实战。接项目定制开发、代码讲解、答辩教学、文档编写、降重等。 ☑文末获取源码☑ 精彩专栏推荐⬇⬇⬇ Java项目 Python…
阅读更多...
SQL注入漏洞WAF绕过

SQL注入漏洞WAF绕过

目录 如何检测和防范SQL注入攻击中的编码伪装？ 检测SQL注入攻击中的编码伪装 防范SQL注入攻击中的编码伪装 WAF在处理SQL注入时为什么有时会对大小写不敏感？ SQL注入中的联合查询注入有哪些常见的攻击方式？ 在绕过Web应用防火墙&#xf…
阅读更多...
软件工程造价师习题练习 22

软件工程造价师习题练习 22

1.公文管理系统可以设置公文处理提示的方式和频率。系统缺省设置为邮件方式及每天提醒。则对于公文管理系统,“公文处理提示方式及频率的缺省设置信息”配置信息缺省默认值是业务数据。 正确 错误 要判断“公文处理提示方式及频率的缺省设置信息”配置信息缺省默认值是否是业务…
阅读更多...
Nginx 反向代理实现 Tomcat 高可用性负载均衡详解

Nginx 反向代理实现 Tomcat 高可用性负载均衡详解

Tomcat 简介 Tomcat是Apache软件基金会（Apache Software Foundation）的Jakarta 项目中的一个核心项目，由Apache、Sun和其他一些公司及个人共同开发而成。 Tomcat服务器是一个免费的开放源代码的Web应用服务器，属于轻量级应用服务…
阅读更多...
vue项目关于ERR_OSSL_EVP_UNSUPPORTED的问题

vue项目关于ERR_OSSL_EVP_UNSUPPORTED的问题

opensslErrorStack: [ error:03000086:digital envelope routines::initialization error ], library: digital envelope routines, reason: unsupported, code: ERR_OSSL_EVP_UNSUPPORTED 该问题通常与 OpenSSL 库版本不兼容或配置问题有关，特别是在使用 No…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023