在当前的 AI 进化阶段，任何参数量少于 10 亿的模型都可以称为小型语言模型（Small Language Model）。回顾过去，像 GPT-3 这样的模型有大约 1750 亿个参数，而据说 GPT-4 可能有 1 万亿个参数。根据 scaling law，参数越多，模型性能越好。所以我们自然会认为，拥有更大的架构会带来更好的结果，但如果一个小型架构模型能比大型模型表现得更好呢？

注：所有代码在文章末的Colab里面运行。

能否构建一个只有 1000 万到 1500 万参数的语言模型，并且还能生成连贯的文本？

完整的训练 pipeline 如下：

Part 1：我们的数据集

我们选择一个小型数据集 TinyStories（https://arxiv.org/abs/2305.07759）。这是一个由 GPT-3.5 和 GPT-4 生成的合成数据集，包含的短篇故事只使用 3 到 4 岁幼儿通常能理解的词汇。我们可以从 HuggingFace 获取它。

TinyStories：语言模型可以小到什么程度，依然能说一口流利的英语？

语言模型（LMs）是自然语言处理的强大工具，但它们常常难以生成连贯的文本……

!pip install datasets
from datasets import load_dataset

ds = load_dataset("roneneldan/TinyStories")

我们的数据集是这样的，每一行对应一个故事。训练集有 200 万行，验证集有 2 万行。

Part 2：数据预处理（Tokenization，输入-输出对）

我们从数据集中拿一个小例子，目标是做两件事：1) 对数据集进行 tokenization——我们会用 GPT-2 的子词分词器；2) 将所有 token IDs 存到一个单独的 .bin 文件中。

样本故事

将输入数据转换为数值格式。

我们会把每个故事的每个词映射到对应的 token ID，然后将所有 token IDs 合并成一个非常大的 token ID 语料库。这就是我们的训练数据。

例如，一个故事可能对应这样的 tokens 和 IDs。Tokens 以字典格式存储，包含 IDs 和长度。

同样地，所有故事都会生成类似的包含 token IDs 和长度的字典，我们会把它们合并在一起，存成 .bin 格式，保存在本地存储中。

为什么用磁盘存储？

1. 1. 安装和导入库

https://github.com/openai/tiktoken

!pip install tiktoken        # 安装 tiktoken 库用于分词

import tiktoken              # 兼容 GPT(-2/3/4) 的 token 编码/解码
import os                    # 用于文件系统操作
import numpy as np           # 数值操作 / memmap 数组
from tqdm.auto import tqdm   # 循环进度条

1. 2. 初始化分词器

enc = tiktoken.get_encoding("gpt2")  # 加载 GPT-2 的编码方案（Byte-Pair Encoding）

这个分词器被 GPT-2/3/4 使用，将原始文本转换为整数“tokens”。

1. 3. 分词函数

def process(example):
    ids = enc.encode_ordinary(example['text'])  # 编码为 token IDs（无特殊 token）
    out = {'ids': ids, 'len': len(ids)}
    return out

输入：包含 'text' 条目的字典（一个文档/样本）。

输出：包含以下内容的字典：

• • 'ids'：token ID 列表（整数）

• • 'len'：token 数量

1. 4. 对数据集进行分词

if not os.path.exists("train.bin"):
    tokenized = ds.map(
        process,
        remove_columns=['text'],
        desc="tokenizing the splits",
        num_proc=8,
    )

检查是否存在“train.bin”文件——避免重复工作。

ds.map：

• • 对数据集中的每个文本样本应用 process 函数

• • 删除原始 'text' 列

• • 使用多处理器加速（num_proc=8）

• • 添加进度标签

1. 5. 将分词数据保存为二进制文件

for split, dset in tokenized.items():
    arr_len = np.sum(dset['len'], dtype=np.uint64)
    filename = f'{split}.bin'
    dtype = np.uint16  # 安全，因为 GPT-2 的 token 值 < 65536
    arr = np.memmap(filename, dtype=dtype, mode='w+', shape=(arr_len,))
    total_batches = 1024

    idx = 0
    for batch_idx in tqdm(range(total_batches), desc=f'writing {filename}'):
        batch = dset.shard(num_shards=total_batches, index=batch_idx, contiguous=True).with_format('numpy')
        arr_batch = np.concatenate(batch['ids'])
        arr[idx : idx + len(arr_batch)] = arr_batch
        idx += len(arr_batch)
    arr.flush()

这段代码是数据预处理 pipeline 的一部分，能高效地为 transformer 模型训练处理大型文本数据集。

对每个 split（训练、验证等）：

• • 计算该 split 的总 token 数

• • 使用 numpy.memmap 准备一个大型二进制文件 (*.bin)，提高效率

• • 分批写入以优化速度和内存（1024 个分片）

• • 循环处理每个批次，获取批次的 token 作为 numpy 数组

• • 将批次 token IDs 按顺序写入内存映射数组

• • 最后将 memmap 文件刷新到磁盘

总结与用途

目的：将文本数据集转换为 GPT 风格的 token IDs，并按顺序存储在快速二进制文件中，优化用于训练神经语言模型（如 GPT）。

为什么分批：在大型数据集上实现高效 I/O 和内存使用。

为什么用 memmap：通过直接映射文件到内存，处理大于 RAM 的数据集。

为什么用 np.uint16：token IDs（GPT-2 最大为 50256）适合 16 位，节省空间。

我们需要将数据集分成批次，全部添加到“train.bin”中。

快速总结：

• • 每个故事被分解为多个 token IDs

• • 每个 token ID 都有对应的长度

• • 所有 token IDs 需要存储在某个地方

• • 这个地方叫 train.bin，这个文件需要保存在磁盘而不是 RAM

• • train.bin 会包含所有 token IDs

1. 1. 对数据集进行 tokenization，生成 token IDs

2. 2. 创建“train.bin”和“validation.bin”文件，存储整个数据集的 token IDs

3. 3. 确保 token IDs 存储在磁盘上，而不是 RAM，以提高计算效率

这份完整版的大模型 AI 学习和面试资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】

Part 3：为数据集创建输入-输出批次

现在我们来创建数据集的输入-输出对。

假设上下文大小是 4 个 token，批次大小也是 4（x1, x2, x3, x4）。每个输入 x1 的输出张量是 y1，与输入相同，但向右移动一个 token。

在理解输入-输出对之前，我们先搞清楚 LLM 是干啥的？它实际上是预测下一个 token，当输入一串词时。

对于上面的每一行，会有 4 个输入-输出的预测任务。

• • 将数据分成每 4 个 token 为一组的输入数据

• • 将上述组向右移动 1 位，变成输出数据

• • 对于每个输入-输出对，你需要进行 4 次预测任务，例如：

当“one”是输入时，“day”必须是输出；“one”+“day”是输入时，“a”必须是输出；“one”+“day”+“a”是输入时，“little”必须是输出，依此类推…… 模型在训练时会理解语言的含义和形式。

# 部分函数来自 https://github.com/karpathy/nanoGPT/blob/master/train.py，略有修改
defget_batch(split):
    # 每次批次重新创建 np.memmap 以避免内存泄漏，参见
    # https://stackoverflow.com/questions/45132940/numpy-memmap-memory-usage-want-to-iterate-once/61472122#61472122
    if split == 'train':
        data = np.memmap('train.bin', dtype=np.uint16, mode='r')
    else:
        data = np.memmap('validation.bin', dtype=np.uint16, mode='r')
    ix = torch.randint(len(data) - block_size, (batch_size,))
    x = torch.stack([torch.from_numpy((data[i:i+block_size]).astype(np.int64)) for i in ix])
    y = torch.stack([torch.from_numpy((data[i+1:i+1+block_size]).astype(np.int64)) for i in ix])
    if device_type == 'cuda':
        # 锁定数组 x,y 的内存，允许异步移动到 GPU（non_blocking=True）
        x, y = x.pin_memory().to(device, non_blocking=True), y.pin_memory().to(device, non_blocking=True)
    else:
        x, y = x.to(device), y.to(device)
    return x, y

pin_memory() 将张量的内存锁定在 RAM 中。这能加快张量传输到 GPU 的速度。就像跟操作系统说：“嘿，别动这块内存，GPU 马上要用！”

通常 to(device) 会阻塞 CPU 直到数据复制到 GPU 完成。non_blocking=True 告诉 CPU 可以继续干其他事（比如准备下一个批次）。

Part 4：组装模型架构

我们来逐一梳理上面的每个模块。

我们以第一个输入批次的第一行为例，看看它的“旅程”——也就是“Tokenized text”。

为了捕捉这些词或 token 的语义，我们需要将它们转换为一定维度的 token Embeddings。这会放在一个 token embedding 矩阵中，矩阵的行数等于词汇表中的单词数。

在这里，每个 token 被转换为一个 768 维的向量。接下来，我们需要关注这些 token 的 positional embeddings。

输入 Embeddings 到 transformer 模块

Dropout

Transformer 模块中的所有操作

Feedforward 神经网络是这样的

上述模块的放大视图

Shortcut 连接很有用，它们提供了另一条路径，可以防止 vanishing gradient 问题。Wq、Wk 和 Wv 参数是我们要学习的。

Q*KT

基本上，我们要看这些模块是如何组装在一起的。

损失函数是根据找到的输出 token 相对于目标 token 计算的。在这一步中，执行了 4 个输入-输出任务。对于每个批次，我们有 4 个损失，总损失 = L1 + L2 + L3 + L4。

Part 5：设置 SLM 训练 pipeline

不同模块的权重初始化

config = GPTConfig(
    vocab_size=50257,     # 使用分词器的词汇表大小
    block_size=128,       # 或你训练时使用的上下文大小
    n_layer=6,            # transformer 模块数量
    n_head=6,             # 注意力头的数量
    n_embd=384,           # Embedding 维度
    dropout=0.1,
    bias=True
)

model = GPT(config)

这部分基本上是模型的配置蓝图。@dataclass 装饰器是一个方便的方式，用来创建主要用于存储数据的类，不需要你自己写繁琐的 __init__ 方法。

• • block_size：这是最大上下文长度。定义了模型在预测时能同时查看的最大 token 数。例如，如果 block_size 是 128，模型可以考虑前 128 个 token 来预测第 129 个。

• • vocab_size：这是词汇表中唯一 token（词或子词）的总数。模型的最终输出将是这些 token 的概率分布。

• • n_layer：指定堆叠的 transformer 模块（或层）的数量。更深的模型（更多层）可以学习更复杂的模式，但计算成本也更高。

• • n_head：这是 multi-head attention 机制中的注意力头数量。分成多个头可以让模型同时关注输入序列的不同部分。

• • n_embd：这是 embedding 向量的维度。输入序列中的每个 token 和位置都会被转换为这个大小的向量。

• • dropout：这是一种正则化技术。在训练期间，它会随机将一部分神经元激活置零，帮助防止模型过拟合训练数据。

• • bias：一个布尔值，决定模型的线性层是否使用偏置项。

class GPT(nn.Module):
    def__init__(self, config):
        super().__init__()
        self.config = config
        self.transformer = nn.ModuleDict(dict(
            wte=nn.Embedding(config.vocab_size, config.n_embd),
            wpe=nn.Embedding(config.block_size, config.n_embd),
            drop=nn.Dropout(config.dropout),
            h=nn.ModuleList([Block(config) for _ inrange(config.n_layer)]),
            ln_f=LayerNorm(config.n_embd, config.bias),
        ))
        self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=False)
        self.transformer.wte.weight = self.lm_head.weight  # 权重共享

        self.apply(self._init_weights)
        for pn, p inself.named_parameters():
            if pn.endswith('c_proj.weight'):
                nn.init.normal_(p, mean=0.0, std=0.02 / math.sqrt(2 * config.n_layer))

    def_init_weights(self, module):
        ifisinstance(module, nn.Linear):
            nn.init.normal_(module.weight, mean=0.0, std=0.02)
            if module.bias isnotNone:
                nn.init.zeros_(module.bias)
        elifisinstance(module, nn.Embedding):
            nn.init.normal_(module.weight, mean=0.0, std=0.02)

    defforward(self, idx, targets=None):
        device = idx.device
        b, t = idx.size()
        assert t <= self.config.block_size
        pos = torch.arange(0, t, dtype=torch.long, device=device)

        tok_emb = self.transformer.wte(idx)
        pos_emb = self.transformer.wpe(pos)
        x = self.transformer.drop(tok_emb + pos_emb)
        for block inself.transformer.h:
            x = block(x)
        x = self.transformer.ln_f(x)

        if targets isnotNone:
            logits = self.lm_head(x)
            loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1), ignore_index=-1)
            return logits, loss
        else:
            logits = self.lm_head(x[:, [-1], :])
            return logits, None

    defgenerate(self, idx, max_new_tokens, temperature=1.0, top_k=None):
        """
        根据给定的条件序列生成 token
        idx: 形状为 (B, T) 的张量
        """
        for _ inrange(max_new_tokens):
            idx_cond = idx if idx.size(1) <= self.config.block_size else idx[:, -self.config.block_size:]
            logits, _ = self(idx_cond)
            logits = logits[:, -1, :] / temperature
            if top_k isnotNone:
                v, _ = torch.topk(logits, min(top_k, logits.size(-1)))
                logits[logits < v[:, [-1]]] = -float('Inf')
            probs = F.softmax(logits, dim=-1)
            idx_next = torch.multinomial(probs, num_samples=1)
            idx = torch.cat((idx, idx_next), dim=1)
        return idx

GPT 类

这是定义整个 GPT 模型架构的主类。

init(self, config) - 构造函数

这个方法在你首次创建 GPT 对象时设置神经网络的所有层。

• • self.transformer = nn.ModuleDict(...)：创建一个字典来存储 transformer 的核心组件。

• • wte (Word Token Embedding)：一个 nn.Embedding 层，将输入 token IDs 转换为 n_embd 大小的密集向量。

• • wpe (Word Position Embedding)：另一个 nn.Embedding 层，为模型提供序列中每个 token 位置的信息。

• • drop：一个 nn.Dropout 层。

• • h：一个 nn.ModuleList，包含 n_layer 个 Block。Block 类（代码中未展示）包含 multi-head self-attention 和 feed-forward 神经网络，是 transformer 的核心。

• • ln_f (Layer Norm Final)：在最后一个 transformer 模块后应用的最终层归一化。

• • self.lm_head：这是“语言模型头”。一个最终的 nn.Linear 层，将 transformer 的输出投影到词汇表大小（vocab_size），生成每个可能下一个 token 的原始分数（logits）。

• • self.transformer.wte.weight = self.lm_head.weight：这是一个叫权重共享的优化技巧。强制输入 embedding 层（wte）和最终输出层（lm_head）共享相同的权重矩阵。这减少了模型的总参数量，还能提升性能。

• • self.apply(self._init_weights)：为网络中的每个模块调用 _init_weights 函数，初始化模型参数，这对稳定训练至关重要。

forward(self, idx, targets=None) - 前向传播

这个方法定义了数据通过模型时的行为。

• • 它接收 idx（一批输入 token 序列），并将它们的 token embeddings 和 positional embeddings 结合。

• • 结合后的 embedding 通过 transformer 模块堆栈（self.transformer.h）。

• • 最终输出通过层归一化（ln_f）。

• • 如果是训练（targets 不为 None）：计算 logits，然后计算模型预测和实际下一个 token（targets）之间的 cross_entropy loss。这个 loss 值用于在训练期间更新模型权重。

• • 如果是生成（targets 为 None）：只计算序列中最后一个 token 的 logits，因为这只需要预测下一个 token。

generate(self, idx, ...) - 文本生成

这个方法使用训练好的模型生成新文本。

• • @torch.no_grad()：告诉 PyTorch 不计算梯度，生成更快，用内存更少。

• • 它循环运行 max_new_tokens 次，生成那么多新 token。

• • 在循环的每一步：

  • • 通过调用 self(idx_cond) 获取模型对下一个 token 的预测（logits）。

  • • 对 logits 应用 temperature，控制输出的随机性。更高的 temperature 意味着更具创意/随机的文本。

  • • 可选择使用 top_k 采样，限制模型选择 k 个最可能的下一个 token。

  • • 使用 softmax 将最终 logits 转换为概率。

  • • 根据这些概率采样下一个 token（torch.multinomial）。

  • • 最后，将新生成的 token 附加到序列中，重复此过程。

定义 SLM 损失函数

假设我们的批次看起来是这样的。

对所有批次一起计算损失。

Part 6：预训练 SLM

定义 SLM 训练配置 Part 1

# 训练配置
import torch
from contextlib import nullcontext

learning_rate = 1e-4# 更稳定的训练，之前是 1e-4
max_iters = 20000# 从 25000 增加
warmup_steps = 1000# 更平滑的初始训练，之前是 100
min_lr = 5e-4# 更低的速率，之前是 5e-4
eval_iters = 500# 从 100 增加
batch_size = 32# 从 16 改为 32，更好的梯度估计
block_size = 128# 从 64 改为 128，捕捉更长距离的依赖

gradient_accumulation_steps = 32# 从 50 减少

device = "cuda"if torch.cuda.is_available() else"cpu"
device_type = 'cuda'if'cuda'in device else'cpu'# 后续用于 torch.autocast
# 注意：float16 数据类型会自动使用 GradScaler

# 如何使用 autocast https://wandb.ai/wandb_fc/tips/reports/How-To-Use-Autocast-in-PyTorch--VmlldzoyMTk4NTky
dtype = 'bfloat16'if torch.cuda.is_available() and torch.cuda.is_bf16_supported() else'float16'# 'float32', 'bfloat16', 或 'float16'，后者会自动使用 GradScaler
ptdtype = {'float32': torch.float32, 'bfloat16': torch.bfloat16, 'float16': torch.float16}[dtype]

ctx = nullcontext() if device_type == 'cpu'else torch.amp.autocast(device_type=device_type, dtype=ptdtype)

torch.set_default_device(device)
torch.manual_seed(42)

定义 SLM 训练配置 Part 2

from torch.optim.lr_scheduler import LinearLR, SequentialLR, CosineAnnealingLR

## 添加 weight decay，将 beta2 改为 0.95
optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate, betas=(0.9, 0.95), weight_decay=0.1, eps=1e-9) # weight decay 用于正则化

scheduler_warmup = LinearLR(optimizer, total_iters=warmup_steps) # 实现线性 warmup
scheduler_decay = CosineAnnealingLR(optimizer, T_max=max_iters - warmup_steps, eta_min=min_lr) # 实现学习率衰减
scheduler = SequentialLR(optimizer, schedulers=[scheduler_warmup, scheduler_decay], milestones=[warmup_steps]) # 从 warmup 切换到衰减

# https://stackoverflow.com/questions/72534859/is-gradscaler-necessary-with-mixed-precision-training-with-pytorch
scaler = torch.cuda.amp.GradScaler(enabled=(dtype == 'float16'))

梯度累积

每 32 步更新一次参数。

预训练 SLM

• • 每轮迭代，选择 X 和 y

• • 将 X 通过模型，获取 logits

• • 计算 logits 和 y 之间的损失（cross-entropy）

• • 反向传播损失

• • 累积梯度，直到达到“gradient-accumulation”步数

• • 使用 AdamW 更新参数

• • 更新学习率

• • 评估并保存最佳模型

best_val_loss = float('inf')
best_model_params_path = "best_model_params.pt"
train_loss_list, validation_loss_list = [], []

# 确保模型在正确的设备上
model = model.to(device)

# 在训练循环中
for epoch in tqdm(range(max_iters)):
    if epoch % eval_iters == 0and epoch != 0:
        # 确保 estimate_loss 使用正确的设备
        losses = estimate_loss(model)
        print(f"Epoch {epoch}: train loss {losses['train']:.4f}, val loss {losses['val']:.4f}")
        print(f"当前学习率: {optimizer.param_groups[0]['lr']:.5f}")
        train_loss_list += [losses['train']]
        validation_loss_list += [losses['val']]

        if losses['val'] < best_val_loss:
            best_val_loss = losses['val']
            torch.save(model.state_dict(), best_model_params_path)

    # 确保 X 和 y 在正确的设备上
    X, y = get_batch("train")
    X, y = X.to(device), y.to(device)

    with ctx:
        logits, loss = model(X, y)
        loss = loss / gradient_accumulation_steps
        scaler.scale(loss).backward()

    if ((epoch + 1) % gradient_accumulation_steps == 0) or (epoch + 1 == max_iters):
        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=0.5)
        scaler.step(optimizer)
        scaler.update()
        optimizer.zero_grad(set_to_none=True)
    scheduler.step()

import matplotlib.pyplot as plt
train_loss_list_converted = [i.cpu().detach() for i in train_loss_list]
validation_loss_list_converted = [i.cpu().detach() for i in validation_loss_list]

plt.plot(train_loss_list_converted, 'g', label='train_loss')
plt.plot(validation_loss_list_converted, 'r', label='validation_loss')
plt.xlabel("Steps - 每 100 个 epoch")
plt.ylabel("Loss")
plt.legend()
plt.show()

Part 7：运行推理

在训练好的模型上运行 SLM 推理

# 加载模型
model = GPT(config)  # 用相同的配置重新创建模型
device = "cuda" if torch.cuda.is_available() else "cpu"
best_model_params_path = "best_model_params.pt"
model.load_state_dict(torch.load(best_model_params_path, map_location=torch.device(device))) # 加载最佳模型状态

对应的下一个 token 的向量被提取出来，并通过 softmax 函数转换为概率分布。

如何学习大模型 AI ？

由于新岗位的生产效率，要优于被取代岗位的生产效率，所以实际上整个社会的生产效率是提升的。

但是具体到个人，只能说是：

“最先掌握AI的人，将会比较晚掌握AI的人有竞争优势”。

这句话，放在计算机、互联网、移动互联网的开局时期，都是一样的道理。

我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。

我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在人工智能学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多互联网行业朋友无法获得正确的资料得到学习提升，故此将并将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

这份完整版的大模型 AI 学习和面试资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】

01.大模型风口已至：月薪30K+的AI岗正在批量诞生

2025年大模型应用呈现爆发式增长，根据工信部最新数据：

国内大模型相关岗位缺口达47万

初级工程师平均薪资28K（数据来源：BOSS直聘报告）

70%企业存在"能用模型不会调优"的痛点

真实案例：某二本机械专业学员，通过4个月系统学习，成功拿到某AI医疗公司大模型优化岗offer，薪资直接翻3倍！

02.如何学习大模型 AI ？

🔥AI取代的不是人类，而是不会用AI的人！麦肯锡最新报告显示：掌握AI工具的从业者生产效率提升47%，薪资溢价达34%！🚀

由于新岗位的生产效率，要优于被取代岗位的生产效率，所以实际上整个社会的生产效率是提升的。

但是具体到个人，只能说是：

“最先掌握AI的人，将会比较晚掌握AI的人有竞争优势”。

这句话，放在计算机、互联网、移动互联网的开局时期，都是一样的道理。

我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。

我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在人工智能学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多互联网行业朋友无法获得正确的资料得到学习提升，故此将并将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

1️⃣ 提示词工程：把ChatGPT从玩具变成生产工具
2️⃣ RAG系统：让大模型精准输出行业知识
3️⃣ 智能体开发：用AutoGPT打造24小时数字员工

📦熬了三个大夜整理的《AI进化工具包》送你：
✔️ 大厂内部LLM落地手册（含58个真实案例）
✔️ 提示词设计模板库（覆盖12大应用场景）
✔️ 私藏学习路径图（0基础到项目实战仅需90天）

第一阶段（10天）：初阶应用

该阶段让大家对大模型 AI有一个最前沿的认识，对大模型 AI 的理解超过 95% 的人，可以在相关讨论时发表高级、不跟风、又接地气的见解，别人只会和 AI 聊天，而你能调教 AI，并能用代码将大模型和业务衔接。

• 大模型 AI 能干什么？
• 大模型是怎样获得「智能」的？
• 用好 AI 的核心心法
• 大模型应用业务架构
• 大模型应用技术架构
• 代码示例：向 GPT-3.5 灌入新知识
• 提示工程的意义和核心思想
• Prompt 典型构成
• 指令调优方法论
• 思维链和思维树
• Prompt 攻击和防范
• …

第二阶段（30天）：高阶应用

该阶段我们正式进入大模型 AI 进阶实战学习，学会构造私有知识库，扩展 AI 的能力。快速开发一个完整的基于 agent 对话机器人。掌握功能最强的大模型开发框架，抓住最新的技术进展，适合 Python 和 JavaScript 程序员。

• 为什么要做 RAG
• 搭建一个简单的 ChatPDF
• 检索的基础概念
• 什么是向量表示（Embeddings）
• 向量数据库与向量检索
• 基于向量检索的 RAG
• 搭建 RAG 系统的扩展知识
• 混合检索与 RAG-Fusion 简介
• 向量模型本地部署
• …

第三阶段（30天）：模型训练

恭喜你，如果学到这里，你基本可以找到一份大模型 AI相关的工作，自己也能训练 GPT 了！通过微调，训练自己的垂直大模型，能独立训练开源多模态大模型，掌握更多技术方案。

到此为止，大概2个月的时间。你已经成为了一名“AI小子”。那么你还想往下探索吗？

• 为什么要做 RAG
• 什么是模型
• 什么是模型训练
• 求解器 & 损失函数简介
• 小实验2：手写一个简单的神经网络并训练它
• 什么是训练/预训练/微调/轻量化微调
• Transformer结构简介
• 轻量化微调
• 实验数据集的构建
• …

第四阶段（20天）：商业闭环

对全球大模型从性能、吞吐量、成本等方面有一定的认知，可以在云端和本地等多种环境下部署大模型，找到适合自己的项目/创业方向，做一名被 AI 武装的产品经理。

• 硬件选型
• 带你了解全球大模型
• 使用国产大模型服务
• 搭建 OpenAI 代理
• 热身：基于阿里云 PAI 部署 Stable Diffusion
• 在本地计算机运行大模型
• 大模型的私有化部署
• 基于 vLLM 部署大模型
• 案例：如何优雅地在阿里云私有部署开源大模型
• 部署一套开源 LLM 项目
• 内容安全
• 互联网信息服务算法备案
• …

学习是一个过程，只要学习就会有挑战。天道酬勤，你越努力，就会成为越优秀的自己。

如果你能在15天内完成所有的任务，那你堪称天才。然而，如果你能完成 60-70% 的内容，你就已经开始具备成为一名大模型 AI 的正确特征了。

这份完整版的大模型 AI 学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】