YOLOv9改进策略：卷积魔改 | AKConv（可改变核卷积），即插即用的卷积，效果秒杀DSConv | 2023年11月最新发表

 💡💡💡本文改进内容： YOLOv9如何魔改卷积进一步提升检测精度？AKConv 通过不规则卷积运算完成高效特征提取的过程，为卷积采样形状带来更多探索选择。 AKConv可以作为即插即用的卷积运算来替代卷积运算来提高网络性能。在数据集 COCO2017、VOC07+12 和 VisDrone-DET2021 上进行的物体检测实验充分展示了 AKConv 的优势。

yolov9-c-AKConv summary: 968 layers, 50952916 parameters, 50952884 gradients, 236.3 GFLOPs

 改进结构图如下：

YOLOv9魔术师专栏

☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️ ☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️

包含注意力机制魔改、卷积魔改、检测头创新、损失&IOU优化、block优化&多层特征融合、 轻量级网络设计、24年最新顶会改进思路、原创自研paper级创新等

☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️☁️

✨✨✨ 新开专栏暂定免费限时开放，后续每月调价一次✨✨✨

🚀🚀🚀 本项目持续更新 | 更新完结保底≥50+ ，冲刺100+🚀🚀🚀

🍉🍉🍉 联系WX: AI_CV_0624 欢迎交流！🍉🍉🍉

YOLOv9魔改：注意力机制、检测头、blcok魔改、自研原创等

 YOLOv9魔术师

💡💡💡全网独家首发创新（原创），适合paper ！！！

💡💡💡 2024年计算机视觉顶会创新点适用于Yolov5、Yolov7、Yolov8等各个Yolo系列，专栏文章提供每一步步骤和源码，轻松带你上手魔改网络 ！！！

💡💡💡重点：通过本专栏的阅读，后续你也可以设计魔改网络，在网络不同位置（Backbone、head、detect、loss等）进行魔改，实现创新！！！

 1.YOLOv9原理介绍

​

论文： 2402.13616.pdf (arxiv.org)

代码：GitHub - WongKinYiu/yolov9: Implementation of paper - YOLOv9: Learning What You Want to Learn Using Programmable Gradient Information摘要： 如今的深度学习方法重点关注如何设计最合适的目标函数，从而使得模型的预测结果能够最接近真实情况。同时，必须设计一个适当的架构，可以帮助获取足够的信息进行预测。然而，现有方法忽略了一个事实，即当输入数据经过逐层特征提取和空间变换时，大量信息将会丢失。因此，YOLOv9 深入研究了数据通过深度网络传输时数据丢失的重要问题，即信息瓶颈和可逆函数。作者提出了可编程梯度信息（programmable gradient information，PGI）的概念，来应对深度网络实现多个目标所需要的各种变化。PGI 可以为目标任务计算目标函数提供完整的输入信息，从而获得可靠的梯度信息来更新网络权值。此外，研究者基于梯度路径规划设计了一种新的轻量级网络架构，即通用高效层聚合网络（Generalized Efficient Layer Aggregation Network，GELAN）。该架构证实了 PGI 可以在轻量级模型上取得优异的结果。研究者在基于 MS COCO 数据集的目标检测任务上验证所提出的 GELAN 和 PGI。结果表明，与其他 SOTA 方法相比，GELAN 仅使用传统卷积算子即可实现更好的参数利用率。对于 PGI 而言，它的适用性很强，可用于从轻型到大型的各种模型。我们可以用它来获取完整的信息，从而使从头开始训练的模型能够比使用大型数据集预训练的 SOTA 模型获得更好的结果。对比结果如图1所示。

​

 YOLOv9框架图

1.1 YOLOv9框架介绍

YOLOv9各个模型介绍

​

2.AKConv原理介绍

论文：https://arxiv.org/pdf/2311.11587.pdf

摘要：基于卷积运算的神经网络在深度学习领域取得了令人瞩目的成果，但标准卷积运算存在两个固有的缺陷。一方面，卷积运算仅限于局部窗口，无法捕获其他位置的信息， 并且它的采样形状是固定的。 另一方面，卷积核的大小固定为k×k，是一个固定的正方形，参数的数量往往随大小呈平方增长。 很明显，不同数据集和不同位置的目标的形状和大小是不同的。 具有固定样本形状和正方形的卷积核不能很好地适应不断变化的目标。 针对上述问题，本工作探索了可改变核卷积（AKConv），它赋予卷积核任意数量的参数和任意采样形状，为网络开销和性能之间的权衡提供更丰富的选择。 在 AKConv 中，我们通过新的坐标生成算法定义任意大小的卷积核的初始位置。 为了适应目标的变化，我们引入了偏移量来调整每个位置的样本形状。 此外，我们通过使用具有相同大小和不同初始采样形状的 AKConv 来探索神经网络的效果。 AKConv 通过不规则卷积运算完成高效特征提取的过程，为卷积采样形状带来更多探索选择。 在代表性数据集 COCO2017、VOC 7+12 和 VisDrone-DET2021 上进行的物体检测实验充分展示了 AKConv 的优势。 AKConv可以作为即插即用的卷积运算来替代卷积运算来提高网络性能。

很明显，与 Deformabled 和标准 Conv 相比，AKConv 有更多的选择，并且卷积参数的数量随着卷积核大小呈线性增加。 注意：为了清楚地描述 AKConv 的优点，在 AKConv 和 Deformable Conv 中我们忽略了学习偏移量的参数数量，因为它远小于特征提取中涉及的卷积参数数量。

作者认为 AKConv 的设计是一种新颖的设计，它实现了从不规则和任意采样形状的卷积核中提取特征的壮举。 即使不使用 Deformable Conv 中的偏移思想，AKConv 仍然可以做出多种卷积核形状。 因为，AKConv可以用初始坐标重新采样来呈现多种变化。 如图4所示，我们为大小为5的卷积设计了各种初始采样形状。在图4中，我们只显示了大小为5的一些示例。但是，AKConv的大小可以是任意的，因此随着大小的增加，初始采样形状会随着大小的增加而变化。 AKConv 的卷积采样形状变得更加丰富甚至无限。 鉴于不同数据集的目标形状各不相同，设计与采样形状相对应的卷积运算至关重要。 AKConv完全是通过根据特定相位域设计相应形状的卷积运算来实现的。 它还可以类似于 Deformable Conv，通过添加可学习的偏移来动态适应对象的变化。 对于特定任务，卷积核初始采样位置的设计很重要，因为它是先验知识。 正如齐等人所言。 [27]，他们为细长管状结构分割任务提出了具有相应形状的采样坐标，但他们的形状选择仅适用于细长管状结构。 

展示核大小为5的初始样本形状。AKConv可以通过设计不同的初始采样形状来实现任意采样形状。

实验结果，数据集 COCO2017、VOC 7+12 和 VisDrone-DET2021 上进行的物体检测实验充分展示了 AKConv 的优势

 

    

3.AKConv加入到YOLOv9

3.1新建py文件，路径为models/Conv/AKConv.py

import torch
import torch.nn as nn
import math
from einops import rearrange
 
class AKConv(nn.Module):
    def __init__(self, inc, outc, num_param, stride=1, bias=None):
        super(AKConv, self).__init__()
        self.num_param = num_param
        self.stride = stride
        self.conv = nn.Sequential(nn.Conv2d(inc, outc, kernel_size=(num_param, 1), stride=(num_param, 1), bias=bias),nn.BatchNorm2d(outc),nn.SiLU())  # the conv adds the BN and SiLU to compare original Conv in YOLOv5.
        self.p_conv = nn.Conv2d(inc, 2 * num_param, kernel_size=3, padding=1, stride=stride)
        nn.init.constant_(self.p_conv.weight, 0)
        self.p_conv.register_full_backward_hook(self._set_lr)
    #https://blog.csdn.net/m0_63774211/category_12289773.html?spm=1001.2014.3001.5482
    @staticmethod
    def _set_lr(module, grad_input, grad_output):
        grad_input = (grad_input[i] * 0.1 for i in range(len(grad_input)))
        grad_output = (grad_output[i] * 0.1 for i in range(len(grad_output)))
 
    def forward(self, x):
        # N is num_param.
        offset = self.p_conv(x)
        dtype = offset.data.type()
        N = offset.size(1) // 2
        # (b, 2N, h, w)
        p = self._get_p(offset, dtype)
 
        # (b, h, w, 2N)
        p = p.contiguous().permute(0, 2, 3, 1)
        q_lt = p.detach().floor()
        q_rb = q_lt + 1
 
        q_lt = torch.cat([torch.clamp(q_lt[..., :N], 0, x.size(2) - 1), torch.clamp(q_lt[..., N:], 0, x.size(3) - 1)],
                         dim=-1).long()
        q_rb = torch.cat([torch.clamp(q_rb[..., :N], 0, x.size(2) - 1), torch.clamp(q_rb[..., N:], 0, x.size(3) - 1)],
                         dim=-1).long()
        q_lb = torch.cat([q_lt[..., :N], q_rb[..., N:]], dim=-1)
        q_rt = torch.cat([q_rb[..., :N], q_lt[..., N:]], dim=-1)
 
        # clip p
        p = torch.cat([torch.clamp(p[..., :N], 0, x.size(2) - 1), torch.clamp(p[..., N:], 0, x.size(3) - 1)], dim=-1)
 
        # bilinear kernel (b, h, w, N)
        g_lt = (1 + (q_lt[..., :N].type_as(p) - p[..., :N])) * (1 + (q_lt[..., N:].type_as(p) - p[..., N:]))
        g_rb = (1 - (q_rb[..., :N].type_as(p) - p[..., :N])) * (1 - (q_rb[..., N:].type_as(p) - p[..., N:]))
        g_lb = (1 + (q_lb[..., :N].type_as(p) - p[..., :N])) * (1 - (q_lb[..., N:].type_as(p) - p[..., N:]))
        g_rt = (1 - (q_rt[..., :N].type_as(p) - p[..., :N])) * (1 + (q_rt[..., N:].type_as(p) - p[..., N:]))
 
        # resampling the features based on the modified coordinates.
        x_q_lt = self._get_x_q(x, q_lt, N)
        x_q_rb = self._get_x_q(x, q_rb, N)
        x_q_lb = self._get_x_q(x, q_lb, N)
        x_q_rt = self._get_x_q(x, q_rt, N)
 
        # bilinear
        x_offset = g_lt.unsqueeze(dim=1) * x_q_lt + \
                   g_rb.unsqueeze(dim=1) * x_q_rb + \
                   g_lb.unsqueeze(dim=1) * x_q_lb + \
                   g_rt.unsqueeze(dim=1) * x_q_rt
 
        x_offset = self._reshape_x_offset(x_offset, self.num_param)
        out = self.conv(x_offset)
 
        return out
    #https://blog.csdn.net/m0_63774211/category_12289773.html?spm=1001.2014.3001.5482
    # generating the inital sampled shapes for the AKConv with different sizes.
    def _get_p_n(self, N, dtype):
        base_int = round(math.sqrt(self.num_param))
        row_number = self.num_param // base_int
        mod_number = self.num_param % base_int
        p_n_x,p_n_y = torch.meshgrid(
            torch.arange(0, row_number),
            torch.arange(0,base_int))
        p_n_x = torch.flatten(p_n_x)
        p_n_y = torch.flatten(p_n_y)
        if mod_number >  0:
            mod_p_n_x,mod_p_n_y = torch.meshgrid(
                torch.arange(row_number,row_number+1),
                torch.arange(0,mod_number))
 
            mod_p_n_x = torch.flatten(mod_p_n_x)
            mod_p_n_y = torch.flatten(mod_p_n_y)
            p_n_x,p_n_y  = torch.cat((p_n_x,mod_p_n_x)),torch.cat((p_n_y,mod_p_n_y))
        p_n = torch.cat([p_n_x,p_n_y], 0)
        p_n = p_n.view(1, 2 * N, 1, 1).type(dtype)
        return p_n
 
    # no zero-padding
    def _get_p_0(self, h, w, N, dtype):
        p_0_x, p_0_y = torch.meshgrid(
            torch.arange(0, h * self.stride, self.stride),
            torch.arange(0, w * self.stride, self.stride))
 
        p_0_x = torch.flatten(p_0_x).view(1, 1, h, w).repeat(1, N, 1, 1)
        p_0_y = torch.flatten(p_0_y).view(1, 1, h, w).repeat(1, N, 1, 1)
        p_0 = torch.cat([p_0_x, p_0_y], 1).type(dtype)
 
        return p_0
 
    def _get_p(self, offset, dtype):
        N, h, w = offset.size(1) // 2, offset.size(2), offset.size(3)
 
        # (1, 2N, 1, 1)
        p_n = self._get_p_n(N, dtype)
        # (1, 2N, h, w)
        p_0 = self._get_p_0(h, w, N, dtype)
        p = p_0 + p_n + offset
        return p
 
    def _get_x_q(self, x, q, N):
        b, h, w, _ = q.size()
        padded_w = x.size(3)
        c = x.size(1)
        # (b, c, h*w)
        x = x.contiguous().view(b, c, -1)
 
        # (b, h, w, N)
        index = q[..., :N] * padded_w + q[..., N:]  # offset_x*w + offset_y
        # (b, c, h*w*N)
        index = index.contiguous().unsqueeze(dim=1).expand(-1, c, -1, -1, -1).contiguous().view(b, c, -1)
 
        x_offset = x.gather(dim=-1, index=index).contiguous().view(b, c, h, w, N)
 
        return x_offset
 
    # https://blog.csdn.net/m0_63774211/category_12289773.html?spm=1001.2014.3001.5482
    #  Stacking resampled features in the row direction.
    @staticmethod
    def _reshape_x_offset(x_offset, num_param):
        b, c, h, w, n = x_offset.size()
        # using Conv3d
        # x_offset = x_offset.permute(0,1,4,2,3), then Conv3d(c,c_out, kernel_size =(num_param,1,1),stride=(num_param,1,1),bias= False)
        # using 1 × 1 Conv
        # x_offset = x_offset.permute(0,1,4,2,3), then, x_offset.view(b,c×num_param,h,w)  finally, Conv2d(c×num_param,c_out, kernel_size =1,stride=1,bias= False)
        # using the column conv as follow， then, Conv2d(inc, outc, kernel_size=(num_param, 1), stride=(num_param, 1), bias=bias)
        
        x_offset = rearrange(x_offset, 'b c h w n -> b c (h n) w')
        return x_offset

3.2修改yolo.py

1)首先进行引用

from models.Conv.AKConv import AKConv

2）修改def parse_model(d, ch):  # model_dict, input_channels(3)

在源码基础上加入AKConv

        n = n_ = max(round(n * gd), 1) if n > 1 else n  # depth gain
        if m in {
            Conv, AConv, ConvTranspose, 
            Bottleneck, SPP, SPPF, DWConv, BottleneckCSP, nn.ConvTranspose2d, DWConvTranspose2d, SPPCSPC, ADown,
            RepNCSPELAN4, SPPELAN,AKConv}:
            c1, c2 = ch[f], args[0]
            if c2 != no:  # if not output
                c2 = make_divisible(c2 * gw, 8)

            args = [c1, c2, *args[1:]]

3.3 yolov9-c-AKConv.yaml

# YOLOv9

# parameters
nc: 80  # number of classes
depth_multiple: 1.0  # model depth multiple
width_multiple: 1.0  # layer channel multiple
#activation: nn.LeakyReLU(0.1)
#activation: nn.ReLU()

# anchors
anchors: 3

# YOLOv9 backbone
backbone:
  [
   [-1, 1, Silence, []],  
   
   # conv down
   [-1, 1, Conv, [64, 3, 2]],  # 1-P1/2

   # conv down
   [-1, 1, Conv, [128, 3, 2]],  # 2-P2/4

   # elan-1 block
   [-1, 1, RepNCSPELAN4, [256, 128, 64, 1]],  # 3

   # avg-conv down
   [-1, 1, ADown, [256]],  # 4-P3/8

   # elan-2 block
   [-1, 1, RepNCSPELAN4, [512, 256, 128, 1]],  # 5

   # avg-conv down
   [-1, 1, ADown, [512]],  # 6-P4/16

   # elan-2 block
   [-1, 1, RepNCSPELAN4, [512, 512, 256, 1]],  # 7

   # avg-conv down
   [-1, 1, ADown, [512]],  # 8-P5/32

   # elan-2 block
   [-1, 1, RepNCSPELAN4, [512, 512, 256, 1]],  # 9
  ]

# YOLOv9 head
head:
  [
   # elan-spp block
   [-1, 1, SPPELAN, [512, 256]],  # 10

   # up-concat merge
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 7], 1, Concat, [1]],  # cat backbone P4

   # elan-2 block
   [-1, 1, RepNCSPELAN4, [512, 512, 256, 1]],  # 13

   # up-concat merge
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 5], 1, Concat, [1]],  # cat backbone P3

   # elan-2 block
   [-1, 1, RepNCSPELAN4, [256, 256, 128, 1]],  # 16 (P3/8-small)

   # avg-conv-down merge
   [-1, 1, ADown, [256]],
   [[-1, 13], 1, Concat, [1]],  # cat head P4

   # elan-2 block
   [-1, 1, RepNCSPELAN4, [512, 512, 256, 1]],  # 19 (P4/16-medium)

   # avg-conv-down merge
   [-1, 1, ADown, [512]],
   [[-1, 10], 1, Concat, [1]],  # cat head P5

   # elan-2 block
   [-1, 1, RepNCSPELAN4, [512, 512, 256, 1]],  # 22 (P5/32-large)
   
   
   # multi-level reversible auxiliary branch
   
   # routing
   [5, 1, CBLinear, [[256]]], # 23
   [7, 1, CBLinear, [[256, 512]]], # 24
   [9, 1, CBLinear, [[256, 512, 512]]], # 25
   
   # conv down
   [0, 1, AKConv, [64, 3, 2]],  # 26-P1/2

   # conv down
   [-1, 1, AKConv, [128, 3, 2]],  # 27-P2/4

   # elan-1 block
   [-1, 1, RepNCSPELAN4, [256, 128, 64, 1]],  # 28

   # avg-conv down fuse
   [-1, 1, ADown, [256]],  # 29-P3/8
   [[23, 24, 25, -1], 1, CBFuse, [[0, 0, 0]]], # 30  

   # elan-2 block
   [-1, 1, RepNCSPELAN4, [512, 256, 128, 1]],  # 31

   # avg-conv down fuse
   [-1, 1, ADown, [512]],  # 32-P4/16
   [[24, 25, -1], 1, CBFuse, [[1, 1]]], # 33 

   # elan-2 block
   [-1, 1, RepNCSPELAN4, [512, 512, 256, 1]],  # 34

   # avg-conv down fuse
   [-1, 1, ADown, [512]],  # 35-P5/32
   [[25, -1], 1, CBFuse, [[2]]], # 36

   # elan-2 block
   [-1, 1, RepNCSPELAN4, [512, 512, 256, 1]],  # 37
   
   
   
   # detection head

   # detect
   [[31, 34, 37, 16, 19, 22], 1, DualDDetect, [nc]],  # DualDDetect(A3, A4, A5, P3, P4, P5)
  ]

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

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

相关文章

修复打印机不能打印的10种方法，总有一种适合你

修复打印机不能打印的10种方法，总有一种适合你

前言 技术有时很奇怪，我们可以用声音控制恒温器，但有时打印机会像15年前一样令人困惑和不可靠。如果打印机向你抛出错误（或完全忽略你的要求），可能有许多原因。 不幸的是，仅仅找出问题才成功一半，另一半是解决方案，它将使你的打印机重新工作。下面是如何解决问题的方…
阅读更多...
Mysql：行锁，间隙锁，next-key锁？

Mysql：行锁，间隙锁，next-key锁？

注：以下讨论基于InnoDB引擎。 文章目录 问题引入猜想1：只加了一行写锁，锁住要修改的这一行。语义问题数据一致性问题 猜想2：要修改的这一行加写锁，扫描过程中遇到其它行加读锁猜想3：要修改的这一行加写锁&…
阅读更多...
STM32 CubeMx创建Lwip+FreeRtos时出现ping不通的问题

STM32 CubeMx创建Lwip+FreeRtos时出现ping不通的问题

STM32 CubeMx创建LwipFreeRtos时出现ping不通 1、配置ETH，使用中断 2、配置Lwip（使用静态ip），其余什么都不用管 3、配置FreeRtos（选择V2版本），其余什么都不用管 4、创建代码 5、查看自动生…
阅读更多...
python爬虫之xpath入门

python爬虫之xpath入门

文章目录 一、前言参考文档： 二、xpath语法-基础语法常用路径表达式举例说明 三、xpath语法-谓语表达式举例注意 四、xpath语法-通配符语法实例 五、选取多个路径实例 六、Xpath Helper安装使用说明例子： 七、python中 xpath 的使用安装xpath 的依赖包xm…
阅读更多...
2024年 信息系统管理工程师(中级)

2024年 信息系统管理工程师(中级)

2024年信息系统管理工程师全套视频、历年真题及解析、历年真题视频解析、教材、模拟题、重点笔记等资料 1、2023、2022、2021、2020年全套教程精讲视频。 2、信息系统管理工程师历年真题及解析（综合知识、案例分析）、历年真题视频解析。 3、官方最新信…
阅读更多...
有实际意义的伦敦金交易策略参考

有实际意义的伦敦金交易策略参考

一谈起有实际意义的伦敦金交易策略参考，很多人以为是讨论的是什么飞天遁地的技术，其实这些都是没有实际意义。对普通投资者来说，什么才是有实际意义的呢？那就是生存。要讨论实际有意义的伦敦金交易策略参考，就是投资者…
阅读更多...
【赠书第21期】游戏力：竞技游戏设计实战教程

【赠书第21期】游戏力：竞技游戏设计实战教程

文章目录 前言 1 竞技游戏设计的核心要素 1.1 游戏机制 1.2 角色与技能 1.3 地图与环境 2 竞技游戏设计的策略与方法 2.1 以玩家为中心 2.2 不断迭代与优化 2.3 营造竞技氛围与社区文化 3 实战案例分析 4 结语 5 推荐图书 6 粉丝福利 前言 在数字化时代的浪潮中&…
阅读更多...
ARM实验 LED流水灯

ARM实验 LED流水灯

.text .global _start _start: 使能GPIOE GPIOF的外设时钟 RCC_MP_AHB4ENSETR的第[4][5]设置为1即可使能GPIOE GPIOF时钟 LDR R0,0X50000A28 指定寄存器地址 LDR R1,[R0] 将寄存器原来的数值读取出来&#xff0c;保存到R1中 ORR R1,R1,#(0x3<<4) 将第4位设置为1 S…
阅读更多...
蓝桥杯需要掌握的几个案例（C/C++）

蓝桥杯需要掌握的几个案例（C/C++）

文章目录 蓝桥杯C/C组的重点主要包括以下几个方面&#xff1a;以下是一些在蓝桥杯C/C组比赛中可能会涉及到的重要案例类型&#xff1a;1. **排序算法案例**&#xff1a;2. **查找算法案例**&#xff1a;3. **数据结构案例**&#xff1a;4. **动态规划案例**&#xff1a;5. **图…
阅读更多...
30天拿下Rust之错误处理

30天拿下Rust之错误处理

概述 在软件开发领域&#xff0c;对错误的妥善处理是保证程序稳定性和健壮性的重要环节。Rust作为一种系统级编程语言&#xff0c;以其对内存安全和所有权的独特设计而著称&#xff0c;其错误处理机制同样体现了Rust的严谨与实用。在Rust中&#xff0c;错误处理通常分为两大类&…
阅读更多...
有没有好的视频素材网站官网？高清无水印素材下载

有没有好的视频素材网站官网？高清无水印素材下载

在这个数字化的时代&#xff0c;找到优质的素材对于创作者来说就像寻找一片绿洲一样重要。无论是个人项目还是专业作品&#xff0c;好的素材能够为作品增色不少。以下是我精选的一些素材网站&#xff0c;它们各具特色&#xff0c;提供从图片、视频到音效等多种素材&#xff0c;…
阅读更多...
蓝桥杯练习03个人博客

蓝桥杯练习03个人博客

个人博客 介绍 很多人都有自己的博客&#xff0c;在博客上面用自己的方式去书写文章&#xff0c;用来记录生活&#xff0c;分享技术等。下面是蓝桥云课的博客&#xff0c;但是上面还缺少一些样式&#xff0c;需要大家去完善。 准备 开始答题前&#xff0c;需要先打开本题的…
阅读更多...
springboot284基于HTML5的问卷调查系统的设计与实现

springboot284基于HTML5的问卷调查系统的设计与实现

问卷调查系统的设计与实现 摘 要 传统信息的管理大部分依赖于管理人员的手工登记与管理&#xff0c;然而&#xff0c;随着近些年信息技术的迅猛发展&#xff0c;让许多比较老套的信息管理模式进行了更新迭代&#xff0c;问卷信息因为其管理内容繁杂&#xff0c;管理数量繁多导…
阅读更多...
2024年3月23日(星期六）骑行陡普鲁

2024年3月23日(星期六）骑行陡普鲁

2024年3月23日 (星期六&#xff09;骑行陡普鲁(春漫西翥千亩梨花节&#xff09;&#xff0c;早8:30到9:00&#xff0c;昆明氧气厂门口&#xff0c;9:30准时出发【因迟到者&#xff0c;骑行速度快者&#xff0c;可自行追赶偶遇。】 偶遇地点:昆明氧气厂门口集合 &#xff0c;家…
阅读更多...
MySQL 多表关系（介绍） 一对多/多对多

MySQL 多表关系（介绍） 一对多/多对多

一对多 举例介绍 例子: 部门与员工 在常理上来说: 一个部门有多个员工&#xff0c;一个员工只对应一个部门实现方式: 在多的一方建立外键&#xff0c;指向一的一方的主键 多对多 举例介绍 例子: 学生与课程 在常理上来说: 一个学生可以有多个课程,一门课程可以有多个学生实…
阅读更多...
ideaSSM 工程车辆人员管理系统bootstrap开发mysql数据库web结构java编程计算机网页源码maven项目

ideaSSM 工程车辆人员管理系统bootstrap开发mysql数据库web结构java编程计算机网页源码maven项目

一、源码特点 idea 开发 SSM 工程车辆人员管理系统是一套完善的信息管理系统&#xff0c;结合SSM框架和bootstrap完成本系统&#xff0c;对理解JSP java编程开发语言有帮助系统采用SSM框架&#xff08;MVC模式开发&#xff09;&#xff0c;系统具 有完整的源代码和数据库&…
阅读更多...
10：00面试，10：06就出来了，问的问题有点变态。。。

10：00面试，10：06就出来了，问的问题有点变态。。。

从小厂出来&#xff0c;没想到在另一家公司又寄了。 到这家公司开始上班&#xff0c;加班是每天必不可少的&#xff0c;看在钱给的比较多的份上&#xff0c;就不太计较了。没想到8月一纸通知&#xff0c;所有人不准加班&#xff0c;加班费不仅没有了&#xff0c;薪资还要降40%…
阅读更多...
Docker之大鲸鱼

Docker之大鲸鱼

什么是Docker&#xff1f; Docker 是一个开源的应用容器引擎&#xff0c;让开发者可以打包他们的应用以及依赖包到一个可移植的容器中&#xff0c;然后发布到任何流行的 Linux 机器上&#xff0c;也可以实现虚拟化。 Docker常见命令&#xff1f; docker run -d \--name mys…
阅读更多...
qt5-入门-国际化

qt5-入门-国际化

参考&#xff1a; Qt 国际化(上)_w3cschool https://www.w3cschool.cn/learnroadqt/fwkx1j4j.html QT5实现语言国际化&#xff08;中英文界面动态切换&#xff0c;超详细&#xff09;_qt qevent::languagechange-CSDN博客 https://blog.csdn.net/m0_49047167/article/details/…
阅读更多...
fs方法举例

fs方法举例

fs.readFile() 读取文件 const fs require(node:fs) const path require(node:path) const s path.resolve(__dirname, ./hello.txt) const buf fs.readFileSync(s) console.log(buf.toString())输出的Buffer对象 用toString()方法转字符串之后 fs.appendFile() 创建新…
阅读更多...
最新文章

Copyright @ 2022~2023