## 传统专家混合模型（Mixture-of-Experts, MoE）在 Transformer 中的实现

在标准 Transformer 模型中，每一层包含一个自注意力模块（Self-Attention）和一个前馈神经网络（FFN）。MoE 的核心思想是用多个专家（Expert）替代 FFN，每个专家本身也是一个 FFN，但通过动态路由机制（门控网络）选择对每个输入 token 最相关的少数专家进行计算。这种设计可以在不显著增加计算量的情况下，大幅提升模型容量。



### MoE 的架构设计
#### 1. **标准 Transformer 模块**
标准 Transformer 层的计算流程如下：
- **自注意力**：  
  $$
  u_{1:T}^l = \text{Self-Att}(h_{1:T}^{l-1}) + h_{1:T}^{l-1}
  $$
- **前馈网络**：  
  $$
  h_t^l = \text{FFN}(u_t^l) + u_t^l
  $$

#### 2. **用 MoE 替代 FFN**
在 MoE 化的 Transformer 中，部分 FFN 层被替换为 MoE 层（通常每隔几层替换一次）。MoE 层的计算步骤如下：

**（1）专家定义**  
- 每个 MoE 层包含 $ N $ 个专家，每个专家 $ \text{FFN}_i $ 的结构与标准 FFN 相同。

**（2）门控机制（Gating Mechanism）**  
- 对每个输入 token $ u_t^l $，计算其与所有专家的“亲和度”（Affinity）：  
  $$
  s_{i,t} = \text{Softmax}_i(u_t^l \cdot e_i^l)
  $$
  其中 $ e_i^l $ 是第 $ i $ 个专家的质心向量（可学习参数）。

**（3）稀疏路由（Sparse Routing）**  
- 选择亲和度最高的 $ K $ 个专家（通常 $ K=1 $ 或 $ 2 $）：  
  $$
  g_{i,t} = 
  \begin{cases} 
  s_{i,t}, & \text{if } s_{i,t} \in \text{TopK}(\{s_{j,t}\}, K) \\
  0, & \text{otherwise}
  \end{cases}
  $$

**（4）加权输出**  
- 对选中的专家输出进行加权求和，并与残差连接结合：  
  $$
  h_t^l = \sum_{i=1}^N g_{i,t} \cdot \text{FFN}_i(u_t^l) + u_t^l
  $$


### 关键特性
#### 1. **计算效率**
- **稀疏性**：每个 token 仅由 $ K $ 个专家处理（而非所有 $ N $ 个），保持计算量与标准 FFN 接近。例如，当 $ K=1 $、$ N=8 $ 时，计算量约为标准 FFN 的 2 倍（假设每个专家的参数量与 FFN 相同）。

#### 2. **动态路由**
- **自适应分配**：门控网络根据输入 token 的语义动态选择专家。例如，某些专家可能擅长处理名词，而另一些擅长处理动词。

#### 3. **模型容量扩展**
- **参数规模**：MoE 层的参数量为 $ N \times \text{FFN\_size} $，但计算量仅与 $ K \times \text{FFN\_size} $ 相关，实现了高效的参数扩展。


### 挑战与优化
1. **负载均衡（Load Balancing）**  
   - 需避免某些专家被过度使用（如通过辅助损失函数惩罚不均衡的路由）。

2. **训练稳定性**  
   - 稀疏路由可能导致梯度传播不稳定，需结合动态路由调整策略。

3. **通信开销（分布式训练）**  
   - 不同专家可能分布在不同的设备上，需优化跨设备数据传输。


### 示例代码（简化版）
```python
class MoELayer(nn.Module):
    def __init__(self, num_experts, hidden_size, expert_size, k=1):
        super().__init__()
        self.experts = nn.ModuleList([FFN(hidden_size, expert_size) for _ in range(num_experts)])
        self.gate = nn.Linear(hidden_size, num_experts)  # 门控网络
        self.k = k

    def forward(self, x):
        # 计算亲和度
        logits = self.gate(x)  # [batch_size, seq_len, num_experts]
        scores = torch.softmax(logits, dim=-1)
        
        # 选择 Top-K 专家
        topk_scores, topk_indices = torch.topk(scores, self.k, dim=-1)  # [batch, seq_len, k]
        
        # 稀疏计算（仅用选中的专家）
        outputs = []
        for i in range(self.k):
            expert_idx = topk_indices[:, :, i]
            expert_output = self.experts[expert_idx](x)  # 伪代码，需具体实现
            outputs.append(expert_output * topk_scores[:, :, i].unsqueeze(-1))
        
        return sum(outputs) + x  # 加权求和 + 残差连接
```

## DeepSeekMoE

下图是DeepSeekMoE 的示意图。子图(a)展示了采用传统 top-2 路由策略的 MoE 层。子图(b)说明了细粒度专家分割策略。随后，子图(c)展示了共享专家隔离策略的集成，构成了完整的 DeepSeekMoE 架构。值得注意的是，在这三种架构中，专家参数的数量和计算成本保持不变。

![image.png](/static/img/78fe5410fd380048e32c81e058f3779e.image.webp)



DeepSeekMoE 是在传统混合专家（MoE）架构上的创新改进，通过**细粒度专家分割**和**共享专家隔离**两大核心策略，显著提升模型的专业化能力与参数效率，同时保持计算成本不变。以下是其核心设计理念与技术实现：


#### 一、细粒度专家分割（Fine-Grained Expert Segmentation）

##### 1. **动机**
- **问题**：传统 MoE 中，每个专家（FFN）参数量较大，但每个 token 仅激活少量专家（如 Top-2）。这导致单个专家需学习多种类型知识，难以充分专业化。
- **解法**：将大专家拆分为多个小专家，允许每个 token 激活更多专家组合，促进知识分解与专业化学习。

##### 2. **实现**
- **专家拆分**：  
  将每个原始专家 FFN 的中间隐藏层维度缩小为原来的 $1/m$，分割为 $m$ 个更小的子专家。例如，原 FFN 中间层维度为 $d$，分割后每个子专家维度为 $d/m$。
- **激活策略调整**：  
  每个 token 激活的子专家数从 $K$ 增加到 $mK$，但每个子专家的计算量降为 $1/m$，**总计算量保持不变**。  
  **公式**：  
  $$
  h_t^l = \sum_{i=1}^{mN} g_{i,t} \cdot \text{FFN}_i(u_t^l) + u_t^l
  $$
  其中 $g_{i,t}$ 仅对 Top-$mK$ 专家非零，$mN$ 为总子专家数。

##### 3. **优势**
- **组合灵活性爆炸式增长**：  
  例如，当 $N=16$ 个专家拆分为 $m=4$ 个子专家（共 $64$ 个），每个 token 激活 $mK=8$ 个子专家时，组合数从传统 Top-2 的 $120$ 种激增至 $4.4 \times 10^9$ 种。
- **知识解耦**：不同子专家专注于更细粒度的知识单元（如词性、句法结构），模型表达能力增强。

---

#### 二、共享专家隔离（Shared Expert Isolation）

##### 1. **动机**
- **问题**：传统路由中，不同专家可能重复学习通用知识（如语法规则），导致参数冗余。
- **解法**：固定分配部分专家作为**共享专家**，强制所有 token 经过它们，专用于捕获通用知识；其余专家专注于领域特异性。

##### 2. **实现**
- **固定路由共享专家**：  
  设定 $K_s$ 个共享专家，每个 token **必须** 经过这些专家，其余路由专家激活数减少至 $mK - K_s$。  
  **公式**：  
  $$
  h_t^l = \underbrace{\sum_{i=1}^{K_s} \text{FFN}_i(u_t^l)}_{\text{共享专家}} + \underbrace{\sum_{i=K_s+1}^{mN} g_{i,t} \cdot \text{FFN}_i(u_t^l)}_{\text{路由专家}} + u_t^l
  $$
- **参数效率**：共享专家集中学习通用知识，减少其他专家的冗余参数。

##### 3. **优势**
- **减少冗余**：通用知识由共享专家统一处理，路由专家专注于差异化任务。
- **训练稳定性**：共享专家作为知识“基座”，缓解稀疏路由带来的梯度不稳定问题。

---

#### 三、负载均衡优化

##### 1. **专家级均衡损失（Expert-Level Balance Loss）**
- **目标**：防止某些专家被过度使用（路由坍塌）。  
  **公式**：  
  $$
  \mathcal{L}_{\text{ExpBal}} = \alpha_1 \sum_{i=1}^{N'} f_i P_i
  $$
  - $f_i$：专家 $i$ 被选中的频率（需接近均匀分布）。
  - $P_i$：专家 $i$ 的平均门控值。

##### 2. **设备级均衡损失（Device-Level Balance Loss）**
- **目标**：在分布式训练中，均衡不同设备上的计算负载。  
  **公式**：  
  $$
  \mathcal{L}_{\text{DevBal}} = \alpha_2 \sum_{i=1}^D f_i' P_i'
  $$
  - 将专家分组到 $D$ 个设备，确保每组计算量均衡。
  - 优先保证设备间平衡，放宽专家级约束以避免性能损失。

---

#### 四、性能与效果

1. **计算效率**：  
   总计算量与传统 MoE 相同（通过细粒度分割与激活数调整实现）。
2. **参数量**：  
   总参数量与传统 MoE 一致，但分配更高效（共享专家 + 细粒度路由专家）。
3. **训练稳定性**：  
   双层级负载均衡损失有效缓解路由坍塌和设备间负载不均问题。

---

#### 五、代码示意（关键逻辑）

```python
class DeepSeekMoELayer(nn.Module):
    def __init__(self, num_experts, m, K, Ks):
        super().__init__()
        # 细粒度分割：每个专家拆分为 m 个子专家
        self.sub_experts = nn.ModuleList([
            SmallFFN(hidden_dim // m) for _ in range(num_experts * m)
        ])
        self.shared_experts = nn.ModuleList([  # 共享专家
            SmallFFN(hidden_dim // m) for _ in range(Ks)
        ])
        self.gate = nn.Linear(hidden_dim, num_experts * m)  # 门控网络
        self.K = K
        self.Ks = Ks

    def forward(self, x):
        # 共享专家计算（强制所有 token 经过）
        shared_out = sum([expert(x) for expert in self.shared_experts])

        # 细粒度路由计算
        logits = self.gate(x)
        scores = torch.softmax(logits, dim=-1)
        topk_scores, topk_indices = torch.topk(scores, self.K - self.Ks, dim=-1)
        
        # 加权求和路由专家输出
        routed_out = 0
        for i in range(self.K - self.Ks):
            expert_idx = topk_indices[:, :, i]
            routed_out += self.sub_experts[expert_idx](x) * topk_scores[:, :, i]

        return shared_out + routed_out + x  # 总输出
```

https://joelotepawembo.medium.com/deepseekmoe-bridging-efficiency-and-capacity-in-large-language-models-using-deepseek-model-from-dbd4e852a637

![image.png](/static/img/6c1a3e85bcdcf98c0c6c7452f24fe72b.image.webp)

DeepSeekMoE

# 一、DeepSeek LLM

DeepSeek LLM: Scaling Open-Source Language Models with Longtermism

https://arxiv.org/abs/2401.02954

**2024 年 1 月发布。使用 GQA 优化推理成本；采用多步学习速率调度器替代余弦调度器；运用 HAI-LLM 训练框架优化训练基础设施；提出新的缩放分配策略。使用 2 万亿字符双语数据集预训练，67B 模型性能超越 LLaMA-2 70B，Chat 版本优于 GPT-3.5。**



### 介绍
- 先摸清楚了模型变大时，训练时该用多大的数据批次（批量大小）和学习速度（学习率）最合适，发现这里头有规律可循；
- 顺着这个发现，我们找到了在增大模型和增加数据量时，怎么分配资源最有效的方法，还能提前预估超大模型的性能表现；
- 但有个重要发现：不同训练数据会导致规律不一样。就像做菜时，换种食材就要调整火候，用别人的数据集不能直接照搬我们的规律，得重新验证。

### 架构

- RMSNorm的 Pre-Norm 结构
- 使用SwiGLU 作为前馈网络 (FFN) 的激活函数
- RoPE
- 67B 模型使用了 GroupedQuery Attention (GQA) (Ainslie et al., 2023) 代替传统的多头注意力 (MHA)


### 价值点

数据批次(size)和学习率(learning rate)设置策略：

1. **批次大小(Batch Size)**:
   - **模型大小不同，计算预算不同**：根据论文的研究，批次大小随着计算预算的增加而增加。
   - **小模型(7B)的批次大小**：论文中了解到，DeepSeek LLM 7B的设置是2304。
   - **大型模型(67B)的批次大小**：DeepSeek LLM 67B的设置为4608。
   - **扩展批次大小公式**:
     - 经验公式：`Bopt = 0.2920 * 计算预算C的0.3271次幂`

2. **学习率(Learning Rate)**:
   - **模型大小不同，计算预算不同**：学习率随着计算预算的增加而减少。
   - **小模型(7B)的学习率**：DeepSeek LLM 7B的设置是4.2e-4。
   - **大型模型(67B)的学习率**：DeepSeek LLM 67B的设置是3.2e-4。
   - **学习率设定公式**：
     - 经验公式：`𝜂opt = 0.3118 * 计算预算C的-0.1250次幂`

3. **学习率调度器(Learning Rate Scheduler)**:
   - **多步学习率调度器(Multi-step Scheduler)**：为了在训练过程中能够继续训练，论文选择了多步学习率调度器。
   - **多步学习率调度分布**：训练初期2000步内达到最大值，然后80%的训练token之后减少到31.6%，接着到达90%的token时减少到10%。
   - **优化策略**：这种调度器能够允许在不同阶段的学习率优化，并且可以实现较好的性能。

# 二、DeepSeekMoE 

DeepSeekMoE: Towards Ultimate Expert Specialization in Mixture-of-Experts Language Models

https://arxiv.org/abs/2401.06066

**发布于 2024 年 1 月。创新提出细粒度专家分割和共享专家隔离；采用专家级和设备级平衡损失缓解负载不均衡问题。通过监督微调构建了聊天模型，性能优于传统 MoE 和部分密集模型，16B 版本可在单 40GB 内存 GPU 上部署。**


现在做大语言模型，用"混合专家"架构（MoE）可以节省算力。传统MoE方法比如GShard会从N个专家里选K个激活，但有个毛病——专家们学的东西容易重复，不够专精。就像让10个厨师做菜，每次随机选3个，结果每个厨师都只会做差不多的菜。

传统的 MoE 架构用 MoE 层替换了 Transformer 中的 Feed-Forward Networks（FFNs）。

DeepSeekMoE架构，主要做了两件事：
- 专家分小组 ：把原本的N个专家拆成mN个小专家（比如2N个），每次激活mK个。相当于把10个厨师分成20个更专业的帮厨，每次选6个组合，能做更精细的菜品搭配。
- 设立共享专家 ：专门留几个"全能型厨师"负责基础工作（比如切菜煮饭），避免其他专家重复做这些基础活。
- 
结果：
- 2B小模型 ≈ 传统2.9B的效果（省1.5倍算力）
- 16B版本 ≈ LLaMA2 7B实力（耗电打4折）
- 145B巨无霸 ≈ 自家67B顶级模型（算力省70%+）

DeepSeekMoE 16B 遥遥领先：

![image.png](/static/img/08a417ac68fe80f90296bf12400f55e2.image.webp)

DeepSeekMoE介绍：
https://www.dong-blog.fun/post/1953

# 三、DeepSeek Math

DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models

https://arxiv.org/abs/2402.03300

2024 年 2 月 5 日发布。通过数学预训练、监督微调、强化学习三阶段训练，构建 120B 数学语料库，提出 GRPO （Group Relative Policy Optimization）算法，在数学推理能力上直逼 GPT-4，超越众多 30B-70B 开源模型。


![image.png](/static/img/7c83c2ad43de6ca7ef84b14bba4aab75.image.webp)

组相对策略优化（Group Relative Policy Optimization, GRPO） 


![image.png](/static/img/159020ffbe2de521ea6d99404401ddac.image.webp)

# 四、DeepSeek V2 

DeepSeek-V2: A Strong, Economical, and Efficient Mixture-of-Experts Language Model

https://arxiv.org/abs/2405.04434

2024 年 5 月 7 日发布。创新提出多头潜在注意力（ MLA）；改进 MoE；基于 YaRN 扩展长上下文；发布了 Lite 版本；训练中设计三种辅助损失并引入 Token-Dropping 策略，通过多阶段训练流程提升性能。

我们推出了 DeepSeek-V2，这是一个以经济训练和高效推理为特点的专家混合（MoE）语言模型。它总共包含 236B 个参数，其中每个 token 激活 21B 个参数，并支持 128K 个 token 的上下文长度。DeepSeek-V2 采用了包括多头潜在注意力（MLA）和 DeepSeekMoE 在内的创新架构。MLA 通过将键值（KV）缓存显著压缩成潜在向量来保证高效推理，而 DeepSeekMoE 则通过稀疏计算以经济成本训练强大的模型。与 DeepSeek 67B 相比，DeepSeek-V2 实现了显著更强的性能，同时节省了 42.5%的训练成本，减少了 93.3%的 KV 缓存，并将最大生成吞吐量提高了 5.76 倍。


![image.png](/static/img/3c74c4ce6dbfc7bf2bc296694a9cfe20.image.webp)


![image.png](/static/img/c74d699788355c33405caf6bd3b40031.image.webp)

# 五、DeepSeek V3 

DeepSeek-V3 Technical Report

https://arxiv.org/abs/2412.19437


2024 年 12 月 26 日发布。创新提出无辅助损失的负载均衡策略、多 Token 预测，有 FP8 混合精度训练框架和高效通信框架。通过知识蒸馏提升推理性能，在低训练成本下性能强大，基础模型超越其他开源模型，聊天版本与领先闭源模型性能相当。


1. **架构创新:**
   - **混合专家（MoE）：** 总参数量为671B，每个token激活37B。结合**DeepSeekMoE**（更细粒度的专家，共享/路由结构）和**多头潜在注意力（MLA）**，通过减少KV缓存实现高效推理。
   - **无辅助损失的负载平衡：** 动态调整专家路由偏差，在不影响性能的情况下实现负载平衡。
   - **多Token预测（MTP）：** 在训练过程中预测多个未来token，提升数据效率，并通过推测解码实现更快的推理。

2. **训练效率:**
   - **FP8混合精度训练：** 首次大规模验证FP8，通过tile/block级量化减少内存并加速计算。
   - **DualPipe并行：** 重叠计算/通信，最小化流水线气泡，并实现跨节点的专家并行化。
   - **优化的基础设施：** 定制通信内核、节省内存的技术（重新计算、CPU EMA）和集群级优化。总训练成本为**2.788M H800 GPU小时**（约550万美元）。

3. **性能及基准测试:**
   - **预训练：** 14.8T高质量tokens，通过YaRN扩展至128K上下文。训练稳定，无损失波动。
   - **后训练：** 通过SFT（1.5M实例）和以DeepSeek-R1为基础进行推理的RL（群体相对策略优化）蒸馏。
   - **先进的结果：** 超越开源模型（Qwen2.5-72B, LLaMA-3.1-405B），媲美GPT-4o/Claude-3.5-Sonnet在以下方面的表现：
     - **数学/代码：** MATH-500（90.2% EM），LiveCodeBench（40.5% Pass@1），Codeforces（51.6%ile）。
     - **知识：** MMLU-Pro（75.9%），GPQA（59.1%）。
     - **中文任务：** C-SimpleQA（64.8%），C-Eval（86.5%）。




# 六、DeepSeek R1 

https://arxiv.org/abs/2501.12948

DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning

2025 年 1 月发布。DeepSeek-R1-Zero 无需 SFT 就有卓越推理能力，与 OpenAI-o1-0912 在 AIME 上性能相当；DeepSeek-R1 采用多阶段训练和冷启动数据，推理性能与 OpenAI-o1-1217 相当；还提炼出6 个蒸馏模型，显著提升小模型推理能力。

这篇解读很好：https://zhuanlan.zhihu.com/p/20844750193

如何得到DeepSeek-R1-Zero：


![image.png](/static/img/6b33f535a052745301845949f6013ccb.image.webp)

如何训练得到DeepSeek-R1：


![image.png](/static/img/f5bc8b5e86d875c1fcbd738ab16560ab.image.webp)


![image.png](/static/img/803676efa0355819b1a3891e1e9405ff.image.webp)

如何知识蒸馏把R1模型能力给其他小模型：

![image.png](/static/img/60c18f33a7db47a2b4fba789931b7e6a.image.webp)

DeepSeek 系列论文解读

https://arxiv.org/abs/2412.04431


![image.png](/static/img/9b6d0b95dcc9c86aac6c441f86594903.image.webp)




![image.png](/static/img/4ef2be5d335602ceb6e8866527d9b274.image.webp)


"Infinity∞: Scaling Bitwise AutoRegressive Modeling for High-Resolution Image Synthesis" 之所以效果出色，原因如下：

### 创新性框架和模型设计
1. **比特级建模**：Infinity 采用比特级建模方法，替代了传统的索引级建模，大大增加了词汇表的容量，理论上可以扩展到无穷大（例如 $2^{64}$）。这极大地减少了量化误差，使得模型能够更好地重建和生成高分辨率图像的细节。

2. **比特级自我修正机制**：在训练过程中，通过随机翻转一些比特来模拟预测错误，并重新量化残差特征，从而增强了模型的自我修正能力，有效地解决了教师强制训练带来的训练-测试差异。

3. **无限词汇分类器 (IVC)**：IVC 可以高效地处理无限大的视觉词汇表，采用并行二值分类器，较传统的索引分类器而言，参数和内存的需求大幅减少，优化更佳。

### 生成能力和细节表现
1. **高保真生成**：模型能够生成高分辨率、逼真度极高的图像，并且在多种样式和不同宽高比中表现优异，不论是精确的提示跟随、空间推理、文本渲染还是美学效果。

2. **强大的扩展能力**：通过同时扩展图像词汇表和转换器的大小，Infinity 显示出了强大的扩展规律和提高细节重建生成质量的能力。如表1和表2所示，在多个基准测试上均取得了出色的成绩。

3. **快速推理**：在生成1024×1024图像时，Infinity在0.8秒内生成完毕，比起目前最快的扩散模型SD3-Medium快了2.6倍，成为目前最快的文本到图像生成模型。

### 强大的模型架构
1. **视觉自回归建模 (VAR)**：Infinity 在视觉自回归模型的基础上进行变革，重新定义了图像的自回归学习，将其表示为一种逐步加细“下一层级预测”的框架。

2. **动态宽高比和位置编码**：Infinity 支持多种宽高比的图像生成，通过预定义的多个比例尺规模表和位置编码方法，有效增强了模型处理不同尺度和宽高比特征的能力。

3. **多阶段训练策略**：在训练阶段，Infinity采用逐步增加分辨率和高质量数据集的多阶段训练策略，显著提升了模型的生成能力和逼真程度。

### 总结
Infinity 通过比特级建模和无限词汇分类器的创新，引入了自我修正机制和视觉新型自回归框架，大幅提升了图像生成质量和细节复现能力，且在多个基准测试中表现优异，树立了新的自回归模型标杆。这些技术改进不仅提升了模型生成效果，还显著加快了推理速度，为未来更快速、更真实的生成模型提供了强大支持。

Infinity 自回归模型生图 论文观点

https://arxiv.org/abs/2410.13863

## 摘要

论文研究了文本生成图像背景下的缩放问题，主要关注两个关键因素：模型使用离散还是连续的标记，以及标记是以随机顺序还是固定光栅顺序生成，使用的是类似于BERT还是GPT的转换器架构。


基于连续标记的模型相比于使用离散标记的模型，在视觉质量上显著更佳。

此外，生成顺序和注意力机制显著影响GenEval分数：随机顺序模型相比于光栅顺序模型获得了显著更好的GenEval分数。

受这些发现的启发，我们训练了Fluid，一个基于连续标记的随机顺序自回归模型。

Fluid 10.5B模型在MS-COCO 30K数据集上实现了新的零样本FID的最先进成绩6.16，并在GenEval基准测试中获得了0.69的总分。

我们希望我们的发现和结果能够鼓励未来的研究工作进一步弥合视觉和语言模型之间的扩展差距。



## 不同顺序的自回归模型

不同顺序的自回归模型。(a) 栅格顺序自回归模型基于已知的标记预测下一个标记，使用具有因果注意力机制的类似 GPT 的 Transformer 实现。(b) 随机顺序自回归模型在给定随机顺序的情况下同时预测一个或多个标记，使用具有双向注意力机制的类似 BERT 的 Transformer 实现。

![image.png](/static/img/75e1e214ed3740bafdd0fb947266775c.image.webp)

## Fluid 模型架构

架构如下：

![image.png](/static/img/1e4c635341b028d11627be2c5ee54ab8.image.webp)


![image.png](/static/img/888cba2d183b899a43a3406b1877d767.image.webp)

组件介绍：

图像标记器。我们使用预训练的图像标记器将256×256图像编码到一个标记空间中。这个标记器可以是离散的或连续的，以便于自回归模型的不同训练目标。在我们的实验中，离散标记器是一个VQGAN模型（Esser等，2021），它在WebLI数据集（Chen等，2022）上进行了预训练。我们遵循Muse（Chang等，2023）的做法，将每张图像编码为16×16的离散令牌，词汇大小为8192。对于连续标记器，我们采用了来自Stable Diffusion（Rombach等，2022b）的广泛使用的模型，该模型将图像编码为32×32的连续令牌，每个令牌包含4个通道。为了在序列长度上与离散标记器保持一致，我们进一步将每个2×2的连续令牌块分组为一个单一的令牌，最终序列长度为256，每个令牌包含16个通道。如图4所示，连续标记器可以比离散标记器实现显著更高的重建质量。

文本编码器。原始文本（最大长度为128）通过SentencePiece（Kudo，2018）进行标记化，并通过预训练的T5-XXL编码器（Raffel等，2020）嵌入，该编码器拥有47亿参数，并且在训练期间被冻结。为了进一步对齐图像生成的文本嵌入，我们在T5嵌入之上添加了一个由六个可训练的Transformer块组成的小型文本对齐器，以提取最终的文本表示。

Transformer。在将原始图像编码为令牌序列后，我们使用标准的仅解码器Transformer模型（Vaswani等，2017）进行自回归生成。每个块由三个连续层组成——自注意力、交叉注意力和MLP层。自注意力和MLP层仅应用于视觉令牌，而交叉注意力层则分别将视觉和文本令牌作为查询和关键。如图2所示，对于光栅顺序模型，Transformer使用因果注意力机制在自注意力块中基于前面的令牌预测下一个令牌，类似GPT。在随机顺序模型中，未知的令牌由可学习标记掩盖，Transformer使用双向注意力机制预测这些被掩盖的令牌，类似BERT。

输出头。对于离散令牌，我们遵循自回归模型的常见做法。输出通过线性层后的softmax转换为分类分布，其权重从输入嵌入层重新使用。对于连续令牌，我们应用六层轻量级MLP作为扩散头（Li等，2024）来建模每个令牌的分布。该头的嵌入维度与骨干Transformer相同。每个令牌的扩散过程遵循（Nichol & Dhariwal，2021；Li等，2024）。噪声计划呈余弦形状，在训练时有1000步；在推理时，它被重新采样为100步。

## 结果对比

栅格顺序模型（raster-order models）+ 离散标记（discrete tokens）：在 10 亿参数（1B）左右，FID 和 GenEval 分数达到性能瓶颈（plateau）。

随机顺序模型（random-order models）+ 连续标记（continuous tokens）（即 Fluid 模型）：FID 和 GenEval 分数在参数规模增加到 30 亿（3B）时持续改进，展现了最佳性能。
                        

![image.png](/static/img/66a932138bf737696758dcb823885478.image.webp)

Fluid 自回归模型生图 论文观点

# Git代理设置与取消指南


作为开发者，我们常遇到企业内网或特殊网络环境下无法直接访问Git仓库的情况。本教程将详细介绍如何为Git设置代理（Proxy）以及如何取消代理配置，并提供常见问题排查方法。





## 一、为什么需要设置Git代理？

以下场景需要使用Git代理：
1. 企业内网限制直接访问外网
2. 国内访问GitHub等国外仓库速度缓慢
3. 需要通过特定代理服务器进行代码审计
4. 使用VPN时需配置代理规则

---

## 二、代理设置方法

### 2.1 全局代理配置（推荐）

```bash
# 设置HTTP协议代理
git config --global http.proxy http://proxy.example.com:8080

# 设置HTTPS协议代理
git config --global https.proxy https://proxy.example.com:8080

# 带认证信息的代理（用户名/密码）
git config --global http.proxy http://user:password@proxy.example.com:8080
```

**验证配置生效**：
```bash
git config --global --get http.proxy
git config --global --get https.proxy
```

### 2.2 项目级代理配置

进入项目目录后执行：
```bash
git config http.proxy http://proxy.example.com:8080
```

### 2.3 代理协议说明

| 协议类型   | 适用场景                  | 示例格式                          |
|------------|---------------------------|-----------------------------------|
| HTTP       | 普通HTTP仓库              | http://proxy.com:8080            |
| HTTPS      | HTTPS仓库/增强安全性      | https://proxy.com:8080           |
| SOCKS5     | 需要加密传输              | socks5://proxy.com:1080          |

---

## 三、取消代理配置方法

### 3.1 通过命令取消

```bash
# 全局取消
git config --global --unset http.proxy
git config --global --unset https.proxy

# 项目级取消（需进入项目目录）
git config --unset http.proxy
```

### 3.2 手动编辑配置文件

打开全局配置文件：
```bash
# Windows
notepad %USERPROFILE%\.gitconfig

# Linux/macOS
nano ~/.gitconfig
```

删除包含以下内容的行：
```ini
[http]
    proxy = http://proxy.example.com:8080
[https]
    proxy = https://proxy.example.com:8080
```

---

## 四、高级配置技巧

### 4.1 域名白名单配置

对特定域名禁用代理：
```ini
[http "https://github.com/"]
    proxy = ""
```

### 4.2 临时禁用代理

单次命令禁用代理：
```bash
git -c http.proxy= clone https://github.com/example/repo.git
```

### 4.3 SSH协议代理配置

编辑SSH配置文件 `~/.ssh/config`：
```
Host github.com
    Hostname github.com
    User git
    ProxyCommand nc -x 127.0.0.1:1080 %h %p
```

---

## 五、常见问题排查

### 5.1 测试代理连通性
```bash
curl -v -x http://proxy.example.com:8080 https://github.com
```

### 5.2 典型错误解决方案

**错误提示**：
```
fatal: unable to access 'https://github.com/.../': Failed to connect to proxy...
```

**解决步骤**：
1. 检查代理地址和端口是否正确
2. 验证代理服务器是否正常运行
3. 尝试关闭防火墙或杀毒软件
4. 使用`git config --list`检查配置冲突

---

## 六、代理配置原理

Git的代理设置存储在以下位置：
1. 全局配置：`~/.gitconfig`（Linux/macOS）或 `%USERPROFILE%\.gitconfig`（Windows）
2. 项目配置：`.git/config`

配置优先级（从高到低）：
1. 命令行临时参数
2. 项目级配置
3. 全局配置
4. 系统环境变量

---

## 七、安全注意事项

1. 避免在配置文件中明文存储密码
2. 定期检查代理服务器证书有效性
3. 企业环境建议使用专用代理账户
4. 重要项目建议使用SSH协议+代理组合

---

Git代理设置与取消指南

我是一个专注技术分享的博主,尤其爱搞深度学习和单片机电子。你现在看到的是我的个人博客网站。