这篇教程将带你一步步在 JupyterLab 中实现一个简单的语言模型。我们将从零开始，使用 PyTorch 实现一个基于 Transformer 架构的字符级语言模型。尽管在实际应用中，大多数人更倾向于使用 Hugging Face 的预训练模型，但本文的目的是让你了解语言模型的基本原理和实现步骤。接下来，我们会讲解数据预处理、模型构建、训练过程以及如何利用模型生成文本，每个环节都附有详细的代码和解释，力求让内容通俗易懂。

近年来，基于 Transformer 架构的语言模型（如 GPT 系列）在自然语言处理领域取得了巨大成功。Transformer 模型能够处理长距离依赖问题，在文本生成、机器翻译、对话系统等方面表现出色。然而，这些大规模模型通常需要海量数据和算力进行训练，对于初学者来说直接训练大模型并不现实。因此，本文将带领你通过一个简单的示例，使用字符级数据和小规模模型，体会构建语言模型的基本流程。

在本教程中，我们将使用 Python 和 PyTorch 实现整个流程。虽然我们的示例数据非常有限，但你可以在此基础上扩展数据集和模型复杂度，进一步深入学习语言模型的工作原理。

想象你在阅读小说时，大脑会自动关注"他举起剑"中的"剑"比"举起"更重要。Transformer的自注意力机制正是模拟这个过程，通过数学计算为每个词语分配注意力权重。在"今天天气真好"这句话中，模型会自动加强"天气"与"真好"的关联，理解这是对天气状况的积极评价。

模块，内部就包含着复杂的注意力计算：这个公式如同精密的筛子，筛选出句子中最关键的语义信息。

传统RNN像传送带处理词语，会混淆"狗咬人"与"人咬狗"，会破坏词语顺序。Transformer采用正弦波位置编码，为每个位置生成独特的ID。如下面的代码所示，这种编码既能标记绝对位置，又能通过波形周期捕捉相对位置关系，完美保留"今天→天气→真好"的语序信息。

Transformer采用正弦波位置编码：

pe[:,0::2] = sin(position/10000^(2i/d_model))
pe[:,1::2] = cos(position/10000^(2i/d_model))

这种设计让每个位置获得唯一坐标，既标记绝对位置，又通过波形周期捕捉相对距离，如同给每个词语佩戴GPS定位器。

模型左侧的编码器像专注的倾听者，将输入语句转化为蕴含深意的"记忆晶体"。右侧的解码器则是睿智的回应者，边生成文字边参考记忆晶体。这种分工协作的设计，使得模型可以处理"听"与"说"两个不同维度的任务。这种分工在代码中体现为：

memory = transformer.encoder(src_emb)  # 编码
output = transformer.decoder(tgt_emb, memory)  # 解码

char2idx = {'<sos>':0, '<eos>':1, '今':2, '天':3...} 

自定义Dataset类实现动态填充：确保每个批次的句子长度统一，如同将不同尺寸的包裹装入标准货箱。

def __getitem__(self, idx):
    src, tgt = self.pairs[idx]
    src_tensor = [0]+[字→编号] + [2]*(剩余长度)

模型类包含四大核心组件：这相当于建造AI大脑的四个功能区域：感觉皮层、位置感知区、思维中枢、语言输出区。这个类定义了AI大脑的结构：先将文字转化为数学向量，添加位置印记，经过多层Transformer块处理，最终输出概率分布。

class MultiTurnTransformer(nn.Module):
    def __init__(self):
        self.embedding = nn.Embedding(...)  # 词语数字化
        self.pos_encoder = PositionalEncoding()  # 添加位置信息
        self.transformer = nn.Transformer(...)  # 核心处理器 
        self.fc = nn.Linear(...)  # 概率解码器

引入三大训练技巧：如同驾校教练的教学诀窍：控制学习速度、调整练习强度、增加训练变化。

torch.nn.utils.clip_grad_norm_(...)  # 梯度裁剪
optim.Adam(..., betas=(0.9, 0.98))  # 优化器调参
temperature=0.7  # 温度采样

采用渐进式生成策略：训练过程如同教幼儿说话：反复展示"问题→答案"配对，通过反向传播算法自动调整神经网络参数。损失值下降曲线，直观展示模型的学习进度。

for _ in range(max_length):
    logits = model.fc(output[:, -1, :])
    next_token = topk_sampling(logits)

这就像画家作画：先勾勒轮廓（首字），再逐步细化（后续词语），最后收笔（遇到

测试案例显示模型已掌握天气对话：

输入: 紫外线强度高吗 → 回复: 指数8，建议防晒
输入: 今晚有雾吗 → 回复: 预计轻雾，能见度500米

曾导致错误的四维张量问题，揭示了深度学习中的维度哲学：

这如同俄罗斯套娃，每一层维度都有其存在意义。

处理填充符号时，我们通过布尔掩码实现"选择性遗忘"：

src_mask = (src == 2)  # 标记填充位置

这教会AI区分真实内容与占位符，如同人类区分重要信息与背景噪音。

这恰似调节AI的"想象力旋钮"，在准确性与创造性间寻找平衡。

当前实现虽能完成基础对话，但距离实用化仍有三大鸿沟：

当我们在JupyterLab中运行出第一个AI回复时，实际上正在参与重塑人机交互的未来。Transformer架构带来的不仅是技术革新，更是对人机关系的重新定义：

正如深度学习先驱Yoshua Bengio所言："语言理解是打开通用人工智能之门的钥匙。"当我们教会AI理解"天气真好"的深意时，也在为机器注入理解人类情感的种子。

每个技术细节的突破，都是人类认知边界的拓展。从

到智能对话，这不仅关乎代码与算法，更映射着人类对创造智能生命的不懈追求。当你亲手运行出第一个AI回复时，请记住：那闪烁的光标，正书写着人机共生的新篇章。冲鸭~，年轻的我们。

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
import math
import numpy as np

# 超参数配置
d_model = 64
nhead = 4
num_layers = 2
dim_feedforward = 256
max_length = 20
batch_size = 2  # 小批量训练
learning_rate = 0.001
epochs = 200

# 多轮对话数据集
dialogue_pairs = [
    ("今天天气真好", "今天是阳光明媚的一天，可以出门郊游哦"),
    ("明天有雨吗", "预计明天将有小到中雨，请带好雨具"),
    ("周末气温如何", "周末气温在22-28摄氏度之间，适宜户外活动"),
    ("空气质量怎么样", "当前空气质量指数为35，属于优等级别"),
    ("会刮大风吗", "风力预计3-4级，请注意防风"),
    ("紫外线强度高吗", "紫外线指数8，建议做好防晒措施"),
    ("现在湿度多少", "当前相对湿度65%，体感舒适"),
    ("今晚有雾吗", "预计夜间将出现能见度500米左右的轻雾")
]

# 构建增强词汇表
all_chars = set()
for src, tgt in dialogue_pairs:
    all_chars.update(src)
    all_chars.update(tgt)

chars = sorted(list(all_chars))
vocab_size = len(chars) + 3
char2idx = {'<sos>': 0, '<eos>': 1, '<pad>': 2}
char2idx.update({c: i + 3 for i, c in enumerate(chars)})
idx2char = {v: k for k, v in char2idx.items()}

# 自定义数据集类
class DialogueDataset(Dataset):
    def __init__(self, pairs, max_len=max_length):
        self.pairs = pairs
        self.max_len = max_len

    def __len__(self):
        return len(self.pairs)

    def __getitem__(self, idx):
        src, tgt = self.pairs[idx]
        
        # 统一处理逻辑
        def process_seq(text, is_target=False):
            indices = [char2idx['<sos>']]
            indices += [char2idx[c] for c in text][:self.max_len - 2]
            if is_target:
                indices.append(char2idx['<eos>'])
            padding = [char2idx['<pad>']] * (self.max_len - len(indices))
            return torch.LongTensor(indices + padding)
        
        src_tensor = process_seq(src)
        tgt_tensor = process_seq(tgt, is_target=True)
        
        return src_tensor, tgt_tensor

# 创建数据加载器
dataset = DialogueDataset(dialogue_pairs)
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

# 改进的位置编码
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):
        x = x + self.pe[:x.size(1), :]
        return x

# 增强模型结构
class MultiTurnTransformer(nn.Module):
    def __init__(self):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, d_model, padding_idx=char2idx['<pad>'])
        self.pos_encoder = PositionalEncoding(d_model)
        self.transformer = nn.Transformer(
            d_model=d_model,
            nhead=nhead,
            num_encoder_layers=num_layers,
            num_decoder_layers=num_layers,
            dim_feedforward=dim_feedforward,
            batch_first=True
        )
        self.fc = nn.Linear(d_model, vocab_size)
        self.init_weights()

    def init_weights(self):
        initrange = 0.1
        self.embedding.weight.data.uniform_(-initrange, initrange)
        self.fc.bias.data.zero_()
        self.fc.weight.data.uniform_(-initrange, initrange)

    def forward(self, src, tgt):
        # 创建布尔型填充掩码
        src_key_padding_mask = (src == char2idx['<pad>'])
        tgt_key_padding_mask = (tgt == char2idx['<pad>'])
        
        # 嵌入和位置编码
        src_emb = self.embedding(src) * math.sqrt(d_model)
        src_emb = self.pos_encoder(src_emb)
        
        tgt_emb = self.embedding(tgt) * math.sqrt(d_model)
        tgt_emb = self.pos_encoder(tgt_emb)
        
        # 生成注意力掩码（统一为布尔类型）
        seq_len = tgt.size(1)
        tgt_mask = nn.Transformer.generate_square_subsequent_mask(seq_len).to(src.device)
        
        # 修正后的Transformer处理
        output = self.transformer(
            src_emb, 
            tgt_emb,
            tgt_mask=tgt_mask,
            src_key_padding_mask=src_key_padding_mask,
            tgt_key_padding_mask=tgt_key_padding_mask
        )
        return self.fc(output)

# 初始化模型
model = MultiTurnTransformer()
criterion = nn.CrossEntropyLoss(ignore_index=char2idx['<pad>'])
optimizer = optim.Adam(model.parameters(), lr=learning_rate, betas=(0.9, 0.98), eps=1e-9)

# 训练循环改进
for epoch in range(epochs):
    total_loss = 0
    for batch_idx, (src, tgt_full) in enumerate(dataloader):
        optimizer.zero_grad()
        
        # 准备输入输出
        tgt_input = tgt_full[:, :-1]  # 输入序列：<sos> ... <last-1>
        tgt_output = tgt_full[:, 1:]   # 目标序列：... <eos>
        
        # 前向传播
        output = model(src, tgt_input)
        loss = criterion(output.reshape(-1, vocab_size), tgt_output.reshape(-1))
        
        # 反向传播
        loss.backward()
        torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)
        optimizer.step()
        
        total_loss += loss.item()
    
    avg_loss = total_loss / len(dataloader)
    if (epoch + 1) % 20 == 0:
        print(f'Epoch [{epoch + 1}/{epochs}], Loss: {avg_loss:.4f}')

# 增强生成函数
# 修改生成函数中的输入预处理部分
def smart_generate(input_str, temperature=0.7, top_k=5):
    model.eval()
    with torch.no_grad():
        # 预处理输入（关键修正点）
        src_indices = [char2idx['<sos>']] + [char2idx[c] for c in input_str] + [char2idx['<eos>']]
        src = torch.LongTensor(src_indices).unsqueeze(0)  # (1, seq_len)
        
        # 编码阶段
        src_emb = model.embedding(src) * math.sqrt(d_model)
        src_emb = model.pos_encoder(src_emb)
        memory = model.transformer.encoder(src_emb)
        
        # 解码初始化
        tgt = torch.LongTensor([[char2idx['<sos>']]])  # (1, 1)
        
        for _ in range(max_length):
            tgt_emb = model.embedding(tgt) * math.sqrt(d_model)
            tgt_emb = model.pos_encoder(tgt_emb)
            
            output = model.transformer.decoder(tgt_emb, memory)
            logits = model.fc(output[:, -1, :])
            
            # 采样策略
            logits = logits / temperature
            top_logits, top_indices = logits.topk(top_k, dim=-1)
            probs = torch.softmax(top_logits, dim=-1)
            next_token = top_indices[0, torch.multinomial(probs[0], 1)]
            
            if next_token == char2idx['<eos>']:
                break
                
            tgt = torch.cat([tgt, next_token.unsqueeze(0)], dim=1)
            
        return ''.join([idx2char[idx.item()] for idx in tgt.squeeze()[1:]])

# 测试多轮对话
test_cases = [
    "空气质量怎么样",
    "会刮大风吗",
    "紫外线强度高吗",
    "今晚有雾吗"
]

for case in test_cases:
    print(f"输入: {case}")
    print(f"回复: {smart_generate(case)}\n")

使用HAI，基于PyTorch 实现一个基于 Transformer 架构的字符级语言模型

这篇教程将带你一步步在 JupyterLab 中实现一个简单的语言模型。我们将从零开始，使用 PyTorch 实现一个基于 Transformer 架构的字符级语言模型。尽管在实际应用中，大多数人更倾向于使用 Hugging Face 的预训练模型，但本文的目的是让你了解语言模型的基本原理和实现步骤。接下来，我们会讲解数据预处理、模型构建、训练过程以及如何利用模型生成文本，每个环节都附有详细的代码

产品KOL

编程语言

本教程通过JupyterLab使用PyTorch实现基于Transformer架构的字符级语言模型，详细讲解数据预处理、模型构建、训练及文本生成，帮助理解语言模型原理，附有代码示例，适合初学者学习并扩展应用。

自然语言处理

对话机器人

数据预处理

机器翻译

人机交互

人工智能

深度学习

数据流

ChatGPT

Python

AI驱动 智领未来

xiaowei

ai-class

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

使用HAI，基于PyTorch 实现一个基于 Transformer 架构的字符级语言模型

使用HAI，基于PyTorch 实现一个基于 Transformer 架构的字符级语言模型

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐