从概念到系统，从能调用模型到真正能做应用

面向零基础与转型开发者的 AI 技术关系图、代码示例、选型方法与学习路线

#人工智能	#AI应用开发	#机器学习	#深度学习	#大模型
#大语言模型	#LLM	#Transformer	#RAG	#AI Agent

第一次接触 AI 开发，最容易被一串名词绕晕：人工智能、机器学习、深度学习、神经网络、大模型、LLM、生成式 AI、RAG、Agent，看起来都像“AI”，却并不处在同一层级。本文从“目标—方法—模型—能力—系统”五个层次重新梳理它们的关系，用一张总览图、多个对比表和可运行的 Python 示例，讲清传统机器学习如何从数据中学习，深度学习为何依赖神经网络，大模型与 LLM 到底是什么关系，以及今天做 AI 应用为什么通常不需要从头训练模型。最后给出从 Python、机器学习、PyTorch 到 LLM、RAG、Agent 和生产化的完整学习路线，并用知识库问答助手串起一条可落地的开发链路。

先给结论：你不是学不会，而是这些词本来就不在同一层

很多入门路线把“机器学习、深度学习、大模型、LLM、RAG、Agent”排成一条直线，于是初学者自然会误以为它们是六代技术、必须从第一代学到第六代。真正准确的理解是：这些词描述的是不同层次的问题。

一句话地图  AI 是总目标；机器学习是实现 AI 的一类方法；深度学习是机器学习中的一大类方法；大模型与基础模型描述的是大规模预训练后的模型形态；LLM 是其中以语言和序列为核心的一类模型；RAG 是给模型接外部知识的应用架构；Agent 是把模型、记忆、工具、状态和控制流程组合起来完成任务的系统。

只要把“目标、方法、模型、能力、系统”这五层分开，后面绝大多数名词都会自动找到位置。更重要的是，你会知道自己到底需要学到哪一层：研究模型的人和做 AI 应用的人，学习路径并不相同。

图 1  AI、机器学习、深度学习、大模型、LLM、生成式 AI 与 Agent 的关系总览

一、先把最容易混淆的八个概念摆到一张桌子上

概念	它本质上是什么	最关键的问题	典型产物/例子	做应用是否必须自己训练
人工智能 AI	目标与学科总称	怎样让机器表现出智能行为	搜索、推荐、识别、生成、决策系统	不一定
机器学习 ML	从数据中学习规律的方法集合	能否用数据学出映射或策略	回归、分类、聚类、排序、强化学习	传统项目常需要
深度学习 DL	基于多层神经网络的机器学习	能否自动学习高维表示	CNN、RNN、Transformer 等	训练模型时需要
基础模型	在广泛数据上预训练、可适配多任务的模型	能否作为很多下游任务的共同底座	语言、视觉、多模态基础模型	应用侧通常直接使用
大模型	强调规模与能力的工程称谓，边界并不严格	参数、数据、算力和泛化能力是否达到大规模	大语言模型、多模态大模型等	应用侧通常不从零训练
大语言模型 LLM	面向语言/代码等序列的大规模模型	如何根据上下文理解并生成 token	问答、写作、代码、总结、推理	通常直接推理或微调
生成式 AI	生成内容的能力与应用范式	能否生成新的文本、图像、音频、视频等	文本生成、文生图、文生视频	通常基于预训练模型
智能体 Agent	围绕目标自主选择步骤并调用工具的系统	如何规划、行动、观察、重试并完成任务	研究助手、运维助手、编码 Agent	通常组装模型与工具

表 1  八个常见概念的层级、职责与开发视角

表里最值得记住的一件事是：**“模型”与“应用系统”不是一回事。**一个模型即使能力很强，如果没有数据治理、检索、工具、权限、评测和异常处理，离可靠产品仍然很远。反过来，很多高价值应用也不需要最强模型，反而更依赖流程设计、数据质量和工程边界。

1.1 人工智能是“想达到什么”，机器学习是“怎么学出来”

传统程序的基本范式是“规则 + 数据 → 结果”。开发者把判断逻辑写进代码，例如“金额大于某阈值并且设备异常就触发风控”。机器学习则把范式改成“数据 + 目标/反馈 → 模型”，再用“模型 + 新数据 → 预测”。

最核心区别  传统编程：人负责写规则。机器学习：人负责定义问题、准备数据和评价标准，让算法从样本中学习规则。

机器学习并不只等于分类。监督学习利用带标签样本学习输入到输出的映射；无监督学习从无标签数据中发现结构；自监督学习从数据自身构造训练信号，是现代基础模型预训练的重要思路；强化学习则通过环境反馈学习策略。它们回答的是不同问题，不宜简单排成高低等级。

1.2 深度学习不是“更高级的机器学习”，而是机器学习中的一大类方法

深度学习依靠多层神经网络学习表示。传统机器学习常常需要人工设计特征，比如图像中的边缘、纹理或文本中的词频；深度学习的优势之一，是可以通过端到端训练逐层学习特征表示。数据经过网络前向传播得到预测，再用损失函数衡量误差，通过反向传播计算梯度，优化器据此更新参数。

这套训练循环——前向计算、计算损失、反向传播、更新权重——是理解深度学习最重要的骨架。CNN、RNN、Transformer 的结构不同，但训练时都围绕可微分计算与参数优化展开。

别把旧方法当成过时方法  不是所有机器学习都是深度学习，也不是所有 AI 问题都必须用神经网络。表格数据、样本不大、需要高可解释性或极低延迟时，线性模型、树模型等经典方法仍然非常实用。

1.3 大模型、基础模型、LLM：三个词最容易被混成一个

“大模型”是一个偏工程化、行业化的称呼，强调模型规模、训练数据、算力投入和通用能力达到较大规模，但没有一个跨领域统一的参数阈值。 “基础模型”强调的是预训练后可以通过提示、微调或其他适配方式服务多种下游任务。二者经常重叠，但强调点不同：一个更强调规模，一个更强调“可作为下游基础”。

LLM，即大语言模型，是面向语言、代码等序列建模的一类大型模型。现代 LLM 大多建立在深度神经网络和 Transformer 家族架构上，但“LLM = Transformer”仍然过于绝对：语言模型早于 Transformer 出现，Transformer 只是今天最重要的实现路线之一。

同样，“大模型 = LLM”也不成立。大模型可以处理图像、语音、视频或多模态；LLM 只是在“大模型/基础模型”体系中最受关注的一支。

1.4 Agent 不是更大的 LLM，而是“模型进入真实世界后的系统形态”

如果 LLM 只做一次“输入文本 → 输出文本”，它本质上还是一个模型服务。Agent 则需要围绕目标维持状态，决定下一步做什么，必要时查询知识库、调用搜索、运行代码、访问数据库或业务 API，再观察结果、修正计划，直到完成任务或触发安全边界。

Agent 的工程公式  一个实用的 Agent 可以抽象为：模型（理解与决策） + 记忆/状态（知道做到哪） + 工具（能行动） + 控制流程（何时继续、何时停止、何时重试） + 安全与评测（知道什么不能做、怎样判断做对了）。

因此，工具调用本身不等于一个可靠 Agent；循环越开放，也不一定越“智能”。对于步骤稳定、规则明确的业务，受控工作流往往比完全开放式 Agent 更易测试、更稳定。

二、从机器学习到大模型，真正变化的是“开发范式”

理解技术演进时，不要只盯模型参数。对开发者影响最大的变化，是“你把知识写在哪里”。

范式	知识主要来自哪里	开发者主要工作	典型优点	典型难点
规则系统	代码和规则库	写 if/else、规则、流程	确定性强、易审计	规则爆炸、维护成本高
传统机器学习	结构化数据 + 标签	特征、数据、训练、评估	适合预测与分类，成本可控	特征工程、分布漂移
深度学习	大规模数据 + 神经网络	网络结构、训练、算力、调参	自动学习复杂表示	数据与算力成本高
基础模型/LLM	大规模预训练知识 + 上下文	提示、检索、工具、微调、评测	一个模型覆盖多任务	幻觉、成本、可控性
Agent/工作流	模型 + 外部知识 + 工具 + 业务规则	编排、状态、权限、验证、回退	能执行多步骤任务	链路更长，错误传播与安全更难

表 2  从规则系统到 Agent，开发者工作重心的变化

这也是为什么今天“AI 应用开发”与“训练大模型”不是同义词。应用开发者更像系统工程师：选合适模型，把企业知识接进来，把工具和权限接进来，规定输出格式，构造评测集，记录调用链路，控制延迟和成本，并在失败时有回退方案。

图 2  一个现代 AI 应用的五层工程结构

三、用三段代码看懂三种开发方式的差别

概念看懂之后，最好用代码建立“手感”。下面三个示例刻意选择同一种语言 Python，但开发范式完全不同。

3.1 传统机器学习：你要 fit 一个面向具体任务的模型

下面用经典 Iris 数据做三分类。代码包含数据划分、标准化、逻辑回归、预测和测试集准确率。这里的模型只解决这个特定任务。

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

X, y = load_iris(return_X_y=True)

X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,
    random_state=42,
    stratify=y
)

model = make_pipeline(
    StandardScaler(),
    LogisticRegression(max_iter=1000)
)

model.fit(X_train, y_train)
pred = model.predict(X_test)

print(f"测试集准确率: {accuracy_score(y_test, pred):.3f}")

你应该观察什么  在固定随机种子和常见 scikit-learn 版本下，这段代码的测试集准确率约为 0.933。重点不在分数，而在流程：数据 → 训练 → 得到任务模型 → 对新样本预测。

传统机器学习项目里，训练过程通常是项目本身的一部分。数据分布变化后，还可能需要重新训练、校准阈值或更新特征。

3.2 深度学习：你不再手工写特征，而是定义网络与训练循环

下面在双月牙数据上训练一个很小的多层感知机。相比逻辑回归，多了神经网络结构、损失函数、反向传播和优化器。

import torch
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

torch.manual_seed(42)

X, y = make_moons(n_samples=1000, noise=0.2, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train).astype("float32")
X_test = scaler.transform(X_test).astype("float32")
y_train = y_train.astype("float32").reshape(-1, 1)
y_test = y_test.astype("float32").reshape(-1, 1)

model = torch.nn.Sequential(
    torch.nn.Linear(2, 16),
    torch.nn.ReLU(),
    torch.nn.Linear(16, 16),
    torch.nn.ReLU(),
    torch.nn.Linear(16, 1)
)

loss_fn = torch.nn.BCEWithLogitsLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

X_train_t = torch.tensor(X_train)
y_train_t = torch.tensor(y_train)

for _ in range(300):
    logits = model(X_train_t)
    loss = loss_fn(logits, y_train_t)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

with torch.no_grad():
    prob = torch.sigmoid(model(torch.tensor(X_test)))
    pred = (prob >= 0.5).float().numpy()

accuracy = (pred == y_test).mean()
print(f"测试集准确率: {accuracy:.3f}")

深度学习的骨架  在本文固定的随机种子下，测试集准确率约为 0.985。真正要记住的是四步：前向计算 → 损失 → backward() → optimizer.step()。这四步是理解神经网络训练的“最小闭环”。

当网络和数据规模扩大到数十亿级甚至更高参数、海量语料、多机多卡训练时，工程复杂度会急剧上升。这正是为什么基础模型预训练通常由大型团队完成，而应用开发者更常从已经训练好的模型开始。

3.3 LLM 应用开发：你通常不再 fit，而是调用已经预训练好的能力

下面是一个供应商无关的 Chat Completions 风格请求。只要你的模型服务兼容该协议，就可以替换地址、模型名和密钥。这里没有 fit、loss、backward，因为预训练已经在你调用之前完成。

import os
import requests

BASE_URL = os.getenv("LLM_BASE_URL", "http://localhost:8000/v1")
MODEL = os.getenv("LLM_MODEL", "your-model")
API_KEY = os.getenv("LLM_API_KEY", "")

headers = {"Content-Type": "application/json"}
if API_KEY:
    headers["Authorization"] = f"Bearer {API_KEY}"

payload = {
    "model": MODEL,
    "messages": [
        {"role": "system", "content": "你是一名严谨的技术助教。"},
        {"role": "user", "content": "用三个要点解释机器学习与深度学习的关系。"}
    ],
    "temperature": 0.2
}

resp = requests.post(
    f"{BASE_URL}/chat/completions",
    headers=headers,
    json=payload,
    timeout=60
)
resp.raise_for_status()

answer = resp.json()["choices"][0]["message"]["content"]
print(answer)

从这一步开始，应用工程的重心转向了另一些问题：输入是否足够清晰？输出能否稳定解析成 JSON？知识是否需要实时更新？模型可以调用哪些工具？失败后重试还是降级？敏感操作是否需要人工确认？怎样用评测集判断新版本是否真的更好？

开发视角  这就是“会调用大模型 API”和“会开发 AI 应用”的分水岭：前者是一次请求，后者是一条可测试、可观测、可控制的完整链路。

四、LLM 为什么突然这么能干：从语言模型到 Transformer 再到大规模预训练

4.1 语言模型最朴素的目标：根据上下文预测接下来会出现什么

语言模型的核心任务可以理解为估计序列概率。文本先被切分成 token，模型根据已有上下文预测下一个 token 的概率分布，再一步一步生成后续内容。现代模型还可以处理代码、结构化文本以及多模态输入，但“基于上下文做条件预测”仍然是理解生成机制的重要入口。

这也解释了一个常见现象：模型生成的是“在当前上下文下高概率、符合模式的输出”，并不等于它天然拥有一个可查询、实时更新、逐条核验的事实数据库。因此，涉及私有知识、最新信息或高准确性要求时，应用层通常还需要检索、工具调用和结果验证。

4.2 Transformer 解决了什么

2017 年提出的 Transformer 用注意力机制作为核心结构，使序列中的不同位置可以更直接地建立依赖关系，并提升并行训练能力。后续大语言模型在 Transformer 家族基础上不断扩展模型规模、训练数据、上下文长度和训练方法，形成今天的大模型生态。

但学习时不要陷入“必须先手推每一个注意力公式才能做应用”的误区。做应用首先要理解 token、上下文窗口、提示、结构化输出、Embedding、RAG、工具调用、评测等工程概念；当你需要微调、推理优化、模型训练或研究时，再深入注意力、位置编码、归一化、优化器和分布式训练。

4.3 预训练、后训练、推理：三个阶段不要混在一起

阶段	在做什么	主要输入	主要输出	应用开发者通常是否参与
预训练	在大规模广泛数据上学习语言/世界模式	海量文本、代码或多模态数据	基础模型参数	通常不参与
后训练	让模型更会遵循指令、更符合目标行为	指令数据、偏好数据、任务数据	可用性更强的模型	有时参与或直接用现成模型
推理	模型参数基本固定，对当前输入生成结果	提示词、上下文、检索结果、工具结果	本次任务输出	每天都在做

表 3  预训练、后训练与推理的职责边界

应用开发的大多数工作发生在“推理及其周边系统”：组织上下文、选择模型、检索知识、调用工具、约束输出、记录链路、评估结果。理解这一点之后，你就不会再把“学 AI”误解成“先准备几千张显卡训练自己的大模型”。

五、RAG、Embedding、微调、Agent 到底各自解决什么问题

5.1 Embedding：把语义变成可以计算距离的向量

Embedding 模型把文本、图像等对象映射到向量空间，使语义相近的内容在向量上更接近。它常用于检索、聚类、去重、推荐和相似度计算。Embedding 模型通常与生成用 LLM 分工：一个负责“找相关内容”，一个负责“理解并生成答案”。

因此，向量数据库也不是“装大模型的数据库”。它主要存向量及其元数据，支持近似最近邻搜索；真正的文档正文、权限、版本、更新时间等工程信息仍然需要认真管理。

5.2 RAG：把“模型记得什么”改成“模型现在能查到什么”

RAG（检索增强生成）的基本流程是：用户问题 → 检索相关文档 → 把检索结果连同问题交给生成模型 → 生成带上下文的答案。它的优势是知识可以独立于模型参数更新，尤其适合企业文档、产品手册、规章制度、知识库等经常变化的内容。

RAG 的工程真相  RAG 不是“接一个向量库就结束”。真实效果往往由文档清洗、切分、元数据、Embedding、召回、重排、上下文拼接、提示约束、引用、评测和知识更新共同决定。

如果检索阶段就找错了，后面的 LLM 再强也只能在错误上下文上生成；因此，RAG 的评测必须把“召回质量”和“最终回答质量”拆开测。

5.3 微调：更适合改变“怎么做”，不适合当作频繁更新知识的数据库

微调会更新模型参数，使模型更贴近某种任务、输出格式、表达风格或领域行为。它可以提高特定任务的一致性，但要付出数据准备、训练、验证、版本管理和部署成本。

如果你的核心问题是“公司今天更新了一份制度，希望模型立刻知道”，通常先考虑 RAG；如果问题是“希望模型持续按照某种专业格式完成任务，单靠提示仍不稳定”，才更值得评估微调。两者也可以组合，而不是非此即彼。

5.4 Agent：当任务需要多步决策和真实行动时才值得引入

Agent 的价值在于：任务不能靠一次生成结束，需要模型根据中间结果决定下一步。例如“查本周销量 → 找异常门店 → 查询库存 → 生成补货建议 → 等待审批 → 调用补货接口”。这里已经不只是问答，而是一个带状态、有工具、有权限边界的业务流程。

Agent 越开放，越要重视停止条件、工具白名单、参数校验、预算、超时、幂等、人工确认和审计日志。一个会自主循环但没有安全边界的系统，不是“更智能”，而是更难验证。

你的问题	优先考虑	为什么	不应期待它解决什么
知识经常更新、属于私有文档	RAG	知识独立更新，可给出来源上下文	不能自动保证检索一定正确
固定任务格式不稳定、需要领域行为适配	微调	改变模型参数与行为分布	不适合频繁灌入最新事实
需要调用数据库/API/搜索等外部能力	工具调用/工作流	让模型获取实时数据并执行动作	工具结果仍需校验
任务步骤不固定，需要根据结果动态规划	Agent	可在观察—决策—行动循环中推进目标	不等于天然可靠或无需规则
任务非常固定、流程可枚举	普通工作流	更容易测试、审计和回退	没必要为了“Agent”而 Agent

表 4  RAG、微调、工具调用与 Agent 的选型逻辑

六、把所有概念串成一个项目：做一个“企业知识库问答助手”

为了把概念从名词变成工程，我们用一个常见项目串起来：员工上传产品手册、制度和 FAQ，用户用自然语言提问，系统给出答案和引用；当问题涉及实时数据时，还可以调用业务 API。

6.1 第一步：定义问题，不要先选模型

• 用户是谁：内部员工、客服、研发，还是外部客户？不同用户的权限完全不同。
• 回答范围：只允许基于内部资料回答，还是允许使用模型通用知识？
• 成功标准：答案正确率、引用命中率、拒答率、延迟、单次成本分别是多少？
• 风险边界：哪些内容必须拒答，哪些工具调用必须人工确认？

这一步看起来不像“AI”，却决定了后面所有技术选型。一个没有成功标准的 AI 项目，只能靠“感觉挺聪明”验收。

6.2 第二步：构建知识链路

1. 解析文档：抽取正文、标题、章节、表格及必要元数据。
2. 切分文档：优先保留章节语义，不要只按固定字符数硬切。
3. 生成 Embedding：将文本片段编码为向量。
4. 写入检索系统：保存向量、正文位置、文档版本、权限、更新时间。
5. 查询时召回：先取候选片段，必要时做重排。
6. 把高质量片段拼入上下文，并要求模型只依据给定资料回答、附引用。

6.3 第三步：为“实时问题”接工具，而不是把一切都塞进知识库

例如库存、订单、余额、天气、工单状态都属于实时或动态数据。把昨天的库存写进向量库不仅浪费，还容易产生过期答案。更合适的做法是：模型识别用户意图 → 调用受控 API → 获取结构化结果 → 再组织自然语言回答。

一个好用的划分  静态/半静态知识用检索；实时状态用工具；稳定流程用工作流；只有步骤高度动态时才引入更开放的 Agent。

6.4 第四步：做评测，而不是只看几个“惊艳案例”

最小评测集至少要覆盖：正常问题、歧义问题、知识库没有答案的问题、跨文档问题、数字/日期问题、权限问题、恶意提示注入、工具失败和模型超时。每次更换模型、提示词、切分策略或检索参数，都用同一组样例回归测试。

评测层	要测什么	示例指标
检索层	正确资料是否被召回	Recall@K、命中文档率、重排命中率
生成层	答案是否基于证据、是否完整	正确性、忠实度、引用一致性
系统层	是否稳定、是否可用	P50/P95 延迟、超时率、错误率、成本
安全层	是否越权、是否被提示注入影响	越权率、危险工具拦截率、人工复核命中
业务层	是否真正改善工作	一次解决率、人工接管率、节省时长、用户满意度

表 5  AI 应用应该分层评测，而不是只看“模型回答好不好”

七、八个最常见的误区，一次纠正

误区一：学 AI 就必须先学会训练大模型

如果目标是 AI 应用开发，先学会使用预训练模型、构建 RAG/工具链、做评测和工程化，投入产出比更高。训练基础模型属于另一条更偏研究与基础设施的路线。

误区二：深度学习淘汰了传统机器学习

没有。表格数据、小样本、低延迟、高可解释场景中，树模型、线性模型等依然常见。技术选型看问题约束，不看“新旧”。

误区三：大模型就是 LLM

LLM 是大模型体系中的语言模型分支；视觉、语音、视频、多模态也有大模型。

误区四：LLM 会“记住互联网全部事实”

模型参数中编码的是统计模式与知识表示，不是可精确查询、实时同步的数据库。最新或私有事实需要外部知识与工具。

误区五：RAG 等于向量数据库

向量库只是检索链路的一部分；文档质量、切分、召回、重排、上下文、提示、引用与评测共同决定效果。

误区六：工具调用就是 Agent

一次函数调用只是能力；Agent 还涉及状态、规划/路由、循环控制、重试、停止条件、权限与审计。

误区七：模型越强，产品就一定越好

产品质量还受检索、提示、工具、延迟、成本、数据质量、权限与失败处理影响。对任务合适的模型往往比“最强模型”更重要。

误区八：Prompt 工程就是 AI 应用开发

Prompt 很重要，但生产系统还要解决数据、接口、状态、评测、监控、安全、缓存、版本与回退。

八、从零开始，应该按什么顺序学

学习路线最好围绕“能交付的项目”设计，而不是围绕名词堆积。下面这条路线同时兼顾基础和应用效率。

图 3  从零到能做 AI 项目的四阶段学习路线

阶段	建议掌握	不必一开始深挖	建议项目
1. 编程与数据	Python、函数/类、虚拟环境、NumPy、pandas、SQL、HTTP/JSON、Git	复杂元编程、底层编译器	数据清洗 + REST API
2. ML 与 DL	监督学习、训练/验证/测试、过拟合、指标；PyTorch 张量、网络、损失、反向传播	从零实现全部优化器、分布式训练	分类模型 + 小型神经网络
3. LLM 应用	Prompt、结构化输出、上下文、Embedding、RAG、工具调用、工作流/Agent	从头预训练百亿级模型	知识库问答 + 工具助手
4. 生产化	评测集、日志、Tracing、监控、缓存、路由、成本、安全、权限、部署	过早追求复杂多 Agent	可观测、可回退的 AI 服务

表 6  四阶段学习重点与项目交付物

8.1 数学要不要学：要，但别把数学当成入门门禁

线性代数、概率统计、微积分和优化非常重要，但学习顺序可以“按需加深”。先知道向量、矩阵、概率、导数、梯度分别解决什么问题，能读懂损失函数和基本训练流程；当你开始做模型训练、微调、推理优化或论文复现时，再系统补齐数学细节。

对应用开发者来说，最危险的不是数学不够深，而是没有评价意识：不知道训练集和测试集为什么要分开，不知道准确率何时会骗人，不知道离线分数与线上业务目标为何可能冲突。

8.2 一条更实用的项目阶梯

项目	你会学到什么	难度	完成标准
文本分类器	数据划分、特征/模型、指标、错误分析	入门	有独立测试集与错误样本分析
图像或表格神经网络	PyTorch、训练循环、过拟合、保存与加载	入门+	能解释 loss 与指标变化
LLM 结构化抽取	提示词、JSON Schema、校验与重试	中等	输出可被程序稳定消费
文档知识库问答	Embedding、切分、检索、RAG、引用	中等	有检索和生成两套评测
带工具的业务助手	函数调用、权限、状态、工作流、人工确认	进阶	关键动作可审计、可回退
生产化 AI 服务	路由、缓存、监控、成本、灰度、评测回归	进阶	模型更新不破坏已有能力

表 7  用项目逐级建立 AI 应用开发能力

九、真正上线之前，还要补齐“模型之外”的工程能力

一个 Demo 能回答问题，不代表它适合放进生产环境。越接近真实业务，模型之外的工程占比越高。

可观测性：记录请求 ID、模型、提示版本、检索结果、工具调用、延迟、token/成本和异常；出了错能还原完整链路。

结构化输出：重要业务不要靠正则从自然语言里“猜字段”；使用明确 schema，并对字段类型、枚举、范围做程序校验。

超时与重试：模型、检索、工具都可能失败。重试要区分可重试错误，并设置次数、退避与总预算，避免无限循环。

缓存与路由：重复问题、Embedding、静态文档可缓存；简单任务可路由给更小更快的模型，复杂任务再升级。

安全与权限：模型不能绕过业务权限。数据库查询、文件读取、外部发送、执行代码等工具必须有最小权限、参数校验和审计。

提示注入防护：外部文档和网页都应视为不可信输入；不要让检索到的文本轻易改写系统规则或工具权限。

人工确认：付款、删除、对外发送、修改生产数据等高风险动作，默认加入显式确认或审批。

版本与回归：提示、检索、模型、工具版本都要可追踪；任何升级先跑固定评测集，再灰度上线。

工程底线  生产 AI 的核心不是“让模型永远不犯错”，而是：让错误可发现、影响可限制、过程可追踪、结果可验证、必要时可回退。

十、最后再回答标题：它们到底是什么关系

如果只保留一张心智地图，可以记成下面这组句子：

• 人工智能 AI：最大的目标集合——让机器表现出智能。
• 机器学习 ML：实现 AI 的一类关键方法——让机器从数据中学规律。
• 深度学习 DL：机器学习的一大分支——用多层神经网络学习表示。
• 基础模型 / 大模型：把深度学习扩展到更大数据、算力和预训练规模，形成可复用的通用模型底座。
• 大语言模型 LLM：基础模型中的语言/代码序列方向，是今天生成式 AI 的核心技术之一。
• 生成式 AI：强调“生成新内容”的能力和应用范式，不等于某一种固定模型。
• Embedding / RAG：让应用能够检索外部知识，把“模型参数里的知识”补成“此刻可以查到的知识”。
• Agent：把模型和工具、记忆、状态、控制流程、安全边界组合成能连续行动的系统。

对想从零进入 AI 应用开发的人，最有效的路径并不是从“训练一个大模型”开始，而是先完成三个跨越：第一，能用 Python 和数据工具解决确定问题；第二，理解机器学习和深度学习的训练逻辑；第三，学会把预训练模型放进可靠的应用系统——检索、工具、工作流、评测、监控、安全一个都不能少。

当你能清楚地区分“模型能力”和“系统能力”，也能根据问题选择传统机器学习、深度学习、RAG、微调、工作流或 Agent，你就真正跨过了 AI 应用开发的入门门槛。

参考资料

1. Google Machine Learning Crash Course  https://developers.google.com/machine-learning/crash-course

2. Google Introduction to Large Language Models  https://developers.google.com/machine-learning/crash-course/llm

3. Google Production ML Systems  https://developers.google.com/machine-learning/crash-course/production-ml-systems

4. PyTorch Learn the Basics  Learn the Basics — PyTorch Tutorials 2.14.0+cu130 documentation

5. scikit-learn Getting Started  Getting Started — scikit-learn 1.9.1 documentation

6. Attention Is All You Need  [1706.03762] Attention Is All You Need

7. Stanford CRFM — On the Opportunities and Risks of Foundation Models  Stanford CRFM

8. Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks  [2005.11401] Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks

9. ReAct — Synergizing Reasoning and Acting in Language Models  [2210.03629] ReAct: Synergizing Reasoning and Acting in Language Models