从机器学习到大语言模型：AI技术演进的核心突破与实践指南

1次阅读

没有评论

共计 3051 个字符，预计需要花费 8 分钟才能阅读完成。

2000-2012 年（传统机器学习时代）：

特征工程 (Feature Engineering) 是核心：手工设计特征占 70% 工作量
模型以浅层结构为主：SVM、随机森林(Random Forest)、GBDT 等
训练方式：完全监督学习(Supervised Learning)，依赖标注数据

2012-2017 年（深度学习崛起）：

特征自动提取：CNN 在图像领域大放异彩，LSTM 处理序列数据
工程痛点：RNN 存在梯度消失问题，LSTM 缓解但计算复杂
训练数据：开始使用数据增强 (Data Augmentation) 技术

2017 年至今（大语言模型时代）：

Transformer 架构革命：自注意力 (Self-Attention) 机制成为标配
训练范式：自监督学习 (Self-supervised Learning) 成为主流
规模效应：模型参数量从百万级跃升至万亿级

注意力权重的计算公式：

$$
\text{Attention}(Q,K,V) = \text{softmax}(\frac{QK^T}{\sqrt{d_k}})V
$$

其中：
– $Q$（Query）、$K$（Key）、$V$（Value）分别对应三种向量
– $d_k$ 是向量的维度，缩放因子防止 softmax 梯度消失

多头注意力 (Multi-Head Attention) 实现：

$$
\text{MultiHead}(Q,K,V) = \text{Concat}(head_1,…,head_h)W^O
$$

每个注意力头的计算：

$$
head_i = \text{Attention}(QW_i^Q, KW_i^K, VW_i^V)
$$

特性	RNN	LSTM	Transformer
并行能力	序列依赖	序列依赖	完全并行
长程依赖	难以捕捉	部分解决	完美解决
内存占用	低	中等	高
计算复杂度	O(n)	O(n)	O(n²)

import torch
import torch.nn as nn

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, dtype=torch.float).unsqueeze(1)
        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)

    def forward(self, x):
        return x + self.pe[:x.size(1)]

class TransformerBlock(nn.Module):
    """Transformer 基础块"""
    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1):
        super().__init__()
        self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
        self.linear1 = nn.Linear(d_model, dim_feedforward)
        self.dropout = nn.Dropout(dropout)
        self.linear2 = nn.Linear(dim_feedforward, d_model)
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)

    def forward(self, src, src_mask=None):
        src2 = self.self_attn(src, src, src, attn_mask=src_mask)[0]
        src = src + self.dropout(src2)
        src = self.norm1(src)
        src2 = self.linear2(self.dropout(F.relu(self.linear1(src))))
        src = src + self.dropout(src2)
        return self.norm2(src)

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import get_peft_model, LoraConfig

# 加载基础模型
model_name = "gpt2-medium"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

# 添加 LoRA 适配器
peft_config = LoraConfig(
    task_type="CAUSAL_LM",
    r=8,
    lora_alpha=32,
    lora_dropout=0.1,
    target_modules=["c_attn"]
)
model = get_peft_model(model, peft_config)

# 训练循环示例
for batch in train_dataloader:
    inputs = tokenizer(batch["text"], return_tensors="pt", padding=True, truncation=True)
    outputs = model(**inputs, labels=inputs["input_ids"])
    loss = outputs.loss
    loss.backward()
    optimizer.step()
    optimizer.zero_grad()