build large language model from scratch on Article

Understanding large language models 理解大型语言模型

Mon, 01 Jan 0001 00:00:00 +0000

Transformer 架构#

原始 Transformer 架构的简化描述，这是一种用于语言翻译的深度学习模型。Transformer 由两部分组成：

编码器：用于处理输入文本并生成文本的嵌入表示（一种在不同维度中捕获许多不同因素的数值表示），
解码器：可以使用该表示一次生成一个翻译单词。此图显示了翻译过程的最后阶段，其中解码器必须仅生成最后一个单词（“Beispiel”），给定原始输入文本（“This is an example”）和部分翻译的句子（“Das ist ein”），以完成翻译。

变种#

BERT 及其变体专门从事掩码词预测，即模型预测给定句子中的掩码或隐藏词，如图 1.5 所示。这种独特的训练策略使 BERT 在文本分类任务中具备优势，包括情感预测和文档分类。作为其能力的一个应用，截至本文撰写时，X（以前的 Twitter）使用 BERT 来检测有毒内容。
GPT 专注于原始 Transformer 架构的解码器部分，并且被设计用于需要生成文本的任务。这包括机器翻译、文本摘要、小说写作、编写计算机代码等。

构建一个 LLM#

构建大模型架构
预训练基础模型
微调

Working with text data 处理文本数据

Mon, 01 Jan 0001 00:00:00 +0000

Work Embedings 词嵌入#

从本质上讲，嵌入是从离散对象（如单词、图像，甚至整个文档）到连续向量空间中点的映射——嵌入的主要目的是将非数值数据转换为神经网络可以处理的格式。虽然词嵌入是文本嵌入最常见的形式，但也有用于句子、段落或整篇文档的嵌入。句子或段落嵌入是检索增强生成的流行选择。检索增强生成将生成（如生成文本）与检索（如搜索外部知识库）相结合，以在生成文本时提取相关信息，这是本书范围之外的技术。由于我们的目标是训练类似 GPT 的 LLMs，它学习一次生成一个单词，我们将专注于词嵌入。

Word2Vec#

早期且最流行的例子之一是 Word2Vec 方法。Word2Vec 训练神经网络架构，通过给定目标词预测词的上下文或反之来生成词嵌入。Word2Vec 背后的主要思想是，出现在相似上下文中的词往往具有相似的含义。因此，当为了可视化目的投影到二维词嵌入中时，相似的术语会聚集在一起

不幸的是，高维嵌入对可视化提出了挑战，因为我们的感官感知和常见的图形表示本质上仅限于三维或更少维度，这就是为什么图 2.3 在二维散点图中显示二维嵌入的原因。然而，当使用LLMs时，我们通常使用具有更高维度的嵌入。对于 GPT-2 和 GPT-3 两者，嵌入大小（通常称为模型隐藏状态的维度）根据具体的模型变体和大小而变化。这是在性能和效率之间的权衡。最小的 GPT-2 模型（117M 和 125M 参数）使用 768 维的嵌入大小来提供具体示例。最大的 GPT-3 模型（175B 参数）使用 12,288 维的嵌入大小。

Tokenizing text 分词#

如何将输入文本拆分为单个标记，这是创建LLM的嵌入所需的预处理步骤。这些标记可以是单个单词或特殊字符，包括标点符号

with open("the-verdict.txt", "r", encoding="utf-8") as f:
 raw_text = f.read()
 preprocessed = re.split(r'([,.:;?_!"()\']|--|\\s)', raw_text)
 preprocessed = [item.strip() for item in preprocessed if item.strip()]
 all_words = sorted(set(preprocessed))
 vocab_size = len(all_words)
 print(vocab_size)

Token to ID 词转 ID#

Coding attention mechanisms 注意力机制

Mon, 01 Jan 0001 00:00:00 +0000

本章，我们来到第 LLM 的第二个部分

The problem with modeling long sequences 长序列建模的问题#

假设我们想要开发一个将文本从一种语言翻译成另一种语言的语言翻译模型。

为了解决这个问题，通常使用具有两个子模块（编码器和解码器）的深度神经网络。编码器的工作是首先读取并处理整个文本，然后解码器生成翻译后的文本。

编码器 - 解码器循环神经网络的一个大限制是，在解码阶段，循环神经网络无法直接访问编码器中的早期隐藏状态。因此，它仅依赖于当前隐藏状态，该状态封装了所有相关信息。这可能导致上下文丢失，特别是在依赖关系可能跨越很长距离的复杂句子中。

因为这样的缺点，促使了注意力机制的设计。

Capturing data dependencies with attention mechanisms 用注意力机制捕获数据依赖关系#

Attending to different parts of the input with self-attention 利用自注意力关注输入的不同部分#

在自注意力 (self-attention) 机制中，“self” 指的是该机制通过关联单个输入序列内的不同位置来计算注意力权重的能力。它评估并学习输入本身各个部分（如句子中的单词或图像中的像素）之间的关系和依赖关系。

A simple self-attention mechanism without trainable weights 一个没有可训练权重的简单自注意力机制#

自注意力的目标是为每个输入元素计算一个上下文向量，该向量结合了所有其他输入元素的信息。在这个例子中，我们计算上下文向量 $z^{\left(2\right)}$ 。计算 $z^{\left(2\right)}$ 时，每个输入元素的重要性或贡献由注意力权重 $a_{21}$ 到 $a_{2T}$ 决定。在计算 $z^{\left(2\right)}$ 时，注意力权重是相对于输入元素 $x^{\left(2\right)}$ 和所有其他输入计算的。

Implementing a GPT model from scratch to generate text 从零实现 GPT 模型

Mon, 01 Jan 0001 00:00:00 +0000

Coding an LLM architecture 编码 LLM 架构#

使用如下配置

GPT_CONFIG_124M = {
 "vocab_size": 50257, # Vocabulary size 词汇量大小
 "context_length": 1024, # Context length 上下文长度
 "emb_dim": 768, # Embedding dimension 嵌入维度
 "n_heads": 12, # Number of attention heads 多头注意力数量
 "n_layers": 12, # Number of layers 层数
 "drop_rate": 0.1, # Dropout rate Dropout 比例
 "qkv_bias": False # Query-Key-Value bias
}

一个抽象架构如下

import torch
import torch.nn as nn

class DummyGPTModel(nn.Module):
 def __init__(self, cfg):
 super().__init__()
 self.tok_emb = nn.Embedding(cfg["vocab_size"], cfg["emb_dim"])
 self.pos_emb = nn.Embedding(cfg["context_length"], cfg["emb_dim"])
 self.drop_emb = nn.Dropout(cfg["drop_rate"])
 #1 TransformerBlock 占位符
 self.trf_blocks = nn.Sequential( 
 *[DummyTransformerBlock(cfg) 
 for _ in range(cfg["n_layers"])] 
 ) 
 #2 LayerNorm
 self.final_norm = DummyLayerNorm(cfg["emb_dim"]) 
 self.out_head = nn.Linear(
 cfg["emb_dim"], cfg["vocab_size"], bias=False
 )

 def forward(self, in_idx):
 batch_size, seq_len = in_idx.shape
 tok_embeds = self.tok_emb(in_idx)
 pos_embeds = self.pos_emb(
 torch.arange(seq_len, device=in_idx.device)
 )
 x = tok_embeds + pos_embeds
 x = self.drop_emb(x)
 x = self.trf_blocks(x)
 x = self.final_norm(x)
 logits = self.out_head(x)
 return logits

class DummyTransformerBlock(nn.Module): 
 def __init__(self, cfg):
 super().__init__()

 def forward(self, x): 
 return x

class DummyLayerNorm(nn.Module): 
 def __init__(self, normalized_shape, eps=1e-5): 
 super().__init__()

 def forward(self, x):
 return x

现在我们就有了一个初始的框架，调用也可以跑通

Pretraining on unlabeled data 在未标签的数据进行预训练

Mon, 01 Jan 0001 00:00:00 +0000

我们来到了第二部分，关于训练

Evaluating generative text models#

简要回顾了第四章的文本生成后，我们将设置我们的 LLM 进行文本生成，然后讨论评估生成文本质量的基本方法。接着，我们将计算训练和验证损失。

Using GPT to generate text#

使用 GPTModel 实例，我们采用第 4 章中的 generate_text_simple 函数，并引入两个实用的函数： text_to_token_ ids 和 token_ids_ to_text 。这些函数便于在文本和 token 表示之间进行转换

import tiktoken
from chapter04 import generate_text_simple

def text_to_token_ids(text, tokenizer):
 encoded = tokenizer.encode(text, allowed_special={'<|endoftext|>'})
 encoded_tensor = torch.tensor(encoded).unsqueeze(0) #1
 return encoded_tensor

def token_ids_to_text(token_ids, tokenizer):
 flat = token_ids.squeeze(0) #2
 return tokenizer.decode(flat.tolist())

start_context = "Every effort moves you"
tokenizer = tiktoken.get_encoding("gpt2")

token_ids = generate_text_simple(
 model=model,
 idx=text_to_token_ids(start_context, tokenizer),
 max_new_tokens=10,
 context_size=GPT_CONFIG_124M["context_length"]
)
print("Output text:\n", token_ids_to_text(token_ids, tokenizer))

Calculating the text generation loss 计算文本生成损失#

Fine-tuning for classification 用于分类的微调

Mon, 01 Jan 0001 00:00:00 +0000

Different categories of fine-tuning 不同类别的微调#

微调语言模型最常见的方法是指令微调与分类微调。指令微调涉及在一组任务上训练语言模型，使用特定的指令来提高其理解和执行自然语言提示中描述的任务的能力

Preparing the dataset 准备数据集#

import urllib.request
import zipfile
import os
from pathlib import Path

url = "https://archive.ics.uci.edu/static/public/228/sms+spam+collection.zip"
zip_path = "sms_spam_collection.zip"
extracted_path = "sms_spam_collection"
data_file_path = Path(extracted_path) / "SMSSpamCollection.tsv"


def download_and_unzip_spam_data(
 url, zip_path, extracted_path, data_file_path):
 if data_file_path.exists():
 print(f"{data_file_path} already exists. Skipping download "
 "and extraction."
 )
 return

 with urllib.request.urlopen(url) as response: #1 下载文件
 with open(zip_path, "wb") as out_file:
 out_file.write(response.read())

 with zipfile.ZipFile(zip_path, "r") as zip_ref: #2 解压
 zip_ref.extractall(extracted_path)

 original_file_path = Path(extracted_path) / "SMSSpamCollection"
 os.rename(original_file_path, data_file_path) #3 保存文件
 print(f"File downloaded and saved as {data_file_path}")

download_and_unzip_spam_data(url, zip_path, extracted_path, data_file_path)

数据集以制表符分隔的文本文件形式保存在 sms_spam_collection 文件夹中的 SMSSpamCollection.tsv，使用 PD 阅读

Fine-tuning to follow instructions 微调以遵循指令

Mon, 01 Jan 0001 00:00:00 +0000

Preparing a dataset for supervised instruction fine-tuning 准备用于监督指令微调的数据集#

import json
import os
import urllib


def download_and_load_file(file_path, url):
 if not os.path.exists(file_path):
 with urllib.request.urlopen(url) as response:
 text_data = response.read().decode("utf-8")
 with open(file_path, "w", encoding="utf-8") as file:
 file.write(text_data)
 else: # 1
 with open(file_path, "r", encoding="utf-8") as file:
 text_data = file.read()
 with open(file_path, "r") as file:
 data = json.load(file)
 return data


def format_input(entry):
 instruction_text = (
 f"Below is an instruction that describes a task. "
 f"Write a response that appropriately completes the request."
 f"\n\\n### Instruction:\\n{entry['instruction']}"
 )

 input_text = (
 f"\n\\n### Input:\\n{entry['input']}" if entry["input"] else ""
 )
 return instruction_text + input_text


if __name__ == '__main__':
 file_path = "instruction-data.json"
 url = (
 "https://raw.githubusercontent.com/rasbt/LLMs-from-scratch"
 "/main/ch07/01_main-chapter-code/instruction-data.json"
 )

 data = download_and_load_file(file_path, url)
 model_input = format_input(data[50])
 desired_response = f"\n\\n### Response:\\n{data[50]['output']}"
 print(model_input + desired_response)

 train_portion = int(len(data) * 0.85) # 1
 test_portion = int(len(data) * 0.1) # 2
 val_portion = len(data) - train_portion - test_portion # 3

 train_data = data[:train_portion]
 test_data = data[train_portion:train_portion + test_portion]
 val_data = data[train_portion + test_portion:]

 print("Training set length:", len(train_data))
 print("Validation set length:", len(val_data))
 print("Test set length:", len(test_data))

Organizing data into training batches 将数据组织成训练批次#

import torch
from torch.utils.data import Dataset

class InstructionDataset(Dataset):
 def __init__(self, data, tokenizer):
 self.data = data
 self.encoded_texts = []
 for entry in data: #1
 instruction_plus_input = format_input(entry)
 response_text = f"\n\\n### Response:\\n{entry['output']}"
 full_text = instruction_plus_input + response_text
 self.encoded_texts.append(
 tokenizer.encode(full_text)
 )

 def __getitem__(self, index):
 return self.encoded_texts[index]

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

Creating data loaders for an instruction dataset 为指令数据集创建数据加载器#

from torch.utils.data import DataLoader

num_workers = 0 #1
batch_size = 8

torch.manual_seed(123)

train_dataset = InstructionDataset(train_data, tokenizer)
train_loader = DataLoader(
 train_dataset,
 batch_size=batch_size,
 collate_fn=customized_collate_fn,
 shuffle=True,
 drop_last=True,
 num_workers=num_workers
)

val_dataset = InstructionDataset(val_data, tokenizer)
val_loader = DataLoader(
 val_dataset,
 batch_size=batch_size,
 collate_fn=customized_collate_fn,
 shuffle=False,
 drop_last=False,
 num_workers=num_workers
)

test_dataset = InstructionDataset(test_data, tokenizer)
test_loader = DataLoader(
 test_dataset,
 batch_size=batch_size,
 collate_fn=customized_collate_fn,
 shuffle=False,
 drop_last=False,
 num_workers=num_workers
)

Loading a pretrained LLM 加载预训练的 LLM#

from gpt_download import download_and_load_gpt2
from chapter04 import GPTModel
from chapter05 import load_weights_into_gpt

BASE_CONFIG = {
 "vocab_size": 50257, # Vocabulary size
 "context_length": 1024, # Context length
 "drop_rate": 0.0, # Dropout rate
 "qkv_bias": True # Query-key-value bias
}

model_configs = {
 "gpt2-small (124M)": {"emb_dim": 768, "n_layers": 12, "n_heads": 12},
 "gpt2-medium (355M)": {"emb_dim": 1024, "n_layers": 24, "n_heads": 16},
 "gpt2-large (774M)": {"emb_dim": 1280, "n_layers": 36, "n_heads": 20},
 "gpt2-xl (1558M)": {"emb_dim": 1600, "n_layers": 48, "n_heads": 25},
}

CHOOSE_MODEL = "gpt2-medium (355M)"
BASE_CONFIG.update(model_configs[CHOOSE_MODEL])

model_size = CHOOSE_MODEL.split(" ")[-1].lstrip("(").rstrip(")")

settings, params = download_and_load_gpt2(
 model_size=model_size, 
 models_dir="gpt2"
)

model = GPTModel(BASE_CONFIG)
load_weights_into_gpt(model, params)
model.eval();

训练逻辑如下