黑马《Java架构师实战训练营 (含完整资料)》

51CTO-AI大模型技术体系课：从Transformer到Agent的代码实践之旅

本文旨在通过关键代码片段，揭示"51CTO-AI大模型技术体系课"所涵盖的核心技术栈。我们将跳过泛泛而谈，直击技术本质，展示课程如何通过代码将复杂的理论落地。

一、基石：Transformer架构的代码解剖

任何大模型课程的核心都是Transformer。课程不会只给你看公式，而是带你用PyTorch搭建其核心组件------自注意力机制。

ini 复制代码

import torch
import torch.nn as nn
import torch.nn.functional as F

class SelfAttention(nn.Module):
    def __init__(self, d_model, heads):
        super().__init__()
        self.d_model = d_model
        self.heads = heads
        self.head_dim = d_model // heads
        
        assert d_model % heads == 0, "d_model must be divisible by number of heads"
        
        # 线性变换得到Q, K, V
        self.to_queries = nn.Linear(d_model, d_model, bias=False)
        self.to_keys = nn.Linear(d_model, d_model, bias=False)
        self.to_values = nn.Linear(d_model, d_model, bias=False)
        
        # 输出线性层
        self.unify_heads = nn.Linear(d_model, d_model)
        
    def forward(self, x):
        # x shape: (batch, seq_len, d_model)
        b, t, d = x.size()
        h = self.heads
        
        # 生成Q, K, V，并分割成多头
        Q = self.to_queries(x).view(b, t, h, self.head_dim).transpose(1, 2) # (b, h, t, head_dim)
        K = self.to_keys(x).view(b, t, h, self.head_dim).transpose(1, 2)
        V = self.to_values(x).view(b, t, h, self.head_dim).transpose(1, 2)
        
        # 计算注意力分数 (Q * K^T) / sqrt(d_k)
        scores = torch.matmul(Q, K.transpose(-2, -1)) / (self.head_dim ** 0.5)
        attn_weights = F.softmax(scores, dim=-1)
        
        # 应用注意力权重到V
        out = torch.matmul(attn_weights, V) # (b, h, t, head_dim)
        
        # 合并多头
        out = out.transpose(1, 2).contiguous().view(b, t, d) # (b, t, d_model)
        
        # 通过线性层
        return self.unify_heads(out)

# 示例：实例化一个8头，512维的自注意力层
attn_layer = SelfAttention(d_model=512, heads=8)
x = torch.randn(2, 10, 512) # (batch_size, sequence_length, d_model)
output = attn_layer(x)
print(f"Input shape: {x.shape}")
print(f"Output shape: {output.shape}")

课程价值：通过手写SelfAttention，学员将深刻理解多头机制、缩放点积、维度变换等核心概念，为理解BERT、GPT等模型打下坚实基础。

二、预训练与微调：从零开始理解GPT的生成过程

课程会深入大模型的预训练目标------因果语言建模，并展示最朴素的文本生成代码。

ini 复制代码

def causal_lm_training_step(model, tokenizer, text_batch):
    """
    简化版的因果语言模型训练步骤
    """
    # 1. 分词并构建输入和标签
    inputs = tokenizer(text_batch, return_tensors='pt', padding=True, truncation=True)
    input_ids = inputs['input_ids']
    
    # 标签是输入向右偏移一位
    labels = input_ids[:, 1:].contiguous() # 从第二个token开始作为标签
    # 需要将输入截断一位，与标签长度对齐
    input_ids = input_ids[:, :-1] # 到倒数第二个token为止作为输入
    
    # 2. 前向传播
    outputs = model(input_ids=input_ids)
    logits = outputs.logits # (batch, seq_len, vocab_size)
    
    # 3. 计算损失（交叉熵）
    loss_fn = nn.CrossEntropyLoss(ignore_index=tokenizer.pad_token_id)
    loss = loss_fn(logits.view(-1, logits.size(-1)), labels.view(-1))
    
    return loss

def simple_generate(model, tokenizer, prompt, max_length=50):
    """
    简单的自回归生成（贪婪解码）
    """
    model.eval()
    input_ids = tokenizer.encode(prompt, return_tensors='pt')
    
    with torch.no_grad():
        for _ in range(max_length):
            outputs = model(input_ids)
            next_token_logits = outputs.logits[:, -1, :] # 取最后一个时间步的logits
            next_token_id = torch.argmax(next_token_logits, dim=-1).unsqueeze(-1) # 贪婪选择
            
            # 将新生成的token拼接到输入中
            input_ids = torch.cat([input_ids, next_token_id], dim=1)
            
            # 如果生成了结束符，则停止
            if next_token_id == tokenizer.eos_token_id:
                break
                
    generated_text = tokenizer.decode(input_ids.squeeze(), skip_special_tokens=True)
    return generated_text

# 示例使用（假设model和tokenizer已加载）
# loss = causal_lm_training_step(model, tokenizer, ["今天天气真好"， "人工智能是未来的方向"])
# generated = simple_generate(model, tokenizer, "人工智能可以")

课程价值：这段代码揭示了GPT家族模型"逐词生成"的本质。学员将明白预训练如何让模型学会语言规律，以及微调如何在此基础上适应特定任务。

三、核心技巧：指令微调与RLHF的关键代码逻辑

课程会深入大模型对齐的核心------指令微调和基于人类反馈的强化学习，展示其核心逻辑。

python 复制代码

# 指令微调（Instruction Tuning）的核心：构造指令-回答对
def format_instruction_data(instruction, response):
    """将指令和回答格式化为模型输入"""
    # 常用模板，如Alpaca格式
    prompt_template = f"Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n### Instruction:\n{instruction}\n\n### Response:\n"
    full_input = prompt_template
    full_target = response # 模型需要生成的目标部分
    return full_input, full_target

# RLHF中的奖励模型训练（简化版）
class RewardModel(nn.Module):
    def __init__(self, base_model):
        super().__init__()
        self.transformer = base_model
        # 在基础模型上加一个回归头，输出一个标量分数
        self.value_head = nn.Linear(base_model.config.hidden_size, 1)
        
    def forward(self, input_ids):
        outputs = self.transformer(input_ids=input_ids)
        hidden_states = outputs.last_hidden_state # (batch, seq, hidden_size)
        # 取最后一个token的隐藏状态作为序列表示
        last_token_hidden = hidden_states[:, -1, :]
        reward_score = self.value_head(last_token_hidden).squeeze(-1)
        return reward_score

# PPO训练循环的关键步骤（概念性代码）
def ppo_training_step(policy_model, ref_model, reward_model, prompt):
    # 1. 策略模型根据prompt生成回答
    generated_response = policy_model.generate(prompt)
    
    # 2. 使用奖励模型为生成的回答打分
    with torch.no_grad():
        reward_score = reward_model(generated_response)
        
    # 3. 计算当前策略模型和参考模型（旧策略）的KL散度，作为惩罚项
    # ... (涉及logits的复杂计算)
    
    # 4. 组合奖励和KL惩罚，形成PPO的优化目标
    # ... (PPO-Clip核心算法)
    
    # 5. 反向传播，更新策略模型
    # ...

课程价值：通过代码化的RLHF流程，学员将理解ChatGPT等对话模型为何能如此"听话"和"有用"，掌握让大模型与人类价值观对齐的关键技术。

四、应用落地：构建基于Function Calling的AI Agent

课程最后会引导学员将大模型转化为能调用工具、执行任务的智能体。

python 复制代码

import json

# 定义工具（函数）
def get_weather(city: str) -> str:
    """获取指定城市的天气情况。"""
    # 这里是模拟实现
    weather_data = {
        "北京": "晴，25°C",
        "上海": "多云，27°C",
        "深圳": "阵雨，30°C"
    }
    return weather_data.get(city, "未找到该城市天气信息")

def calculator(expression: str) -> str:
    """计算数学表达式。"""
    try:
        result = eval(expression) # 注意：生产环境禁用eval，此处仅为示例
        return f"{expression} = {result}"
    except:
        return "计算错误，请检查表达式。"

# 可供模型调用的工具列表
available_functions = {
    "get_weather": get_weather,
    "calculator": calculator
}

# 模拟大模型的Function Calling输出
def mock_llm_function_call(user_query):
    """模拟大模型分析用户意图并决定调用哪个函数。"""
    if "天气" in user_query:
        return {
            "reasoning": "用户询问天气，需要调用天气查询函数。",
            "function_name": "get_weather",
            "parameters": {"city": "北京"} # 简单起见，这里固定城市，实际应由模型提取
        }
    elif "计算" in user_query or "+" in user_query or "-" in user_query:
        return {
            "reasoning": "用户需要数学计算，调用计算器函数。",
            "function_name": "calculator",
            "parameters": {"expression": "3 + 5 * 2"}
        }
    else:
        return {"reasoning": "无需调用函数，直接回答。", "action": "direct_response"}

# AI Agent 执行循环
def run_ai_agent(user_input):
    print(f"用户: {user_input}")
    
    # 1. 大模型分析意图，决定行动
    decision = mock_llm_function_call(user_input)
    print(f"AI决策: {decision['reasoning']}")
    
    # 2. 如果决定调用函数
    if 'function_name' in decision:
        func_name = decision['function_name']
        params = decision['parameters']
        func = available_functions[func_name]
        
        # 执行函数
        result = func(**params)
        print(f"执行工具 `{func_name}`: 输入 {params}, 输出 {result}")
        
        # 3. （可选）将函数执行结果返回给大模型，让其生成最终的自然语言回答
        final_response = f"根据查询，结果是：{result}"
        return final_response
    else:
        # 直接回答的逻辑
        return "这是一个需要我直接回答的问题。"

# 运行Agent
response = run_ai_agent("今天北京天气怎么样？")
print(f"Agent: {response}")

response = run_ai_agent("帮我算一下3加5乘以2等于多少？")
print(f"Agent: {response}")

课程价值：此代码构建了一个简易AI Agent的核心循环。学员将学会如何将大模型的推理能力与外部工具/API相结合，创造出能解决实际问题的应用，这是当前AI应用开发的最前沿。

总结

"51CTO-AI大模型技术体系课"的独特之处在于，它不是知识的罗列，而是通过层层递进的代码实践，将Transformer、预训练、微调、对齐、Agent化等宏大概念，逐一拆解为可运行、可调试、可扩展的工程模块。从一行行代码中，您将真正构建出对大模型技术的深刻直觉和工程能力，而不仅仅是停留在理论层面。这正是成为一名合格的AI工程师或研究员所必需的硬核训练。