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

到目前为止，我们主要使用预训练模型并通过重用预训练权重来微调它们以适应新的用例。正如我们在第 1 章中看到的，这通常被称为*迁移学习*，它是将 Transformer 模型应用于大多数标记数据稀缺的实际用例的非常成功的策略。在本章中，我们将采用不同的方法，从头开始训练一个全新的模型。如果你有大量数据并且它与现有模型使用的预训练数据非常不同，这是一个很好的方法。然而，预训练语言模型比仅微调现有模型需要更多的计算资源。训练新模型可能很有意义的示例包括由音符、DNA 等分子序列或编程语言组成的数据集。后者最近因 TabNine 和 GitHub 的 Copilot 等工具而受到关注，这些工具由 OpenAI 的 Codex 模型提供支持，可以生成长串代码。这种文本生成任务最适合使用自回归或因果语言模型，例如 GPT-2。

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

在第 6 章中，我们创建了一个高效的 tokenizer 来处理 Python 源代码，但我们仍然需要一个大规模数据集来预训练模型。在这里，我们将把我们的 tokenizer 应用到一个源自 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。

大多数文档包含的 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 亿和 100 亿个 token 上训练，其中 Codex 模型是从 GPT-3 检查点初始化的。我们本节的目标不是与这些能够生成长而连贯文本的模型竞争，而是创建一个缩小版，为数据科学家提供一个快速自动补全功能。

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

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

初始化新模型

我们的第一步是重新初始化一个 GPT-2 模型。我们将为模型使用与小型 GPT-2 模型相同的配置，因此我们加载预训练配置，确保 tokenizer 大小与模型词汇表大小匹配，并传递 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()

训练完成后，我们可以将模型和 tokenizer 推送到 Hub。

trainer.push_to_hub()

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

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

使用管道进行代码生成

现在是检验成果的时候了：让我们看看训练好的模型实际表现如何！我们可以从日志中看到损失稳步下降，但为了真正测试模型，让我们看看它在一些提示上的表现。为此，我们将模型封装在一个文本生成 pipeline 中，如果可用，我们将把它放到 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 最常用的导入名称，以及后者的拟合/预测模式。如果这些都表示为单个 token，我们可以轻松检查它们是否出现在输入序列中。token 可以有空格前缀，所以我们也会检查 tokenizer 词汇表中这些版本。为了验证其工作原理，我们将添加一个应该拆分为多个 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 等工具记录重要指标是一个好主意。为训练循环添加适当的日志记录，以便您始终可以检查训练的进展情况。