1. 项目概述：从零构建百万参数语言模型

最近在社区里看到不少朋友对大型语言模型（LLM）的内部构造充满好奇，但一看到动辄千亿参数的规模就望而却步，觉得那是只有大厂才能玩的游戏。其实，理解LLM最好的方式不是看论文，而是亲手搭一个。FareedKhan-dev的这个“create-million-parameter-llm-from-scratch”项目，就提供了一个绝佳的切入点。它不是一个玩具，而是一个功能完整、架构清晰、参数规模在百万级别的语言模型实现，麻雀虽小，五脏俱全。

这个项目的核心价值在于“教学性”和“实践性”。它剥离了分布式训练、混合精度、复杂优化器等工业级繁复外衣，将Transformer架构最核心的组件——自注意力机制、前馈网络、层归一化、词嵌入——用清晰、可读的代码呈现出来。通过构建一个百万参数（例如，1.2M或2.5M参数）的模型，你能够亲手触摸到模型训练的每一个环节：从文本的Token化处理，到将Token转换为向量表示，再到模型前向传播计算损失，最后通过反向传播更新每一个参数。这个过程会让你对“语言模型是如何工作的”产生肌肉记忆般的理解。

它适合谁呢？首先，是那些对Transformer和LLM有理论学习基础，但缺乏动手经验的开发者或学生。其次，是希望深入AI模型底层，未来有志于进行模型架构创新或优化的工程师。最后，甚至是对AI有兴趣的资深程序员，想通过一个具体的项目来窥探当今AI技术的核心。你不需要拥有超算集群，一台配备现代GPU（甚至只用CPU，只是慢一些）的个人电脑就能跑起来。接下来，我会带你深入这个项目的每一个细节，从设计思路到代码实现，再到训练技巧和问题排查，让你不仅能复现，更能吃透。

2. 核心架构设计与思路拆解

2.1 为什么选择“百万参数”这个尺度？

构建LLM的第一个决策就是规模。千亿参数模型固然强大，但其训练和调试成本对个人开发者来说是天文数字。百万参数（1M-10M）是一个黄金平衡点。它足够小，可以在个人设备上快速进行训练迭代（几分钟到几小时一个周期），方便你快速实验和调试。同时，它又足够大，能够展现出语言模型的基本能力，比如学习简单的语法规则、词序依赖，甚至在小数据集上完成文本补全或分类任务。

在这个项目中，典型的配置可能是：词汇表大小（vocab_size）设为10,000，模型维度（d_model）为256，Transformer块的数量（n_layers）为6，注意力头数（n_heads）为8。我们来快速估算一下参数量：参数主要来源于词嵌入层、注意力层的QKV投影矩阵、前馈网络的两个线性层以及各层的偏置项。一个粗略的计算是：参数量 ≈ vocab_size * d_model + n_layers * (4 * d_model^2 + 2 * 4 * d_model^2)。代入上述数字，大约在120万到250万之间。这个规模确保了模型具有学习能力，同时又不会让训练过程变得不可控。

注意：这里的“百万参数”是一个教学目标，而非性能指标。它的目的不是达到ChatGPT的水平，而是为了让你理解每一行代码、每一个张量运算如何贡献于最终的语言理解能力。通过调整这些超参数，你可以直观地感受到模型容量（参数量）与学习能力、训练速度、过拟合风险之间的关系。

2.2 Transformer解码器架构的精简与实现

现代大语言模型大多基于Transformer的解码器（Decoder-Only）架构，比如GPT系列。本项目也遵循这一范式。为什么是解码器而不是完整的编码器-解码器？因为对于生成式语言模型任务（预测下一个词），我们只需要解码器的自回归（Auto-Regressive）特性。它通过掩码（Mask）确保在预测当前位置的词时，只能看到它之前的词，这完美契合了文本生成的场景。

项目的核心是一个由多个相同的“块”（Block）堆叠而成的模型。每个块内部包含两个核心子层：

  1. 多头自注意力层（Multi-Head Self-Attention） ：这是Transformer的灵魂。它允许序列中的每个位置（词）去“关注”序列中所有之前的位置，并根据相关性动态地聚合信息。实现的关键在于“缩放点积注意力”（Scaled Dot-Product Attention）和将模型维度分割成多个“头”（Head）以并行学习不同的关注模式。
  2. 前馈网络层（Feed-Forward Network） ：这是一个简单的两层全连接网络，通常中间有一个扩展维度（例如，d_model * 4）。它为每个位置独立地进行非线性变换，为模型增加表达能力和复杂性。

每个子层后面都紧跟着“残差连接”（Add）和“层归一化”（LayerNorm）。残差连接让梯度更容易流动，缓解了深层网络训练中的梯度消失问题。层归一化则稳定了每一层的输入分布，加速训练收敛。这是构建深层模型稳定训练的关键技巧。

2.3 训练目标与数据流设计

语言模型的训练目标是标准的“下一个词预测”（Next Token Prediction）。给定一个词序列（例如，“今天天气真”），模型的任务是预测出序列的下一个词（例如，“好”）。在技术实现上，这通过“交叉熵损失”（Cross-Entropy Loss）来完成。

具体的数据流如下：

  1. 文本预处理 ：将原始文本（比如一本小说或一堆维基百科文章）分割成较短的、固定长度的序列（例如，长度为256的文本块）。
  2. Token化 ：使用一个分词器（Tokenizer，如BPE或WordPiece，本项目可能实现一个简单的基于字符或子词的分词器）将文本序列转换为整数ID序列。
  3. 构造输入-目标对 ：对于序列 [x1, x2, x3, ..., xT] ，输入模型的是 [x1, x2, ..., xT-1] ，而训练的目标（标签）是 [x2, x3, ..., xT] 。模型在位置 i 的输出，经过一个线性投影层（通常与词嵌入层共享权重）后，会得到一个对整个词汇表大小的概率分布，我们期望这个分布中，对应 x_{i+1} 这个ID的概率尽可能高。
  4. 前向与反向传播 ：模型计算每个位置的预测分布，与真实的下一个词ID计算交叉熵损失，然后平均得到整个批次（Batch）的损失。通过反向传播算法（Backpropagation），损失梯度会流经模型的所有层，最终更新每一个可训练参数。

这个流程是理解语言模型训练的基石。在项目中，你会清晰地看到数据是如何一步步从文本变成损失值，再驱动模型参数更新的。

3. 关键组件实现细节与源码解析

3.1 词嵌入与位置编码：模型的“眼睛”和“记忆”

模型接收的输入是整数ID，但计算机无法直接理解整数。词嵌入层（Embedding Layer）的作用就是将每个ID映射为一个高维的、稠密的向量（例如，256维）。你可以把这个向量理解为这个词在模型“语义空间”中的坐标。语义相近的词，其向量在空间中的距离也应该较近。这个嵌入矩阵的形状是 [vocab_size, d_model] ，它是模型中最大的可训练参数块之一。

然而，标准的神经网络（如全连接层）本身不具备处理序列顺序的能力。为了注入序列中词的位置信息，我们需要位置编码（Positional Encoding）。Transformer原论文使用了正弦和余弦函数来生成固定位置编码。在本项目中，为了实现简单和可学习性，更常见的做法是使用一个可学习的位置嵌入矩阵，其形状为 [max_seq_len, d_model] 。对于序列中第 pos 个位置的词，我们将它的词嵌入向量与第 pos 行的位置嵌入向量相加，作为Transformer块的输入。这样，模型就能同时知道“是什么词”和“在什么位置”。 

# 伪代码示例：词嵌入与位置编码的相加
import torch
import torch.nn as nn

class EmbeddingsWithPE(nn.Module):
    def __init__(self, vocab_size, d_model, max_seq_len):
        super().__init__()
        self.token_embedding = nn.Embedding(vocab_size, d_model)
        self.position_embedding = nn.Embedding(max_seq_len, d_model)
        self.max_seq_len = max_seq_len

    def forward(self, token_ids): # token_ids shape: [batch_size, seq_len]
        seq_len = token_ids.size(1)
        positions = torch.arange(seq_len, device=token_ids.device).unsqueeze(0) # [1, seq_len]
        # 获取词嵌入和位置嵌入
        token_embeds = self.token_embedding(token_ids) # [batch, seq, d_model]
        pos_embeds = self.position_embedding(positions) # [1, seq, d_model]
        # 相加作为最终输入
        return token_embeds + pos_embeds

3.2 自注意力机制：模型理解上下文的核心

自注意力机制是Transformer最具革命性的设计。它的核心思想是：序列中的每个词，都可以通过计算与序列中所有词（在解码器中是之前的所有词）的“相关性分数”，来动态地决定应该从其他词那里吸收多少信息。

缩放点积注意力（Scaled Dot-Product Attention） ：

  1. 对于输入序列 X （形状 [batch, seq, d_model] ），我们通过三个不同的线性变换得到查询（Query, Q）、键（Key, K）、值（Value, V）矩阵。
  2. 计算注意力分数： Attention(Q, K, V) = softmax( (Q * K^T) / sqrt(d_k) ) * V 。这里 d_k 是每个注意力头的维度（ d_model / n_heads ）。
  3. 除以 sqrt(d_k) 是为了在 d_k 较大时，防止点积结果过大导致softmax函数梯度消失。
  4. 对于解码器，我们需要一个上三角掩码（Mask），将其加到 (Q * K^T) 上，使得当前位置无法“看到”未来的词。通常是将未来位置的值设为负无穷（ -1e9 ），这样经过softmax后，未来位置的权重就为0。

多头注意力（Multi-Head Attention） ： 单一的注意力机制可能只关注一种类型的依赖关系（例如语法依赖）。多头注意力将 d_model 维度的Q、K、V投影到 n_heads 个不同的、维度为 d_k 的子空间，在每个子空间里并行地执行注意力计算，最后将结果拼接起来再投影回 d_model 维度。这允许模型同时关注来自不同表示子空间的信息。 

# 伪代码示例：带掩码的多头注意力实现核心
import torch.nn.functional as F

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) # [batch, heads, seq, seq]
    if mask is not None:
        scores = scores.masked_fill(mask == 0, -1e9) # 将mask为0的位置填充为负无穷
    attn_weights = F.softmax(scores, dim=-1) # 在最后一个维度（seq）上做softmax
    output = torch.matmul(attn_weights, v) # [batch, heads, seq, d_k]
    return output, attn_weights

# 在Transformer块中，通常会这样调用：
# 假设 x 是输入，形状 [batch, seq, d_model]
# 1. 线性投影得到 q, k, v，并重塑为多头
batch_size, seq_len, d_model = x.shape
q = self.w_q(x).view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2)
k = self.w_k(x).view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2)
v = self.w_v(x).view(batch_size, seq_len, self.n_heads, self.d_k).transpose(1, 2)
# 2. 创建因果掩码（下三角为1，上三角为0）
causal_mask = torch.tril(torch.ones(seq_len, seq_len)).view(1, 1, seq_len, seq_len)
# 3. 计算注意力
attn_output, _ = scaled_dot_product_attention(q, k, v, mask=causal_mask)
# 4. 重塑并投影回原维度
attn_output = attn_output.transpose(1, 2).contiguous().view(batch_size, seq_len, d_model)
attn_output = self.out_projection(attn_output)

3.3 前馈网络与归一化层：稳定与非线性

前馈网络（FFN）相对简单，但不可或缺。它通常由两个线性层和一个非线性激活函数（如GELU或ReLU）组成，中间有一个扩展因子（例如4倍）。公式为： FFN(x) = W2 * GELU(W1 * x + b1) + b2 。它为每个位置的表示增加了非线性和模型容量。虽然它独立处理每个位置，但得益于前面的注意力层已经混合了全局信息，FFN可以基于丰富的上下文信息进行变换。

层归一化（LayerNorm）和残差连接是训练深层模型的稳定器。每个子层（注意力、FFN）的输出在传递给下一层之前，都会先与子层的输入相加（残差连接），然后再进行层归一化： LayerNorm(x + Sublayer(x)) 。这里的顺序在原始Transformer论文和后续实践中有所不同（Pre-Norm vs Post-Norm）。在本项目中，为了训练稳定性，很可能采用 Pre-Norm 结构，即先对输入进行归一化，再送入子层： x = x + Sublayer(LayerNorm(x)) 。Pre-Norm通常能让梯度流动更顺畅，更容易训练深层模型。

4. 从零开始的完整训练流程实操

4.1 数据准备与预处理流水线

模型的好坏，一半取决于数据。对于语言模型，我们需要大量、干净、连续的文本数据。开源数据集如WikiText-2/103、OpenWebText的子集、或者你感兴趣的特定领域文本（如代码、小说）都是不错的选择。数据预处理流程如下：

  1. 文本清洗 ：移除或替换非标准UTF-8字符、过多的空白符、HTML标签等。确保文本是纯正的、可读的自然语言。
  2. 训练分词器（Tokenizer） ：如果你不使用现成的分词器（如tiktoken），可以基于你的训练数据训练一个简单的BPE（Byte Pair Encoding）或WordPiece分词器。这会将文本分割成子词单元，能有效处理未登录词（OOV）。对于百万参数模型，词汇表大小建议在5k到10k之间。
  3. 数据集构建 ：将整个文本语料库通过分词器转换成ID序列。然后，将这个长序列切割成许多个固定长度（如256）的片段。这些片段就是模型的一个个训练样本。同时，需要生成对应的“目标”序列（即输入序列向右偏移一位）。
  4. 创建DataLoader ：使用PyTorch的 Dataset 和 DataLoader 来组织数据。设置合适的批大小（Batch Size）。对于百万参数模型，在8GB显存的GPU上，批大小设为32或64通常是可行的。 DataLoader 会自动将多个样本打包成一个批次张量。

实操心得：数据质量至关重要。如果数据噪声大（如充满乱码、广告），模型会学到垃圾。在训练初期，可以先用一个极小的数据集（如几MB）快速跑通整个流程，验证代码正确性，这能节省大量调试时间。

4.2 模型初始化、损失函数与优化器选择

模型搭建好后，需要正确初始化参数。常用的初始化方法有Xavier均匀初始化或Kaiming（He）初始化。在PyTorch中，可以自定义一个初始化函数，遍历所有模块进行初始化。 

def init_weights(module):
    if isinstance(module, nn.Linear):
        nn.init.xavier_uniform_(module.weight)
        if module.bias is not None:
            nn.init.zeros_(module.bias)
    elif isinstance(module, nn.Embedding):
        nn.init.normal_(module.weight, mean=0.0, std=0.02)

model.apply(init_weights)

损失函数 ：语言模型的标准损失是交叉熵损失（CrossEntropyLoss）。PyTorch的 nn.CrossEntropyLoss 非常方便，它内部已经包含了softmax操作。我们需要将模型输出的形状从 [batch, seq, vocab_size] 调整为 [batch*seq, vocab_size] ，并将目标标签的形状从 [batch, seq] 调整为 [batch*seq] ，再送入损失函数。

优化器 ：AdamW优化器是目前训练Transformer模型的事实标准。它相比原始Adam加入了权重衰减（Weight Decay）的正确实现，能更好地防止过拟合。学习率（Learning Rate）是关键超参数。通常会使用一个带有热身（Warmup）的学习率调度器。例如，在前几步训练中，学习率从0线性增长到设定的峰值，然后在后续训练中按余弦函数衰减到0。这有助于训练初期稳定，后期精细调优。 

import torch.optim as optim
from torch.optim.lr_scheduler import LambdaLR

optimizer = optim.AdamW(model.parameters(), lr=6e-4, betas=(0.9, 0.95), weight_decay=0.1)

# 简单的线性Warmup调度器
def get_lr_scheduler(optimizer, warmup_steps, total_steps):
    def lr_lambda(current_step):
        if current_step < warmup_steps:
            return float(current_step) / float(max(1, warmup_steps))
        # 余弦衰减
        progress = float(current_step - warmup_steps) / float(max(1, total_steps - warmup_steps))
        return max(0.0, 0.5 * (1.0 + math.cos(math.pi * progress)))
    return LambdaLR(optimizer, lr_lambda)

scheduler = get_lr_scheduler(optimizer, warmup_steps=1000, total_steps=total_training_steps)

4.3 训练循环与关键监控指标

训练循环是核心驱动引擎。一个典型的训练步骤包括：

  1. 从 DataLoader 获取一个批次的输入ID和目标ID。
  2. 将输入ID送入模型，得到预测logits。
  3. 计算预测logits和目标ID之间的交叉熵损失。
  4. 将优化器的梯度清零（ optimizer.zero_grad() ）。
  5. 执行反向传播（ loss.backward() ）。
  6. 可选地，进行梯度裁剪（ torch.nn.utils.clip_grad_norm_ ），防止梯度爆炸。
  7. 优化器更新参数（ optimizer.step() ）。
  8. 学习率调度器更新（ scheduler.step() ）。

关键监控指标 ：

  • 训练损失（Training Loss） ：这是最直接的指标。它应该随着训练步数稳步下降。如果损失不降反升，可能是学习率太高、数据有问题或模型实现有bug。
  • 验证损失（Validation Loss） ：定期在模型未见过的验证集上计算损失。训练损失下降但验证损失上升，是过拟合的典型标志。
  • 困惑度（Perplexity, PPL） ：这是评估语言模型的更直观指标。它等于指数级的交叉熵损失（ exp(loss) ）。困惑度越低，说明模型对下一个词的预测越确定、越好。一个随机猜测的模型的困惑度等于词汇表大小。一个训练良好的小型模型在简单数据集上的困惑度可能降到几十甚至十几。
  • 生成样本（Generated Samples） ：定期让模型根据一个提示（prompt）生成一段文本。这是最直观的定性评估方式。观察生成的文本是否通顺、是否符合语法、是否与上下文相关。

在训练百万参数模型时，由于规模小，你可能在几千到几万步内就能看到损失明显下降，并开始生成有意义的文本片段。这是非常有成就感的一刻。

5. 实战中常见问题、调试技巧与优化策略

5.1 损失不下降或出现NaN/Inf

这是训练初期最常见的问题。

  • 检查数据 ：首先确保你的输入数据（Token ID）在合理的范围内（0到vocab_size-1）。打印几个样本看看。
  • 检查初始化 ：错误的初始化（如权重全为0或过大）会导致梯度问题。使用标准的初始化方法。
  • 学习率过高 ：这是首要怀疑对象。尝试将学习率降低一个数量级（例如从1e-3降到1e-4）开始训练。使用Warmup策略能有效避免初期的不稳定。
  • 梯度爆炸 ：在反向传播后，打印或记录梯度的范数。如果梯度范数非常大（如超过10），就需要进行梯度裁剪。 clip_grad_norm_(model.parameters(), max_norm=1.0) 是一个常用设置。
  • 损失函数输入 ：确保你传递给交叉熵损失函数的logits和labels形状正确，且labels不包含padding token的ID（如果使用了padding）。
  • 数值稳定性 ：在softmax计算中，如果输入值极大，可能导致溢出。确保缩放点积注意力中的除以 sqrt(d_k) 操作正确执行。在计算交叉熵时，PyTorch的 CrossEntropyLoss 内部已经做了数值稳定处理，通常没问题。

5.2 模型过拟合与泛化能力提升

当训练损失很低但验证损失很高时，就是过拟合了。

  • 增加数据量 ：这是最根本的方法。如果数据有限，可以尝试文本数据增强，如随机删除、交换词语（需谨慎，可能破坏语法）。
  • 正则化 ：
    • Dropout ：在Transformer的FFN层内部、注意力权重之后添加Dropout是有效的。Dropout率通常在0.1到0.3之间。
    • 权重衰减（Weight Decay） ：AdamW优化器中已经包含了。确保你设置了一个非零的值（如0.1）。
    • 标签平滑（Label Smoothing） ：在计算交叉熵损失时，不将真实标签设为1，而是设为略小于1的值（如0.9），将其他标签设为一个小正值。这可以防止模型对训练数据过于自信。
  • 简化模型 ：如果数据量确实很小，可以考虑减少模型层数（ n_layers ）或维度（ d_model ），降低模型容量。
  • 早停（Early Stopping） ：持续监控验证损失，当其在连续多个评估周期内不再下降时，停止训练，并回滚到验证损失最低的模型 checkpoint。

5.3 训练效率与性能优化

在个人设备上训练，效率很重要。

  • 混合精度训练（AMP） ：使用PyTorch的自动混合精度（ torch.cuda.amp ）可以大幅减少GPU显存占用并加速训练。它通过将部分计算（如线性层）转换为半精度（float16）来实现，同时用动态损失缩放来保持梯度精度。 
    from torch.cuda.amp import autocast, GradScaler
scaler = GradScaler()
for data in dataloader:
    optimizer.zero_grad()
    with autocast():
        logits = model(data.input)
        loss = criterion(logits.view(-1, logits.size(-1)), data.target.view(-1))
    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()
  • 梯度累积（Gradient Accumulation） ：如果你的GPU显存不足以支持想要的批大小，可以通过梯度累积来模拟更大的批大小。例如，设置 accumulation_steps=4 ，每4个前向-反向步骤才真正更新一次参数（ optimizer.step() ），相当于将有效批大小扩大了4倍。注意，在每一步（ accumulation_steps 内）需要调用 scaler.scale(loss/accumulation_steps).backward() 来累加梯度。
  • 检查点（Checkpoint）保存 ：定期保存模型的状态字典和优化器状态。这不仅可以用于恢复训练，还可以在训练中途对不同的checkpoint进行生成测试，观察模型能力的演进。
  • 使用 torch.compile （PyTorch 2.0+） ：如果使用较新版本的PyTorch，可以用 model = torch.compile(model) 来对模型进行图编译，这通常能带来一次性的前向/反向传播速度提升。

5.4 生成文本质量差与解码策略

训练完成后，用模型生成文本是终极测试。如果生成结果杂乱无章，可能是以下原因：

  • 训练不充分 ：模型还没有学到足够的语言规律。继续训练，观察验证损失是否还有下降空间。
  • 解码策略单一 ：直接选择概率最高的词（贪心搜索）往往会导致重复、乏味的文本。
  • 采样温度（Temperature） ：在将模型输出的logits转换为概率前，除以一个温度参数T。T=1为标准softmax；T>1会平滑概率分布，增加随机性（更有创意但可能不合逻辑）；T<1会锐化分布，使高概率词更高（更确定但更保守）。通常设置在0.7到1.0之间尝试。
  • Top-k / Top-p（核）采样 ：
    • Top-k采样 ：只从概率最高的k个候选词中采样。这避免了选择那些概率极低的生僻词。
    • Top-p采样（核采样） ：从累积概率超过p的最小候选词集合中采样。这能动态调整候选词的数量，比固定的Top-k更灵活。 结合温度调节和Top-p采样是当前获得高质量、多样性文本的常用方法。 
def generate_text(model, prompt, max_len=50, temperature=0.8, top_p=0.9):
    model.eval()
    tokens = tokenizer.encode(prompt)
    for _ in range(max_len):
        with torch.no_grad():
            logits = model(torch.tensor([tokens[-block_size:]])) # 只取最后block_size个token
        logits = logits[:, -1, :] / temperature # 取最后一个位置的logits并应用温度
        probs = F.softmax(logits, dim=-1)
        # Top-p采样
        sorted_probs, sorted_indices = torch.sort(probs, descending=True)
        cumulative_probs = torch.cumsum(sorted_probs, dim=-1)
        sorted_indices_to_remove = cumulative_probs > top_p
        sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
        sorted_indices_to_remove[..., 0] = 0
        indices_to_remove = sorted_indices[sorted_indices_to_remove]
        probs[0, indices_to_remove] = 0
        probs = probs / probs.sum() # 重新归一化
        next_token = torch.multinomial(probs, num_samples=1).item()
        tokens.append(next_token)
        if next_token == tokenizer.eos_token_id: # 遇到结束符则停止
            break
    return tokenizer.decode(tokens)

构建一个百万参数的语言模型就像亲手搭建一台精密的机械钟表，你能看清每一个齿轮（模块）是如何咬合，最终驱动指针（生成文本）的。这个过程会极大地深化你对深度学习、自然语言处理乃至当前AI浪潮底层逻辑的理解。它剥离了黑箱，赋予了掌控感。当你看到自己从零开始敲出的代码，经过几个小时的训练后，能结结巴巴地续写你给出的句子时，那种成就感是无可替代的。这个项目是一个起点，从这里出发，你可以尝试增加参数、更换架构（如Rotary Position Embedding, SwiGLU激活函数）、在更大数据集上训练，甚至尝试微调（Fine-tuning）来完成特定任务。真正的乐趣，始于动手之后。

# 语言模型
Logo
乐奇 Rokid 开放社区

更多推荐

在 Rokid AI Glasses 上做背单词应用：AIUI拍照听写的实现

分享在 Rokid AI Glasses 上用 AIUI 开发背单词应用的实践：从镜腿单击拍照、图片编码和多模态识别，到切题时的异步任务处理、语音调度与学习进度保存，结合关键代码和界面动图说明实现过程。

avatar 乐奇 Rokid 开放社区
cover

极刻觅镜 | AI眼镜周报｜智能眼镜周报：销售高增长、标准落地与新品密集发布

avatar 乐奇 Rokid 开放社区
cover

极刻觅镜 | AI眼镜日报｜Rokid无人店落地香港，中科创达发布Veda平台

avatar 乐奇 Rokid 开放社区