大语言模型简介

引言

什么是大语言模型？回答这个问题之前，让我们先从熟悉的事物开始。想象一下，你在手机上编写短信。输入几个字后，手机会建议下一个词——有时它足够准确，你只需点击建议就能继续输入。这个预测文本功能就是一个非常简单的语言模型。大语言模型（LLM）的基本原理与此相同，但规模要大得多。

LLM 是基于海量文本——书籍、文章、网站、代码等——训练的神经网络。在这个训练过程中，模型阅读了数十亿个句子，学习词汇和短语之间的统计关系。它发现了诸如：某些词出现时，什么词往往会跟着出现；句子是如何组织的；上下文如何改变含义；以及不同的信息片段如何相互关联。一旦训练完成，模型就可以根据你提供的提示，生成连贯的、符合上下文的文本。

"大"语言模型中的"大"同时指两件事。首先是训练数据的规模——现代 LLM 训练的数据集包含数千亿到数万亿个 token（一个 token 大约是一个词或词的一部分）。其次是模型本身——这些模型包含数十亿个参数，这些内部数值编码了模型学到的所有内容。例如，一个拥有 70 亿参数的模型，其 70 亿个可调数字共同代表它对语言的理解。

为什么这对作为 Jetson 开发者的你很重要？直到最近，运行这种规模的模型需要配备多个高端 GPU 的昂贵云服务器。过去两年最大的突破是，像量化这样的技术——压缩模型的数值精度——现在使得在 NVIDIA Jetson Orin Nano 和 Orin NX 等边缘设备上运行能力强大的 LLM 成为可能。这意味着你可以构建完全离线运行的 AI 应用程序，保持数据私密，无需依赖互联网连接。

LLM 工作原理

现在你了解了什么是 LLM，自然的问题是：它实际上是如何生成文本的？答案围绕一个核心操作——预测序列中的下一个 token。

Token：构建块

在讨论模型如何生成文本之前，我们需要澄清将文本处理为"token"的含义。LLM 不像人类那样阅读原始文本。相反，分词器（tokenizer）将你的输入分解成称为 token 的更小单元。一个 token 可能是"computer"这样的完整词，也可能是"the"这样的常见词片段，甚至可能是不熟悉语言中的单个字符。例如：

"The reComputer runs Linux"
→ ["The", " re", "Computer", " runs", " Linux"]   (5 个 token)

分词器的词汇表通常包含 30,000 到 100,000 个 token。模型看到的所有文本在处理之前都会转换为这些 token 的序列。

训练过程

训练 LLM 涉及三个关键阶段，每个阶段都建立在前一个阶段的基础上：

阶段 1 — 原始文本预训练。 模型被喂入大量文本（常见来源包括 Common Crawl、Wikipedia、GitHub 仓库和已出版的书籍）。在这个阶段，模型的任务看似简单：给定一个 token 序列，预测下一个 token。例如，当模型看到"The Eiffel Tower is located in"时，它了解到"Paris"是最可能的下一个 token。通过在数十亿个例子上重复这个练习，模型逐渐构建了语法、事实、推理模式甚至编程逻辑的内部表示。

阶段 2 — 监督微调（SFT）。 预训练后，模型拥有广泛的知识，但不知道如何作为一个有用的助手行事。在这个阶段，人工标注员创建高质量提示-响应对的示例。模型在这些示例上进行训练，以学习有帮助响应的格式和风格。

阶段 3 — 对齐（RLHF 或类似方法）。 在最后阶段，人工评估员将多个模型响应从最佳到最差排序。这种反馈训练了一个奖励模型，进而引导 LLM 产生更有帮助、更无害、更诚实的响应。这就是为什么现代聊天模型比仅靠预训练阶段产生的答案更连贯、更有用的原因。

推理：一次生成一个 Token 的文本

训练完成后，模型通过称为推理的过程生成文本。以下是你输入提示时发生的情况：

分词器将其转换为 token ID。模型处理这些 token，并对其词汇表中所有 token 产生概率分布。token"Paris"获得最高概率，因此被选中并附加到输出中。更新后的序列现在是"The capital of France is Paris"，模型重复这个过程——再次预测下一个 token。这个过程一直持续，直到模型输出一个特殊的序列结束 token，或达到最大长度限制。

步骤 1："The capital of France is"         → 预测 "Paris"
步骤 2："The capital of France is Paris"    → 预测 "and"
步骤 3："The capital of France is Paris and"→ 预测 " the"
步骤 4：...继续直到完成

一个值得理解的关键点：模型不像数据库查找那样"知道"答案。它根据其训练数据生成统计上可能的文本。这就是为什么 LLM 有时会生成听起来合理但实际错误的陈述——这是你在构建应用程序时应记住的一个限制。

整个过程——从你的提示到完整响应——就是每次与 LLM 交互时发生的情况。在下一节中，我们将了解使这一切成为可能的特定神经网络架构。

_{大语言模型如何处理和生成文本}

Transformer 架构

几乎所有现代 LLM 都基于 Transformer 架构，该架构在 2017 年 Google 研究人员发表的里程碑论文"Attention Is All You Need"中首次提出。这篇论文从根本上改变了 AI 的发展轨迹——你将在 Jetson 上运行的模型（Llama、Qwen、DeepSeek、Gemma）都是这个架构的直接后代。

关键创新是 自注意力机制，它允许模型在处理文本时权衡不同词的重要性——使其能够以前所未有的水平理解上下文、关系和含义。

_{Transformer：现代 LLM 的基础}

从顺序到并行：为什么 Transformer 胜出

在 Transformer 出现之前，RNN（循环神经网络）和 LSTM 等模型一次处理一个词，从左到右顺序处理。这导致了两个主要问题：

1. 慢：每个词依赖于前一个词的计算——无法并行
2. 健忘：当模型到达第 100 个词时，它已经基本"忘记"了第 1 个词

RNN（旧）：     "The" → "cat" → "sat" → "on" → "the" → "mat"   （慢，顺序）
Transformer:    ["The", "cat", "sat", "on", "the", "mat"] → 同时处理！   （快，并行）

Transformer 通过自注意力同时处理所有词解决了这两个问题。这使得训练速度大大提高，并使模型能够有效地捕获长距离关系。

自注意力如何工作

自注意力是 Transformer 的核心创新。让我们通过一个具体的例子来理解它。

现实世界的类比——招聘选拔过程：

想象你正在招聘一个职位，收到了 5 份简历。你需要通过与"职位描述"（你在寻找什么）比较来评估每个候选人。以下是自注意力的工作方式：

• 每份简历既是候选人又是职位描述——听起来很奇怪，但自注意力正是这样对待句子中的每个词的
• 用于评估候选人 A 的"职位描述"称为 Query（查询，Q）
• 每份简历都有"资质"部分——这些是 Key（键，K）
• 实际的简历内容（经验、技能、教育）是 Value（值，V）

现在想象你想弄清楚句子中的 "it" 指什么：

"The robot picked up the ball because it was heavy."

以下是逐步过程：

步骤 1：为每个词生成 Q/K/V

句子中的每个词生成自己的 Query、Key 和 Value 向量。可以把它想象成每个词同时准备"搜索问题"和"分享内容"：

步骤 2：计算相关性分数——点积

对于"it"这个词，我们取它的 Query 向量并与所有其他词的 Key 向量计算点积：

"it" Query × "robot" Key = 0.2（低相关性——在这个上下文中，机器人通常不被描述为重的）
"it" Query × "picked" Key = 0.1（不相关——"picked" 与重量无关）
"it" Query × "ball" Key = 0.9（高相关性——球肯定可以很重！）

步骤 3：应用 softmax 归一化

这些原始分数通过 softmax，转换为总和为 1 的概率：

"ball":  0.82（82% — "it" 最可能指"ball"）
"robot": 0.15（15%）
"picked": 0.03（3%）

步骤 4：值的加权求和

现在我们使用这些权重组合所有 Value 向量：

新的 "it" 表示 = 0.82 × ball.Value + 0.15 × robot.Value + 0.03 × picked.Value

结果呢？"it"这个词现在"知道"它指的是球，并将这个含义向前传递。

步骤 5：每个词都重复此过程

这个过程对句子中的每个词同时发生。"robot"查看"ball"、"picked"等以理解其上下文。"ball"查看"robot"和"picked"。每个人通过 Query-Key-Value 机制同时"查看"彼此。

数学原理：

这个过程可以写成：

其中 dₖ 是向量维度，√dₖ 是一个缩放因子，防止点积计算时数字变得过大。关键不是公式本身，而是：每个词计算其他每个词与自己的相关性，然后相应地收集信息。

_{自注意力：词与词之间的相互关注}

多头注意力

在上一节中，你看到了自注意力如何让每个词查看所有其他词并计算相关性分数。结果是一组新的向量，每个词已经混合了它所关注的词中的上下文。这很强大，但有一个限制：单次注意力只能捕获一种类型的关系。

考虑"The robot picked up the ball because it was heavy。""it"和"ball"之间的联系（代词指代）和"robot"和"picked"之间的联系（主谓）是两种根本不同类型的关系。单次注意力计算可以发现一种，但要同时捕获多种关系类型，你需要并行运行多次注意力。

多头注意力正是这样做的。想法很简单：不要只运行一次注意力，而是并行运行多次，让每个"头"学习自己独立的关系模式。

具体来说，每个头都有自己独立的 Q、K、V 权重矩阵集。这意味着对于同一个词，每个头将其映射到不同的Q、K、V 向量，导致它关注不同的其他词。处理同一个句子的四个头就像四个观察者透过不同颜色的滤镜看，每个看到句子的不同"方面"：

句子：[The] [robot] [picked] [up] [the] [ball] [because] [it] [was] [heavy]

头 1（语法）：      robot ↔ picked   picked ↔ up
头 2（邻近性）：    the ↔ robot      picked ↔ up
头 3（语义）：      heavy ↔ ball     robot ↔ machine
头 4（指代）：      it ↔ ball

所有四个头同时运行，每个产生自己的注意力输出。四个输出然后被拼接并通过线性变换合并成单一的统一输出：

   头 1（语法）    头 2（邻近性）    头 3（语义）    头 4（指代）
        ↓               ↓               ↓               ↓
   [输出 1]        [输出 2]         [输出 3]         [输出 4]
        ↓               ↓               ↓               ↓
                      拼接 + 线性变换
                              ↓
              [携带所有四种类型信息的统一输出]

这个统一输出同时携带所有四个维度的关系信息，准备好进入下一网络层。这就是为什么 Transformer 如此深入地理解语言——它们不是从单一角度看待句子，而是并行地从多个维度分析它。

Transformer 块结构

你现在理解了多头注意力的核心：通过多个并行注意力头，每个词可以同时从语法、语义和指代角度理解句子。但注意力并不是全部。Transformer 模型是通过将许多相同的块堆叠在一起来构建的——例如 Llama 3.2 3B 堆叠了 28 个。这些构建块称为 Transformer 块，每个都遵循相同的内部流程。

阶段 1 — 多头自注意力。 如你所知，每个词查看所有其他词，通过 Query-Key 匹配计算相关性分数，并从最相关的邻居收集信息。输出是每个词的新表示，现在携带了整个句子的上下文信息。

阶段 2 — 前馈网络（FFN）。 在注意力为每个词丰富了上下文之后，FFN 独立地处理每个词。把它想象成一个小型两层神经网络，它的工作是问："既然我知道了上下文，我可以从这个词中提取哪些更深层的特征？"FFN 存储了模型"知识"的惊人数量——它充当每个词的推理引擎。

在这两个阶段之间和周围，有两个重要的保障机制保持深度网络可训练：

• 残差连接（Add）： 在注意力和 FFN 阶段之后，原始输入被加回到输出中。这就像给电器安装保险丝——即使中间模块产生了不完美的结果，原始信息也永远不会丢失。没有这个机制，在 28 层的堆叠中，训练信号（梯度）在反向传播时会衰减到接近零，模型将完全无法学习。

• 层归一化： 在残差相加之后，所有值都被重新缩放到稳定范围。把它想象成电路中的稳压器——它防止信号在通过 28 个连续放大阶段后"爆炸"。

关键的洞察是 每个连续的块都构建更深层次的抽象。早期块捕获基本语法——哪些词是邻居，哪些词是主语或宾语。中层块开始组装语义——"the ball"是一个名词短语，"was heavy"是一个描述。到最后的块时，模型已经构建了对整个输入的丰富、多层理解，准备好进行准确的下一个 token 预测。

编码器与解码器

"Attention Is All You Need"（2017）中描述的原始 Transformer 架构实际上有两半，每个都有不同的工作。理解这种分离有助于解释为什么现代 LLM 是这样构建的。

编码器——读者。 编码器的工作是一次看完整个输入句子，并构建对上下文中每个词的深入理解。它使用双向注意力——意味着每个词可以查看所有其他词，包括左边和右边的。因为它同时看到完整句子，编码器擅长理解任务：总结段落、分类情感或提取文档的主题。BERT 是最著名的纯编码器模型，Qwen 和 Gemma 也提供编码器变体。

解码器——写作者。 解码器的工作根本不同：它一次生成一个 token，从左到右。它使用掩码自注意力，这意味着在预测第三个词时，它只能看到第一个和第二个词——永远看不到未来。这种强制的盲区是必不可少的：如果模型可以"作弊"偷看答案，它就永远不会学会自己生成。GPT、Llama 和 DeepSeek 都使用这种纯解码器架构。

编码器-解码器——两者结合。 有些任务需要同时理解和生成：例如，将句子从英语翻译成中文，需要首先阅读整个英语句子（编码器），然后逐词生成中文翻译（解码器）。Whisper（你之前在本章中遇到的语音识别模型）使用这种组合架构。

现代 LLM 如 Llama、GPT、Qwen 和 DeepSeek 选择纯解码器的原因很简单：在足够数据上训练的解码器学会同时理解和生成文本。当它预测下一个 token 时，它必须隐含地理解之前的所有内容——而这种隐含的理解足以完成范围惊人的各种任务。

位置编码：知道词的顺序

在前几节中，你看到了自注意力如何让每个词查看所有其他词并计算相关性分数。但有一个容易忽略的微妙之处：注意力不知道词出现的顺序。它计算所有词对之间的相关性，但计算完全独立于位置。

这意味着如果你把"The cat chased the dog"和"The dog chased the cat"输入模型，从注意力的角度来看，计算是完全相同的——两个句子包含完全相同的词，只是顺序不同。这显然是行不通的：重新排列相同的词会完全改变含义。

位置编码正是为解决这个问题而设计的。想法很直观：在每个词的向量输入注意力之前，添加一个位置指纹——一个数学上精心设计的向量，其唯一目的是说"这个词在这个位置"。把它想象成电影院里的座位号：座位号告诉你电影是什么，但它让你始终能区分第 3 排第 5 座和第 10 排第 2 座。

在实践中，每个位置的指纹使用正弦和余弦函数生成：

位置 0："What"   + [0.00, 1.00, 0.00, 1.00, ...]
位置 1："is"     + [0.84, 0.54, 0.84, 0.54, ...]
位置 2："Jet"    + [0.91, -0.42, 0.91, -0.42, ...]

为什么用正弦和余弦？因为相邻位置总是产生略有不同的指纹值，这些值是连续的（不是简单的整数 0、1、2）。这意味着即使模型只在最长 100 个位置的句子上训练，它也可以泛化到 200 个位置的句子——位置编码的"节奏"是可预测和规则的。

Llama 和 Qwen 等现代模型已升级到 RoPE（旋转位置嵌入）。RoPE 不是添加位置值，而是根据其位置将每个词的向量在高位空间中旋转一个角度。这带来了额外的好处：两个词之间的相对距离（它们相距多少个位置）直接反映在它们旋转向量之间的角度差异中，而不仅仅是它们的绝对位置。这使得模型在处理不同长度的文本时更加稳定和灵活。

逐步解析：Transformer 如何处理文本

现在你已经学习了 Transformer 的所有核心组件，让我们通过一个完整的例子来追踪它们是如何协同工作的。我们将跟随这个问题："What is Jetson?"

步骤 1 — 分词 原始输入文本被分割成 token（通常是子词片段）：

步骤 2 — 嵌入 每个 token 被转换为高维数值向量。例如，Llama 3.2 3B 为每个 token 生成 3072 维向量：

"What" → [0.23, -0.45, 0.67, ..., 0.12]   (3072 个数字)
"is"   → [0.12, 0.89, -0.34, ..., 0.56]
"Jet"  → [0.78, 0.11, 0.56, ..., -0.33]
"son"  → [0.45, -0.23, 0.91, ..., 0.78]
"?"    → [0.67, 0.34, -0.12, ..., 0.45]

步骤 3 — 添加位置编码 每个 token 的嵌入加上位置编码向量，赋予模型词序意识，如上一节详细解释的那样。

步骤 4 — 自注意力（重复 N 层） 模型计算所有 token 之间的注意力分数以找到关系：

"What" 最关注：   "?" (0.5)、"Jet" (0.4)、"is" (0.3)
"is"  最关注：   "What" (0.4)、"Jetson" (0.5)
"Jet" 最关注：   "son" (0.8)、"is" (0.3)

注意力之后，每个 token 的表示现在包含它所关注的词的信息。

步骤 5 — 前馈网络 每个 token 的丰富表示通过一个小型神经网络独立处理以提取更高层次的特征。

步骤 6 — 重复（N 层堆叠） 步骤 4 和 5 重复多次（Llama 3.2 3B 为 28 次）。每层构建更深层次的理解：

• 早期层 捕获基本语法和局部关系（词序、搭配）
• 中层 组装语义（"Jetson"是名词，指计算平台）
• 后期层 形成准备好预测的高级、特定任务的理解

步骤 7 — 输出预测 最终 token 的表示被投影到整个词汇表上，选择概率最高的 token 作为模型对下一个词的预测：

{"NVIDIA": 0.92, "AI": 0.03, "a": 0.02, ...}
→ 预测："NVIDIA"（最高概率）

关键 Transformer 概念

扩展定律：为什么更大的模型更聪明

AI 研究中最引人注目的发现之一是 Transformer 性能遵循扩展定律——随着模型规模、数据或计算预算的增加，性能可预测地提升。这一发现解释了过去十年 AI 能力的快速飞跃。

扩展定律涉及三个关键维度：

• 更多参数（模型规模）： 增加参数数量——例如从 30 亿到 700 亿——显著提升模型的深度理解和表达能力。更大的模型可以捕获更微妙的模式并存储更多知识。

• 更多训练数据： 在不充分的数据上训练的大模型就像一个大胃王被给了小餐——它无法发挥其潜力。研究表明，模型大小和训练 token 数量应大致以 1:1 的比例同时扩展。

• 更多计算： 训练更大的模型需要更多的 GPU 时间和预算。大型 AI 实验室可以在单次训练运行中花费数亿美元，这就是为什么他们的专有模型远远超过开源项目所能达到的水平。

由于这三个维度同时扩展，该领域从 2017 年的原始 Transformer（仅 1.1 亿参数）发展到今天的 700 亿+参数模型。对于你的 Jetson 设备，更重要的含义是：即使 10 亿到 30 亿参数的模型也拥有扎实的理解和生成能力——足以在边缘提供实用的 AI 服务。

模型规模与本地部署

并非所有 LLM 都一样大。理解模型规模对于为你的硬件选择合适的模型至关重要——参数数量直接决定内存需求和推理速度：

对于 Jetson 设备，最佳选择是 1B 到 8B。1B–3B 范围的模型在 Orin Nano 上提供非常流畅的交互体验，而 7B–8B 模型可以在 16GB Orin NX 上可靠运行。

提示：量化后（下一节介绍），内存使用量急剧下降。INT4 量化的 7B 模型只需要约 3.5GB 内存——小到几乎可以在任何 Jetson 设备上运行。

流行的开源 LLM 系列

以下是一些最突出的开源 LLM 系列，它们都有能在 Jetson 上良好运行的变体：

Llama（Meta）

Meta 的开源 LLM——目前最活跃的社区和最丰富的生态系统。

• Llama 3.2 有 1B 和 3B 两种规格，专为边缘设备构建，性能和占用空间平衡出色
• 支持多种语言；社区提供了广泛的微调变体
• Ollama 和 llama.cpp 生态系统中支持最好的模型系列

Qwen（阿里云）

阿里巴巴的开源 LLM，在中文能力方面领先于开源模型。

• Qwen3.5 涵盖 0.8B 到 122B 参数；0.8B 变体是资源受限边缘场景的理想选择
• 中英文双语支持出色
• 原生支持工具使用和思维链推理

DeepSeek

专注于推理的模型系列，在数学、编程和逻辑任务方面表现出色。

• DeepSeek-R1 提供蒸馏版本（1.5B、7B、8B），在推理基准测试中显著优于同规模模型
• 非常适合需要精确逻辑分析的边缘 AI 应用
• 7B 蒸馏版本是 Jetson 上性价比最好的推理模型之一

Phi（微软）

微软的紧凑型模型系列，建立在"更少参数、更高质量"的理念上。

• Phi-4-mini 只有 38 亿参数，但在标准基准测试中匹配或超过许多 7B 模型 -专为资源受限环境设计——非常适合边缘部署
• 使用独特的训练方法在高质量"教科书级"数据上训练

Gemma（谷歌）

谷歌的轻量级开源模型系列，涵盖 1B 到 27B 参数。

• Gemma 4 的 2B 和 4B 变体在 Jetson 上运行良好
• 语言理解和代码生成性能都很强
• 提供预训练和指令微调两种版本

量化：让模型更小

要在 Jetson 这样的边缘设备上流畅运行 70 亿参数模型，你需要应用量化——降低模型内部权重的数值精度，用"不完美但轻量"的低精度数字换取"完美但笨重"的高精度数字，从而大幅缩小内存使用。

直观地说，这就像把 4K 图像压缩到 720p：内容完全保留，但文件大小缩小了很多倍。对于 7B 模型，不同精度级别的内存节省是相当可观的：

INT4 量化是边缘部署的主力：7B 模型只需 3.5GB 内存，小到可以在大多数 Jetson 设备上流畅运行。

常见的量化格式

不同的推理引擎支持不同的量化文件格式，每个都有自己的优势：

• GGUF（llama.cpp 生态系统）：本地推理的主导格式——Ollama 和 llama.cpp 原生支持，自描述，无需配置即可运行
• SafeTensors（HuggingFace 生态系统）：更安全（加载时不执行任意代码），是 vLLM 和基于 HuggingFace 流水线的标准格式
• AWQ（激活感知的权重量化）：为 GPU 推理优化，常与 vLLM 一起使用，是高吞吐量场景的最佳性能选择

推理框架概述

模型训练完成后，你需要推理框架来实际在 Jetson 上运行它。本章涵盖了三个主流框架——每个框架专为旅程的不同阶段设计，从新手到生产部署。

Ollama — 最简单的入门方式

Ollama 是在本地运行 LLM 最快的方式。一行安装、内置模型下载和管理——开箱即用，对初学者非常友好：

# 安装 Ollama
curl -fsSL https://ollama.com/install.sh | sh

# 运行模型（首次启动自动下载）
ollama run llama3.2:3b

最适合： 首次体验 LLM、快速原型设计、学习和探索

llama.cpp — 最精确的控制

llama.cpp 是一个轻量级的 C/C++ 实现，能高效地在 CPU 和 GPU 上运行模型。其优势是资源使用最少，对量化格式的广泛支持——使其成为资源受限边缘设备的首选：

# 克隆并构建
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp && make -j$(nproc)

# 运行推理
./llama-cli -m model.gguf -p "Hello, how are you?"

最适合： 需要最大控制和性能优化的场景；轻量级边缘部署

vLLM — 生产级服务

vLLM 是为生产部署设计的高性能推理服务框架。它支持 PagedAttention（显著提升并发的内存分页管理）和连续批处理等高级功能，并提供 OpenAI 兼容 API：

# 安装 vLLM
pip install vllm

# 启动 API 服务器
vllm serve meta-llama/Llama-3.2-3B --host 0.0.0.0 --port 8000

最适合： 生产 API 服务、高并发、高吞吐量场景

对比表

每个框架都有自己的优势。正确的选择取决于你的具体需求：

本章你将学到的内容

本章的其余部分将引导你在 Jetson 上设置 LLM 并构建完整的语音 AI 应用：

模块 5.2：Ollama 快速入门

从零开始在 Jetson 上安装 Ollama，拉取你的第一个模型，与 AI 进行本地对话——完全离线。

模块 5.3：使用 llama.cpp 运行 LLM

深入底层：从源码构建 llama.cpp，学习加载和运行 GGUF 量化模型，掌握边缘设备的细粒度优化技术。

模块 5.4：vLLM 高性能推理

使用 OpenAI 兼容 API 设置生产级 LLM 服务基础设施，将你的 Jetson 变成本地 AI 后端。

模块 5.5：Jetson Examples 快速入门

使用 jetson-examples 仓库中的预构建 Docker 容器，单个命令部署 LLM，跳过所有繁琐的环境设置。

模块 5.6：ASR + LLM + TTS 流水线

将语音识别（ASR）、大语言模型（LLM）和文本转语音（TTS）链接成完整的语音 AI 助手——全部在你的 Jetson 上离线运行。

实践：评估你的硬件

在进入部署模块之前，检查你的 Jetson 设备的硬件能力，以便选择正确的模型：

# 检查可用内存
free -h

# 检查 GPU 型号和 VRAM
nvidia-smi

# 检查 JetPack 版本（决定 CUDA 和 TensorRT 版本）
dpkg -l | grep nvidia-jetpack

# 检查可用存储
df -h /

记录你的结果：

• 总 RAM：______ GB
• GPU VRAM：______ MB
• 可用存储：______ GB
• JetPack 版本：___________

有了这些数字，你可以确定哪些模型大小可以在你的设备上舒适运行。

实践：使用视觉语言模型检测物体

现在你了解了 LLM 如何处理文本，让我们看看**视觉语言模型（VLM）**的实际应用——一种可以看到图像并描述其中内容的模型。下面的示例使用 Ollama 将本地图像发送到 VLM，VLM 返回物体名称和像素坐标。然后 OpenCV 在图像上绘制带标签的边界框。

前置要求

pip install ollama opencv-python Pillow
ollama pull llava:7b   # 仅首次，~4.7GB

运行

cd code/
python vlm_object_detector.py --image your_photo.jpg
python vlm_object_detector.py --image photo.jpg --model minicpm-v --output results.jpg

VLM 不是像 YOLO（第 4 章）那样的专用检测器——边界框准确性因模型而异。这个练习的目的是让你亲身体验 LLM 背后相同的基于 token 的推理，通过多模态模型扩展到图像——文本和视觉在 Transformer 内部遵循相同的路径。

常见问题

我可以在 Jetson 上运行 ChatGPT 吗？

不完全是。ChatGPT 是 OpenAI 在大型服务器集群上运行的专有系统。但是，你可以在 Jetson 上本地运行提供类似对话能力的开源模型，还享有完全数据隐私的好处。

使用 Jetson 上的 LLM 需要互联网访问吗？

初始模型下载后，你可以完全离线运行 LLM。对于连接受限地区的边缘部署，这是关键优势之一。

生成响应需要多长时间？

响应时间取决于模型大小和你的硬件。在运行 3B 模型的 Jetson Orin NX 16GB 上，预计每秒 10-30 个 token——足以进行实时对话。

参考资料

• Attention Is All You Need（原始 Transformer 论文）
• The Illustrated Transformer — Jay Alammar 的可视化指南
• https://huggingface.co/blog/Esmail-AGumaan/attention-is-all-you-need
• Hugging Face LLM 课程 — NLP 和 LLM 基础
• Llama 3.2 模型卡
• Qwen3 文档
• NVIDIA Jetson AI Lab — Jetson AI 开发资源

下一步：继续学习 模块 5.2：Ollama 快速入门，在你的 Jetson 上运行第一个 LLM！