YOLOv5改进 | 2023注意力篇 | FocusedLinearAttention聚焦线性注意力

一、本文介绍

本文给大家带来的改进机制是FLAttention（聚焦线性注意力）是一种用于视觉Transformer模型的注意力机制(但是其也可以用在我们的YOLO系列当中从而提高检测精度)，旨在提高效率和表现力。其解决了两个在传统线性注意力方法中存在的问题：聚焦能力和特征多样性。这种方法通过一个高效的映射函数和秩恢复模块来提高计算效率和性能，使其在处理视觉任务时更加高效和有效。简言之，FLAttention是对传统线性注意力方法的一种重要改进，提高了模型的聚焦能力和特征表达的多样性。通过本文你能够了解到：FLAttention的基本原理和框架，能够在你自己的网络结构中进行添加。

专栏回顾：YOLOv5改进专栏——持续复现各种顶会内容——内含100+创新

目录

一、本文介绍

二、FLAttention的机制原理

2.1 Softmax和线性注意力机制的对比

2.2 FLAttention的提出

2.3 效果对比

三、实验效果对比

四、FLAttention代码

五、添加FLAttention到模型中

5.1 细节修改教程

5.1.1 修改一

​4.1.2 修改二

4.1.3 修改三 

4.1.4 修改四

5.2 FLAttention的yaml文件和训练截图

5.2.1 FLAttention的yaml文件一

5.2.2 FLAttention的yaml文件二 

5.2.2 FLAttention的训练过程截图 

六、全文总结 

二、FLAttention的机制原理

论文地址：官方论文地址

代码地址：官方代码地址

2.1 Softmax和线性注意力机制的对比

上面的图片是关于比较Softmax注意力和线性注意力的差异。在这张图中，Q、K、V 分别代表查询、键和值矩阵，它们的维度为 R N×d。这里提到的几个关键点包括：

1. Softmax注意力：它需要计算查询和键之间的成对相似度，导致计算复杂度为 O(N^2 d)。这种方法在计算上是昂贵的，特别是当处理大规模数据时。

2. 线性注意力：通过适当的近似手段，线性注意力可以解耦Softmax操作，并通过先计算K^{T}V来改变计算顺序，从而将复杂度降低到 O(Nd^{^{2}})。由于在现代视觉Transformer设计中通道维度 d 通常小于标记数 N（例如，在DeiT中d=64, N=196，在Swin Transformer中d=32, N=49），线性注意力模块实际上降低了总体计算成本。

此处提出了线性注意力机制的优势(为了后面提出论文提到的注意力机制在线性注意力机制上的优化)：线性注意力模块因此能够在节省计算成本的同时，享受更大的接收域和更高的吞吐量的好处。

总结：这张图片可能是在说明线性注意力如何在保持注意力机制核心功能的同时，提高计算效率，尤其是在处理大规模数据集时的优势。这种方法对于改善视觉Transformer的性能和效率具有重要意义(我下面会出将其用在RT-DETR的模型上看看效果)。

2.2 FLAttention的提出

线性注意力的限制和改进: 尽管线性注意力降低了复杂度，但现有的线性注意力方法仍存在性能下降的问题，并可能因映射函数带来额外的计算开销。为了解决这些问题，作者提出了一个新颖的聚焦线性注意力（Focused Linear Attention）模块。该模块通过简单的映射函数调整查询和键的特征方向，使注意力权重更加明显。此外，还通过深度卷积（DWC）应用于原始注意力矩阵的秩恢复模块来增加特征多样性。

Focused Linear Attention（聚焦线性注意力）是一种用于视觉Transformer模型的注意力机制(但是其也可以用在我们的YOLO系列当中从而提高检测精度)，旨在提高效率和表现力。它解决了传统线性注意力方法的两个主要问题：

1. 聚焦能力: 以往的线性注意力缺乏足够的聚焦能力，导致模型难以有效地关注重要特征。Focused Linear Attention通过改进的机制增强了这种聚焦能力。

2. 特征多样性: 传统方法在特征表达上缺乏多样性，影响了模型的表现力。Focused Linear Attention通过特殊的设计来增加特征的多样性和丰富性。

这种方法通过一个高效的映射函数和秩恢复模块来提高计算效率和性能，使其在处理视觉任务时更加高效和有效。

总结：Focused Linear Attention是对传统线性注意力方法的一种重要改进，提高了模型的聚焦能力和特征表达的多样性。

2.3 效果对比

上面的图片显示了多个视觉Transformer模型的性能和计算复杂度的比较。图中分为四个部分：

1. PVT: 对比了不同版本的PVT（Pyramid Vision Transformer），DeiT（Data-efficient Image Transformer），以及T2T（Tokens-to-Token ViT）的Top-1准确率和计算量（FLOPs）。

2. PVT v2: 类似地，展示了PVT v2、ConvNext、DAT（Deformable Attention Transformer）的性能对比。

3. Swin: 对比了Swin Transformer、CvT（Convolutional vision Transformer），以及CoTNet（Contextual Transformer Network）的模型。

4. CSwin: 展示了CSwin Transformer、MViTv2、CoAtNet的性能对比。

在每个图中，还包括了作者提出的FLatten版本的Transformer模型（标记为“Ours”），其在每个分类中都显示了相对较高的准确率或者在相似的FLOPs计算量下具有竞争力的准确率。

右侧的表格详细列出了不同模型的分辨率（Reso）、参数数量（#Params）、计算量（Flops）和Top-1准确率。表中突出了FLatten版本的Transformer模型在Top-1准确率上相对于原始模型的提升（括号中的百分点）。

个人总结：这张图片展示了通过改进的线性注意力模块，即FLatten模型，在保持或稍微增加计算量的前提下，提高了Transformer架构的图像识别准确率。

三、实验效果对比

四、FLAttention代码

在场的FocusedLinearAttention代码是用于Transformer的想要将其用于YOLO上是需要进行很大改动的，所以我这里进行了挺多的改动的，创作不易而且免费给大家看，所以如果能够帮助到大家希望大家能给点个赞和关注支持一下。

import torch.nn as nn
import torch
from einops import rearrange

def autopad(k, p=None, d=1):  # kernel, padding, dilation
    # Pad to 'same' shape outputs
    if d > 1:
        k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k]  # actual kernel-size
    if p is None:
        p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
    return p


class Conv(nn.Module):
    # Standard convolution with args(ch_in, ch_out, kernel, stride, padding, groups, dilation, activation)
    default_act = nn.SiLU()  # default activation

    def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
        super().__init__()
        self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p, d), groups=g, dilation=d, bias=False)
        self.bn = nn.BatchNorm2d(c2)
        self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()

    def forward(self, x):
        return self.act(self.bn(self.conv(x)))

    def forward_fuse(self, x):
        return self.act(self.conv(x))


class FocusedLinearAttention(nn.Module):
    def __init__(self, dim, num_patches=64, num_heads=8, qkv_bias=True, qk_scale=None, attn_drop=0.0, proj_drop=0.0, sr_ratio=1,
                 focusing_factor=3.0, kernel_size=5):
        super().__init__()
        assert dim % num_heads == 0, f"dim {dim} should be divided by num_heads {num_heads}."
        self.dim = dim
        self.num_heads = num_heads
        head_dim = dim // num_heads

        self.q = nn.Linear(dim, dim, bias=qkv_bias)
        self.kv = nn.Linear(dim, dim * 2, bias=qkv_bias)
        self.attn_drop = nn.Dropout(attn_drop)
        self.proj = nn.Linear(dim, dim)
        self.proj_drop = nn.Dropout(proj_drop)

        self.sr_ratio = sr_ratio
        if sr_ratio > 1:
            self.sr = nn.Conv2d(dim, dim, kernel_size=sr_ratio, stride=sr_ratio)
            self.norm = nn.LayerNorm(dim)

        self.focusing_factor = focusing_factor
        self.dwc = nn.Conv2d(in_channels=head_dim, out_channels=head_dim, kernel_size=kernel_size,
                             groups=head_dim, padding=kernel_size // 2)
        self.scale = nn.Parameter(torch.zeros(size=(1, 1, dim)))
        # self.positional_encoding = nn.Parameter(torch.zeros(size=(1, num_patches // (sr_ratio * sr_ratio), dim)))


    def forward(self, x):
        B, C, H, W = x.shape  # 输入为四维：[批次大小, 通道数, 高度, 宽度]
        dtype, device = x.dtype, x.device
        # 调整输入以匹配原始模块的预期格式
        x = rearrange(x, 'b c h w -> b (h w) c')
        q = self.q(x)
        if self.sr_ratio > 1:
            x_ = x.permute(0, 2, 1).reshape(B, C, H, W)
            x_ = self.sr(x_).reshape(B, C, -1).permute(0, 2, 1)
            x_ = self.norm(x_)
            kv = self.kv(x_).reshape(B, -1, 2, C).permute(2, 0, 1, 3)
        else:
            kv = self.kv(x).reshape(B, -1, 2, C).permute(2, 0, 1, 3)
        k, v = kv[0], kv[1]
        N = H * W  # 序列长度
        # 重新生成位置编码
        positional_encoding = nn.Parameter(torch.zeros(size=(1, N, self.dim), device=device))
        k = k + positional_encoding
        focusing_factor = self.focusing_factor
        kernel_function = nn.ReLU()
        scale = nn.Softplus()(self.scale)
        q = kernel_function(q) + 1e-6
        k = kernel_function(k) + 1e-6
        q = q / scale
        k = k / scale
        q_norm = q.norm(dim=-1, keepdim=True)
        k_norm = k.norm(dim=-1, keepdim=True)
        q = q ** focusing_factor
        k = k ** focusing_factor
        q = (q / q.norm(dim=-1, keepdim=True)) * q_norm
        k = (k / k.norm(dim=-1, keepdim=True)) * k_norm
        bool = False
        if dtype == torch.float16:
            q = q.float()
            k = k.float()
            v = v.float()
            bool = True
        q, k, v = (rearrange(x, "b n (h c) -> (b h) n c", h=self.num_heads) for x in [q, k, v])
        i, j, c, d = q.shape[-2], k.shape[-2], k.shape[-1], v.shape[-1]
        z = 1 / (torch.einsum("b i c, b c -> b i", q, k.sum(dim=1)) + 1e-6)
        if i * j * (c + d) > c * d * (i + j):
            kv = torch.einsum("b j c, b j d -> b c d", k, v)
            x = torch.einsum("b i c, b c d, b i -> b i d", q, kv, z)
        else:
            qk = torch.einsum("b i c, b j c -> b i j", q, k)
            x = torch.einsum("b i j, b j d, b i -> b i d", qk, v, z)
        if self.sr_ratio > 1:
            v = nn.functional.interpolate(v.permute(0, 2, 1), size=x.shape[1], mode='linear').permute(0, 2, 1)
        if bool:
            v = v.to(torch.float16)
            x = x.to(torch.float16)

        num = int(v.shape[1] ** 0.5)
        feature_map = rearrange(v, "b (w h) c -> b c w h", w=num, h=num)
        feature_map = rearrange(self.dwc(feature_map), "b c w h -> b (w h) c")
        x = x + feature_map
        x = rearrange(x, "(b h) n c -> b n (h c)", h=self.num_heads)

        x = self.proj(x)
        x = self.proj_drop(x)
        x = rearrange(x, 'b (h w) c -> b c h w', h=H, w=W)
        return x


class Bottleneck(nn.Module):
    """Standard bottleneck."""

    def __init__(self, c1, c2, shortcut=True, g=1, k=(3, 3), e=0.5):
        """Initializes a bottleneck module with given input/output channels, shortcut option, group, kernels, and
        expansion.
        """
        super().__init__()
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, k[0], 1)
        self.cv2 = Conv(c_, c2, k[1], 1, g=g)
        self.Attention = FocusedLinearAttention(c2)
        self.add = shortcut and c1 == c2

    def forward(self, x):
        """'forward()' applies the YOLO FPN to input data."""
        return x + self.Attention(self.cv2(self.cv1(x))) if self.add else self.Attention(self.cv2(self.cv1(x)))


class C3_FLAttention(nn.Module):
    # CSP Bottleneck with 3 convolutions
    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, number, shortcut, groups, expansion
        super().__init__()
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c1, c_, 1, 1)
        self.cv3 = Conv(2 * c_, c2, 1)  # optional act=FReLU(c2)
        self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n)))

    def forward(self, x):
        return self.cv3(torch.cat((self.m(self.cv1(x)), self.cv2(x)), 1))

五、添加FLAttention到模型中

5.1 细节修改教程

5.1.1 修改一

我们找到如下的目录'yolov5-master/models'在这个目录下创建一个文件目录(注意是目录，因为我这个专栏会出很多的更新，这里用一种一劳永逸的方法)文件目录起名modules，然后在下面新建一个文件，将我们的代码复制粘贴进去。

​

​4.1.2 修改二

然后新建一个__init__.py文件，然后我们在里面添加一行代码。注意标记一个'.'其作用是标记当前目录。

4.1.3 修改三 

然后我们找到如下文件''models/yolo.py''在开头的地方导入我们的模块按照如下修改->

(如果你看了我多个改进机制此处只需要添加一个即可，无需重复添加)

​​​​

4.1.4 修改四

然后我们找到parse_model方法，按照如下修改->

到此就修改完成了，复制下面的ymal文件即可运行。

5.2 FLAttention的yaml文件和训练截图

5.2.1 FLAttention的yaml文件一

同时我发现这个FLAttention在训练的适合不稳定，有的数据集可以用有的不可以用，我一开始用一个数据集跑不通换了一个就可以了。

# YOLOv5 🚀 by Ultralytics, AGPL-3.0 license

# Parameters
nc: 80  # number of classes
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.25  # layer channel multiple
anchors:
  - [10,13, 16,30, 33,23]  # P3/8
  - [30,61, 62,45, 59,119]  # P4/16
  - [116,90, 156,198, 373,326]  # P5/32

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


# YOLOv5 v6.0 head
head:
  [[-1, 1, Conv, [512, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 6], 1, Concat, [1]],  # cat backbone P4
   [-1, 3, C3, [512, False]],  # 13

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

   [-1, 1, Conv, [256, 3, 2]],
   [[-1, 14], 1, Concat, [1]],  # cat head P4
   [-1, 3, C3_FLAttention, [512, False]],  # 20 (P4/16-medium)

   [-1, 1, Conv, [512, 3, 2]],
   [[-1, 10], 1, Concat, [1]],  # cat head P5
   [-1, 3, C3_FLAttention, [1024, False]],  # 23 (P5/32-large)

   [[17, 20, 23], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
  ]

5.2.2 FLAttention的yaml文件二 

下面的是放在Neck部分的截图，参数我以及设定好了，无需进行传入会根据模型输入自动计算，帮助大家省了一些事。

# YOLOv5 🚀 by Ultralytics, AGPL-3.0 license

# Parameters
nc: 80  # number of classes
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.25  # layer channel multiple
anchors:
  - [10,13, 16,30, 33,23]  # P3/8
  - [30,61, 62,45, 59,119]  # P4/16
  - [116,90, 156,198, 373,326]  # P5/32

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


# YOLOv5 v6.0 head
head:
  [[-1, 1, Conv, [512, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 6], 1, Concat, [1]],  # cat backbone P4
   [-1, 3, C3, [512, False]],  # 13

   [-1, 1, Conv, [256, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 4], 1, Concat, [1]],  # cat backbone P3
   [-1, 3, C3, [256, False]],  # 17 (P3/8-small)
   [-1, 1, FocusedLinearAttention, []],  # 18

   [-1, 1, Conv, [256, 3, 2]],
   [[-1, 14], 1, Concat, [1]],  # cat head P4
   [-1, 3, C3, [512, False]],  # 21 (P4/16-medium)
   [-1, 1, FocusedLinearAttention, []], #22

   [-1, 1, Conv, [512, 3, 2]],
   [[-1, 10], 1, Concat, [1]],  # cat head P5
   [-1, 3, C3, [1024, False]],  # 25 (P5/32-large)
   [-1, 1, FocusedLinearAttention, []], #26

   [[18, 22, 26], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
  ]

5.2.2 FLAttention的训练过程截图 

下面的是将FLAttention机制我添加到了C3和Bottleneck的训练截图。

下面的是我将FLAttention放在Neck中的截图。 

六、全文总结 

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

专栏回顾：YOLOv5改进专栏——持续复现各种顶会内容——内含100+创新

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

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

相关文章

【2023 CCF 大数据与计算智能大赛】基于TPU平台实现超分辨率重建模型部署 基于FSRCNN的TPU平台超分辨率模型部署方案

【2023 CCF 大数据与计算智能大赛】基于TPU平台实现超分辨率重建模型部署 基于FSRCNN的TPU平台超分辨率模型部署方案

2023 CCF 大数据与计算智能大赛 基于TPU平台实现超分辨率重建模型部署 基于FSRCNN的TPU平台超分辨率模型部署方案 WELL 刘渝 人工智能 研一 西安交通大学 中国-西安 1461003622qq.com 史政立 网络空间安全 研一 西安交通大学 中国-西安 1170774291qq.com 崔琳、张…
阅读更多...
Hive中支持毫秒级别的时间精度

Hive中支持毫秒级别的时间精度

实际上，Hive 在较新的版本中已经支持毫秒级别的时间精度。你可以通过设置 hive.exec.default.serialization.format 和 mapred.output.value.format 属性为 1，启用 Hive 的时间精度为毫秒级。可以使用以下命令进行设置： set hive.exec.defau…
阅读更多...
idea中终端Terminal页面输入命令git log后如何退出

idea中终端Terminal页面输入命令git log后如何退出

1、idea中Terminal输入命令git log后如何退出？ 2、解决 输入q键会自动退出git log命令
阅读更多...
【Redis前奏曲】初识Redis

【Redis前奏曲】初识Redis

文章目录 一.Redis的一些特性(优点)1. 在内存中存储数据2. 可编程的3. 可扩展的4.持久化5. 聚集(集群)6. 高可用Redis快的原因 二. 使用案例1.数据库2. 缓存3. 消息队列 一.Redis的一些特性(优点) 我们在上一篇博客中说到,Redis是一个在内存中存储数据的中间件.用作数据库,数据…
阅读更多...
C++面向对象（OOP）编程-C++11新特性详解

C++面向对象（OOP）编程-C++11新特性详解

C11作为一个重要的版本，引入了很多新的特性，解决了C语言本身很多遗留的内存泄露问题，并且提供了很多比较灵活的用法。引入的auto，智能指针、线程机制都使得C语言的灵活性、安全性、并发性有了很大的提升。 本文会比较详细的介绍C1…
阅读更多...
ffmpeg两种windows版本区别说明

ffmpeg两种windows版本区别说明

版本一 必须拷贝exe和dll文件才能使用，如果缺少dll则exe不正正常执行 如果缺少dll ，执行 exe会报错如下 版本2 直接拷贝exe就能使用，没有依赖的环境
阅读更多...
防火墙什么用，软件防火墙与硬件防火墙有什么不一样

防火墙什么用，软件防火墙与硬件防火墙有什么不一样

防火墙是一种网络安全技术，通过有机结合各类用于安全管理与筛选的软件和硬件设备，在计算机网络的内、外网之间构建一道相对隔绝的保护屏障，以保护用户资料与信息的安全性。 防火墙的作用的详细说明： 1.访问控制：防火…
阅读更多...
绝地求生：【PC】12月额外特殊空投

绝地求生：【PC】12月额外特殊空投

亲爱的玩家朋友们，大家好！ 有一个好消息要告诉大家，12月丰富的活动列表中又添加了新的活动啦！希望大家在闲游盒PUBG的陪伴下，为2023年画上圆满的句号！ ※可在大厅内的活动页面查看活动详情 PUBG空投节&am…
阅读更多...
[每周一更]-(第44期)：GIT版本控制之忽略文件

[每周一更]-(第44期)：GIT版本控制之忽略文件

基础概念 在 Git 中，可以通过 .gitignore 文件来指定不需要纳入版本控制的文件或文件夹，这些被忽略的文件或文件夹不会被提交到仓库中。 在项目根目录下创建一个名为 .gitignore 的文件，并在其中列出需要忽略的文件或文件夹。一些常见的示例…
阅读更多...
Spring Boot学习随笔- Jasypt加密数据库用户名和密码以及解密

Spring Boot学习随笔- Jasypt加密数据库用户名和密码以及解密

学习视频：【编程不良人】2021年SpringBoot最新最全教程 第十九章、Jasypt加密 Jasypt全称是Java Simplified Encryption，是一个开源项目。 Jasypt与Spring Boot集成，以便在应用程序的属性文件中加密敏感信息，然后在应用程序运行…
阅读更多...
如何在VSCode搭建ESP-IDF开发ESP32

如何在VSCode搭建ESP-IDF开发ESP32

文章目录 概要安装VScode安装ESP-IDF插件使用官方例程小结 概要 ESP-IDF(Espressif IoT Development Framework) 即乐鑫物联网开发框架，它基于 C/C 语言提供了一个自给自足的 SDK，可为在 Windows、Linux 和 macOS 系统平台上开发 ESP32 应用程序提供工具…
阅读更多...
架构设计系列 5：常见架构介绍

架构设计系列 5：常见架构介绍

前面讲了架构是什么，架构的发展史，架构设计的基础理论，这次针对常见架构设计风格进行介绍和分析。 一、MVC：三层架构经典 经典的 MVC 架构（Model-View-Controller）架构是软件系统架构设计中的经典&#xf…
阅读更多...
2022年第十三届中国数据库技术大会（DTCC2022）-核心PPT资料下载

2022年第十三届中国数据库技术大会（DTCC2022）-核心PPT资料下载

一、峰会简介 本届大会以“数据智能 价值创新”为主题，设置2大主会场，20技术专场，邀请超百位行业专家，重点围绕时序数据库、图数据技术、实时数仓技术与应用实践、云原生数据库、大数据平台与数据安全等内容展开分享和探讨&#…
阅读更多...
18-网络安全框架及模型-信息系统安全保障模型

18-网络安全框架及模型-信息系统安全保障模型

信息系统安全保障模型 1 基本概念 信息系统安全保障是针对信息系统在运行环境中所面临的各种风险，制定信息系统安全保障策略，设计并实现信息系统安全保障架构或模型，采取工程、技术、管理等安全保障要素，将风险减少至预定可接受的…
阅读更多...
小梅哥Xilinx FPGA学习笔记18——专用时钟电路 PLL与时钟向导 IP

小梅哥Xilinx FPGA学习笔记18——专用时钟电路 PLL与时钟向导 IP

目录 一：IP核简介（具体可参考野火FPGA文档） 二： 章节导读 三：PLL电路原理 3.1 PLL基本实现框图 3.2 PLL倍频实现 3.3 PLL分频实现 四: 基于 PLL 的多时钟 LED 驱动设计 4.1 配置 Clocking Wizard 核 4.2 led …
阅读更多...
[卷积神经网络]FCOS--仅使用卷积的Anchor Free目标检测

[卷积神经网络]FCOS--仅使用卷积的Anchor Free目标检测

项目源码： FCOShttps://github.com/tianzhi0549/FCOS/ 一、概述 作为一种Anchor Free的目标检测网络，FCOS并不依赖锚框，这点类似于YOLOx和CenterNet，但CenterNet的思路是寻找目标的中心点，而FCOS则是寻找每个像素点&…
阅读更多...
[每周一更]-(第43期)：Golang版本的升级历程

[每周一更]-(第43期)：Golang版本的升级历程

从1.13接触go语言开始更新我们公司内第一个Go项目，直至现在go版本已经发展到1.20（20230428），我们从go发版开始认识go语言，有利于我们更深入 了解这门语言，洞悉一些深层方式，加深我们学习的动力&…
阅读更多...
Android---Kotlin 学习013

Android---Kotlin 学习013

互操作性和可空性 Java 世界里所有对象都可能是 null，而 kotlin 里面不能随便给一个变量赋空值的。所有，kotlin 取调用 java 的代码就很容易出现返回一个 null，而 Kotlin 的接收对象不能为空，你不能想当然地认为 java 的返回值就…
阅读更多...
有了向量数据库，我们还需 SQL 数据库吗？

有了向量数据库，我们还需 SQL 数据库吗？

“除了向量数据库外，我是否还需要一个普通的 SQL 数据库？” 这是我们经常被问到的一个问题。如果除了向量数据以外，用户还有其他标量数据信息，那么其业务可能需要在进行语义相似性搜索前先根据某种条件过滤数据，例如&a…
阅读更多...
数据仓库-数仓优化小厂实践

数据仓库-数仓优化小厂实践

一、背景 由于公司规模较小，大数据相关没有实现平台化，相关的架构都是原生的Apache组件，所以集群的维护和优化都需要人工的参与。根据自己的实践整理一些数仓相关的优化。 二、优化 1、简易架构图 2、ODS层优化 2.1 分段式解析 随着业务增长…
阅读更多...
最新文章

Copyright @ 2022~2023