首页
/ DeepSeek-V3架构深度解析：MLA与DeepSeekMoE

DeepSeek-V3架构深度解析：MLA与DeepSeekMoE

2026-02-04 04:45:55作者：翟江哲Frasier
DeepSeek-V3
项目地址：https://gitcode.com/GitHub_Trending/de/DeepSeek-V3

本文深入解析DeepSeek-V3的核心架构创新，重点介绍多头潜在注意力(MLA)机制和DeepSeekMoE专家混合架构。MLA通过低秩联合压缩技术显著降低KV缓存内存占用，解决传统注意力机制的内存瓶颈问题；DeepSeekMoE采用671B总参数中仅激活37B参数的设计，实现极高的计算效率。文章还将详细分析无辅助损失负载平衡策略和FP8混合精度训练框架，这些技术创新共同奠定了DeepSeek-V3卓越性能的基础。

多头潜在注意力(MLA)机制原理

多头潜在注意力（Multi-head Latent Attention，MLA）是DeepSeek-V3架构中的核心创新技术，专门为解决传统注意力机制在推理阶段面临的内存瓶颈问题而设计。MLA通过引入低秩联合压缩技术，显著降低了Key-Value（KV）缓存的内存占用，同时保持了模型的表达能力。

MLA的核心设计思想

MLA的核心思想是将传统的多头注意力机制中的Key和Value投影进行低秩分解，通过共享的潜在表示来减少内存消耗。具体而言，MLA将每个token的隐藏状态投影到一个低维的共享潜在空间中，然后从这个共享表示中重构出各个注意力头所需的Key和Value向量。

flowchart TD
    A[输入隐藏状态 hₜ] --> B[低秩压缩<br/>cₜᴷⱽ = Wᴰᴷⱽ · hₜ]
    B --> C[Key重构<br/>kₜᴷ = Wᵁᴷ · cₜᴷⱽ]
    B --> D[Value重构<br/>vₜ = Wᵁⱽ · cₜᴷⱽ]
    C --> E[注意力计算]
    D --> E
    E --> F[输出表示]

数学原理与实现细节

MLA的数学表达可以分解为三个关键步骤：

  1. 低秩联合压缩：将输入隐藏状态投影到低维潜在空间

    ctKV=WDKVht\mathbf{c}_t^{KV} = W^{DKV} \mathbf{h}_t

    其中 WDKV∈Rdc×dW^{DKV} \in \mathbb{R}^{d_c \times d} 是降维矩阵，dcd_c 是潜在维度（通常远小于 dd）

  2. Key重构：从潜在表示重构各个注意力头的Key向量

    ktC=WUKctKV\mathbf{k}_t^C = W^{UK} \mathbf{c}_t^{KV}

    WUK∈R(nh×dh)×dcW^{UK} \in \mathbb{R}^{(n_h \times d_h) \times d_c} 是Key的上投影矩阵

  3. Value重构：从同一潜在表示重构Value向量

    vt=WUVctKV\mathbf{v}_t = W^{UV} \mathbf{c}_t^{KV}

    WUV∈R(nh×dh)×dcW^{UV} \in \mathbb{R}^{(n_h \times d_h) \times d_c} 是Value的上投影矩阵

MLA与传统注意力机制对比

特性 传统多头注意力(MHA) 多头潜在注意力(MLA)
KV缓存大小 O(n×nh×dh)O(n \times n_h \times d_h) O(n×dc)O(n \times d_c)
内存效率 较低 较高（减少3-8倍）
计算复杂度 较高 较低
参数数量 标准 略有增加
推理速度 较慢 较快

DeepSeek-V3中的MLA实现

在DeepSeek-V3的具体实现中，MLA采用了以下配置参数：

# MLA配置参数示例
q_lora_rank = 1536      # Query的低秩投影维度
kv_lora_rank = 512      # Key-Value的潜在维度
qk_nope_head_dim = 128  # 无位置编码的QK头维度
qk_rope_head_dim = 64   # 旋转位置编码的QK头维度
v_head_dim = 128        # Value头维度

MLA的实现包含两个主要变体：

  1. 朴素实现（naive）：直接存储重构后的Key和Value缓存
  2. 吸收实现（absorb）：存储原始潜在表示，在注意力计算时动态重构

注意力计算过程

MLA的注意力得分计算采用混合策略：

# 注意力得分计算（简化版）
scores = (einsum("bshc,btc->bsht", q_nope, kv_cache) +
          einsum("bshr,btr->bsht", q_pe, pe_cache)) * softmax_scale

其中：

  • q_nope：无位置编码的Query部分
  • q_pe：带旋转位置编码的Query部分
  • kv_cache：存储的Key-Value潜在表示
  • pe_cache：位置编码缓存

性能优势分析

MLA机制在DeepSeek-V3中带来了显著的性能提升：

  1. 内存优化：KV缓存内存占用减少约75%，支持更长的上下文长度
  2. 计算效率：通过低秩投影减少矩阵运算复杂度
  3. 可扩展性：为超长上下文（128K tokens）提供可行性
  4. 硬件友好：更好的内存访问模式和计算并行性

技术挑战与解决方案

MLA实现面临的主要挑战包括：

  1. 精度保持：通过精细的数值稳定性设计确保低秩压缩不损失模型性能
  2. 计算优化：利用高效的矩阵分解和并行计算策略
  3. 内存管理：智能的缓存策略和内存分配机制

MLA机制的成功实施使得DeepSeek-V3在保持卓越性能的同时，实现了前所未有的推理效率，为大规模语言模型的实际部署奠定了坚实基础。

DeepSeekMoE专家混合架构设计

DeepSeek-V3采用了创新的专家混合（Mixture-of-Experts，MoE）架构设计，这一设计在保持模型性能的同时显著提升了计算效率。DeepSeekMoE架构通过精心设计的门控机制、专家网络结构和分布式计算策略，实现了671B总参数中仅激活37B参数的惊人效率。

架构核心组件

DeepSeekMoE架构由三个核心组件构成：门控机制（Gate）、专家网络（Expert）和MoE模块本身，形成了一个高效的专家选择与计算流水线。

门控机制设计

门控机制是MoE架构的核心，负责将输入路由到最合适的专家网络。DeepSeek-V3的门控机制采用以下设计：

class Gate(nn.Module):
    def __init__(self, args: ModelArgs):
        super().__init__()
        self.dim = args.dim
        self.topk = args.n_activated_experts  # 激活专家数量
        self.n_groups = args.n_expert_groups   # 专家分组数量
        self.topk_groups = args.n_limited_groups  # 激活分组数量
        self.score_func = args.score_func      # 评分函数类型
        self.route_scale = args.route_scale    # 路由缩放因子
        self.weight = nn.Parameter(torch.empty(args.n_routed_experts, args.dim))
        self.bias = nn.Parameter(torch.empty(args.n_routed_experts)) if self.dim == 7168 else None

门控机制支持两种评分函数：

  • Softmax函数：传统的专家选择方式，确保概率分布归一化
  • Sigmoid函数：创新的评分机制，提供更灵活的专家激活策略

专家网络架构

每个专家网络采用三线性变换结构，结合Swish激活函数：

class Expert(nn.Module):
    def __init__(self, dim: int, inter_dim: int):
        super().__init__()
        self.w1 = Linear(dim, inter_dim)    # 输入到隐藏层变换
        self.w2 = Linear(inter_dim, dim)    # 隐藏层到输出变换  
        self.w3 = Linear(dim, inter_dim)    # 辅助特征变换

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return self.w2(F.silu(self.w1(x)) * self.w3(x))

这种设计确保了专家网络具有足够的表达能力，同时保持了计算效率。

分布式MoE架构

DeepSeekMoE采用分布式设计，支持在多GPU环境中高效运行：

flowchart TD
    A[输入张量] --> B[门控机制]
    B --> C[专家选择]
    C --> D[分布式专家计算]
    D --> E[结果聚合]
    E --> F[共享专家处理]
    F --> G[最终输出]
    
    subgraph DistributedExperts[分布式专家网络]
        H[专家0]
        I[专家1]
        J[...]
        K[专家N]
    end
    
    C --> DistributedExperts
    DistributedExperts --> E

关键技术创新

无辅助损失负载均衡策略

DeepSeek-V3创新性地采用了无辅助损失的负载均衡策略，避免了传统MoE模型中因强制负载均衡而导致的性能下降。这一策略通过智能的路由算法实现专家间的自然负载分布。

多专家分组机制

# 专家分组路由逻辑
if self.n_groups > 1:
    scores = scores.view(x.size(0), self.n_groups, -1)
    group_scores = scores.amax(dim=-1) if self.bias is None else scores.topk(2, dim=-1)[0].sum(dim=-1)
    indices = group_scores.topk(self.topk_groups, dim=-1)[1]
    mask = scores.new_ones(x.size(0), self.n_groups, dtype=bool).scatter_(1, indices, False)
    scores = scores.masked_fill_(mask.unsqueeze(-1), float("-inf")).flatten(1)

这种分组机制允许模型在不同专家子集间进行更精细的路由决策，提升了专家利用效率。

共享专家设计

DeepSeekMoE包含共享专家网络，这些专家处理所有输入，确保基础功能的统一处理：

self.shared_experts = MLP(args.dim, args.n_shared_experts * args.moe_inter_dim)

性能优化特性

计算效率优化

参数类型 数量 占比 说明
总参数 671B 100% 模型全部参数
激活参数 37B 5.5% 每个token实际计算的参数
路由专家 256 - 可供选择的总专家数
激活专家 6 - 每个token激活的专家数

内存访问优化

DeepSeekMoE通过以下策略优化内存访问：

  • 专家数据局部性：每个GPU只存储部分专家，减少内存占用
  • 批量路由计算：一次性计算所有token的路由决策
  • 零填充优化：对未激活的专家跳过计算

架构配置参数

DeepSeekMoE的关键配置参数如下表所示：

参数名称 默认值 说明
n_routed_experts 64 路由专家总数
n_shared_experts 2 共享专家数量
n_activated_experts 6 每个token激活专家数
n_expert_groups 1 专家分组数量
n_limited_groups 1 限制激活分组数
score_func "softmax" 评分函数类型
route_scale 1.0 路由权重缩放因子

实际工作流程

DeepSeekMoE的前向传播流程如下：

sequenceDiagram
    participant Input as 输入张量
    participant Gate as 门控机制
    participant Experts as 专家网络
    participant Shared as 共享专家
    participant Output as 输出张量

    Input->>Gate: 输入特征
    Gate->>Gate: 计算专家评分
    Gate->>Gate: 选择top-k专家
    Gate->>Experts: 路由到对应专家
    Experts->>Experts: 并行专家计算
    Experts->>Output: 专家输出加权和
    Input->>Shared: 同时输入共享专家
    Shared->>Output: 共享专家输出
    Output->>Output: 合并最终结果

这种设计确保了DeepSeek-V3在保持强大表达能力的同时，实现了极高的计算效率，为大规模语言模型的实用化部署提供了可行的架构方案。

无辅助损失负载平衡策略

DeepSeek-V3在混合专家（MoE）架构中引入了一项突破性的创新——无辅助损失负载平衡策略，这一技术彻底改变了传统MoE模型中依赖辅助损失函数来实现专家负载均衡的方法。该策略通过精巧的架构设计和路由机制，在不引入额外损失项的情况下实现了高效的专家利用率，显著提升了模型的训练稳定性和推理效率。

传统MoE负载平衡的挑战

在传统的MoE架构中，负载平衡通常通过引入辅助损失函数来实现，这类损失函数旨在：

  • 鼓励均匀的专家利用率
  • 防止专家坍塌（某些专家被过度使用而其他专家被忽略）
  • 维持路由决策的稳定性

然而，辅助损失函数存在几个关键问题：

传统方法问题 影响
超参数敏感性 需要精心调整损失权重
训练不稳定性 可能干扰主损失函数的优化
性能下降 辅助损失可能与目标任务冲突
计算开销 增加额外的计算和内存需求

DeepSeek-V3的无辅助损失方案

DeepSeek-V3通过以下创新机制实现了无辅助损失的负载平衡：

1. 智能路由门设计

class Gate(nn.Module):
    """智能路由门机制，实现无辅助损失的负载平衡"""
    
    def __init__(self, args: ModelArgs):
        super().__init__()
        self.topk = args.n_activated_experts  # 激活的专家数量
        self.n_groups = args.n_expert_groups  # 专家分组数量
        self.route_scale = args.route_scale   # 路由缩放因子
        
        # 可学习的路由权重参数
        self.weight = nn.Parameter(torch.empty(args.n_routed_experts, args.dim))
        self.bias = nn.Parameter(torch.empty(args.n_routed_experts)) if self.dim == 7168 else None
        
        # 参数初始化
        nn.init.normal_(self.weight, std=0.02)
        if self.bias is not None:
            nn.init.zeros_(self.bias)

2. 动态负载感知路由

路由机制采用动态负载感知策略，通过实时监控专家利用率来自适应调整路由决策：

flowchart TD
    A[输入令牌] --> B[计算专家得分]
    B --> C{负载评估}
    C -->|高负载| D[降低得分权重]
    C -->|低负载| E[提高得分权重]
    D --> F[选择Top-K专家]
    E --> F
    F --> G[执行专家计算]
    G --> H[输出结果]

3. 专家分组与负载均衡

DeepSeek-V3将专家划分为多个组，每个组内的专家共享相似的计算特性：

# 专家分组配置示例
n_expert_groups = 1      # 专家分组数量
n_limited_groups = 0     # 受限分组数量
n_routed_experts = 64    # 路由专家总数
n_activated_experts = 6  # 每个令牌激活的专家数

技术实现细节

路由得分计算

路由得分的计算采用改进的softmax函数，引入温度参数和缩放因子：

def compute_routing_scores(x: torch.Tensor, weight: torch.Tensor, bias: Optional[torch.Tensor]) -> torch.Tensor:
    """计算专家路由得分"""
    # 线性变换
    scores = torch.matmul(x, weight.t())
    if bias is not None:
        scores = scores + bias
    
    # 应用缩放和softmax
    scaled_scores = scores * self.route_scale
    return torch.softmax(scaled_scores, dim=-1)

负载平衡指标

系统实时监控以下负载平衡指标：

指标 描述 目标值
专家利用率 每个专家处理令牌的比例 ~15.6% (6/64)
负载方差 专家间负载差异 < 5%
路由稳定性 相同输入的路由一致性 > 90%

性能优势分析

无辅助损失策略带来了显著的性能提升：

训练效率提升

graph LR
    A[传统MoE] --> B[辅助损失计算]
    B --> C[梯度冲突]
    C --> D[训练不稳定]
    
    E[DeepSeek-V3] --> F[无辅助损失]
    F --> G[纯净梯度]
    G --> H[稳定训练]

推理性能对比

下表展示了无辅助损失策略在推理阶段的优势：

指标 传统方法 DeepSeek-V3 改进幅度
推理延迟 基准值 -15% 显著降低
内存占用 基准值 -12% 明显减少
专家利用率 60-80% 85-95% 大幅提升
负载均衡度 中等 优秀 显著改善

实际应用效果

在实际的大规模预训练中，无辅助损失负载平衡策略表现出色：

  1. 训练稳定性：在整个14.8T令牌的预训练过程中，没有出现不可恢复的损失尖峰或需要回滚的情况
  2. 专家利用率：所有64个路由专家都得到了有效利用，避免了专家坍塌现象
  3. 计算效率：相比传统方法，训练时间减少约20%，GPU小时消耗降低至2.788M H800小时

技术挑战与解决方案

实现无辅助损失负载平衡面临的主要挑战及解决方案：

挑战 解决方案
专家选择偏差 引入动态负载感知路由
梯度传播问题 设计稳定的反向传播路径
计算资源分配 实现智能的专家分组策略
长尾分布处理 采用自适应缩放机制

DeepSeek-V3的无辅助损失负载平衡策略代表了MoE架构设计的重要进步，为未来大规模语言模型的发展提供了新的技术方向。这一创新不仅提升了模型性能，更重要的是为MoE模型的实用化部署奠定了坚实的基础。

FP8混合精度训练框架

DeepSeek-V3在训练框架设计上实现了重大突破，首次在超大规模语言模型上成功验证了FP8（8位浮点数）混合精度训练的可行性和有效性。这一创新不仅显著提升了训练效率，还大幅降低了GPU内存使用，为671B参数规模的模型训练提供了关键的技术支撑。

FP8数值格式与量化原理

FP8格式采用E4M3（4位指数+3位尾数）配置，相比传统的FP16/BF16格式，内存占用减少50%，同时保持了足够的数值精度范围。DeepSeek-V3采用的FP8格式具有以下技术特性：

数值格式 总位数 指数位 尾数位 数值范围 内存占用
FP32 32 8 23 ±3.4×10³⁸ 100%
BF16 16 8 7 ±3.4×10³⁸ 50%
FP16 16 5 10 ±6.5×10⁴ 50%
FP8(E4M3) 8 4 3 ±1.1×10¹ 25%

FP8量化过程采用128×128块级缩放策略，每个权重块独立计算缩放因子，确保数值精度损失最小化。量化配置如下：

{
  "quantization_config": {
    "activation_scheme": "dynamic",
    "fmt": "e4m3", 
    "quant_method": "fp8",
    "weight_block_size": [128, 128]
  }
}

核心量化算法实现

DeepSeek-V3的FP8训练框架包含三个核心组件：权重量化、激活值量化和矩阵乘法优化。

权重量化与反量化

权重采用静态量化策略，训练前预先量化并存储缩放因子。反量化过程使用Triton优化的内核函数：

@triton.jit
def weight_dequant_kernel(x_ptr, s_ptr, y_ptr, M, N, BLOCK_SIZE: tl.constexpr):
    pid_m = tl.program_id(axis=0)
    pid_n = tl.program_id(axis=1)
    n = tl.cdiv(N, BLOCK_SIZE)
    offs_m = pid_m * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE)
    offs_n = pid_n * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE)
    offs = offs_m[:, None] * N + offs_n[None, :]
    mask = (offs_m[:, None] < M) & (offs_n[None, :] < N)
    x = tl.load(x_ptr + offs, mask=mask).to(tl.float32)
    s = tl.load(s_ptr + pid_m * n + pid_n)
    y = x * s
    tl.store(y_ptr + offs, y, mask=mask)

动态激活值量化

激活值采用动态量化策略，每个token的每128个通道独立计算缩放因子：

@triton.jit
def act_quant_kernel(x_ptr, y_ptr, s_ptr, BLOCK_SIZE: tl.constexpr):
    pid = tl.program_id(axis=0)
    offs = pid * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE)
    x = tl.load(x_ptr + offs).to(tl.float32)
    s = tl.max(tl.abs(x)) / 448.  # 缩放因子计算
    y = x / s
    y = y.to(y_ptr.dtype.element_ty)
    tl.store(y_ptr + offs, y)
    tl.store(s_ptr + pid, s)

FP8矩阵乘法优化

FP8 GEMM（通用矩阵乘法）内核采用自动调优策略，针对不同矩阵尺寸选择最优的块大小配置：

fp8_gemm_configs = [
    Config({'BLOCK_SIZE_M': block_m, 'BLOCK_SIZE_N': block_n, 'BLOCK_SIZE_K': 128}, 
           num_stages=num_stages, num_warps=8)
    for block_m in [16, 32, 64] for block_n in [32, 64, 128] for num_stages in [3, 4, 5, 6]
]

@triton.autotune(configs=fp8_gemm_configs, key=['N', 'K'])
@triton.jit
def fp8_gemm_kernel(a_ptr, b_ptr, c_ptr, a_s_ptr, b_s_ptr,
                    M, N: tl.constexpr, K: tl.constexpr,
                    BLOCK_SIZE_M: tl.constexpr, BLOCK_SIZE_N: tl.constexpr, BLOCK_SIZE_K: tl.constexpr):
    # FP8矩阵乘法实现
    accumulator = tl.zeros((BLOCK_SIZE_M, BLOCK_SIZE_N), dtype=tl.float32)
    for i in range(k):
        a = tl.load(a_ptrs, mask=offs_k[None, :] < K - i * BLOCK_SIZE_K, other=0.0)
        b = tl.load(b_ptrs, mask=offs_k[:, None] < K - i * BLOCK_SIZE_K, other=0.0)
        a_s = tl.load(a_s_ptrs)
        b_s = tl.load(b_s_ptrs)
        accumulator += tl.dot(a, b) * a_s[:, None] * b_s[None, :]

混合精度训练策略

DeepSeek-V3采用精细化的混合精度策略，不同操作使用不同的数值精度：

graph TD
    A[输入数据 FP32] --> B[嵌入层 FP8]
    B --> C[注意力计算 FP8]
    C --> D[MLP前向传播 FP8]
    D --> E[损失计算 FP32]
    E --> F[梯度计算 FP32]
    F --> G[优化器更新 FP32]
    G --> H[权重更新 FP8]
    
    style A fill:#e1f5fe
    style E fill:#fff3e0
    style F fill:#fff3e0
    style G fill:#fff3e0
    style H fill:#e8f5e8

内存优化与性能提升

FP8训练框架为DeepSeek-V3带来了显著的内存和性能优势：

  1. 内存占用降低：相比BF16训练，FP8将权重内存占用减少50%，激活值内存占用减少50%
  2. 计算吞吐提升：FP8矩阵乘法在NVIDIA H100 GPU上提供2倍于BF16的计算吞吐量
  3. 通信优化：FP8格式减少跨节点通信带宽需求，实现近乎完全的计算-通信重叠

训练稳定性保障

为确保FP8训练的数值稳定性，DeepSeek-V3采用了多项技术措施：

  • 梯度缩放：动态调整梯度缩放因子，防止梯度下溢
  • 损失缩放：对损失函数进行适当缩放，保持训练稳定性
  • 数值监控：实时监控数值范围，自动调整量化参数
  • 回退机制：检测到数值异常时自动回退到高精度计算

实际部署与转换

DeepSeek-V3提供完整的FP8到BF16权重转换工具，支持灵活的部署方案：

def fp8_to_bf16_conversion(fp8_path, bf16_path):
    """将FP8权重转换为BF16格式"""
    torch.set_default_dtype(torch.bfloat16)
    os.makedirs(bf16_path, exist_ok=True)
    
    # 加载FP8权重和缩放因子
    fp8_weights = load_fp8_weights(fp8_path)
    scale_factors = load_scale_factors(fp8_path)
    
    # 执行反量化
    bf16_weights = {}
    for weight_name, fp8_weight in fp8_weights.items():
        if weight_name.endswith("_scale_inv"):
            continue
        scale_name = f"{weight_name}_scale_inv"
        scale = scale_factors[scale_name]
        bf16_weights[weight_name] = weight_dequant(fp8_weight, scale)
    
    # 保存BF16权重
    save_bf16_weights(bf16_path, bf16_weights)

这一FP8混合精度训练框架的成功实践，不仅为DeepSeek-V3的高效训练提供了技术保障，也为整个大模型训练领域树立了新的技术标杆，证明了在超大规模模型上使用低精度数值格式的可行性和巨大潜力。

DeepSeek-V3通过多项架构创新实现了性能与效率的突破。MLA机制将KV缓存内存占用减少约75%，支持更长的上下文长度；DeepSeekMoE架构在671B总参数中仅激活37B参数，大幅提升计算效率；无辅助损失负载平衡策略避免了传统MoE的辅助损失问题，提高训练稳定性；FP8混合精度训练框架降低50%内存占用并提供2倍计算吞吐。这些技术创新共同使DeepSeek-V3在保持卓越性能的同时，实现了前所未有的推理和训练效率，为超大规模语言模型的实用化部署提供了可行的技术方案。

DeepSeek-V3
项目地址：https://gitcode.com/GitHub_Trending/de/DeepSeek-V3
登录后查看全文

相关内容推荐

1 【亲测免费】 DeepSeek-V3 开源项目使用与启动教程2 DeepSeek-V3模型参数规模解析：37B激活参数的计算方法3 7大痛点解决：DeepSeek-V3模型在SGLang中的部署优化指南4 【免费下载】 深入探索 DeepSeek-V2.5：从入门到精通的实战教程5 突破训练瓶颈：DeepSeek-V3梯度累积策略与micro_batch_size调优指南6 突破128K限制：DeepSeek-V3上下文压缩技术全解析7 DeepSeek-V3 的代码实现解析8 突破大模型推理吞吐量瓶颈：昇腾FusionSpec投机框架深度解析9 ktransformers项目中的H100显卡模型加载问题分析与解决方案10 MaxText项目中MLA注意力机制softmax缩放因子的优化分析
热门项目推荐
相关项目推荐

热门内容推荐

1 【亲测免费】 开源项目 `build-your-own-x` 使用指南2 【亲测免费】 探索科技之旅：《Build Your Own X》项目详解3 GitHub_Trending/bu/build-your-own-x自动化：CI/CD流程在自制项目中的应用

最新内容推荐

如何让明日方舟干员住进你的桌面？Ark-Pets桌宠神器完整指南5分钟上手screego/server：Docker一键部署与基础配置全攻略告别复杂依赖：在Qt应用中轻松集成stb单文件库 🚀Midscene.js教学案例集：从入门到精通实战项目Splide轮播组件性能基准测试：与其他轮播库的对比分析vue3-element-admin表单设计器：可视化表单配置工具深度学习论文精读终极指南：从GPT到Sora的AI发展脉络解析EfficientDet目标检测可视化：检测结果与特征图可视化实战指南零基础玩转Luckysheet自定义公式：从解析到扩展计算引擎Vim编辑模式终极指南：从入门到精通的10个高效技巧

项目优选

收起
kernelkernel
deepin linux kernel
C
27
11
docsdocs
OpenHarmony documentation | OpenHarmony开发者文档
Dockerfile
525
3.72 K
pytorchpytorch
Ascend Extension for PyTorch
Python
332
395
flutter_flutterflutter_flutter
暂无简介
Dart
766
189
ops-mathops-math
本项目是CANN提供的数学类基础计算算子库，实现网络在NPU上加速计算。
C++
878
586
kernelkernel
openEuler内核是openEuler操作系统的核心，既是系统性能与稳定性的基石，也是连接处理器、设备与服务的桥梁。
C
336
165
ohos_react_nativeohos_react_native
React Native鸿蒙化仓库
JavaScript
302
352
nop-entropynop-entropy
Nop Platform 2.0是基于可逆计算理论实现的采用面向语言编程范式的新一代低代码开发平台，包含基于全新原理从零开始研发的GraphQL引擎、ORM引擎、工作流引擎、报表引擎、规则引擎、批处理引引擎等完整设计。nop-entropy是它的后端部分，采用java语言实现，可选择集成Spring框架或者Quarkus框架。中小企业可以免费商用
Java
12
1
RuoYi-Vue3RuoYi-Vue3
🎉 (RuoYi)官方仓库 基于SpringBoot，Spring Security，JWT，Vue3 & Vite、Element Plus 的前后端分离权限管理系统
Vue
1.33 K
748
agent-studioagent-studio
openJiuwen agent-studio提供零码、低码可视化开发和工作流编排，模型、知识库、插件等各资源管理能力
TSX
985
246