YOLOv8改进 | DAttention (DAT)注意力机制实现极限涨点

news2024/12/23 4:58:20

论文地址： DAT论文地址

官方地址：官方代码的地址

代码地址：文末有修改了官方代码BUG的代码块复制粘贴即可

一、本文介绍

本文给大家带来的是YOLOv8改进DAT(Vision Transformer with Deformable Attention)的教程，其发布于2022年CVPR2022上同时被评选为Best Paper，由此可以证明其是一种十分有效的改进机制，其主要的核心思想是：引入可变形注意力机制和动态采样点(听着是不是和可变形动态卷积DCN挺相似)。同时在网络结构中引入一个DAT计算量由8.9GFLOPs涨到了9.4GFLOPs。本文的讲解主要包含三方面：DAT的网络结构思想、DAttention的代码复现，如何添加DAttention到你的结构中实现涨点，下面先来分享我测试的对比图(因为资源有限，我只用了100张图片的数据集进行了100个epoch的训练，虽然这个实验不能产生确定性的结论，但是可以作为一个参考)。

适用检测对象->各种检测目标都可以使用，并不针对于某一特定的目标有效。

视频讲解->暂未更新

前文回顾->YOLOv8改进有效涨点专栏->持续复现各种最新机制

目录

一、本文介绍

二、DAT的网络结构思想

2.1 DAT的主要思想和改进

2.2 DAT的网络结构图 

2.3 DAT和其他机制的对比

三、DAT即插即用的代码块

四、添加DAT到你的网络中

五、DAT可添加的位置

5.1推荐DAT可添加的位置 

5.2图示DAT可添加的位置 

六、本文总结 

二、DAT的网络结构思想

2.1 DAT的主要思想和改进

DAT（Vision Transformer with Deformable Attention）是一种引入了可变形注意力机制的视觉Transformer，DAT的核心思想主要包括以下几个方面：

  1. 可变形注意力（Deformable Attention）：传统的Transformer使用标准的自注意力机制，这种机制会处理图像中的所有像素，导致计算量很大。而DAT引入了可变形注意力机制，它只关注图像中的一小部分关键区域。这种方法可以显著减少计算量，同时保持良好的性能。

  2. 动态采样点：在可变形注意力机制中，DAT动态地选择采样点，而不是固定地处理整个图像。这种动态选择机制使得模型可以更加集中地关注于那些对当前任务最重要的区域。

  3. 即插即用：DAT的设计允许它适应不同的图像大小和内容，使其在多种视觉任务中都能有效工作，如图像分类、对象检测等。

总结：DAT通过引入可变形注意力机制，改进了视觉Transformer的效率和性能，使其在处理复杂的视觉任务时更加高效和准确。

2.2 DAT的网络结构图 

(a) 展示了可变形注意力的信息流。左侧部分，一组参考点均匀地放置在特征图上，这些点的偏移量是由查询通过偏移网络学习得到的。然后，如右侧所示，根据变形点从采样特征中投影出变形的键和值。相对位置偏差也通过变形点计算，增强了输出转换特征的多头注意力。为了清晰展示，图中仅显示了4个参考点，但在实际实现中实际上有更多的点。

(b) 展示了偏移生成网络的详细结构，每层输入和输出特征图的大小都有标注(这个Offset network在网络的代码中需要控制可添加可不添加)。

通过上面的方式产生多种参考点分布在图像上，从而提高检测的效率，最终的效果图如下->

2.3 DAT和其他机制的对比

DAT与其他视觉Transformer模型和CNN模型中的DCN（可变形卷积网络）的对比图如下，突出了它们处理查询的不同方法(图片展示的很直观，不给大家描述过程了)：

三、DAT即插即用的代码块

下面的代码是DAT的网络结构代码，官方的代码中存在许多bug而且参数都未定义，这里我替大家都行了修改而且在使用时无需手动添加任何参数，我都设置了通过模型进行了自动计算，使用方法看章节四。

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import einops
from timm.models.layers import to_2tuple, trunc_normal_

class LayerNormProxy(nn.Module):

    def __init__(self, dim):
        super().__init__()
        self.norm = nn.LayerNorm(dim)

    def forward(self, x):
        x = einops.rearrange(x, 'b c h w -> b h w c')
        x = self.norm(x)
        return einops.rearrange(x, 'b h w c -> b c h w')


class DAttentionBaseline(nn.Module):

    def __init__(
            self, q_size=(224,224), kv_size=(224,224), n_heads=8, n_head_channels=32, n_groups=1,
            attn_drop=0.0, proj_drop=0.0, stride=1,
            offset_range_factor=-1, use_pe=True, dwc_pe=True,
            no_off=False, fixed_pe=False, ksize=9, log_cpb=False
    ):

        super().__init__()
        n_head_channels = int(q_size / 8)
        q_size = (q_size, q_size)

        self.dwc_pe = dwc_pe
        self.n_head_channels = n_head_channels
        self.scale = self.n_head_channels ** -0.5
        self.n_heads = n_heads
        self.q_h, self.q_w = q_size
        # self.kv_h, self.kv_w = kv_size
        self.kv_h, self.kv_w = self.q_h // stride, self.q_w // stride
        self.nc = n_head_channels * n_heads
        self.n_groups = n_groups
        self.n_group_channels = self.nc // self.n_groups
        self.n_group_heads = self.n_heads // self.n_groups
        self.use_pe = use_pe
        self.fixed_pe = fixed_pe
        self.no_off = no_off
        self.offset_range_factor = offset_range_factor
        self.ksize = ksize
        self.log_cpb = log_cpb
        self.stride = stride
        kk = self.ksize
        pad_size = kk // 2 if kk != stride else 0


        self.conv_offset = nn.Sequential(
            nn.Conv2d(self.n_group_channels, self.n_group_channels, kk, stride, pad_size, groups=self.n_group_channels),
            LayerNormProxy(self.n_group_channels),
            nn.GELU(),
            nn.Conv2d(self.n_group_channels, 2, 1, 1, 0, bias=False)
        )

        if self.no_off:
            for m in self.conv_offset.parameters():
                m.requires_grad_(False)

        self.proj_q = nn.Conv2d(
            self.nc, self.nc,
            kernel_size=1, stride=1, padding=0
        )

        self.proj_k = nn.Conv2d(
            self.nc, self.nc,
            kernel_size=1, stride=1, padding=0)

        self.proj_v = nn.Conv2d(
            self.nc, self.nc,
            kernel_size=1, stride=1, padding=0
        )
        self.proj_out = nn.Conv2d(
            self.nc, self.nc,
            kernel_size=1, stride=1, padding=0
        )

        self.proj_drop = nn.Dropout(proj_drop, inplace=True)
        self.attn_drop = nn.Dropout(attn_drop, inplace=True)

        if self.use_pe and not self.no_off:
            if self.dwc_pe:
                self.rpe_table = nn.Conv2d(
                    self.nc, self.nc, kernel_size=3, stride=1, padding=1, groups=self.nc)
            elif self.fixed_pe:
                self.rpe_table = nn.Parameter(
                    torch.zeros(self.n_heads, self.q_h * self.q_w, self.kv_h * self.kv_w)
                )
                trunc_normal_(self.rpe_table, std=0.01)
            elif self.log_cpb:
                # Borrowed from Swin-V2
                self.rpe_table = nn.Sequential(
                    nn.Linear(2, 32, bias=True),
                    nn.ReLU(inplace=True),
                    nn.Linear(32, self.n_group_heads, bias=False)
                )
            else:
                self.rpe_table = nn.Parameter(
                    torch.zeros(self.n_heads, self.q_h * 2 - 1, self.q_w * 2 - 1)
                )
                trunc_normal_(self.rpe_table, std=0.01)
        else:
            self.rpe_table = None

    @torch.no_grad()
    def _get_ref_points(self, H_key, W_key, B, dtype, device):

        ref_y, ref_x = torch.meshgrid(
            torch.linspace(0.5, H_key - 0.5, H_key, dtype=dtype, device=device),
            torch.linspace(0.5, W_key - 0.5, W_key, dtype=dtype, device=device),
            indexing='ij'
        )
        ref = torch.stack((ref_y, ref_x), -1)
        ref[..., 1].div_(W_key - 1.0).mul_(2.0).sub_(1.0)
        ref[..., 0].div_(H_key - 1.0).mul_(2.0).sub_(1.0)
        ref = ref[None, ...].expand(B * self.n_groups, -1, -1, -1)  # B * g H W 2

        return ref

    @torch.no_grad()
    def _get_q_grid(self, H, W, B, dtype, device):

        ref_y, ref_x = torch.meshgrid(
            torch.arange(0, H, dtype=dtype, device=device),
            torch.arange(0, W, dtype=dtype, device=device),
            indexing='ij'
        )
        ref = torch.stack((ref_y, ref_x), -1)
        ref[..., 1].div_(W - 1.0).mul_(2.0).sub_(1.0)
        ref[..., 0].div_(H - 1.0).mul_(2.0).sub_(1.0)
        ref = ref[None, ...].expand(B * self.n_groups, -1, -1, -1)  # B * g H W 2

        return ref

    def forward(self, x):
        x = x
        B, C, H, W = x.size()
        dtype, device = x.dtype, x.device

        q = self.proj_q(x)
        q_off = einops.rearrange(q, 'b (g c) h w -> (b g) c h w', g=self.n_groups, c=self.n_group_channels)
        offset = self.conv_offset(q_off).contiguous()  # B * g 2 Hg Wg
        Hk, Wk = offset.size(2), offset.size(3)
        n_sample = Hk * Wk

        if self.offset_range_factor >= 0 and not self.no_off:
            offset_range = torch.tensor([1.0 / (Hk - 1.0), 1.0 / (Wk - 1.0)], device=device).reshape(1, 2, 1, 1)
            offset = offset.tanh().mul(offset_range).mul(self.offset_range_factor)

        offset = einops.rearrange(offset, 'b p h w -> b h w p')
        reference = self._get_ref_points(Hk, Wk, B, dtype, device)

        if self.no_off:
            offset = offset.fill_(0.0)

        if self.offset_range_factor >= 0:
            pos = offset + reference
        else:
            pos = (offset + reference).clamp(-1., +1.)

        if self.no_off:
            x_sampled = F.avg_pool2d(x, kernel_size=self.stride, stride=self.stride)
            assert x_sampled.size(2) == Hk and x_sampled.size(3) == Wk, f"Size is {x_sampled.size()}"
        else:
            x_sampled = F.grid_sample(
                input=x.reshape(B * self.n_groups, self.n_group_channels, H, W),
                grid=pos[..., (1, 0)],  # y, x -> x, y
                mode='bilinear', align_corners=True)  # B * g, Cg, Hg, Wg

        x_sampled = x_sampled.reshape(B, C, 1, n_sample)
        # self.proj_k.weight = torch.nn.Parameter(self.proj_k.weight.float())
        # self.proj_k.bias = torch.nn.Parameter(self.proj_k.bias.float())
        # self.proj_v.weight = torch.nn.Parameter(self.proj_v.weight.float())
        # self.proj_v.bias = torch.nn.Parameter(self.proj_v.bias.float())
        # 检查权重的数据类型
        q = q.reshape(B * self.n_heads, self.n_head_channels, H * W)

        k = self.proj_k(x_sampled).reshape(B * self.n_heads, self.n_head_channels, n_sample)
        v = self.proj_v(x_sampled).reshape(B * self.n_heads, self.n_head_channels, n_sample)

        attn = torch.einsum('b c m, b c n -> b m n', q, k)  # B * h, HW, Ns
        attn = attn.mul(self.scale)

        if self.use_pe and (not self.no_off):

            if self.dwc_pe:
                residual_lepe = self.rpe_table(q.reshape(B, C, H, W)).reshape(B * self.n_heads, self.n_head_channels,
                                                                              H * W)
            elif self.fixed_pe:
                rpe_table = self.rpe_table
                attn_bias = rpe_table[None, ...].expand(B, -1, -1, -1)
                attn = attn + attn_bias.reshape(B * self.n_heads, H * W, n_sample)
            elif self.log_cpb:
                q_grid = self._get_q_grid(H, W, B, dtype, device)
                displacement = (
                            q_grid.reshape(B * self.n_groups, H * W, 2).unsqueeze(2) - pos.reshape(B * self.n_groups,
                                                                                                   n_sample,
                                                                                                   2).unsqueeze(1)).mul(
                    4.0)  # d_y, d_x [-8, +8]
                displacement = torch.sign(displacement) * torch.log2(torch.abs(displacement) + 1.0) / np.log2(8.0)
                attn_bias = self.rpe_table(displacement)  # B * g, H * W, n_sample, h_g
                attn = attn + einops.rearrange(attn_bias, 'b m n h -> (b h) m n', h=self.n_group_heads)
            else:
                rpe_table = self.rpe_table
                rpe_bias = rpe_table[None, ...].expand(B, -1, -1, -1)
                q_grid = self._get_q_grid(H, W, B, dtype, device)
                displacement = (
                            q_grid.reshape(B * self.n_groups, H * W, 2).unsqueeze(2) - pos.reshape(B * self.n_groups,
                                                                                                   n_sample,
                                                                                                   2).unsqueeze(1)).mul(
                    0.5)
                attn_bias = F.grid_sample(
                    input=einops.rearrange(rpe_bias, 'b (g c) h w -> (b g) c h w', c=self.n_group_heads,
                                           g=self.n_groups),
                    grid=displacement[..., (1, 0)],
                    mode='bilinear', align_corners=True)  # B * g, h_g, HW, Ns

                attn_bias = attn_bias.reshape(B * self.n_heads, H * W, n_sample)
                attn = attn + attn_bias

        attn = F.softmax(attn, dim=2)
        attn = self.attn_drop(attn)

        out = torch.einsum('b m n, b c n -> b c m', attn, v)

        if self.use_pe and self.dwc_pe:
            out = out + residual_lepe
        out = out.reshape(B, C, H, W)

        y = self.proj_drop(self.proj_out(out))
        h, w = pos.reshape(B, self.n_groups, Hk, Wk, 2), reference.reshape(B, self.n_groups, Hk, Wk, 2)

        return y

四、添加DAT到你的网络中

添加教程这里不再重复介绍、因为专栏内容有许多，添加过程又需要截特别图片会导致文章大家读者也不通顺如果你已经会添加注意力机制了，可以跳过本章节，如果你还不会，大家可以看我下面的文章，里面详细的介绍了拿到一个任意机制(C2f、Conv、Bottleneck、Loss、DetectHead)如何添加到你的网络结构中去。

添加教程->YOLOv8改进 | 如何在网络结构中添加注意力机制、C2f、卷积、Neck、检测头

五、DAT可添加的位置

5.1推荐DAT可添加的位置 

DAT可以是一种即插即用的注意力机制，其可以添加的位置有很多，添加的位置不同效果也不同，所以我下面推荐几个添加的位，置大家可以进行参考，当然不一定要按照我推荐的地方添加。

  1. 残差连接中：在残差网络的残差连接中加入注意力机制(这个位置我推荐的原因是因为DCN放在残差里面效果挺好的大家可以尝试)

  2. 特征金字塔（SPPF）：在特征金字塔网络之前，可以帮助模型更好地融合不同尺度的特征。

  3. Neck部分：YOLOv8的Neck部分负责特征融合，这里添加注意力机制可以帮助模型更有效地融合不同层次的特征。

  4. 输出层前：在最终的输出层前加入注意力机制可以使模型在做出最终预测之前，更加集中注意力于最关键的特征。

大家可能看我描述不太懂，大家可以看下面的网络结构图中我进行了标注。

5.2图示DAT可添加的位置 

六、本文总结 

到此本文的正式分享内容就结束了，在这里给大家推荐我的YOLOv8改进有效涨点专栏，本专栏目前为新开的平均质量分98分，后期我会根据各种最新的前沿顶会进行论文复现，也会对一些老的改进机制进行补充，目前本专栏免费阅读(暂时，大家尽早关注不迷路~)，如果大家觉得本文帮助到你了，订阅本专栏，关注后续更多的更新~

本专栏其它内容(持续更新) 

YOLOv8改进 | 如何在网络结构中添加注意力机制、C2f、卷积、Neck、检测头

YOLOv8改进 | ODConv附修改后的C2f、Bottleneck模块代码

YOLOv8改进有效涨点系列-＞手把手教你添加动态蛇形卷积(Dynamic Snake Convolution)

YOLOv8性能评估指标-＞mAP、Precision、Recall、FPS、IoU

YOLOv8改进有效涨点系列-＞适合多种检测场景的BiFormer注意力机制(Bi-level Routing Attention)

 YOLOv8改进有效涨点系列-＞多位置替换可变形卷积(DCNv1、DCNv2、DCNv3) 

详解YOLOv8网络结构/环境搭建/数据集获取/训练/推理/验证/导出/部署

​

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

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

相关文章

java.net.UnknownHostException: eureka

java.net.UnknownHostException: eureka

java.net.UnknownHostException: eureka 哦。HOST漏了 #linux /etc/hosts #windows C:\Windows\System32\drivers\etc\hosts 127.0.0.1 eureka7000 127.0.0.1 eureka7001 127.0.0.1 eureka7002
阅读更多...
Echarts柱状图配置代码详解，含常用图例代码

Echarts柱状图配置代码详解，含常用图例代码

一、初识柱状图 从echarts官网引入基础的柱状图后，可以看到他有如下的配置项。我们可以改变各个配置项的属性，将图例调整为我们期望的效果。 二、常用配置项 因为引入echarts图例后，改变图例的东西都在option配置项中，所以其他部…
阅读更多...
腾讯云轻量级服务器和云服务器什么区别？轻量服务器是干什么用的

腾讯云轻量级服务器和云服务器什么区别？轻量服务器是干什么用的

随着互联网的迅速发展，服务器成为了许多人必备的工具。然而，面对众多的服务器选择，我们常常会陷入纠结之中。在这篇文章中，我们将探讨轻量服务器和标准云服务器的区别，帮助您选择最适合自己需求的服务器。 腾讯云双十…
阅读更多...
python中sklearn库在数据预处理中的详细用法，及5个常用的Scikit-learn（通常简称为 sklearn）程序代码示例

python中sklearn库在数据预处理中的详细用法，及5个常用的Scikit-learn（通常简称为 sklearn）程序代码示例

文章目录 前言1. 数据清洗：使用 sklearn.preprocessing 中的 StandardScaler 和 MinMaxScaler 进行数据规范化。2. 缺失值处理：使用 sklearn.impute 中的 SimpleImputer 来填充缺失值。3. 数据编码：使用 sklearn.preprocessing 中的 OneHotEn…
阅读更多...
python中的NumPy和Pandas往往都是同时使用，NumPy和Pandas的在数据分析中的联合使用

python中的NumPy和Pandas往往都是同时使用，NumPy和Pandas的在数据分析中的联合使用

文章目录 前言一、numpy的介绍与用法二、pandas的介绍与用法三、numpy与pandas的联合使用说明四、numpy与pandas的联合使用程序代码4.1 读取CSV文件并进行数据清洗，如去除NaN值4.2 矩阵操作和特征工程，如标准化处理4.3 使用Pandas进行数据筛选和分组聚合…
阅读更多...
ogrinfo不是内部或者外部命令

ogrinfo不是内部或者外部命令

这个是GDAL的问题，我是通过OSGeo4w安装的，出来就是这个问题，教程没有仔细看干。 第一次安装，选择express install！！！！ 第一次安装，选择express install！&…
阅读更多...
代码随想录算法训练营第三十九天【动态规划part02】 | 62.不同路径、63. 不同路径 II

代码随想录算法训练营第三十九天【动态规划part02】 | 62.不同路径、63. 不同路径 II

62.不同路径 题目链接： 力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台 求解思路： 动规五部曲 确定dp数组及其下标含义：dp[i][j] 表示从（0,0）出发，到（i,j&#x…
阅读更多...
【算法】最短路径——弗洛伊德 (Floyd) 算法

【算法】最短路径——弗洛伊德 (Floyd) 算法

目录 1.概述2.代码实现3.扩展3.应用 1.概述 （1）弗洛伊德 (Floyd) 算法又称为插点法，是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法，与 Dijkstra 算法类似。该算法名称以创始人之一、1978 年图灵奖获得者、…
阅读更多...
Matalab插值详解和源码

Matalab插值详解和源码

转载：Matalab插值详解和源码 - 知乎 (zhihu.com) 插值法 插值法又称“内插法”，是利用函数f (x)在某区间中已知的若干点的函数值，作出适当的特定函数，在区间的其他点上用这特定函数的值作为函数f (x)的近似值，这种方…
阅读更多...
腾讯云服务器租用价格，腾讯云服务器价格流量怎么算？

腾讯云服务器租用价格，腾讯云服务器价格流量怎么算？

首先，让我们来看看腾讯云服务器租用价格。根据您的需求不同，腾讯云提供了多种不同的配置选项，从轻量级应用服务器到高性能的GPU服务器，都可以满足您的需求。以下是一些常见的腾讯云服务器租用价格： 一、腾讯云服务器租…
阅读更多...
VPN创建连接 提示错误 628: 在连接完成前，连接被远程计算机终止。

VPN创建连接 提示错误 628: 在连接完成前，连接被远程计算机终止。

提示错误 628: 在连接完成前，连接被远程计算机终止。 需要把这个地址配置一下： VPN类型：点对点PPTP 数据加密：如果没有加密的话， 要把这个选一下。
阅读更多...
Flask 接口

Flask 接口

目录 前言 代码实现 简单接口实现 执行其它程序接口 携带参数访问接口 前言 有时候会想着开个一个接口来访问试试，这里就给出一个基础接口代码示例 代码实现 导入Flask模块，没安装Flask 模块需要进行 安装：pip install flask 使用镜…
阅读更多...
LeetCode——字符串（Java）

LeetCode——字符串（Java）

字符串 简介[简单] 344. 反转字符串[简单] 541. 反转字符串 II[中等] 151. 反转字符串中的单词 简介 记录一下自己刷题的历程以及代码。写题过程中参考了 代码随想录。会附上一些个人的思路，如果有错误，可以在评论区提醒一下。 [简单] 344. 反转字符串…
阅读更多...
AIGC创作系统ChatGPT源码，AI绘画源码，支持最新GPT-4-Turbo模型，支持DALL-E3文生图

AIGC创作系统ChatGPT源码，AI绘画源码，支持最新GPT-4-Turbo模型，支持DALL-E3文生图

一、AI创作系统 SparkAi创作系统是基于OpenAI很火的ChatGPT进行开发的Ai智能问答系统和Midjourney绘画系统，支持OpenAI-GPT全模型国内AI全模型。本期针对源码系统整体测试下来非常完美，可以说SparkAi是目前国内一款的ChatGPT对接OpenAI软件系统。那么如…
阅读更多...
课程设计(毕业设计)—基于机器学习(CNN+opencv+python)的车牌识别—(可远程调试)计算机专业课程设计(毕业设计)

课程设计(毕业设计)—基于机器学习(CNN+opencv+python)的车牌识别—(可远程调试)计算机专业课程设计(毕业设计)

基于机器学习(CNNopencvpython)的车牌识别 下载本文机器学习(CNNopencvpython)的车牌识别系统完整的代码和参考报告链接（或者可以联系博主koukou(壹壹23七2五六98)，获取源码和报告）https://download.csdn.net/download/shooter7/88548767此处…
阅读更多...
操作系统·进程同步

操作系统·进程同步

进程同步：异步环境下的一组并发进程因直接制约而互相发送消息、互相合作、互相等待，使得各进程按照一定的速度执行的过程。 进程同步的主要任务是使并发执行的诸进程之间能有效地共享资源和相互合作，使执行的结果具有可再现性。 4.1 进程同…
阅读更多...
智慧城市指挥中心，大屏幕究竟有什么用？

智慧城市指挥中心，大屏幕究竟有什么用？

目前很多地区有在兴建智慧城市的项目，其城市指挥中心内一般都建有一张巨大的屏幕，这张屏幕究竟有什么用？是否可以用普通的电脑显示器进行代替呢？ 智慧城市指挥中心内的巨大屏幕是智慧城市项目中的重要组成部分，其作用不…
阅读更多...
​软考-高级-系统架构设计师教程（清华第2版）【第14章 云原生架构设计理论与实践（P496~526）-思维导图】​

​软考-高级-系统架构设计师教程（清华第2版）【第14章 云原生架构设计理论与实践（P496~526）-思维导图】​

软考-高级-系统架构设计师教程（清华第2版）【第14章 云原生架构设计理论与实践（P496~526）-思维导图】 课本里章节里所有蓝色字体的思维导图
阅读更多...
Springboot+vue的应急物资管理系统（有报告），Javaee项目，springboot vue前后端分离项目

Springboot+vue的应急物资管理系统（有报告），Javaee项目，springboot vue前后端分离项目

演示视频： Springbootvue的应急物资管理系统（有报告），Javaee项目，springboot vue前后端分离项目 前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。…
阅读更多...
【GUI】-- 09 JComboBox JList、JTextField JPasswordField JTextArea

【GUI】-- 09 JComboBox JList、JTextField JPasswordField JTextArea

GUI编程 03 Swing 3.6 列表 下拉框 package com.duo.lesson06;import javax.swing.*; import java.awt.*;public class ComboBoxDemo01 extends JFrame {public ComboBoxDemo01() throws HeadlessException {Container contentPane getContentPane();JComboBox<Object&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023