Transformer十问

1. Self-Attention 的参数量

 一个 dmodel=512, dff=2048,h=8、最大序列长度 L=1024 的标准 Transformer Encoder Layer(一个 MHA + 一个 FFN),不包含 embedding 和 bias,它的总可训练参数量是多少?

MHA部分,输入token嵌入向量转为KQV需要三个参数矩阵,其维度为dmodel×dmodeld_{model} \times d_{model}。 多头注意力会将512维分解为八份,然后内部分别计算attention再拼接起来,实际上只影响计算形式而不会影响参数量。最后还需要一个投影矩阵,维度也是dmodel×dmodeld_{model} \times d_{model},总参数量4*512*512。

FFN部分,512维向量被投影到中间层的2048维再被投影回512维。总参数量2×dmodel×dff2\times d_{model} \times d_{ff} 。

因此总参数量为3145728 大约是3.15M参数。记住这个值有助于估算transformer的大小。同时可以看出,FFN的参数量在transformer里面占大头。

2. 为什么 Scaled Dot-Product Attention 要除以 dk​​? 

如果 dk=1024 时不除以 dk​​,softmax 输出分布会发生什么数学上的变化?具体到梯度层面,这会怎么影响训练?请用 softmax 函数在高温/低温下的行为来解释。

假设K\Q向量的每个元素都是在N(0,1)独立采样,则其点积S=∑i=1dkqikiS = \sum^{d_k}_{i=1} q_i k_i的方差为1​。

S=∑i=1dkqikiVar(s)=∑i=1dkVar(qiki)S = \sum^{d_k}_{i=1} q_i k_i Var(s) = \sum^{d_k}_{i=1} Var(q_i k_i)
E(kiqi)=E(ki)E(qi)=0E(k_i q_i) = E(k_i)E(q_i)=0
E[(kiqi)2]=E(ki2)E(qi2)=1E[(k_i q_i)^2] = E(k_i^2)E(q_i^2)=1
Var(kiQi)=E[(kiqi)2]−(E(kiqi))2=1Var(k_iQ_i)=E[(k_iq_i)^2]-(E(k_iq_i))^2=1
Var(S)=dkVar(S)=d_k

所以要令结果的方差依然是1,就需要加一个缩放系数

Var(Sdk)=1Var(\frac{S}{\sqrt{d_k}})=1

假如没有这个缩放系数,则计算出的矩阵的值的元素的标准差会等于dk\sqrt{d_k},导致在计算softmax的时候等效加了一个很低的温度系数,函数坍缩成了处处不可微分的argmax,梯度消失。可以通过计算雅各比矩阵来直观证明这一点。

这也解释了高温训练低温推理的工程实践。

3. Pre-LN vs Post-LN 的梯度秘密

 Pre-LayerNorm(Pre-LN)和 Post-LayerNorm(Post-LN)的残差连接位置不同。为什么 Pre-LN 训练更稳定、允许更大的学习率?从梯度的链式法则出发,分析 Pre-LN 比 Post-LN 到底好在哪。

Post-LN: x → MHA → Add → LN → FFN → Add → LN

xl+1=LN(xl+Sublayer(xl))x_{l+1}=LN(x_l + Sublayer(x_l))


Pre-LN: x → LN → MHA → Add → LN → FFN → Add

xl+1=xl+LN(Sublayer(xl))x_{l+1}=x_l +LN( Sublayer(x_l))

Pre-LN中残差链接跳过了LN,不会被LN影响,保持了梯度畅通

4. RoPE 旋转位置编码的本质 

Rotary Position Embedding (RoPE) 把一个 token 的位置信息编码进了 attention score 的计算中。请解释:

  • RoPE 如何实现 “相对位置” 的效果?(提示:内积的形式)
  • 为什么 RoPE 的”远程衰减”性质对 NLP 任务有用?

原始的transformer论文里将位置编码成一个向量加到了embedding上,这个编码是绝对位置的,因此3-4和5-6其实是完全不同的位置关系,模型需要学习到的位置关系太多。

RoPE的思想就是位置不应该体现在embedding上,而是应该体现在attention中。

score(m,n)=qmT×kn→score(m,n)=(Rmqm)T×Rnkn=qmTRmTRnknscore(m,n)=q_m^T\times k_n \rightarrow score(m,n)=(R_mq_m)^T\times R_nk_n = q_m^TR_m^TR_n k_n

现在的任务就变成了构造一个矩阵使得RmTRn=Rm−nR_m^TR_n = R_{m-n}

RoPE旋转矩阵将d维分解为d/2个二维子空间。每个子空间独立旋转mθim\theta_i弧度。其中θi=10000−2i/d\theta_i=10000^{-2i/d}。

\begin{bmatrix} 
\cos{m\theta_0} & -\sin{m\theta_0}\\ 
\sin{m\theta_0} & \cos{m\theta_0}  
\end{bmatrix}^T
\cdot
\begin{bmatrix} 
\cos{n\theta_0} & -\sin{n\theta_0}\\ 
\sin{n\theta_0} & \cos{n\theta_0}  
\end{bmatrix}
\\
=\begin{bmatrix} 
\cos{m\theta_0}\cos{n\theta_0}+\sin{m\theta_0}\sin{n\theta_0} & 
-\cos{m\theta_0}\sin{n\theta_0}+\sin{m\theta_0}\cos{n\theta_0}\\ 
-\sin{m\theta_0}\cos{n\theta_0}+\cos{m\theta_0}\sin{n\theta_0}&
\sin{m\theta_0}\sin{n\theta_0}+\cos{m\theta_0}\cos{n\theta_0}
\end{bmatrix}\\
=\begin{bmatrix} 
\cos{(m\theta_0-n\theta_0)} & -\sin{(m\theta_0-n\theta_0)}\\ 
\sin{(m\theta_0-n\theta_0)} & \cos{(m\theta_0-n\theta_0)} 
\end{bmatrix}

旋转矩阵的转置就是反向旋转,点积就是旋转角度相加,转置点积就是旋转角度相减。

那么剩下的问题就是为什么对不同的维度我们要使用不同的旋转角度?

我们可以观察到对于前两个维度,旋转角度是1,而对于最后两个维度,旋转角度仅有约0.0001。

原因在于cos是一个周期性的函数,假如所有θ=π6\theta=\frac{\pi}{6},则很容易得出当m-n=12、24、36等值的时候,R矩阵取得了完全一样的值,所以距离的分辨也变成了周期性的,无法区分长距离和短距离。

因此使用指数差距的旋转角度可以覆盖表示非常大的频率范围,大旋转角度用于短距离信息,小旋转角度用于长距离信息。我们称之为快慢指针,就好像我们常用的钟表一共有3个快慢指针,我们用它可以精确定位12小时内的时间,假如去掉时针,则我们只能分辨出一个小时内的精确时间了。对于512维向量,我们有256个这样的快慢指针。

当我们获得了一个完整的RmTRnR_m^TR_n的时候,其内积元素的和为∑i=0d/2−1cos((m−n)⋅10000−2i/d))\sum^{d/2-1}_{i=0}cos((m-n)\cdot 10000^{-2i/d})),随着m-n上升,此值不断减小。这就是位置编码的远程衰减,它使得注意力天然更能关注到距离自己更近的信息。

5. Attention 的 O(L2)复杂度 vs Flash Attention 

标准 attention 的内存复杂度和计算复杂度分别是多少?Flash Attention 通过什么技巧在不近似结果的前提下做到了 O(L)的显存占用?它的核心思想是什么,为什么 IO-aware 比 FLOPs-aware 更重要?

标准Scaled Dot-Product Attention:

Attention(Q,K,V) = softmax(\frac{QK^T}{\sqrt d_k})V
Step运算计算复杂度显存复杂度
S=QKTS = QK^T[L,d]⋅[d,L][L,d]\cdot[d, L]O(L2⋅d)O(L^2 \cdot d)3×d×L+L×L3\times d\times L+ L \times L
P=softmax(S)P=softmax(S)元素指数+行归一化O(L2)O(L^2)L×LL \times L
O=PVO = PV[L,L]⋅[L,d][L,L]\cdot[L,d]O(L2⋅d)O(L^2 \cdot d)2×d×L+L×L2\times d\times L+ L \times L

因此总计算复杂度为O(L2⋅d)O(L^2\cdot d) ,总显存复杂度为O(L2+Ld)O(L^2+Ld)

因此无论是计算还是显存占用,序列长度都是主导项。由于矩阵过于庞大,因此SRAM不可能装得下,S矩阵和P矩阵需要在SRAM和HBM间不断搬运。

S = Q @ K.T # 写 S 到 HBM ← L²

P = softmax(S, dim=-1) # 读 S,写 P 到 HBM ← 2×L²

O = P @ V # 读 P 和 V,写 O 到 HBM ← L²

其中的关键洞察是,其实全过程我们都不需要一个完整的S矩阵存在。在计算S矩阵的时候我们可以分块计算,在计算softmax的时候我们只进行行归一化。

核心思想:Tiling & Online Softmax

K = [K₁, K₂, ..., K_T]   每个块大小 B
V = [V₁, V₂, ..., V_T]
对于每个query行qi (一个d维向量):
对于每个块 j = 1..T:
    ① 从 HBM 加载 K_j, V_j 到 SRAM         ← O(L) 的 load
    ② 算 S_j = q_i @ K_j_T                ← B 个 score
    ③ 对 S_j 算部分 softmax,得到部分 P_j
    ④ 用 rescaling trick 合并到总的 O_i     ← 不需要 P_j
    ⑤ 丢弃 P_j,保留统计量                  ← 不写回 HBM!

关键还是需要理解Online Softmax

首先理解一下矩阵形式,矩阵的行方向L代表着序列,列方向d代表embeding的维度。使用完整的Q[L,d]Q[L,d]对部分的K[B,d]K[B,d]的转置KT[d,B]K^T[d,B]进行点积得到Si[L,B]S_i[L,B] ,其中的信息相当于是全序列对部分序列的查询结果,但softmax是在行向量中计算的,因此我们需要分步计算softmax。

softmax(x_i)=\frac{x_i}{\sum_{j=0}^{n} x_j}

如果需要使用标量来形容softmax需要哪些信息呢?

m_1=max(s_1)\\
l_1=\sum^B_{j=1}e^{s_j-m_1}\\
O_1=\sum s^{s_j-m_1}v_j

softmax块内的相对大小是不会被拆分破坏的,因此可以直接计算最终的O矩阵元素值(还没除softmax的分母),最后归一化权重即可

现在合并第一和第二个区块

m_{new}=max(s_1,s_2)\\
l_{new}=e^{m_1-m_{new}}\cdot l_1 + e^{m_2-m_{new}}\cdot l_2\\
O_{new}=e^{m_1-m_{new}} \cdot O_1+e^{m_2-m_{new}} \cdot O_2

第一行是一个不断更新的缩放系数

第二行存储了softmax中分母的部分

第三行存储了softmax中分子的部分和V矩阵计算的结果

最后一次合并的时候,额外令最后一次合并的时候,额外令O除以l,则可以得到最终的加权矩阵。

m_{final}=max(s_1,s_2)\\
l_{final}=e^{m_1-m_{final}}\cdot l_1 + e^{m_2-m_{final}}\cdot l_2\\
O_{final}=\frac{e^{m_1-m_{final}} \cdot O_1+e^{m_2-m_{final}} \cdot O_2}{l_{final}}
标准AttentionFlash Attention
FLOPS2L2d+L22L^2d+L^22L2d+L22L^2d+L^2
HBM读写O(L2)O(L^2)O(L)O(L)
速度受限于HBM带宽受限于SRAM带宽

既然计算量并没有下降,甚至上升了些许,那么怎么评价这个操作是赚到了?这就要引入一个算数强度的概念。

现代 GPU 的算术强度(arithmetic intensity)是:

  • HBM 带宽:~1.8 TB/s (RTX 5070 Ti)
  • Tensor Core 算力:~300 TFLOPS (稀疏)
  • 平衡点:300 TFLOPs/1.8 TB/s≈167300 TFLOPs/1.8 TB/s≈167 FLOPs/byte

当算术强度 < 167 时,瓶颈是带宽。Attention 的算术强度是:

2L2d+L24L2+4Ld≈2d4=64 (当 d=128)

64 < 167,所以标准 attention 是带宽受限的——GPU 的 tensor core 在闲着等你从 HBM 搬数据!

而SRAM的带宽高达约20TB/s,这就拉开了巨大的差距。

6. Autoregressive Decoding 的内存瓶颈 

一个 7B 参数(float16)的模型做自回归生成,KV Cache 的大小是多少?(假设 Lgen=2048, dmodel=4096, nlayers=32, nkv_heads=8,GQA)。如果 batch size = 1 和 batch size = 64,KV Cache 分别占多少 GB?从这笔账来看,长上下文生成时,瓶颈在哪里?

当transformer运行时,每生成一个token,就要完整的跑一遍transformer流程,因此KV矩阵如果不存储起来的话,会被重复计算,对于长上下文这显然不可接受。

那为什么是KV cache而不是KQV cache呢?因为Q不会被复用,Q一生只上岗一次,在输入侧,当注意力被计算完成的时候Q矩阵就功成身退,在输出侧,由于遵循因果性,只有新token的Q会去查询旧token的KV值,旧的token永远看不见新的token,所以Q不需要被缓存。

那么现在就可以计算KV矩阵的大小了,一个KVhead的维度为dmodel/nkv_headers=512d_{model}/n_{kv\_headers}=512,共有2⋅nkv_headers⋅Lgen⋅nlayer=10485762\cdot n_{kv\_headers}\cdot L_{gen}\cdot n_{layer}= 1048576个KVhead,总占用为512×1048576×16512 \times 1048576 \times 16 bit,正好是1GB。

也就是每个KVhead 1KB,一个token16KB,总序列单层32MB,模型共1GB,竟然有这么大吗?

如果加上batch size=64,则KV cache的体积达到了惊人的64GB,而7B参数的模型参数体积为14GB。

自回归生成分为两个阶段:

① Prefill(预填充):一次处理整个 prompt,算所有 token 的 K/V 并建 cache。FLOPs 巨大,计算密集。

② Decode(解码):一个 token 一个 token 生成。每步只算 1 个新 token 的 K/V,但 attention 要读整个 KV Cache,也就是每一个token的内存读取量就达到了78GB;

而decode的计算消耗仅有几个GFLOPS,算数强度远远小于现代GPU的平衡点,因此这是一个带宽受限的过程。这也解释了为什么针对推理开发的硬件的参数,显存带宽和显存容量要比算力更加关键。

这笔账引出的三个核心优化

  1. vLLM 的 PagedAttention:KV Cache 不连续分配,像操作系统分页一样管理显存碎片,让 batch 能开更大
  2. GQA/MQA:砍 nkv_heads→ KV Cache 直接缩水。8 个 KV head 比 32 个(标准 MHA)省 4 倍
  3. DeepSeek 的 MLA:把 KV Cache 压到更低维的隐空间,省到极致

7. SwiGLU / GEGLU 是什么? 

很多现代 LLM(LLaMA、DeepSeek)用 SwiGLU 或 GEGLU 替代了标准 FFN 的 ReLU 激活函数。请解释 SwiGLU 的数学形式,以及它相比 ReLU 的好处是什么。为什么它需要三个权重矩阵而不是两个?

先回忆一下ReLU,ReLU是一个正值滤波器,在标准的FFN里FFN(x)=W2​⋅ReLU(W1​x)FFN(x)=W_2​\cdot ReLU(W_1​x),ReLU有一个致命的问题,负值区没有梯度,一旦一个神经元的输入总是负值,该神经元将不会再被更新,等同于死掉。

SwiGLU(Swish-Gated Linear Unit)的表达式为

SwiGLU(x,W,V,b,c)=Swish(xW+b)⊗(xV+c)SwiGLU(x,W,V,b,c)=Swish(xW+b)⊗(xV+c)
Swish(z)=z⋅σ(z)=z1+e−zSwish(z)=z\cdot \sigma(z)=\frac{z}{1+e^{-z}}

其中⊗代表矩阵逐元素相乘。

可以看出SwiGLU有几个非常优秀的特质,首先它的梯度连续没有突变点,其次它在负区域仍然有梯度不会导致神经元死亡,最后它是一个有下界的函数,当输入趋于负无穷,其输出趋近于零。

SwiGLU还有一个很关键的特点,它自己是包含一个V参数矩阵的,我们称之为门控矩阵。所以使用SwiGLU的FFN,共有三个参数矩阵,分别是W升维矩阵dmodel​×dff​d _{model }​ \times d_{ff} ​、V门控矩阵dmodel​×dff​d _{model }​ \times d_{ff} ​、W2降维矩阵dff​×dmodel​d _{ff}​ \times d_{model} ​。激活函数本身变成了可训练的。

可训练的激活函数使得每个神经元可以自己选择自己的激活强度,直观理解就是他们知道自己代表的特征在什么样的输入下更加的重要。增加的一个乘区给了模型更强的表达能力,当一个神经元的输出为0,既可能是信息本身没有意义,也可能是信息在这种情况下没有意义。实际的测试效果也显示SwiGLU表现除了优秀的训练性能。

那么代价是什么呢?参数量增加了整整50%!应对这种情况也很直接,把隐藏层维度变成原来的2/3……

然后就要介绍另外的两个激活函数了,其原理和SwiGLU类似。

GeLU (Gaussian Error Linear Unit)表达式为

GELU(x)=x⋅P(X<=x)=xΦ(x)GELU(x)=x\cdot P(X<=x)=x\Phi(x)

而 GeGLU则是将SwiGLU中的Swish函数更换为GELU

GEGLU(x)=GELU(xW+b)⊗(xV+c)GEGLU(x)=GELU(xW+b)⊗(xV+c)

8. Weight Initialization 对 Transformer 训练的影响

 如果用 N(0,0.1)初始化所有参数去训练一个 32-layer 的 Transformer,会发生什么?从前向传播的信号强度和反向传播的梯度范数两个角度分析。现代 Transformer 通常用什么初始化策略?(Hint:DeepNet / Init)

直接说结论的话是loss大概率会算出NaN,原因是方差传播定律。

对于一个线性层y=Wxy=Wx ,假设Wij=𝒩(0,σω2)W_{ij}=\mathcal{N}(0,\sigma^2_\omega),xx均值为0,方差为σx2\sigma^2_x

Var(y_i)=d_{in}\cdot \sigma^2_x \cdot \sigma^2_\omega

每经过一个线性层,方差信号会被放大din⋅σω2d_{in}\cdot \sigma^2_\omega ,可以理解为神经网络的增益。

在题目中的例子里面,对于一个512维向量,在32层后方差已经被放大到了5.12325.12^{32}

在前向传播中

  • 注意力计算中的softmax直接过热变成one-hot,梯度消失。
  • FP16溢出,中间激活值超过65504直接变inf,然后最终传染NaN到loss
  • 残差相加变成了残差噪声+结果巨值,LN层只看到了后者,失去了意义

在反向传播中∂L∂x=WT∂L∂y\frac{\partial L}{\partial x}=W^T\frac{\partial L}{\partial y} ,因此梯度范数会爆炸。

现代Transformer的初始化策略有:

策略公式思想
Xavier / Glorot (2010)σω2=2din+dout\sigma^2_\omega=\frac{2}{d_{in}+d_{out}}前向反向方差同时守恒
He / Kaiming (2015)σω2=2din\sigma^2_\omega=\frac{2}{d_{in}}适配 ReLU 族的方差修正
GPT-2 scaled init残差输出额外 ×1N\times \frac{1}{\sqrt{N}}层数感知:越深,残差贡献越小
DeepNorm (DeepNet, 2022)残差缩放 α(随层数增长)能把 Transformer 推到 1000 层
deepseek-init (DeepSeek-V2)输出投影(WO)初始化缩小保证残差流的方差稳定,让深层 MoE 好训

现代Transformer的最大区别是初始化除了对抗一层线性层的影响外,还要关注模型的层数,毕竟事情的重点是让残差流方差不随深度增长。

9. MHA、MQA、GQA 的 trade-off 

Multi-Query Attention (MQA) 和 Grouped-Query Attention (GQA) 是对 MHA 的优化。它们各自:

  • 节省了多少参数量和 KV Cache?
  • 对模型质量有什么影响?
  • DeepSeek V2/V3 的 MLA (Multi-head Latent Attention) 跟它们有什么本质不同?

🟦 MHA(Multi-Head Attention)—— 原始版

Q: [head1, head2, head3, …, head32] ← 32 个 Q head K: [head1, head2, head3, …, head32] ← 32 个 K head(每个都不同) V: [head1, head2, head3, …, head32] ← 32 个 V head

每个 head 完全独立——各有各的 K、V。表达力最强,但 KV Cache 最大。

🟩 MQA(Multi-Query Attention)—— 激进共享

Q: [head1, head2, head3, …, head32] ← 32 个 Q head K: [共享同一个] ← 只有 1 个 K V: [共享同一个] ← 只有 1 个 V

质量损失明显——所有 head 看到的信息来源都一样,多头就失去意义了。

🟨 GQA(Grouped-Query Attention)—— 折中

Q: [h1 h2 h3 h4 | h5 h6 h7 h8 | …] ← 32 个 Q head K: [ 共享1 | 共享2 | …] ← 8 个 K head(每 4 个 Q 共享 1 个) V: [ 共享1 | 共享2 | …] ← 8 个 V head

把 Q head 分成几组,每组内共享 K/V。这是 MHA 和 MQA 的中间地带

KVcahce大小为2×nkv_heads×dk×L×nlayers2\times n_{kv\_heads} \times d_k \times L \times n_{layers}, 因此MQA和GQA对于节省显存消耗意义重大。

三者对比MHAMQAGQA
KV head 数nheads=32n_{heads}=321ngroups=8n_{groups}=8
KV Cache4.3 GB(基准)0.13 GB(÷32)1.07 GB(÷4)
质量最好有损失接近 MHA

在实际操作中,可以通过对权重矩阵取平均将MHA化为GQA甚至MQA,然后进行微调后部署推理。

那么MLA(Multi-head Latent Attention)是什么?

MLA不是共享KV而是压缩KV,实际的做法是把KV压缩成低维的隐向量c

c=W_{DKV}\cdot h\\ k=W{UK}\cdot c

隐向量的维度可能只有64维,可以实现8倍的压缩比。问题的关键是为什么这种压缩可以做到几乎无损?

因为K和V本质上是低秩的,空间里有用的子信息往往集中在一个低维子空间中。但这其实直观上比较难以理解

对于秩,我们可以分为名义秩(nominal rank)和有效秩(effective rank)低秩指的就是有效秩远小于名义秩。

在实际的观察中,最开始KV的分布各向同性,有效秩几乎是满的,但训练后有效秩可能只剩下了十分之一。

① 数据本征低秩:语言由几十万 token 组成,但真正区分它们的语义概念(主语、时态、情感、主题、句法角色……)只有几十到几百个。Zipf 分布下极少数 token 出现频率极高,大多数是长尾。一个 512 维的 K 向量要编码的信息量,远小于 512 个自由方向能承载的。

② 任务只需要低秩信息:K 的用途是算注意力分数——只需要区分”哪些 token 相关、哪些不相关”。这是个很”软”的任务,不需要完美表示每个 token 的全部信息,只需要足够的判别力。

③ 梯度只推有用的方向:训练时,与预测相关的方向收到大梯度、能量被放大;无关的方向收到 ~0 梯度,停留在初始化噪声水平。于是能量逐渐集中到少数主方向——有效秩塌缩。

更具体的等到后面再讨论。

10. Attention is All You Need 中 Embedding 的三重身份

 Transformer 中的 embedding 层做了三件事:token embedding、positional encoding、最终的 linear + softmax(tied embedding)。请问:

  • 为什么 tie embedding weights(输入/输出共享权重)能提高质量?
  • 为什么 Linear + softmax 的输出层本质上也在做一次 “attention”?(提示:把输出层看作一种特殊的记忆检索)

首先定义一下embedding这个概念,embedding是一张可以学习的查找表,将token ID转化成向量是查表,将隐藏向量转化成token ID是反向查表,他们都是embedding,非要严谨表述的话,输出层可以叫unembedding。

第一个问题:为什么共享权重(tied embedding)?

原版 Transformer 用Wout=ETW_{out}=E^T

① 语义一致性。 同一个词,在输入侧和输出侧应该表达同一个意思。如果不共享,模型被迫维护两套不一致的语义。共享 = 强制它们对齐。

② 正则化。 词表通常 10 万+,输出矩阵0.05B参数。共享后这部分参数复用,等于给模型加了一层隐式正则,减少过拟合。

第二个问题:为什么输出层本质是”一次 attention”?

在注意力计算层和输出层:

score = q \cdot k_i \quad\underrightarrow{softmax}\quad Weight \\
logit_i = h\cdot e_i \quad\underrightarrow{softmax}\quad P_{(next word = i)} \\

直观上理解,h是此时我想表达什么,e是我是一个什么词,点积就是算相似度,即注意力分数。

某种程度上和射频调制挺像的,用什么算法调制就得用什么算法解调。

Related Posts