从零开始训练因果语言模型

到目前为止，我们主要使用预训练模型，并通过重用预训练的权重来为新的用例对其进行微调。正如我们在第 1 章中看到的，这通常被称为迁移学习，并且是将 Transformer 模型应用于大多数标记数据稀疏的真实世界用例的非常成功的策略。在本章中，我们将采取不同的方法，从头开始训练一个全新的模型。如果您有大量数据，并且这些数据与可用模型的预训练数据截然不同，那么这是一个很好的方法。但是，与仅微调现有模型相比，预训练语言模型也需要明显更多的计算资源。从音乐音符、DNA 等分子序列或编程语言组成的数据集来看，训练新模型可能是有意义的。由于 TabNine 和 GitHub 的 Copilot 等工具的出现，后者最近获得了关注，这些工具由 OpenAI 的 Codex 模型提供支持，可以生成长代码序列。文本生成的这项任务最好通过 GPT-2 等自回归或因果语言模型来解决。

在本节中，我们将构建代码生成模型的缩小版本：我们将专注于单行补全，而不是完整的函数或类，使用 Python 代码的子集。在 Python 中处理数据时，您会经常接触到 Python 数据科学堆栈，该堆栈由 matplotlib、seaborn、pandas 和 scikit-learn 库组成。使用这些框架时，通常需要查找特定的命令，因此如果我们能够使用模型为我们补全这些调用，那就太好了。

在第 6 章中，我们创建了一个高效的分词器来处理 Python 源代码，但我们仍然需要的是一个大规模数据集来预训练模型。在这里，我们将把我们的分词器应用于从 GitHub 存储库派生的 Python 代码语料库。然后，我们将使用 Trainer API 和 🤗 Accelerate 来训练模型。让我们开始吧！

这实际上是在展示使用本节中显示的代码训练并上传到 Hub 的模型。您可以在此处找到它。请注意，由于文本生成中存在一些随机性，您可能会得到略有不同的结果。

收集数据

Python 代码可以从 GitHub 等代码存储库中大量获取，我们可以通过抓取每个 Python 存储库来创建数据集。《Transformers 教材》中采用了这种方法来预训练大型 GPT-2 模型。作者使用了一个约 180 GB 的 GitHub 转储，其中包含大约 2000 万个名为 codeparrot 的 Python 文件，构建了一个数据集，然后他们在 Hugging Face Hub 上共享了该数据集。

但是，在完整语料库上进行训练既耗时又耗费计算资源，而我们只需要与 Python 数据科学堆栈相关的数据集子集。因此，让我们首先过滤 codeparrot 数据集，以查找包含此堆栈中任何库的所有文件。由于数据集的大小，我们希望避免下载它；相反，我们将使用流式传输功能来动态过滤它。为了帮助我们使用我们前面提到的库过滤代码示例，我们将使用以下函数

def any_keyword_in_string(string, keywords):
    for keyword in keywords:
        if keyword in string:
            return True
    return False

让我们在两个示例上测试一下

filters = ["pandas", "sklearn", "matplotlib", "seaborn"]
example_1 = "import numpy as np"
example_2 = "import pandas as pd"

print(
    any_keyword_in_string(example_1, filters), any_keyword_in_string(example_2, filters)
)

False True

我们可以使用它来创建一个函数，该函数将流式传输数据集并过滤我们想要的元素

from collections import defaultdict
from tqdm import tqdm
from datasets import Dataset


def filter_streaming_dataset(dataset, filters):
    filtered_dict = defaultdict(list)
    total = 0
    for sample in tqdm(iter(dataset)):
        total += 1
        if any_keyword_in_string(sample["content"], filters):
            for k, v in sample.items():
                filtered_dict[k].append(v)
    print(f"{len(filtered_dict['content'])/total:.2%} of data after filtering.")
    return Dataset.from_dict(filtered_dict)

然后我们可以简单地将此函数应用于流式数据集

# This cell will take a very long time to execute, so you should skip it and go to
# the next one!
from datasets import load_dataset

split = "train"  # "valid"
filters = ["pandas", "sklearn", "matplotlib", "seaborn"]

data = load_dataset(f"transformersbook/codeparrot-{split}", split=split, streaming=True)
filtered_data = filter_streaming_dataset(data, filters)

3.26% of data after filtering.

这使我们只剩下原始数据集的大约 3%，但这仍然相当可观 — 生成的数据集为 6 GB，由 600,000 个 Python 脚本组成！

过滤完整数据集可能需要 2-3 小时，具体取决于您的机器和带宽。如果您不想自己完成这个漫长的过程，我们在 Hub 上提供了过滤后的数据集供您下载

from datasets import load_dataset, DatasetDict

ds_train = load_dataset("huggingface-course/codeparrot-ds-train", split="train")
ds_valid = load_dataset("huggingface-course/codeparrot-ds-valid", split="validation")

raw_datasets = DatasetDict(
    {
        "train": ds_train,  # .shuffle().select(range(50000)),
        "valid": ds_valid,  # .shuffle().select(range(500))
    }
)

raw_datasets

DatasetDict({
    train: Dataset({
        features: ['repo_name', 'path', 'copies', 'size', 'content', 'license'],
        num_rows: 606720
    })
    valid: Dataset({
        features: ['repo_name', 'path', 'copies', 'size', 'content', 'license'],
        num_rows: 3322
    })
})

预训练语言模型将需要一段时间。我们建议您首先在数据样本上运行训练循环，取消注释上面的两个部分行，并确保训练成功完成并存储模型。没有什么比训练运行在最后一步失败更令人沮丧的了，因为您忘记创建文件夹或因为训练循环末尾存在拼写错误！

让我们看一下数据集中的一个示例。我们将仅显示每个字段的前 200 个字符

for key in raw_datasets["train"][0]:
    print(f"{key.upper()}: {raw_datasets['train'][0][key][:200]}")

'REPO_NAME: kmike/scikit-learn'
'PATH: sklearn/utils/__init__.py'
'COPIES: 3'
'SIZE: 10094'
'''CONTENT: """
The :mod:`sklearn.utils` module includes various utilites.
"""

from collections import Sequence

import numpy as np
from scipy.sparse import issparse
import warnings

from .murmurhash import murm
LICENSE: bsd-3-clause'''

我们可以看到 content 字段包含我们希望我们的模型训练的代码。现在我们有了数据集，我们需要准备文本，使其格式适合预训练。

准备数据集

第一步是标记数据，以便我们可以将其用于训练。由于我们的目标主要是自动完成简短的函数调用，我们可以保持上下文大小相对较小。这样做的好处是我们可以更快地训练模型，并且需要的内存也明显减少。如果您的应用程序需要更多上下文（例如，如果您希望模型根据包含函数定义的文件编写单元测试），请务必增加该数字，但也要记住，这会增加 GPU 内存占用。现在，让我们将上下文大小固定为 128 个 token，而不是 GPT-2 或 GPT-3 中使用的 1,024 或 2,048。

大多数文档包含的 token 远远超过 128 个，因此仅将输入截断为最大长度会消除我们数据集的很大一部分。相反，我们将使用 return_overflowing_tokens 选项来标记整个输入并将其拆分为多个块，正如我们在第 6 章中所做的那样。我们还将使用 return_length 选项来自动返回每个创建的块的长度。通常，最后一个块会小于上下文大小，我们将摆脱这些片段以避免填充问题；我们反正有大量数据，所以我们真的不需要它们。

Chunking a large texts in several pieces.

让我们通过查看前两个示例来准确了解这是如何工作的

from transformers import AutoTokenizer

context_length = 128
tokenizer = AutoTokenizer.from_pretrained("huggingface-course/code-search-net-tokenizer")

outputs = tokenizer(
    raw_datasets["train"][:2]["content"],
    truncation=True,
    max_length=context_length,
    return_overflowing_tokens=True,
    return_length=True,
)

print(f"Input IDs length: {len(outputs['input_ids'])}")
print(f"Input chunk lengths: {(outputs['length'])}")
print(f"Chunk mapping: {outputs['overflow_to_sample_mapping']}")

Input IDs length: 34
Input chunk lengths: [128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 117, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 41]
Chunk mapping: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

我们可以看到我们从这两个示例中总共获得了 34 个段。查看块长度，我们可以看到两个文档末尾的块少于 128 个 token（分别为 117 和 41）。这些仅占我们拥有的总块的一小部分，因此我们可以安全地丢弃它们。通过 overflow_to_sample_mapping 字段，我们还可以重建哪些块属于哪些输入样本。

通过此操作，我们使用了 🤗 Datasets 中 Dataset.map() 函数的一个方便功能，即它不需要一对一映射；正如我们在第 3 节中看到的那样，我们可以创建批次，其元素多于或少于输入批次。当执行数据增强或更改元素数量的数据过滤等操作时，这非常有用。在我们的例子中，当将每个元素标记化为指定上下文大小的块时，我们从每个文档创建了许多样本。我们只需要确保删除现有列，因为它们具有冲突的大小。如果我们想保留它们，我们可以适当地重复它们并在 Dataset.map() 调用中返回它们

def tokenize(element):
    outputs = tokenizer(
        element["content"],
        truncation=True,
        max_length=context_length,
        return_overflowing_tokens=True,
        return_length=True,
    )
    input_batch = []
    for length, input_ids in zip(outputs["length"], outputs["input_ids"]):
        if length == context_length:
            input_batch.append(input_ids)
    return {"input_ids": input_batch}


tokenized_datasets = raw_datasets.map(
    tokenize, batched=True, remove_columns=raw_datasets["train"].column_names
)
tokenized_datasets

DatasetDict({
    train: Dataset({
        features: ['input_ids'],
        num_rows: 16702061
    })
    valid: Dataset({
        features: ['input_ids'],
        num_rows: 93164
    })
})

我们现在有 1670 万个示例，每个示例包含 128 个 token，总共约 21 亿个 token。作为参考，OpenAI 的 GPT-3 和 Codex 模型分别在 300 亿和 1000 亿个 token 上进行训练，其中 Codex 模型是从 GPT-3 检查点初始化的。本节的目标不是与这些可以生成长篇连贯文本的模型竞争，而是创建一个缩小版本，为数据科学家提供快速自动完成功能。

现在我们已经准备好数据集了，让我们设置模型！

✏️ 试一试！ 丢弃所有小于上下文大小的块在这里不是什么大问题，因为我们使用的是小的上下文窗口。随着您增加上下文大小（或者如果您有短文档语料库），丢弃的块的比例也会增加。准备数据的更有效方法是将批次中的所有标记化样本与中间的 eos_token_id token 连接起来，然后在连接的序列上执行分块。作为练习，修改 tokenize() 函数以利用该方法。请注意，您需要设置 truncation=False 并从分词器中删除其他参数以获取 token ID 的完整序列。

初始化新模型

我们的第一步是全新初始化 GPT-2 模型。我们将对我们的模型使用与小型 GPT-2 模型相同的配置，因此我们加载预训练配置，确保分词器大小与模型词汇表大小匹配，并传递 bos 和 eos（序列的开始和结束）token ID

from transformers import AutoTokenizer, GPT2LMHeadModel, AutoConfig

config = AutoConfig.from_pretrained(
    "gpt2",
    vocab_size=len(tokenizer),
    n_ctx=context_length,
    bos_token_id=tokenizer.bos_token_id,
    eos_token_id=tokenizer.eos_token_id,
)

使用该配置，我们可以加载一个新模型。请注意，这是我们第一次不使用 from_pretrained() 函数，因为我们实际上是在自己初始化模型

model = GPT2LMHeadModel(config)
model_size = sum(t.numel() for t in model.parameters())
print(f"GPT-2 size: {model_size/1000**2:.1f}M parameters")

GPT-2 size: 124.2M parameters

我们的模型有 1.24 亿个参数，我们需要调整这些参数。在我们开始训练之前，我们需要设置一个数据整理器，它将负责创建批次。我们可以使用 DataCollatorForLanguageModeling 整理器，该整理器专为语言建模而设计（顾名思义）。除了堆叠和填充批次外，它还负责创建语言模型标签 — 在因果语言建模中，输入也充当标签（仅偏移一个元素），并且此数据整理器在训练期间动态创建它们，因此我们无需复制 input_ids。

请注意，DataCollatorForLanguageModeling 同时支持掩码语言建模 (MLM) 和因果语言建模 (CLM)。默认情况下，它为 MLM 准备数据，但我们可以通过设置参数 mlm=False 切换到 CLM

from transformers import DataCollatorForLanguageModeling

tokenizer.pad_token = tokenizer.eos_token
data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)

让我们看一个例子

out = data_collator([tokenized_datasets["train"][i] for i in range(5)])
for key in out:
    print(f"{key} shape: {out[key].shape}")

input_ids shape: torch.Size([5, 128])
attention_mask shape: torch.Size([5, 128])
labels shape: torch.Size([5, 128])

我们可以看到示例已被堆叠，并且所有张量都具有相同的形状。

⚠️ 输入和标签的移位以对齐它们发生在模型内部，因此数据整理器只是复制输入以创建标签。

现在我们已经准备好一切来实际训练我们的模型了 — 毕竟，这并没有花费太多精力！在我们开始训练之前，我们应该登录 Hugging Face。如果您在笔记本电脑中工作，您可以使用以下实用程序函数来执行此操作

from huggingface_hub import notebook_login

notebook_login()

这将显示一个小部件，您可以在其中输入您的 Hugging Face 登录凭据。

如果您不是在笔记本电脑中工作，只需在终端中键入以下行

huggingface-cli login

剩下的就是配置训练参数并启动 Trainer。我们将使用带有少量预热的余弦学习率计划和 256 的有效批次大小（per_device_train_batch_size * gradient_accumulation_steps）。当单个批次不适合内存时，使用梯度累积，并通过多次前向/后向传递逐步构建梯度。当我们使用 🤗 Accelerate 创建训练循环时，我们将看到这一点。

from transformers import Trainer, TrainingArguments

args = TrainingArguments(
    output_dir="codeparrot-ds",
    per_device_train_batch_size=32,
    per_device_eval_batch_size=32,
    evaluation_strategy="steps",
    eval_steps=5_000,
    logging_steps=5_000,
    gradient_accumulation_steps=8,
    num_train_epochs=1,
    weight_decay=0.1,
    warmup_steps=1_000,
    lr_scheduler_type="cosine",
    learning_rate=5e-4,
    save_steps=5_000,
    fp16=True,
    push_to_hub=True,
)

trainer = Trainer(
    model=model,
    tokenizer=tokenizer,
    args=args,
    data_collator=data_collator,
    train_dataset=tokenized_datasets["train"],
    eval_dataset=tokenized_datasets["valid"],
)

现在我们就可以启动 Trainer 并等待训练完成。根据您是在完整训练集还是训练集子集上运行它，这将分别花费 20 或 2 个小时，因此请喝几杯咖啡并读一本好书！

trainer.train()

训练完成后，我们可以将模型和分词器推送到 Hub

trainer.push_to_hub()

✏️ 试一试！ 除了 TrainingArguments 之外，我们只用了大约 30 行代码就从原始文本到训练 GPT-2。使用您自己的数据集试一试，看看您是否可以获得良好的结果！

💡 如果您有权访问具有多个 GPU 的机器，请尝试在那里运行代码。Trainer 自动管理多台机器，这可以极大地加快训练速度。

使用管道生成代码

现在是真相大白的时候了：让我们看看训练后的模型实际效果如何！我们可以在日志中看到损失稳步下降，但为了测试模型，让我们看看它在某些提示下的效果如何。为此，我们将模型包装在文本生成 pipeline 中，如果有 GPU 可用，我们将将其放在 GPU 上以进行快速生成

import torch
from transformers import pipeline

device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
pipe = pipeline(
    "text-generation", model="huggingface-course/codeparrot-ds", device=device
)

让我们从创建散点图的简单任务开始

txt = """\
# create some data
x = np.random.randn(100)
y = np.random.randn(100)

# create scatter plot with x, y
"""
print(pipe(txt, num_return_sequences=1)[0]["generated_text"])

# create some data
x = np.random.randn(100)
y = np.random.randn(100)

# create scatter plot with x, y
plt.scatter(x, y)

# create scatter

结果看起来是正确的。它也适用于 pandas 操作吗？让我们看看我们是否可以从两个数组创建一个 DataFrame

txt = """\
# create some data
x = np.random.randn(100)
y = np.random.randn(100)

# create dataframe from x and y
"""
print(pipe(txt, num_return_sequences=1)[0]["generated_text"])

# create some data
x = np.random.randn(100)
y = np.random.randn(100)

# create dataframe from x and y
df = pd.DataFrame({'x': x, 'y': y})
df.insert(0,'x', x)
for

不错，这是正确的答案 — 尽管它随后再次插入了列 x。由于生成的 token 数量有限，因此下面的 for 循环被截断了。让我们看看我们是否可以做一些更复杂的事情，并让模型帮助我们使用 groupby 操作

txt = """\
# dataframe with profession, income and name
df = pd.DataFrame({'profession': x, 'income':y, 'name': z})

# calculate the mean income per profession
"""
print(pipe(txt, num_return_sequences=1)[0]["generated_text"])

# dataframe with profession, income and name
df = pd.DataFrame({'profession': x, 'income':y, 'name': z})

# calculate the mean income per profession
profession = df.groupby(['profession']).mean()

# compute the

还不错；这是正确的方法。最后，让我们看看我们是否也可以将其用于 scikit-learn 并设置一个随机森林模型

txt = """
# import random forest regressor from scikit-learn
from sklearn.ensemble import RandomForestRegressor

# fit random forest model with 300 estimators on X, y:
"""
print(pipe(txt, num_return_sequences=1)[0]["generated_text"])

# import random forest regressor from scikit-learn
from sklearn.ensemble import RandomForestRegressor

# fit random forest model with 300 estimators on X, y:
rf = RandomForestRegressor(n_estimators=300, random_state=random_state, max_depth=3)
rf.fit(X, y)
rf

查看这些示例，似乎该模型已经学习了一些 Python 数据科学堆栈的语法（当然，在现实世界中部署模型之前，我们需要更彻底地评估它）。但是，有时需要更多地自定义模型训练才能为给定的用例实现必要的性能。例如，如果我们想动态更新批次大小或具有在运行时跳过错误示例的条件训练循环怎么办？一种选择是子类化 Trainer 并添加必要的更改，但有时从头开始编写训练循环更简单。这就是 🤗 Accelerate 的用武之地。

使用 🤗 Accelerate 进行训练

我们已经了解了如何使用 Trainer 训练模型，这允许进行一些自定义。但是，有时我们希望完全控制训练循环，或者我们想进行一些奇异的更改。在这种情况下，🤗 Accelerate 是一个不错的选择，在本节中，我们将逐步介绍使用它来训练模型的步骤。为了使事情更有趣，我们还将在训练循环中添加一个曲折。

由于我们主要对数据科学库的合理自动完成感兴趣，因此有必要更加重视更多使用这些库的训练样本。我们可以通过使用诸如 plt、pd、sk、fit 和 predict 等关键字轻松识别这些示例，这些关键字是 matplotlib.pyplot、pandas 和 sklearn 以及后者的 fit/predict 模式的最常用导入名称。如果这些都表示为单个 token，我们可以轻松检查它们是否出现在输入序列中。Token 可以具有空格前缀，因此我们还将在分词器词汇表中检查这些版本。为了验证它是否有效，我们将添加一个应拆分为多个 token 的测试 token

keytoken_ids = []
for keyword in [
    "plt",
    "pd",
    "sk",
    "fit",
    "predict",
    " plt",
    " pd",
    " sk",
    " fit",
    " predict",
    "testtest",
]:
    ids = tokenizer([keyword]).input_ids[0]
    if len(ids) == 1:
        keytoken_ids.append(ids[0])
    else:
        print(f"Keyword has not single token: {keyword}")

'Keyword has not single token: testtest'

太棒了，这似乎运行良好！我们现在可以编写一个自定义损失函数，该函数将输入序列、logits 和我们刚刚选择的关键 token 作为输入。首先，我们需要对齐 logits 和输入：输入序列向右偏移一个形成标签，因为下一个 token 是当前 token 的标签。我们可以通过从输入序列的第二个 token 开始标签来实现这一点，因为模型无论如何都不会对第一个 token 进行预测。然后我们切断最后一个 logit，因为我们没有后跟完整输入序列的 token 的标签。这样，我们可以计算每个样本的损失，并计算每个样本中所有关键字的出现次数。最后，我们使用出现次数作为权重计算所有样本的加权平均值。由于我们不想丢弃所有没有关键字的样本，因此我们在权重中加 1

from torch.nn import CrossEntropyLoss
import torch


def keytoken_weighted_loss(inputs, logits, keytoken_ids, alpha=1.0):
    # Shift so that tokens < n predict n
    shift_labels = inputs[..., 1:].contiguous()
    shift_logits = logits[..., :-1, :].contiguous()
    # Calculate per-token loss
    loss_fct = CrossEntropyLoss(reduce=False)
    loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1))
    # Resize and average loss per sample
    loss_per_sample = loss.view(shift_logits.size(0), shift_logits.size(1)).mean(axis=1)
    # Calculate and scale weighting
    weights = torch.stack([(inputs == kt).float() for kt in keytoken_ids]).sum(
        axis=[0, 2]
    )
    weights = alpha * (1.0 + weights)
    # Calculate weighted average
    weighted_loss = (loss_per_sample * weights).mean()
    return weighted_loss

在我们开始使用这个令人敬畏的新损失函数进行训练之前，我们需要准备一些东西

我们需要数据加载器以批量加载数据。
我们需要设置权重衰减参数。
我们希望不时进行评估，因此将评估代码包装在一个函数中是有意义的。

让我们从数据加载器开始。我们只需要将数据集的格式设置为 "torch"，然后我们可以将其传递给具有适当批次大小的 PyTorch DataLoader

from torch.utils.data.dataloader import DataLoader

tokenized_datasets.set_format("torch")
train_dataloader = DataLoader(tokenized_datasets["train"], batch_size=32, shuffle=True)
eval_dataloader = DataLoader(tokenized_datasets["valid"], batch_size=32)

接下来，我们对参数进行分组，以便优化器知道哪些参数将获得额外的权重衰减。通常，所有偏差和 LayerNorm 权重项都免于此；以下是我们如何做到这一点

weight_decay = 0.1


def get_grouped_params(model, no_decay=["bias", "LayerNorm.weight"]):
    params_with_wd, params_without_wd = [], []
    for n, p in model.named_parameters():
        if any(nd in n for nd in no_decay):
            params_without_wd.append(p)
        else:
            params_with_wd.append(p)
    return [
        {"params": params_with_wd, "weight_decay": weight_decay},
        {"params": params_without_wd, "weight_decay": 0.0},
    ]

由于我们希望在训练期间定期在验证集上评估模型，因此让我们也编写一个函数。它只是运行评估数据加载器并收集跨进程的所有损失

def evaluate():
    model.eval()
    losses = []
    for step, batch in enumerate(eval_dataloader):
        with torch.no_grad():
            outputs = model(batch["input_ids"], labels=batch["input_ids"])

        losses.append(accelerator.gather(outputs.loss))
    loss = torch.mean(torch.cat(losses))
    try:
        perplexity = torch.exp(loss)
    except OverflowError:
        perplexity = float("inf")
    return loss.item(), perplexity.item()

使用 evaluate() 函数，我们可以定期报告损失和困惑度。接下来，我们重新定义我们的模型以确保我们再次从头开始训练

model = GPT2LMHeadModel(config)

然后我们可以定义我们的优化器，使用之前的函数拆分权重衰减的参数

from torch.optim import AdamW

optimizer = AdamW(get_grouped_params(model), lr=5e-4)

现在让我们准备模型、优化器和数据加载器，以便我们可以开始训练

from accelerate import Accelerator

accelerator = Accelerator(fp16=True)

model, optimizer, train_dataloader, eval_dataloader = accelerator.prepare(
    model, optimizer, train_dataloader, eval_dataloader
)

🚨 如果您在 TPU 上进行训练，则需要将以上单元格中的所有代码移动到专用的训练函数中。有关更多详细信息，请参阅第 3 章。

现在我们已经将我们的 train_dataloader 发送到 accelerator.prepare()，我们可以使用它的长度来计算训练步骤的数量。请记住，我们应该始终在准备数据加载器后执行此操作，因为该方法会更改其长度。我们使用从学习率到 0 的经典线性计划

from transformers import get_scheduler

num_train_epochs = 1
num_update_steps_per_epoch = len(train_dataloader)
num_training_steps = num_train_epochs * num_update_steps_per_epoch

lr_scheduler = get_scheduler(
    name="linear",
    optimizer=optimizer,
    num_warmup_steps=1_000,
    num_training_steps=num_training_steps,
)

最后，为了将我们的模型推送到 Hub，我们需要在工作文件夹中创建一个 Repository 对象。首先登录 Hugging Face Hub，如果您尚未登录。我们将从我们要给模型的模型 ID 中确定存储库名称（随意用您自己的选择替换 repo_name；它只需要包含您的用户名，这就是函数 get_full_repo_name() 所做的事情）

from huggingface_hub import Repository, get_full_repo_name

model_name = "codeparrot-ds-accelerate"
repo_name = get_full_repo_name(model_name)
repo_name

'sgugger/codeparrot-ds-accelerate'

然后我们可以将该存储库克隆到本地文件夹中。如果它已经存在，则此本地文件夹应该是我们正在使用的存储库的现有克隆

output_dir = "codeparrot-ds-accelerate"
repo = Repository(output_dir, clone_from=repo_name)

我们现在可以通过调用 repo.push_to_hub() 方法上传我们在 output_dir 中保存的任何内容。这将帮助我们在每个 epoch 结束时上传中间模型。

在训练之前，让我们运行一个快速测试，看看评估函数是否正常工作

evaluate()

(10.934126853942871, 56057.14453125)

这些损失和困惑度的值非常高，但这并不奇怪，因为我们尚未训练模型。这样，我们已经准备好一切来编写训练脚本的核心部分：训练循环。在训练循环中，我们迭代数据加载器并将批次传递给模型。使用 logits，我们可以评估我们的自定义损失函数。我们按梯度累积步骤数缩放损失，以便在聚合更多步骤时不会产生更大的损失。在优化之前，我们还剪裁梯度以获得更好的收敛性。最后，每隔几步，我们使用新的 evaluate() 函数在评估集上评估模型

from tqdm.notebook import tqdm

gradient_accumulation_steps = 8
eval_steps = 5_000

model.train()
completed_steps = 0
for epoch in range(num_train_epochs):
    for step, batch in tqdm(
        enumerate(train_dataloader, start=1), total=num_training_steps
    ):
        logits = model(batch["input_ids"]).logits
        loss = keytoken_weighted_loss(batch["input_ids"], logits, keytoken_ids)
        if step % 100 == 0:
            accelerator.print(
                {
                    "samples": step * samples_per_step,
                    "steps": completed_steps,
                    "loss/train": loss.item() * gradient_accumulation_steps,
                }
            )
        loss = loss / gradient_accumulation_steps
        accelerator.backward(loss)
        if step % gradient_accumulation_steps == 0:
            accelerator.clip_grad_norm_(model.parameters(), 1.0)
            optimizer.step()
            lr_scheduler.step()
            optimizer.zero_grad()
            completed_steps += 1
        if (step % (eval_steps * gradient_accumulation_steps)) == 0:
            eval_loss, perplexity = evaluate()
            accelerator.print({"loss/eval": eval_loss, "perplexity": perplexity})
            model.train()
            accelerator.wait_for_everyone()
            unwrapped_model = accelerator.unwrap_model(model)
            unwrapped_model.save_pretrained(output_dir, save_function=accelerator.save)
            if accelerator.is_main_process:
                tokenizer.save_pretrained(output_dir)
                repo.push_to_hub(
                    commit_message=f"Training in progress step {step}", blocking=False
                )

就是这样 — 您现在拥有了自己的自定义训练循环，用于 GPT-2 等因果语言模型，您可以根据自己的需要进一步自定义。

✏️ 试一试！ 创建针对您的用例量身定制的自定义损失函数，或在训练循环中添加另一个自定义步骤。

✏️ 试一试！ 在运行长时间训练实验时，最好使用 TensorBoard 或 Weights & Biases 等工具记录重要指标。向训练循环添加适当的日志记录，以便您可以随时检查训练的进展情况。