企业官网建设流程全解析

1. 从零理解 Transformer：自注意力机制到底解决了什么问题

如果你刚开始接触大模型，大概率会被一堆名词砸晕：自注意力、多头注意力、编码器、解码器、位置编码……每个词单看都认识，拼在一起就不知道在说什么。我当初也是这样，直到把 Transformer 拆成“它到底想解决什么问题”来看，才慢慢理顺。

先说结论：Transformer 是一个完全依赖自注意力机制来计算输入和输出表示的序列到序列模型。它最早是为机器翻译设计的，但后来成了几乎所有大语言模型的底座。你熟悉的 GPT、BERT、LLaMA，本质上都是 Transformer 的变体。所以想系统入门大模型，Transformer 是绕不过去的第一座山。

那它到底解决了什么问题？在 Transformer 之前，处理序列数据主要靠 RNN 和 CNN。RNN 的问题是必须按顺序一步步算，第 t 步依赖第 t-1 步，没法并行，长序列还会梯度消失。CNN 虽然能并行，但要堆很多层才能让距离远的两个位置产生关联。Transformer 的思路很直接：既然序列里每个词和其他词的关系才是重点，那我干脆让每个词直接去“看”所有词，一次性算出所有位置之间的关联权重。这就是自注意力机制的核心。

用一个类比：读一句话“小猫追着球跑，因为它很开心”。这里的“它”指谁？人脑会自动把“它”和“小猫”关联起来。自注意力做的就是这件事——对每个词，计算它和其他所有词的关联分数，然后按分数加权汇总信息。这样“它”的表示里就混入了“小猫”的信息，模型自然就“懂”了指代关系。

自注意力的计算靠三个向量：Query（查询）、Key（键）、Value（值）。你可以这样理解：Query 是“我在找什么”，Key 是“我有什么标签”，Value 是“我实际的内容”。对每个词，用它自己的 Query 去和所有词的 Key 做点积，得到一组相似度分数，Softmax 归一化后作为权重，再对所有词的 Value 加权求和，就得到这个位置的新表示。公式就是 Attention(Q,K,V) = softmax(QKᵀ/√d_k)V。那个 √d_k 是缩放因子，防止点积结果太大导致 Softmax 梯度消失。

这里有个关键点很多人一开始会忽略：自注意力本身不包含位置信息。因为它是把所有位置一起算的，打乱词序结果不变。但语言是有顺序的，“猫追狗”和“狗追猫”意思完全不同。所以 Transformer 额外加了位置编码，用不同频率的正弦余弦函数给每个位置生成一个向量，加到词嵌入上。这样模型既能并行计算，又能感知顺序。

理解了自注意力，多头注意力就好懂了。一组 QKV 只能学到一种关联模式，比如语法主谓关系。但语言里的关系是多维的：有语法、有语义、有指代、有情感。多头注意力就是并行跑 h 组独立的 QKV 变换，每组关注不同的模式，最后把结果拼接再线性变换。原论文里 h=8，每个头的维度是 512/8=64。这样总计算量和单头差不多，但表达能力更强。

编码器和解码器的分工也值得说清楚。编码器由 6 个相同块堆叠，每块包含一个多头自注意力子层和一个前馈网络子层，每个子层后面都有残差连接加 LayerNorm。编码器的任务是理解输入，输出一组富含上下文的表示。解码器也是 6 个块，但每块多了一个编码器-解码器注意力子层，它的 Query 来自解码器上一层，Key 和 Value 来自编码器输出。这样解码器在生成每个词时，能动态地从输入序列里取相关信息。另外解码器的自注意力是带掩码的，确保预测第 i 个位置时只能看到小于 i 的位置，不能偷看未来。

前馈网络部分相对简单，就是两层线性变换加 ReLU，中间维度 2048，输入输出 512。它给模型提供非线性变换能力。嵌入层和最后的 Softmax 层共享权重矩阵，这是为了减少参数量并提升泛化。

把这些拼起来，整个数据流就是：输入词 → 词嵌入 + 位置编码 → 编码器堆叠（自注意力 + 前馈）→ 编码器输出 → 解码器堆叠（掩码自注意力 + 编码器-解码器注意力 + 前馈）→ 线性 + Softmax → 输出概率分布。训练时用 teacher forcing，并行计算所有位置的损失；推理时自回归地一个词一个词生成。

为什么这个架构能赢 RNN 和 CNN？论文里给了三个维度的对比：每层计算复杂度、可并行操作数、最长相关路径长度。自注意力在这三项上综合最优。尤其是最长路径，自注意力是 O(1)，RNN 是 O(n)，这意味着学长距离依赖容易得多。当然自注意力复杂度是 O(n²d)，序列特别长时开销大，这也是后来各种高效注意力变体的动机。

对想动手的开发者来说，最小可复现路径是：先用 PyTorch 实现单头缩放点积注意力，验证输出形状和权重归一化；再加多头，验证拼接后维度；然后搭一个编码器块，跑通残差和 LayerNorm；最后拼完整模型，用随机数据做一次前向，检查输出形状和损失是否能下降。每一步都打印中间张量形状，比一口气写完再 debug 高效得多。

如果你在本地跑这些实验，模型下载和 API 调用可能会遇到网络配置问题。我习惯把常用模型的接入统一走一个兼容端点，省得每个库单独配。比如在环境变量里设好 base_url 和 api_key，OpenAI SDK、LangChain、LlamaIndex 都能直接读。这样切换模型时只改一个 model id，不用动代码。具体配置我放在第三节，你可以直接复制。

2. TaoToken 前置准备：把模型接入统一到一个端点

在真正跑 Transformer 代码之前，有个现实问题得先解决：你不可能每次都从零训练一个模型。绝大多数时候，你是调用现成的大模型 API 来做推理、微调或者对比实验。但不同厂商的 SDK、鉴权方式、参数命名都不一样，代码里到处是 if-else，维护起来很痛苦。

我的做法是找一个兼容 OpenAI 协议的端点，把所有模型调用统一起来。TaoToken 就是这样一个入口，它的 API 地址是 https://taotoken.net/api，完全兼容 OpenAI 的 /v1/chat/completions 和 /v1/models 接口。这意味着你原来用 openai 库写的代码，只需要改 base_url 和 api_key 两行，就能切换到不同模型。

为什么这对学 Transformer 有帮助？因为你在验证自注意力、多头注意力这些概念时，经常需要对比不同模型的行为。比如你想看同一个 prompt 在不同规模模型上的输出差异，或者想用大模型来辅助解释代码。如果每个模型都要单独注册、单独配 SDK，实验节奏会被打断。统一端点后，你只需要维护一份配置，换模型就是改一个字符串。

具体怎么配？我推荐用环境变量，这样代码里不出现密钥，也方便在不同项目间复用。在 Linux/macOS 的 ~/.bashrc 或 ~/.zshrc 里加：

export TAOTOKEN_API_KEY="你的密钥" export TAOTOKEN_BASE_URL="https://taotoken.net/api"

Windows 用户在系统环境变量里加同样的两项，或者在 PowerShell 里用 $env:TAOTOKEN_API_KEY="..." 临时设置。密钥在控制台的 API Keys 页面创建，地址是 https://taotoken.net/console/api-keys。创建时建议按用途命名，比如 “transformer-study”，方便后面排查。

配好之后，Python 里这样用：

import os from openai import OpenAI client = OpenAI( api_key=os.environ["TAOTOKEN_API_KEY"], base_url=os.environ["TAOTOKEN_BASE_URL"] ) resp = client.chat.completions.create( model="gpt-4o-mini", messages=[{"role": "user", "content": "用一句话解释自注意力机制"}] ) print(resp.choices[0].message.content)

注意 base_url 后面不要加 /v1，OpenAI SDK 会自动补。如果你用的是 requests 直接调，那完整路径是 https://taotoken.net/api/v1/chat/completions。model 字段填你想用的模型 ID，具体支持哪些可以在模型对话页面查看，地址是 https://taotoken.net/models。这个页面也能直接在线试，不用写代码就能对比不同模型的输出。

对于长期做编码和 Agent 开发的场景，可以考虑 Coding Plan，地址是 https://taotoken.net/coding-plan。它针对代码补全、多轮对话、工具调用这些高频操作做了优化，配额和并发更宽松。如果你只是偶尔跑几个实验，按量付费就够了。

还有一个容易踩的坑：有些库（比如 LangChain）会自己读 OPENAI_API_KEY 和 OPENAI_BASE_URL，不认你自定义的变量名。这时候要么在代码里显式传参，要么把变量名改成它认识的。我一般显式传，避免隐式行为导致排查困难。

配置完成后，先跑一个最小验证：列出可用模型。这一步能确认密钥有效、网络通、端点正确。

models = client.models.list() for m in models.data[:5]: print(m.id)

如果这里报 401，说明密钥不对或没生效；如果报连接错误，检查 base_url 是否写错。验证通过后再往下做 Transformer 实验，能省掉很多“到底是模型问题还是配置问题”的纠结。

3. 可复制配置：JSON/TOML/settings 片段与三件套

这一节给你可以直接抄的配置文件。不管你是用 Cline、Claude Code、Codex 还是自己写脚本，核心都是三件套：Base URL、API Key、Model ID。缺一个都跑不通。

先看 Cline（VS Code 插件）的配置。Cline 支持 OpenAI Compatible 提供商，在设置里填：

{ "apiProvider": "openai", "openAiBaseUrl": "https://taotoken.net/api", "openAiApiKey": "sk-你的密钥", "openAiModelId": "gpt-4o-mini" }

如果你用 Cline 的 MCP 功能，配置文件通常在 ~/.cline/mcp_settings.json 或项目下的 .cline/mcp.json。MCP server 如果要调模型，同样走这个端点：

{ "mcpServers": { "taotoken-helper": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-everything"], "env": { "OPENAI_BASE_URL": "https://taotoken.net/api", "OPENAI_API_KEY": "sk-你的密钥", "OPENAI_MODEL": "gpt-4o-mini" } } } }

注意 MCP 直连生产数据库是禁止的，这里只是示例环境变量传递，实际用的时候把 server 换成你需要的工具，别把数据库连接串塞进去。

Claude Code 的配置在 ~/.claude/settings.json 或项目下的 .claude/settings.json。它支持通过环境变量覆盖 Anthropic 端点，但如果你要走 OpenAI 兼容层，需要用支持转换的代理配置。更简单的做法是在项目里用 .env：

ANTHROPIC_BASE_URL=https://taotoken.net/api ANTHROPIC_API_KEY=sk-你的密钥 ANTHROPIC_MODEL=claude-3-5-sonnet-20241022

然后在 Claude Code 里通过 /config 确认端点生效。Claude Code 的文档页在 https://taotoken.net/doc，里面有各客户端的详细接入步骤。

Codex 的 auth.json 通常在 ~/.codex/auth.json。配置如下：

{ "openai": { "base_url": "https://taotoken.net/api", "api_key": "sk-你的密钥", "model": "gpt-4o-mini" } }

如果你用 Codex CLI，也可以在命令行直接指定：

codex --base-url https://taotoken.net/api --api-key $TAOTOKEN_API_KEY --model gpt-4o-mini

Python 项目的 TOML 配置（比如 pyproject.toml 或独立的 config.toml）：

[llm] base_url = "https://taotoken.net/api" api_key = "sk-你的密钥" model = "gpt-4o-mini" timeout = 60 max_retries = 3

然后在代码里用 tomllib 或 pydantic-settings 读取。这样配置和代码分离，换模型不用改逻辑。

Node.js 项目的 .env：

OPENAI_BASE_URL=https://taotoken.net/api OPENAI_API_KEY=sk-你的密钥 OPENAI_MODEL=gpt-4o-mini

用 dotenv 加载后，openai 包会自动读取这两个变量。

这里强调一下三件套的对应关系：Base URL 决定请求发到哪，API Key 决定你有没有权限，Model ID 决定用哪个模型。三个必须匹配。常见错误是 Base URL 写了 https://taotoken.net 但漏了 /api，或者 Model ID 填了不存在的名字。前者会 404，后者会 400 或 model not found。

另外，如果你在代码里同时用多个库，建议统一从一个配置源读取。比如定义一个 get_llm_config() 函数，返回 dict，所有客户端都从这里取。这样改一处全生效，避免某个库还在用旧密钥。

对于需要频繁切换模型的实验，可以在配置里加一个模型映射表：

{ "models": { "fast": "gpt-4o-mini", "balanced": "gpt-4o", "reasoning": "o1-mini", "coding": "claude-3-5-sonnet-20241022" } }

代码里用 config["models"]["fast"] 取，语义清晰，也方便团队统一。

配置完成后，跑一个带重试的验证脚本，确认三件套都生效：

import os, time from openai import OpenAI, APIError, APIConnectionError client = OpenAI( api_key=os.environ["TAOTOKEN_API_KEY"], base_url=os.environ["TAOTOKEN_BASE_URL"] ) for attempt in range(3): try: r = client.chat.completions.create( model="gpt-4o-mini", messages=[{"role": "user", "content": "回复 OK"}], max_tokens=5 ) print("成功:", r.choices[0].message.content) break except APIConnectionError as e: print(f"连接失败，重试 {attempt+1}/3:", e) time.sleep(2) except APIError as e: print("API 错误:", e.status_code, e.message) break

这个脚本能区分网络问题和鉴权问题。连接失败通常是 base_url 或网络环境；API 错误通常是密钥或模型 ID。跑通后再进入 Transformer 代码实验。

4. 验证请求与成功结果：逐层跑通最小 Transformer

配置就绪后，我们用一个最小 PyTorch 实现来验证对 Transformer 的理解。目标不是训练出能用的模型，而是每一步都能打印形状、确认计算正确。这样你对自注意力、多头、编码器块的理解会从“好像懂了”变成“确实懂了”。

先实现缩放点积注意力：

import torch import torch.nn as nn import math def scaled_dot_product_attention(Q, K, V, mask=None): d_k = Q.size(-1) scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(d_k) if mask is not None: scores = scores.masked_fill(mask == 0, -1e9) weights = torch.softmax(scores, dim=-1) output = torch.matmul(weights, V) return output, weights # 验证 batch, seq_len, d_model = 2, 4, 8 Q = torch.randn(batch, seq_len, d_model) K = torch.randn(batch, seq_len, d_model) V = torch.randn(batch, seq_len, d_model) out, w = scaled_dot_product_attention(Q, K, V) print("输出形状:", out.shape) # torch.Size([2, 4, 8]) print("权重形状:", w.shape) # torch.Size([2, 4, 4]) print("权重每行和:", w.sum(dim=-1)) # 应接近 1

跑一下，确认权重每行和都是 1，输出形状和 V 一致。这一步验证了注意力机制的核心：加权求和。

接着实现多头注意力：

class MultiHeadAttention(nn.Module): def __init__(self, d_model, num_heads): super().__init__() assert d_model % num_heads == 0 self.d_model = d_model self.num_heads = num_heads self.d_k = d_model // num_heads self.W_q = nn.Linear(d_model, d_model) self.W_k = nn.Linear(d_model, d_model) self.W_v = nn.Linear(d_model, d_model) self.W_o = nn.Linear(d_model, d_model) def forward(self, Q, K, V, mask=None): batch = Q.size(0) # 线性变换后拆头: (batch, seq, d_model) -> (batch, heads, seq, d_k) q = self.W_q(Q).view(batch, -1, self.num_heads, self.d_k).transpose(1, 2) k = self.W_k(K).view(batch, -1, self.num_heads, self.d_k).transpose(1, 2) v = self.W_v(V).view(batch, -1, self.num_heads, self.d_k).transpose(1, 2) out, weights = scaled_dot_product_attention(q, k, v, mask) # 拼头: (batch, heads, seq, d_k) -> (batch, seq, d_model) out = out.transpose(1, 2).contiguous().view(batch, -1, self.d_model) return self.W_o(out), weights mha = MultiHeadAttention(d_model=8, num_heads=2) out, w = mha(Q, K, V) print("多头输出形状:", out.shape) # torch.Size([2, 4, 8]) print("多头权重形状:", w.shape) # torch.Size([2, 2, 4, 4])

关键验证点：拆头后形状是 (batch, heads, seq, d_k)，拼头后回到 (batch, seq, d_model)。权重形状多了一个 heads 维度。如果这里形状对不上，检查 view 和 transpose 的顺序。

然后搭编码器块：

class EncoderBlock(nn.Module): def __init__(self, d_model, num_heads, d_ff, dropout=0.1): super().__init__() self.attn = MultiHeadAttention(d_model, num_heads) self.norm1 = nn.LayerNorm(d_model) self.norm2 = nn.LayerNorm(d_model) self.ff = nn.Sequential( nn.Linear(d_model, d_ff), nn.ReLU(), nn.Linear(d_ff, d_model) ) self.dropout = nn.Dropout(dropout) def forward(self, x, mask=None): attn_out, _ = self.attn(x, x, x, mask) x = self.norm1(x + self.dropout(attn_out)) ff_out = self.ff(x) x = self.norm2(x + self.dropout(ff_out)) return x enc = EncoderBlock(d_model=8, num_heads=2, d_ff=32) out = enc(Q) print("编码器块输出形状:", out.shape) # torch.Size([2, 4, 8])

这里验证残差连接和 LayerNorm：输入输出形状一致，说明可以堆叠。你可以试着堆 6 层，形状不变。

位置编码：

class PositionalEncoding(nn.Module): def __init__(self, d_model, max_len=5000): super().__init__() pe = torch.zeros(max_len, d_model) position = torch.arange(0, max_len).unsqueeze(1).float() div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)) pe[:, 0::2] = torch.sin(position * div_term) pe[:, 1::2] = torch.cos(position * div_term) self.register_buffer('pe', pe.unsqueeze(0)) def forward(self, x): return x + self.pe[:, :x.size(1)] pe = PositionalEncoding(d_model=8) x_with_pos = pe(Q) print("加位置编码后形状:", x_with_pos.shape) # torch.Size([2, 4, 8])

验证方式：打印 pe 的前几个值，确认不同位置的正弦值不同，且同一维度上随位置变化。

最后拼一个完整的前向：

class MiniTransformer(nn.Module): def __init__(self, vocab_size, d_model=8, num_heads=2, d_ff=32, num_layers=2): super().__init__() self.embed = nn.Embedding(vocab_size, d_model) self.pos = PositionalEncoding(d_model) self.encoder_layers = nn.ModuleList([ EncoderBlock(d_model, num_heads, d_ff) for _ in range(num_layers) ]) self.fc = nn.Linear(d_model, vocab_size) def forward(self, x): x = self.pos(self.embed(x)) for layer in self.encoder_layers: x = layer(x) return self.fc(x) model = MiniTransformer(vocab_size=100) input_ids = torch.randint(0, 100, (2, 6)) logits = model(input_ids) print("最终输出形状:", logits.shape) # torch.Size([2, 6, 100])

跑通这个，你就有了一个可工作的 Transformer 编码器。解码器在此基础上加掩码自注意力和交叉注意力，掩码用上三角矩阵：

def causal_mask(seq_len): mask = torch.tril(torch.ones(seq_len, seq_len)).unsqueeze(0).unsqueeze(0) return mask # (1, 1, seq_len, seq_len) mask = causal_mask(4) print(mask)

验证掩码：下三角为 1，上三角为 0。在注意力里把 0 的位置填 -1e9，Softmax 后权重就为 0，实现“不看未来”。

每一步都打印形状和关键值，比一次性写完再调试快得多。如果你在调用远程模型辅助解释代码时遇到连接问题，回到第二节检查三件套配置。

5. 本篇常见错排查：401、local proxy failed、reading choices、OAuth

这一节整理我在配置和实验过程中真实遇到过的报错，以及对应的排查路径。你大概率会碰到其中至少一个。

401 Unauthorized。这是最常见的鉴权错误。表现是请求返回 401，消息通常是 “Invalid API key” 或 “No auth credentials found”。排查顺序：第一，确认 API Key 复制完整，没有多余空格或换行；第二，确认环境变量真的生效了，在 Python 里 print(os.environ.get("TAOTOKEN_API_KEY")) 看是不是 None；第三，确认 base_url 和 key 是配套的，别把 A 平台的 key 用到 B 平台的端点；第四，如果用的是库自动读取，确认库读的变量名和你设的一致。我踩过的坑是把 key 写在 .env 里但没装 python-dotenv，代码里读不到，报 401 还以为是 key 失效。

local proxy failed。这个报错通常出现在你本地设置了 HTTP_PROXY 或 HTTPS_PROXY 环境变量，但代理服务没启动或端口不对。表现是连接被拒绝或超时。排查：先 echo $HTTP_PROXY 看有没有值，如果有但你不确定是否可用，临时 unset 掉再试。另一个可能是公司网络要求走特定出口，这时候需要确认你的网络环境是否允许直连。注意，这里不涉及任何绕过网络管理的手段，只是排查本地环境变量配置错误。如果你在容器里跑，检查容器的网络模式和环境变量传递。

reading choices 相关报错。典型消息是 “Error reading choices” 或 “choices field missing”。这通常不是网络问题，而是响应格式不符合预期。原因可能是：模型返回了错误信息但 HTTP 状态是 200，或者你用的库版本和端点返回的 JSON 结构不匹配。排查：先用 curl 直接打端点，看原始返回：

curl -s https://taotoken.net/api/v1/chat/completions \ -H "Authorization: Bearer $TAOTOKEN_API_KEY" \ -H "Content-Type: application/json" \ -d '{"model":"gpt-4o-mini","messages":[{"role":"user","content":"hi"}]}'

如果 curl 返回正常但代码报错，就是库的问题。检查 openai 库版本，老版本可能不兼容某些字段。升级到最新版通常能解决。另外，如果你传了 stream=True 但按非流式解析，也会读不到 choices。

OAuth 相关错误。如果你用 Claude Code 或某些 CLI 工具，可能会遇到 OAuth token 过期或刷新失败。表现是 “OAuth token expired” 或 “refresh failed”。排查：检查 ~/.claude/ 或 ~/.codex/ 下的凭证文件是否过期，重新登录或重新生成 API Key。有些工具会缓存 token，删掉缓存文件再试。如果你同时配了 OAuth 和 API Key，确认工具优先用哪个，避免冲突。

model not found。消息是 “The model does not exist” 或 “invalid model”。检查 model ID 拼写，大小写敏感。去模型对话页面确认可用列表。有些模型有版本后缀，比如 claude-3-5-sonnet-20241022，少一段就不行。

超时或连接重置。如果请求偶尔成功偶尔失败，可能是网络抖动。加重试逻辑，指数退避。如果一直超时，检查 base_url 是否可达，用 ping 或 curl -v 看握手过程。容器环境注意 DNS 配置。

形状不匹配。这是代码层面的错，不是 API 错。典型如 “Expected input batch_size (2) to match target batch_size (4)”。排查：打印每一步的张量形状，对照本文第四节的验证输出。多头注意力的 view/transpose 最容易出错，确保拆头后是 (batch, heads, seq, d_k)，拼头前先 contiguous。

梯度为 NaN。训练时出现，通常是学习率太大或缩放因子漏了。检查是否除以了 sqrt(d_k)。另外 LayerNorm 的位置也很关键，原论文是 Post-LN，后来很多实现用 Pre-LN 更稳定。如果你自己搭，先用小学习率跑通再调。

显存不足。自注意力是 O(n²) 复杂度，序列长时显存涨得快。减小 batch size 或序列长度，或者用梯度累积。推理时可以用 torch.no_grad() 省显存。

排查通用原则：先隔离层次。用 curl 确认端点通，用最小 Python 脚本确认 SDK 通，再用你的业务代码。每层都通了，问题范围就缩小到具体代码。别一上来就改模型结构，先确认配置和网络没问题。

6. 语义一致 CTA：继续深入的方向

走到这里，你已经把 Transformer 的核心组件跑了一遍：自注意力的加权求和、多头注意力的拆拼、编码器块的残差和 LayerNorm、位置编码的注入、掩码的生成。这些代码加起来不到 200 行，但覆盖了理解大模型最关键的几个概念。接下来你可以往几个方向深入。

第一个方向是补全解码器和完整训练循环。把交叉注意力加上，用 teacher forcing 跑一个玩具翻译任务，观察损失下降。第二个方向是对比不同注意力变体，比如把缩放点积换成加性注意力，看收敛速度差异。第三个方向是读源码，HuggingFace 的 transformers 库里 modeling_bert.py 和 modeling_gpt2.py 是最适合入门的两个文件，对照本文的实现看差异。

如果你在实验过程中需要频繁调用模型来辅助理解代码、生成测试数据或者对比输出，统一端点能省不少事。API Keys 在 https://taotoken.net/console/api-keys 创建，接入文档在 https://taotoken.net/doc 有各语言示例。想先在线试模型效果，模型对话页面 https://taotoken.net/models 可以直接输入 prompt 对比。长期做编码和 Agent 开发的话，Coding Plan 在 https://taotoken.net/coding-plan 有更宽松的配额。

最后分享一个我自己的习惯：每学一个新概念，就写一个最小可运行脚本，打印中间形状和关键值。看懂和跑通是两回事，跑通和能改又是两回事。Transformer 看起来复杂，但拆到每一层都是矩阵乘法和归一化。你把这几个积木搭一遍，再看任何大模型架构都不会慌。