$ head -n 8 ci.txt虞美人 李煜春花秋月何时了，往事知多少？小楼昨夜又东风，故国不堪回首月明中。雕栏玉砌应犹在，只是朱颜改。问君能有几多愁？恰似一江春水向东流。
乌夜啼 李煜昨夜风兼雨，帘帏飒飒秋声。

import random
random.seed(42) # 去掉此行，获得随机结果
prompt = "春江"max_new_token = 100
with open('ci.txt', 'r', encoding='utf-8') as f:    text = f.read()
chars = sorted(list(set(text)))vocab_size = len(chars)stoi = { ch:i for i,ch in enumerate(chars) }itos = { i:ch for i,ch in enumerate(chars) }encode = lambda s: [stoi[c] for c in s]decode = lambda l: ''.join([itos[i] for i in l])
transition = [[0 for _ in range(vocab_size)] for _ in range(vocab_size)]
for i in range(len(text) - 1):    current_token_id = encode(text[i])[0]    next_token_id = encode(text[i + 1])[0]    transition[current_token_id][next_token_id] += 1
generated_token = encode(prompt)
for i in range(max_new_token - 1):    current_token_id = generated_token[-1]    logits = transition[current_token_id]    total = sum(logits)    logits = [logit / total for logit in logits]    next_token_id = random.choices(range(vocab_size), weights=logits, k=1)[0]    generated_token.append(next_token_id)


    
    current_token_id = next_token_id
print(decode(generated_token))

$ python simplemodel.py春江月 张先生疑被。
倦旅。清歌声月边、莼鲈清唱，尽一卮酒红蕖花月，彩笼里繁蕊珠玑。只今古。浣溪月上宾鸿相照。乞团，烟渚澜翻覆古1半吐，还在蓬瀛烟沼。木兰花露弓刀，更任东南楼缥缈。黄柳，

>>> from transformers import AutoTokenizer>>> tokenizer = AutoTokenizer.from_pretained('Qwen/Qwen2.5-0.5B')>>> tokenizer.vocab_size151643>>> tokenizer.encode("春江花月夜")[99528, 69177, 99232, 9754, 99530]>>> tokenizer.encode("阿里巴巴")[107076]>>> tokenizer.encode("阿里妈妈")[102661, 101935]>>> tokenizer.encode("人工智能")[104455]>>> tokenizer.decode([102661, 104455, 101935])'阿里人工智能妈妈'

import randomfrom typing import List
random.seed(42) # 去掉此行，获得随机结果prompts = ["春江", "往事"]max_new_token = 100max_iters = 8000batch_size = 32block_size = 8with open('ci.txt', 'r', encoding='utf-8') as f:    text = f.read()class Tokenizer:    def __init__(self, text: str):        self.chars = sorted(list(set(text)))        self.vocab_size = len(self.chars)        self.stoi = {ch: i for i, ch in enumerate(self.chars)}        self.itos = {i: ch for i, ch in enumerate(self.chars)}        def encode(self, s: str) -> List[int]:        return [self.stoi[c] for c in s]        def decode(self, l: List[int]) -> str:        return''.join([self.itos[i] for i in l])


    
class BigramLanguageModel():    def __init__(self, vocab_size: int):        self.vocab_size = vocab_size        self.transition = [[0 for _ in range(vocab_size)]                           for _ in range(vocab_size)]            def __call__(self, x):        # 方便直接调用model(x)        return self.forward(x)        def forward(self, idx: List[List[int]]) -> List[List[List[float]]]:        '''        输入idx，是一个二维数组，如[[1, 2, 3],                                  [4, 5, 6]]        表示同时希望推理的多个序列        输出是一个三维数组，如[[[0.1, 0.2, 0.3, .. (vocab_size)],                                [0.4, 0.5, 0.6, .. (vocab_size)],                                [0.7, 0.8, 0.9, .. (vocab_size)]],                               [[0.2, 0.3, 0.4, .. (vocab_size)],                                [0.5, 0.6, 0.7, .. (vocab_size)],                                [0.8, 0.9, 1.0, .. (vocab_size)]]]                '''        B = len(idx)  # 批次大小        T = len(idx[0])  # 每一批的序列长度                logits = [            [[0.0 for _ in range(self.vocab_size)]              for _ in range(T)]            for _ in range(B)        ]                for b in range(B):            for t in range(T):                current_token = idx[b][t]                # 计算了每一个token的下一个token的概率                logits[b][t] = self.transition[current_token]                        return logits    def generate(self, idx: List[List[int]], max_new_tokens: int) -> List[int]:        for _ in range(max_new_tokens):            logits_batch = self(idx)            for batch_idx, logits in enumerate(logits_batch):                # 我们计算了每一个token的下一个token的概率                # 但实际上我们只需要最后一个token的“下一个token的概率”                logits = logits[-1]                total = max(sum(logits),1)                # 归一化                logits = [logit / total for logit in logits]                # 根据概率随机采样                next_token = random.choices(                    range(self.vocab_size),                    weights=logits,                    k=1                )[0]                idx[batch_idx].append(next_token)        return idx    def get_batch(tokens, batch_size, block_size):    '''    随机获取一批数据x和y用于训练    x和y都是二维数组，可以用于并行训练    其中y数组内的每一个值，都是x数组内对应位置的值的下一个值    格式如下：    x = [[1, 2, 3],         [9, 10, 11]]    y = [[2, 3, 4],         [10, 11, 12]]    '''    ix = random.choices(range(len(tokens) - block_size), k=batch_size)    x, y = [], []


    
    for i in ix:        x.append(tokens[i:i+block_size])        y.append(tokens[i+1:i+block_size+1])    return x, ytokenizer = Tokenizer(text)vocab_size = tokenizer.vocab_sizetokens = tokenizer.encode(text)model = BigramLanguageModel(vocab_size)# 训练for iter in range(max_iters):    x_batch, y_batch = get_batch(tokens, batch_size, block_size)    for i in range(len(x_batch)):        for j in range(len(x_batch[i])):            x = x_batch[i][j]            y = y_batch[i][j]            model.transition[x][y] += 1prompt_tokens = [tokenizer.encode(prompt) for prompt in prompts]# 推理result = model.generate(prompt_tokens, max_new_token)# decodefor tokens in result:    print(tokenizer.decode(tokens))    print('-'*10)

$ python simplebigrammodel.py春江红紫霄效颦。
怎。兰修月。两个事对西风酒伴寄我登临，看雪惊起步，总不与泪满南园春来。最关上阅。信断，名姝，夜正坐认旧武仙 朱弦。
岁，回。

看一丝竹。愿皇受风，当。
妆一笑时，不堪----------往事多闲田舍、十三楚珪酒困不须紫芝兰花痕皱，青步虹。暗殿人物华高层轩者，临江渌池塘。三峡。天、彩霞冠燕翻云垂杨、一声羌笛罢瑶觥船窗幽园春生阵。长桥。无恙，中有心期。
开处。燕姹绿遍，烂□----------

def get_batch(tokens, batch_size, block_size):    ix = random.choices(range(len(tokens) - block_size), k=batch_size)    x, y = [], []    for i in ix:        x.append(tokens[i:i+block_size])        y.append(tokens[i+1:i+block_size+1])    return x, y

    def forward(self, idx: List[List[int]]) -> List[List[List[float]]]:        B = len(idx)  # 批次大小        T = len(idx[0])  # 每一批的序列长度                logits = [            [[0.0for _ in range(self.vocab_size)]              for _ in range(T)]            for _ in range(B)        ]                for b in range(B):            for t in range(T):                current_token = idx[b][t]                # 计算了每一个token的下一个token的概率                logits[b][t] = self.transition[current_token]                        return logits

import torchfrom torch import nnfrom torch.nn import functional as F
torch.manual_seed(42) # 随机数种子，方便复现
# 判断环境中是否有GPUdevice = 'cuda'if torch.cuda.is_available() else'mps'if torch.mps.is_available() else'cpu'print(f"Using {device} device")
# 1. 创建tensor演示x = torch.tensor([1.0, 2.0, 3.0])y = torch.tensor([2.0, 4.0, 6.0])
# 2. 基本运算演示print(x + y)                # 加法: tensor([3., 6., 9.])


    
print(x * y)                # 点乘: tensor([2., 8., 18.])print(torch.matmul(x, y))   # 矩阵乘法: tensor(28.)print(x @ y)                # 另一种矩阵乘写法: tensor(28.)print(x.shape)              # tensor的形状: torch.Size([3])
# 3. 定义模型class SimpleNet(nn.Module):    def __init__(self):        super().__init__()        self.linear = nn.Linear(1, 1)  # 输入维度=1，输出维度=1        def forward(self, x):        return self.linear(x)
# 4. 生成训练数据# 真实关系: y = 2x + 1x_train = torch.rand(100, 1) * 10  # 生成 0-10 之间的随机数y_train = 2 * x_train + 1 + torch.randn(100, 1) * 0.1  # 真实函数：y = 2x + 1 加上一些噪声# 将数据移动到指定设备x_train = x_train.to(device)y_train = y_train.to(device)
# 5. 创建模型和优化器model = SimpleNet().to(device)optimizer = torch.optim.SGD(model.parameters(), lr=0.01)criterion = nn.MSELoss()
# 6. 训练循环epochs = 5000
print("\n训练开始...")for epoch in range(epochs):    # 前向传播，预测结果    y_pred = model(x_train)        # 计算预测值和真实值之间的损失    loss = criterion(y_pred, y_train)        # 反向传播，修改模型参数    optimizer.zero_grad() # 清除旧的梯度    loss.backward() # 计算新的梯度     optimizer.step() # 更新参数：参数 -= 学习率 * 梯度        if (epoch + 1) % 100 == 0:        w = model.linear.weight.item()        b = model.linear.bias.item()        print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}, w: {w:.2f}, b: {b:.2f}')
# 7. 打印结果w = model.linear.weight.item()b = model.linear.bias.item()print(f'\n训练完成！')print(f'学习到的函数: y = {w:.2f}x + {b:.2f}')print(f'实际函数: y = 2.00x + 1.00')
# 8. 测试模型test_x = torch.tensor([[0.0], [5.0], [10.0]]).to(device)with torch.no_grad():    test_y = model(test_x)    print("\n预测结果：")    for x, y in zip(test_x, test_y):        print(f'x = {x.item():.1f}, y = {y.item():


    
.2f}')

$ python pytorch_5min.py Using mps devicetensor([3., 6., 9.])tensor([ 2.,  8., 18.])tensor(28.)tensor(28.)torch.Size([3])
训练开始...Epoch [100/5000], Loss: 0.0988, w: 2.09, b: 0.41Epoch [200/5000], Loss: 0.0420, w: 2.05, b: 0.64...Epoch [5000/5000], Loss: 0.0066, w: 2.00, b: 1.02
训练完成！学习到的函数: y = 2.00x + 1.02实际函数: y = 2.00x + 1.00
预测结果：x = 0.0, y = 1.02x = 5.0, y = 11.00x = 10.0, y = 20.98

>>> layer = nn.Linear(1, 1)>>> layer.weight.item(), layer.bias.item()(0.8262009620666504, 0.9049515724182129)>>> torch.tensor([[1.0],[2.]])tensor([[1.],        [2.]])>>> layer(_)tensor([[1.7312],        [2.5574]], grad_fn=)

import torchimport torch.nn as nnfrom torch.nn import functional as Ffrom typing import Listimport timetorch.manual_seed(42)prompts = ["春江", "往事"] # 推理的输入promptsmax_new_token = 100 # 推理生成的最大tokens数量max_iters = 5000 # 训练的最大迭代次数eval_iters = 100 # 评估的迭代次数eval_interval = 200 # 评估的间隔batch_size = 32 # 每个批次的大小block_size = 8 # 每个序列的最大长度learning_rate = 1e-2 # 学习率n_embed = 32 # 嵌入层的维度tain_data_ratio = 0.9 # 训练数据占数据集的比例，剩下的是验证数据device = 'cuda'if torch.cuda.is_available() else'mps'if torch.mps.is_available() else'cpu'with open('ci.txt', 'r', encoding='utf-8') as f:    text = f.read()class Tokenizer:    def __init__(self, text: str):        self.chars = sorted(list(set(text)))        self.vocab_size = len(self.chars)        self.stoi = {ch: i for i, ch in enumerate(self.chars)}        self.itos = {i: ch for i, ch in enumerate(self.chars)}        def encode(self, s: str) -> List[int]:        return [self.stoi[c] for c in s]        def decode(self, l: List[int]) -> str:        return''.join([self.itos[i] for i in l])    class BabyGPT(nn.Module):    def __init__(self, vocab_size: int, n_embd: int):        super().__init__()        self.token_embedding_table = nn.Embedding(vocab_size, n_embd) # 嵌入层，把token映射到n_embd维空间        self.lm_head = nn.Linear(n_embd, vocab_size) # 线性层，把n_embd维空间映射到vocab_size维空间，    def forward(self, idx, targets=None):        tok_emb = self.token_embedding_table(idx) # 获得token的嵌入表示 (B,T,n_embd)        logits = self.lm_head(tok_emb) # 通过线性层，把embedding结果重新映射回vocab_size维空间 (B,T,vocab_size)        if targets is None: # 推理场景，不需要计算损失值            loss = None        else:            B, T, C = logits.shape            logits = logits.view(B*T, C) # 把(B,T,C)的形状转换为(B*T,C)，因为交叉熵损失函数第一个参数只接受二维输入。这个操作并没有丢失信息            targets = targets.view(B*T) # 把(B,T)的形状转换为(B*T)，因为交叉熵损失函数第二个参数只接受一维输入。这个操作并没有丢失信息            loss = F.cross_entropy(logits, targets) # 计算交叉熵损失        return logits, loss    def generate


    
(self, idx, max_new_tokens):        for _ in range(max_new_tokens):            logits, _ = self(idx) # logits的形状是(B,T,vocab_size)，每一个token都计算了下一个token的概率            logits = logits[:, -1, :] # 实际上我们只需要最后一个token算出来的值            probs = F.softmax(logits, dim=-1) # 使用softmax函数算概率分布，这里dim=-1表示对最后一个维度进行softmax            idx_next = torch.multinomial(probs, num_samples=1) # 根据概率分布随机采样，这里num_samples=1表示采样一个token            idx = torch.cat((idx, idx_next), dim=1) # 把采样的token拼接到序列后面        return idxtokenizer = Tokenizer(text)vocab_size = tokenizer.vocab_sizeraw_data = torch.tensor(tokenizer.encode(text), dtype=torch.long).to(device)n = int(tain_data_ratio*len(raw_data))data = {'train': raw_data[:n], 'val': raw_data[n:]}def get_batch(data, batch_size, block_size):    ix = torch.randint(len(data) - block_size, (batch_size,))    x = torch.stack([data[i:i+block_size] for i in ix])    y = torch.stack([data[i+1:i+block_size+1] for i in ix])    x, y = x.to(device), y.to(device)    return x, y@torch.no_grad()def estimate_loss(model, data, batch_size, block_size, eval_iters):    '''    计算模型在训练集和验证集上的损失    '''    out = {}    model.eval() # 切换到评估模式    for split in ['train', 'val']:        losses = torch.zeros(eval_iters)        for k in range(eval_iters):            x, y = get_batch(data[split], batch_size, block_size)            _, loss = model(x, y)            losses[k] = loss.item()        out[split] = losses.mean()    model.train() # 切换回训练模式    return outmodel = BabyGPT(vocab_size, n_embed).to(device)# 训练optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate)start_time = time.time()tokens_processed = 0for iter in range(max_iters):    x, y = get_batch(data['train'], batch_size, block_size)    logits, loss = model(x, y)    optimizer.zero_grad(set_to_none=True)    loss.backward()    optimizer.step()    tokens_processed += batch_size * block_size    if iter % eval_interval == 0:        elapsed = time.time() - start_time        tokens_per_sec = tokens_processed / elapsed if elapsed > 0else0        losses = estimate_loss(model, data, batch_size, block_size, eval_iters)        print(f"step {iter}: train loss {losses['train']:.4f}, val loss {losses['val']:.4f}, speed: {tokens_per_sec:.2f} tokens/sec")# 推理prompt_tokens = torch.stack([torch.tensor(tokenizer.encode(p)).to(device) for p in prompts])# 生成result = model.generate(prompt_tokens, max_new_token)# 解码并打印结果for tokens in result:    print(tokenizer.decode(tokens.tolist()))    print('-'*10)

$ python babygpt_v1.py step 0: train loss 8.9236, val loss 8.9194, speed: 1118.03 tokens/secstep 200: train loss 5.8334, val loss 5.9927, speed: 50238.47 tokens/secstep 400: train loss 5.5678, val loss 5.7631, speed: 56604.35 tokens/secstep 600: train loss 5.4697, val loss 5.7274, speed: 59267.69 tokens/secstep 800: train loss 5.3885, val loss 5.6038, speed: 60842.13 tokens/secstep 1000: train loss 5.3467, val loss 5.5955, speed: 61404.86 tokens/sec...

>>> layer = nn.Embedding(10, 3)>>> layer.weight.shapetorch.Size([10, 3])>>> layer(torch.tensor(1))tensor([0.4534, 1.1587, 1.6280], grad_fn=)>>> layer.weight[torch.tensor(1)]tensor([0.4534, 1.1587, 1.6280], grad_fn=)