从头开始训练因果语言模型
到目前为止，我们主要使用的是预训练模型，并通过重用预训练权重将其微调到新的用例。正如我们在第 1 章中看到的那样，这通常被称为迁移学习，它是一种非常成功的策略，可将变压器模型应用于大多数实际用例，在这些用例中，标记数据稀疏。在本章中，我们将采用不同的方法，从头开始训练一个全新的模型。如果你有大量的数据并且它与用于可用模型的预训练数据非常不同，那么这是一个很好的方法。但是，与仅微调现有模型相比，预训练语言模型需要更多的计算资源。可以考虑训练新模型的示例包括由音乐音符、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 万个 Python 文件，称为codeparrot，作者构建了一个数据集，然后他们在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_datasetsDatasetDict({
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 选项自动返回每个创建的块的长度。通常最后一个块将小于上下文大小，我们将删除这些块以避免填充问题；我们实际上并不需要它们，因为我们已经拥有足够多的数据。
让我们通过查看前两个示例来了解它是如何工作的。
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 个片段。查看块长度，我们可以看到，两个文档末尾的块的 token 数少于 128 个（分别为 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_datasetsDatasetDict({
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 模型分别在 3000 亿个和 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()
✏️ 试一试！ 从原始文本到训练 GPT-2，除了 TrainingArguments 之外，我们只用了大约 30 行代码。使用您自己的数据集试试看，看看是否能获得良好的效果！
💡 如果您有权访问具有多个 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最常见的导入名称，以及后者的拟合/预测模式。如果这些每个都表示为单个标记，我们可以轻松地检查它们是否出现在输入序列中。标记可以有空格前缀，因此我们还将检查标记器词汇表中的这些版本。为了验证它是否有效，我们将添加一个应被拆分为多个标记的测试标记。
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 和我们刚刚选择的关键标记作为输入。首先我们需要对齐 logits 和输入：向右移动一个位置的输入序列形成标签，因为下一个标记是当前标记的标签。我们可以通过从输入序列的第二个标记开始标签来实现这一点，因为模型不会对第一个标记进行预测。然后我们截断最后一个 logit，因为我们没有对跟随完整输入序列的标记的标签。有了它，我们可以计算每个样本的损失并计算每个样本中所有关键字的出现次数。最后，我们使用出现次数作为权重，计算所有样本的加权平均值。由于我们不想丢弃所有没有关键字的样本，因此我们在权重中加 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_dataset.set_format("torch")
train_dataloader = DataLoader(tokenized_dataset["train"], batch_size=32, shuffle=True)
eval_dataloader = DataLoader(tokenized_dataset["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 等工具记录重要指标。在训练循环中添加适当的日志记录，这样您就可以始终检查训练情况。