目标检测-RT-DETR

news2024/9/21 20:45:08

RT-DETR (Real-Time Detection Transformer) 是一种结合了 Transformer 和实时目标检测的创新模型架构。它旨在解决现有目标检测模型在速度和精度之间的权衡问题，通过引入高效的 Transformer 模块和优化的检测头，提升了模型的实时性和准确性。RT-DETR 可以直接用于端到端目标检测，省去了锚框设计，并且在推理阶段具有较高的速度。

RT-DETR 的主要特点

  1. 基于 Transformer 的高效目标检测
    RT-DETR 利用 Transformer 结构来处理特征提取和目标检测任务，能够通过自注意力机制捕捉到全局的上下文信息。Transformer 的并行计算能力使得 RT-DETR 能够在大型数据集上保持较高的推理速度和检测精度。

  2. 实时性能优化
    与传统的基于 CNN 的目标检测模型相比，RT-DETR 采用了轻量化的设计，减少了计算复杂度，优化了推理时间。通过减少多余的特征提取层和非必要的卷积运算，RT-DETR 在实时检测任务中的表现非常出色。

  3. 无锚框设计
    RT-DETR 不依赖于锚框（anchor boxes），通过直接预测物体的边界框和类别，提高了模型的灵活性和检测效率。这种 Anchor-Free 的检测方式不仅减少了超参数调优的工作量，还提升了小目标检测的性能。

  4. 高效的多尺度特征融合
    RT-DETR 集成了多尺度特征融合模块，使模型能够同时处理大中小不同尺寸的目标。在检测小目标时，模型的表现尤其优异。

  5. 端到端训练
    RT-DETR 采用了端到端的训练方式，不需要像传统的检测方法那样经过复杂的后处理步骤，如非极大值抑制（NMS）。这不仅提高了训练的效率，还减少了推理的复杂度。

RT-DETR 核心代码展示

以下是 RT-DETR 的简化核心代码示例，包含了 Transformer 的实现和检测头的设计。

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import TransformerEncoder, TransformerEncoderLayer

# 1. 基本的 RT-DETR Backbone
class Backbone(nn.Module):
    def __init__(self):
        super(Backbone, self).__init__()
        # 一个简单的卷积层模拟主干网络特征提取
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)

    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        return self.relu(x)

# 2. Transformer 编码器部分
class TransformerEncoderModule(nn.Module):
    def __init__(self, d_model=256, nhead=8, num_layers=6):
        super(TransformerEncoderModule, self).__init__()
        encoder_layer = TransformerEncoderLayer(d_model=d_model, nhead=nhead)
        self.transformer_encoder = TransformerEncoder(encoder_layer, num_layers=num_layers)

    def forward(self, x):
        # Transformer 输入前需要展平
        x = x.flatten(2).permute(2, 0, 1)  # [batch_size, channels, h, w] -> [h*w, batch_size, channels]
        x = self.transformer_encoder(x)
        return x.permute(1, 2, 0).view(x.size(1), -1, int(x.size(0)**0.5), int(x.size(0)**0.5))

# 3. 检测头部分
class DetectionHead(nn.Module):
    def __init__(self, num_classes, d_model=256):
        super(DetectionHead, self).__init__()
        self.num_classes = num_classes
        # 分类预测
        self.class_head = nn.Linear(d_model, num_classes)
        # 边界框预测
        self.bbox_head = nn.Linear(d_model, 4)

    def forward(self, x):
        # 对每个特征图位置进行分类和边界框回归
        class_logits = self.class_head(x)
        bbox_reg = self.bbox_head(x)
        return class_logits, bbox_reg

# 4. RT-DETR 总体结构
class RTDETR(nn.Module):
    def __init__(self, num_classes=80):
        super(RTDETR, self).__init__()
        self.backbone = Backbone()
        self.transformer = TransformerEncoderModule()
        self.detection_head = DetectionHead(num_classes)

    def forward(self, x):
        # 1. 特征提取
        features = self.backbone(x)
        # 2. Transformer 编码
        transformer_out = self.transformer(features)
        # 3. 目标检测头进行分类和边界框预测
        class_logits, bbox_reg = self.detection_head(transformer_out)
        return class_logits, bbox_reg

代码解析

  1. Backbone：模型的主干网络，用于提取输入图像的特征。在这个简单示例中，使用了一个卷积层模拟特征提取的过程，实际实现中，RT-DETR 的 Backbone 可以是 ResNet、Swin Transformer 等网络。

  2. Transformer 编码器：RT-DETR 的核心模块，负责将提取到的特征输入 Transformer 编码器，通过自注意力机制捕捉全局的上下文信息。在实际应用中，编码器的层数可以根据需求调整，默认情况下为 6 层。

  3. Detection Head：检测头负责对 Transformer 的输出进行处理，包括目标的类别分类和边界框的回归。RT-DETR 的检测头设计为 Anchor-Free，即不依赖锚框，直接预测目标的位置和类别。
    在 RT-DETR 模型中，TransformerEncoder 和 TransformerEncoderLayer 是 Transformer 的核心模块。它们用于在序列数据（如特征图或文本）中捕获全局的上下文信息。Transformer 结构最初由 Vaswani 等人在《Attention is All You Need》论文中提出，广泛应用于自然语言处理、目标检测和图像分类等任务。

1. TransformerEncoderLayer

TransformerEncoderLayer 是 Transformer 编码器的基本组成单元，它包含两个主要部分：

  • 多头自注意力机制（Multi-Head Self-Attention, MHSA）：这是 Transformer 的核心机制，它允许模型在每个时间步（或特征点）上关注输入序列中的所有其他时间步（或特征点），以获得全局的信息。这种机制通过加权平均处理输入序列中的各个位置，使模型能够捕捉到序列中的长距离依赖关系。

  • 前馈神经网络（Feedforward Neural Network, FFN）：每个 Transformer 编码器层中还包含一个独立的前馈神经网络，通常由两层线性变换和非线性激活函数组成。前馈网络在每个输入位置独立地处理经过自注意力模块后的特征。

此外，TransformerEncoderLayer 使用残差连接（Residual Connection）和层归一化（Layer Normalization）来确保梯度稳定并提高模型的收敛性。

核心组成：
  • Self-Attention Layer（自注意力层）：用于计算输入序列中每个元素相对于其他元素的重要性。
  • Feedforward Network（前馈网络）：对经过注意力机制处理的结果进行进一步非线性转换。
  • Layer Normalization（层归一化）：在每个注意力和前馈网络之后应用，以稳定训练。
  • Residual Connections（残差连接）：跳跃连接用于避免梯度消失问题，确保深层网络的训练稳定。
代码示例：
import torch.nn as nn

class TransformerEncoderLayer(nn.Module):
    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1):
        super(TransformerEncoderLayer, self).__init__()
        # 多头自注意力层
        self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
        # 前馈神经网络
        self.linear1 = nn.Linear(d_model, dim_feedforward)
        self.dropout = nn.Dropout(dropout)
        self.linear2 = nn.Linear(dim_feedforward, d_model)

        # 层归一化
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        
        # Dropout
        self.dropout1 = nn.Dropout(dropout)
        self.dropout2 = nn.Dropout(dropout)

    def forward(self, src):
        # 自注意力机制
        src2 = self.self_attn(src, src, src)[0]
        # 残差连接和归一化
        src = src + self.dropout1(src2)
        src = self.norm1(src)

        # 前馈网络
        src2 = self.linear2(self.dropout(F.relu(self.linear1(src))))
        # 残差连接和归一化
        src = src + self.dropout2(src2)
        src = self.norm2(src)

        return src

2. TransformerEncoder

TransformerEncoder 是由多个 TransformerEncoderLayer 叠加组成的整体编码器。它负责处理输入序列，将其转换为一个更高层次的表示。编码器中的每一层都会逐步对输入数据中的依赖关系进行建模，从而产生富有语义的全局特征表示。

关键特性：
  • 多层堆叠：编码器可以包含多个 TransformerEncoderLayer，通常设置为 6 层或更多，以捕捉输入序列的复杂依赖关系。
  • 并行计算：Transformer 通过自注意力机制能够并行处理整个输入序列，使其在处理长序列时非常高效。
代码示例：
import torch.nn as nn

class TransformerEncoder(nn.Module):
    def __init__(self, encoder_layer, num_layers):
        super(TransformerEncoder, self).__init__()
        # 堆叠多层 Transformer 编码器层
        self.layers = nn.ModuleList([encoder_layer for _ in range(num_layers)])
        self.num_layers = num_layers

    def forward(self, src):
        # 依次通过每一层 Transformer 编码器层
        output = src
        for layer in self.layers:
            output = layer(output)

        return output

工作流程：

  1. 输入数据经过 TransformerEncoderLayer 中的多头自注意力机制，每个时间步/特征点在整个输入序列的上下文中进行信息交流。
  2. 每层的输出被送入前馈神经网络进行进一步处理。
  3. 多个 TransformerEncoderLayer 叠加起来，逐层细化输入的全局表示。

Transformer 的核心优势

  1. 捕捉长距离依赖：自注意力机制可以直接建模序列中任意位置之间的依赖关系，无需像 RNN 那样逐步传播信息，因此能够更高效地捕捉长距离依赖。

  2. 并行处理：Transformer 能够并行处理整个序列，而不像 RNN 需要按顺序处理每个时间步。这使得 Transformer 在处理大规模数据时具有更高的效率。

  3. 全局信息建模：通过多头自注意力机制，模型能够在不同的子空间中关注序列的不同部分，建模全局上下文关系。

TransformerEncoderLayer 和 TransformerEncoder 是 Transformer 结构的核心部分。它们利用自注意力机制与前馈网络相结合的方式，能够高效地处理序列数据中的全局上下文信息，使得 RT-DETR 这样的目标检测模型可以更好地进行端到端的检测，尤其是在复杂的场景中表现尤为出色。
nn.MultiheadAttention 是 PyTorch 中实现多头自注意力机制的模块，它是 Transformer 的核心组件。多头注意力机制允许模型在多个不同的子空间中计算注意力，从而使模型能够捕捉到序列中不同层次和不同位置的信息。

多头注意力的原理

多头自注意力机制的目标是让模型能够关注输入序列中不同位置的相关性。在每个头中，输入序列通过线性投影映射到 query（查询）、key（键）和 value（值）三个向量空间，然后计算注意力得分。多个头可以并行计算，通过不同的权重来关注序列中的不同部分，最后将所有头的输出拼接起来进行进一步处理。

公式上，Scaled Dot-Product Attention 计算如下：
在这里插入图片描述
其中：

  • ( Q )（Query）：查询向量
  • ( K )（Key）：键向量
  • ( V )（Value）：值向量
  • ( d_k )：键向量的维度，用于缩放点积的结果，避免梯度消失

对于多头注意力机制，多个注意力头可以并行计算：
在这里插入图片描述

每个头的计算为：

在这里插入图片描述

nn.MultiheadAttention 的实现

在 PyTorch 中，nn.MultiheadAttention 封装了上述的多头自注意力机制，并支持批量处理序列数据。

关键步骤：

  1. 输入线性变换：输入的特征会通过线性层投影，生成 query、key 和 value 三个矩阵。每个矩阵有多个头，分别用不同的权重矩阵进行线性变换。

  2. Scaled Dot-Product Attention：对于每个头，计算 query 和 key 的点积，应用缩放和 softmax，然后将结果与 value 相乘，得到注意力输出。

  3. 多头拼接：所有头的输出被拼接在一起，并通过最后的线性变换得到最终的多头注意力结果。

  4. 残差连接：注意力的输出与输入序列通过残差连接结合，保持信息的稳定性。

PyTorch 中 nn.MultiheadAttention 的核心代码结构：
import torch
import torch.nn.functional as F
from torch import nn

class MultiheadAttention(nn.Module):
    def __init__(self, embed_dim, num_heads, dropout=0.0):
        super(MultiheadAttention, self).__init__()
        self.embed_dim = embed_dim
        self.num_heads = num_heads
        self.dropout = dropout

        # 确保嵌入维度能被头的数量整除
        assert embed_dim % num_heads == 0, "Embedding dimension must be divisible by the number of heads"

        # 每个头的维度
        self.head_dim = embed_dim // num_heads

        # 定义 Q、K、V 的线性投影层
        self.q_proj = nn.Linear(embed_dim, embed_dim)
        self.k_proj = nn.Linear(embed_dim, embed_dim)
        self.v_proj = nn.Linear(embed_dim, embed_dim)

        # 最终的输出投影层
        self.out_proj = nn.Linear(embed_dim, embed_dim)

    def forward(self, query, key, value):
        # 1. 线性投影 Q、K、V
        Q = self.q_proj(query)  # [batch_size, seq_len, embed_dim]
        K = self.k_proj(key)    # [batch_size, seq_len, embed_dim]
        V = self.v_proj(value)  # [batch_size, seq_len, embed_dim]

        # 2. 将 Q、K、V 分成多头
        Q = self._split_heads(Q)  # [batch_size, num_heads, seq_len, head_dim]
        K = self._split_heads(K)  # [batch_size, num_heads, seq_len, head_dim]
        V = self._split_heads(V)  # [batch_size, num_heads, seq_len, head_dim]

        # 3. 计算每个头的自注意力
        attn_output = self._scaled_dot_product_attention(Q, K, V)

        # 4. 将多头的输出拼接起来
        attn_output = self._combine_heads(attn_output)

        # 5. 最终的线性投影
        output = self.out_proj(attn_output)  # [batch_size, seq_len, embed_dim]
        return output

    def _split_heads(self, x):
        # 将输入按照头的数量进行分割，batch_size 和 seq_len 保持不变，embed_dim 分成 num_heads * head_dim
        batch_size, seq_len, embed_dim = x.size()
        x = x.view(batch_size, seq_len, self.num_heads, self.head_dim)
        return x.permute(0, 2, 1, 3)  # [batch_size, num_heads, seq_len, head_dim]

    def _combine_heads(self, x):
        # 将多头的输出重新组合成一个张量
        batch_size, num_heads, seq_len, head_dim = x.size()
        x = x.permute(0, 2, 1, 3).contiguous()
        return x.view(batch_size, seq_len, num_heads * head_dim)

    def _scaled_dot_product_attention(self, Q, K, V):
        # Q 和 K 的点积，然后缩放
        scores = torch.matmul(Q, K.transpose(-2, -1)) / self.head_dim ** 0.5  # [batch_size, num_heads, seq_len, seq_len]
        attn_weights = F.softmax(scores, dim=-1)  # 注意力权重
        attn_output = torch.matmul(attn_weights, V)  # 通过权重加权的 V
        return attn_output

代码解释：

  1. 初始化 (__init__)：

    • embed_dim：输入的嵌入维度，即每个序列元素的特征长度。
    • num_heads：多头注意力中的头数，embed_dim 必须能被 num_heads 整除。
    • q_proj、k_proj、v_proj：分别是对 query、key 和 value 进行线性变换的投影层。

  2. 前向传播 (forward)：

    • 将输入的 query、key、value 分别通过线性层投影到 Q、K、V 向量。
    • 使用 _split_heads 将它们分割成多头。
    • 计算缩放的点积注意力 (_scaled_dot_product_attention)。
    • 将多头的结果拼接起来 (_combine_heads)。
    • 最后通过 out_proj 投影到最终的输出。

  3. 注意力计算 (_scaled_dot_product_attention)：

    • 通过矩阵乘法计算 Q 和 K 的点积，得到每个位置之间的相似度得分。
    • 使用 softmax 将这些得分归一化为注意力权重。
    • 用这些权重对 V 进行加权求和，得到注意力的输出。

  4. 多头处理 (_split_heads 和 _combine_heads)：

    • _split_heads：将 Q、K 和 V 分解为多个头，以便并行计算每个头的自注意力。
    • _combine_heads：将每个头的输出重新组合为一个完整的张量，供后续处理。

总结

nn.MultiheadAttention 模块实现了多头自注意力机制，它通过并行计算多个注意力头来捕获输入序列中不同位置和不同层次的依赖关系。每个头可以学习不同的注意力模式，最终将这些模式结合起来，生成更加丰富的特征表示。这一机制在 Transformer 中的应用，使模型具备了捕捉长距离依赖关系和并行处理的能力，大大提高了计算效率。

结论

RT-DETR 是一种结合 Transformer 和目标检测的新型模型，具有实时检测的能力，并且在精度上比传统的目标检测模型有显著提升。通过自注意力机制和高效的特征提取设计，RT-DETR 在检测大中小目标时均有出色的表现，同时减少了复杂的后处理步骤，使其更加适用于实际应用场景，如自动驾驶、监控、机器人视觉等。

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

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

相关文章

Linux-实用指令

Linux-实用指令

目录 前言 指定运行级别 基本介绍 切换运行级别 指令类 帮助指令 man 获得帮助信息 help指令 文件目录类 pwd指令 ls指令 cd指令 mkdir命令 rmdir指令删除空目录 touch指令 cp指令 rm指令 mv指令 cat指令 more指令 less指令 echo指令 head指令 tail指令…
阅读更多...
2024.9.6 作业

2024.9.6 作业

手写unique_ptr指针指针 代码&#xff1a; #include <iostream> #include <stdexcept>template <typename T> class unique_ptr { public:// 构造函数explicit unique_ptr(T* ptr nullptr) : m_ptr(ptr) {}// 析构函数~unique_ptr() {delete m_ptr;}// 禁…
阅读更多...
设置GB/T35114服务

设置GB/T35114服务

GB/T35114服务是下联模式&#xff0c;支持GB/T35114标准A级双向认证&#xff0c;支持国密系列硬件设备。 操作步骤 在配置-》设备-》级联配置-》GB服务配置 进行编辑。 1、点击 编辑 2、修改国标服务器地址 3、如果其他参数也需要修改&#xff0c;都可自定义&#xff0c;除了国…
阅读更多...
FME教程：通过更新读模块，解决FME读取shapefile数据，提示意外输入，“在转换中，某些读取的要素与工作空间的要素类不匹配……”的问题

FME教程：通过更新读模块，解决FME读取shapefile数据，提示意外输入，“在转换中，某些读取的要素与工作空间的要素类不匹配……”的问题

目录 一、问题情况 二、解决方法 一、问题情况 在使用制作好的FME模板读取shapefile数据时&#xff0c;有时候会遇到弹窗提示意外输入&#xff0c;模板无法运行&#xff0c;在日志信息中警示“在转换中&#xff0c;某些读取的要素与工作空间的要素类不匹配。可能由于读模块的…
阅读更多...
2024年全国大学生数学建模竞赛（E题） 建模解析|交通流量管控|小鹿学长带队指引全代码文章与思路

2024年全国大学生数学建模竞赛（E题） 建模解析|交通流量管控|小鹿学长带队指引全代码文章与思路

我是鹿鹿学长&#xff0c;就读于上海交通大学&#xff0c;截至目前已经帮200人完成了建模与思路的构建的处理了&#xff5e; 本篇文章是鹿鹿学长经过深度思考&#xff0c;独辟蹊径&#xff0c;实现综合建模。独创复杂系统视角&#xff0c;帮助你解决国赛的难关呀。 完整内容可以…
阅读更多...
【前端学习】AntV G6-06 使用图算法

【前端学习】AntV G6-06 使用图算法

课程链接 图算法 Algorithm | G6 (antgroup.com) 【例子 pageRank】 ​​​​​​力导向图布局 | G6 (antgroup.com) 重点部分添加注释 import G6 from antv/g6;const { pageRank } G6.Algorithm; // 在此引入 pageRankconst container document.getElementById(containe…
阅读更多...
无人机之报警器的作用

无人机之报警器的作用

一、紧急救援与辅助搜救 紧急救援&#xff1a;在事故或紧急情况下&#xff0c;无人机报警器可以迅速发出警报&#xff0c;指引救援人员前往事故地点&#xff0c;提高救援效率。 辅助搜救&#xff1a;无人机搭载报警器可以辅助寻找失踪人员或其他需要搜救的场景&#xff0c;通…
阅读更多...
MySQL数据库的介绍

MySQL数据库的介绍

目录 1.什么是MySQL数据库 2.MySQL数据库的设计 MySQL的进一步认识 MySQL的客户端 —— mysql MySQL的服务端 —— mysqld 3.MySQL数据库的架构 MySQL架构图 连接层 服务层 存储引擎层 文件系统层 4.MySQL的存储引擎 认识存储引擎 MySQL中的存储引擎 存储引擎之…
阅读更多...
电工类 ，今日行业动态

电工类 ，今日行业动态

电工类今日行业动态 一、技术发展趋势 智能化、自动化推进&#xff1a;随着人工智能、物联网等技术的不断发展&#xff0c;电工行业正逐步向智能化、自动化转型。智能电网、智能家居等领域的快速发展&#xff0c;对电工技术提出了新的要求&#xff0c;电工人员需要不断学习和…
阅读更多...
使用matplotlib绘制散点图、柱状图和饼状图-学习篇

使用matplotlib绘制散点图、柱状图和饼状图-学习篇

一、散点图 Python代码如下&#xff1a; num_points 100 x np.random.rand(num_points) #x点位随机 y np.random.rand(num_points) #y点位随机 colors np.random.rand(num_points) #颜色随机 sizes 1000 * np.random.rand(num_points) # 大小随机 alphas np.random.ran…
阅读更多...
网络安全评测评技术与标准

网络安全评测评技术与标准

网络安全测评概况 概念 参照一定的标准规范要求&#xff0c;通过一系列技术和管理方法&#xff0c;获取评估对象网络安全状况信息&#xff0c;对其给出相应网络安全情况综合判定 测评对象&#xff1a;信息系统的组成要素或信息系统自身 CC&#xff08;Common Criteria&#…
阅读更多...
Versioned Staged Flow-Sensitive Pointer Analysis

Versioned Staged Flow-Sensitive Pointer Analysis

VSFS 1.Introduction2.Approach2.1.相关概念2.2.VSFS 3.Evaluation参考文献 1.Introduction 上一篇blog我介绍了目前flow-sensitive pointer analysis常用的SFS算法。相比IFDS-based方法&#xff0c;SFS显著通过稀疏分析提升了效率&#xff0c;但是其内部依旧有许多冗余计算&a…
阅读更多...
12道经典性能测试人员面试题

12道经典性能测试人员面试题

1.性能测试包含了哪些软件测试&#xff08;至少举出3种&#xff09;&#xff1f; 参考答案&#xff1a;负载测试、压力测试、容量测试。 负载测试&#xff08;Load Testing&#xff09;&#xff1a;负载测试是一种主要为了测试软件系统是否达到需求文档设计的目标&#xff0c…
阅读更多...
Linux系统编程实现ls -l | wc -l指令

Linux系统编程实现ls -l | wc -l指令

由于该指令是通过管道的形式实现的&#xff0c;所以我们要使用系统函数pipe。ls -l |wc -l的作用就是统计当前目录有多少文件。如果又父进程实现ls -l&#xff0c;子进程实现wc -l指令&#xff0c;代码如下&#xff1a; #include<unistd.h> #include<stdio.h> #in…
阅读更多...
帝可得智能售货机运营管理系统

帝可得智能售货机运营管理系统

1.项目介绍 帝可得是一个基于物联网概念下的智能售货机运营管理系统 应用场景&#xff1a;智能家居、共享充电中、智能售货机 智能售货机的优势在于其自我管理能力 。 物联网技术&#xff1a;像是售货机的顺风耳和千里眼。 智能分析与推荐 人员设备绑定管理 移动支付支持…
阅读更多...
下一代皮克斯：AI如何融合电影与游戏

下一代皮克斯：AI如何融合电影与游戏

故事是人类体验的核心，通过故事我们理解世界、寻找意义并与他人建立联系。技术的进步不断推动着故事叙述的形式，从迪士尼的多平面摄影机到皮克斯的3D图形技术，每一次技术革命都带来了故事叙述的新方式。 游戏：现代叙事的前沿 今天，有两个主要的趋势正在加速下一代叙事公…
阅读更多...
球球大作战

球球大作战

代码&#xff1a; #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdbool.h> #include<graphics.h> #include<stdlib.h> #include<conio.h> #include<time.h>//随机数库文件 #include<math.h> #include<tchar.h…
阅读更多...
单点登录CAS

单点登录CAS

CAS&#xff08;Central Authentication Service&#xff09;是耶鲁大学发起的一个开源项目&#xff0c;旨在为Web应用系统提供一种可靠的单点登录解决方案。CAS服务器独立部署&#xff0c;作为独立的Web应用&#xff0c;负责处理用户的认证请求并颁发票据&#xff08;Ticket&a…
阅读更多...
P0.7全倒装COB超微小间距LED显示屏厂家已量产，加速高清显示的发展

P0.7全倒装COB超微小间距LED显示屏厂家已量产，加速高清显示的发展

随着P0.7全倒装COB超微小间距LED显示屏技术的成功量产&#xff0c;这一里程碑式的成就不仅标志着高清显示技术迈入了全新纪元&#xff0c;更预示着未来视觉体验将迎来前所未有的变革。各大应用场景&#xff0c;如指挥中心、会议中心、大型活动直播、高端影院乃至家庭娱乐&#…
阅读更多...
如何高效学习越南语，求方法，急！！！

如何高效学习越南语，求方法，急！！！

高效学习越南语需要掌握基础语法和词汇&#xff0c;并通过将自己置于语言环境中来加强实际应用。与母语为越南语的人进行语言交换&#xff0c;利用语言学习应用&#xff0c;制定学习计划&#xff0c;以及进行阅读和写作练习都是提高语言能力的有效方法。同时&#xff0c;通过听…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023