构建大规模语料库的挑战

预训练后的模型质量很大程度上反映了预训练语料库的质量。特别是，该模型将继承预训练语料库中的任何缺陷。因此，在我们尝试创建自己的语料库之前，最好了解与构建大型语料库进行预训练相关的一些常见问题和挑战。

随着数据集变得越来越大，您可以完全控制或至少准确了解其中的内容的机会会减少。一个非常大的数据集很可能不会由专门的创建者组装，他们一次制作一个示例，同时了解并了解完整的管道和机器学习模型将应用于的任务。相反，通过收集作为其他活动的副作用而生成的数据，更有可能以自动或半自动的方式创建一个非常大的数据集。例如，它可能包含公司存储的所有文件（例如，合同、采购订单等）、用户活动日志或从互联网收集的数据。

大规模数据集大多是通过高度自动化创建的，这会产生几个重要的后果。一个重要的考虑因素是对其内容和创建方式的控制有限，因此在有偏见和低质量数据上训练模型的风险增加。最近对分别用于训练 BERT 和 T5 的著名大型数据集（如 BookCorpus 和 C4）的调查发现（除其他外）：1

• C4 语料库的很大一部分是机器翻译的，而不是人工翻译的。

• 由于 C4 中的停用词过滤导致非裔美国人英语的不同擦除导致此类内容的代表性不足。

• 在大型文本语料库中，通常很难在包括（通常太多）性或其他露骨内容和完全删除所有提及性或性别的内容之间找到中间立场。作为一个令人惊讶的结果，一个相当常见的词，如“sex”（它可以具有中性和明确的含义）对于在 C4 上训练的分词器来说是完全未知的，因为这个词在语料库中完全不存在。

• BookCorpus 中存在许多侵犯版权的事件，可能在其他大规模数据集中也是如此。2

• BookCorpus 中的类型偏向于“浪漫”小说。

这些发现可能与在这些语料库上训练的模型的下游使用不兼容。例如，如果该模型旨在用作言情小说写作工具或构建游戏，那么 BookCorpus 中言情小说的过度表现可能是可以接受的。

让我们通过比较来自 GPT 和 GPT-2 的文本生成来说明模型被数据扭曲的概念。GPT 主要在 BookCorpus 上进行训练，而 GPT-2 则在从 Reddit 链接的网页、博客和新闻文章上进行训练。我们将在同一提示下比较两个模型的相似大小版本，因此主要区别在于预训练数据集，我们将使用text-generation管道来调查模型输出：

    

     

      

       

      
      

       

        from transformers 
        import pipeline, set_seed
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        generation_gpt = 
        pipeline(
        "text-generation", model=
        "openai-gpt")
       
      
     

      

       

      
      

       

        generation_gpt2 = 
        pipeline(
        "text-generation", model=
        "gpt2")
       
      
    

接下来，让我们创建一个简单的函数来计算每个模型中的参数数量：

    

     

      

       

      
      

       

        def 
        model_size(
        model):
       
      
     

      

       

      
      

       
    
        return 
        sum(t.numel() 
        for t 
        in model.parameters())
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        print(
        f"GPT size: {model_size(generation_gpt.model)/1000**2:.1f}M parameters")
       
      
     

      

       

      
      

       

        print(
        f"GPT2 size: {model_size(generation_gpt2.model)/1000**2:.1f}M parameters")
       
      
    

GPT  size: 116.5M parameters
GPT2 size: 124.4M parameters

最初的 GPT 模型与最小的 GPT-2 模型大小差不多。现在我们可以从每个模型生成三个不同的补全，每个补全都有相同的输入提示：

    

     

      

       

      
      

       

        def 
        enum_pipeline_ouputs(pipe, prompt, num_return_sequences):
       
      
     

      

       

      
      

       

            out = 
        pipe(prompt, num_return_sequences=num_return_sequences,
       
      
     

      

       

      
      

       

                       clean_up_tokenization_spaces=True)
       
      
     

      

       

      
      

       

            return 
        "\n".
        join(f
        "{i+1}." + s[
        "generated_text"] for i, s in 
        enumerate(out))
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        prompt = 
        "\nWhen they came back"
       
      
     

      

       

      
      

       

        print(
        "GPT completions:\n" + 
        enum_pipeline_ouputs(generation_gpt, prompt, 
        3))
       
      
     

      

       

      
      

       

        print(
        "")
       
      
     

      

       

      
      

       

        print(
        "GPT-2 completions:\n" + 
        enum_pipeline_ouputs(generation_gpt2, prompt, 
        3))
       
      
    

GPT completions:
1.
When they came back.
 " we need all we can get, " jason said once they had settled into the back of
the truck without anyone stopping them. " after getting out here, it 'll be up
to us what to find. for now
2.
When they came back.
 his gaze swept over her body. he 'd dressed her, too, in the borrowed clothes
that she 'd worn for the journey.
 " i thought it would be easier to just leave you there. " a woman like
3.
When they came back to the house and she was sitting there with the little boy.
 " don't be afraid, " he told her. she nodded slowly, her eyes wide. she was so
lost in whatever she discovered that tom knew her mistake

GPT-2 completions:
1.
When they came back we had a big dinner and the other guys went to see what
their opinion was on her. I did an hour and they were happy with it.
2.
When they came back to this island there had been another massacre, but he could
not help but feel pity for the helpless victim who had been left to die, and
that they had failed that day. And so was very, very grateful indeed.
3.
When they came back to our house after the morning, I asked if she was sure. She
said, "Nope." The two kids were gone that morning. I thought they were back to
being a good friend.

When Dost

通过从两个模型中抽取少量输出，我们已经可以看到 GPT 生成中独特的“浪漫”偏差，这通常会想象一个女人和男人之间浪漫互动的对话。另一方面，GPT-2 接受了与 Reddit 文章链接的网络文本的训练，并且在其几代人中大多采用中性的“他们”，其中包含“类似博客”或与冒险相关的元素。

一般来说，在数据集上训练的任何模型都将反映其训练数据中的人口和事件的语言偏见和过度或不足的代表性。考虑到与模型交互的目标受众，模型行为中的这些偏差很重要；对于一些有用的指南，我们建议您参考 Google 的一篇论文，该论文提供了数据集开发的框架。3

这个简短的介绍应该让您了解在创建大型文本语料库时所面临的困难挑战。考虑到这些，现在让我们来看看创建我们自己的数据集！

构建自定义代码数据集

为了稍微简化任务，我们将只专注于为 Python 编程语言构建代码生成模型。4我们首先需要一个包含 Python 源代码的大型预训练语料库。幸运的是，有一个每个软件工程师都知道的自然资源：GitHub！著名的代码共享网站拥有 数 TB的代码存储库，这些存储库可以公开访问，并且可以根据各自的许可证下载和使用。在本书写作之时，GitHub 拥有超过 2000 万个代码库。其中许多是用户创建的小型或测试存储库，用于学习、未来的辅助项目或测试目的。

可以通过两种主要方式访问 GitHub 存储库：

• 通过 GitHub REST API，就像我们在第 9 章下载 Transformers 存储库的所有 GitHub 问题时看到的那样

• 通过Google BigQuery等公共数据集清单

由于 REST API 是速率受限的，并且我们需要大量数据用于预训练语料库，因此我们将使用 Google BigQuery 提取所有 Python 存储库。该 bigquery-public-data.github_repos.contents表包含所有小于 10 MB 的 ASCII 文件的副本。根据GitHub 的 License API确定，项目还需要是开源 的。

让我们看看使用 Google BigQuery 创建代码数据集需要什么。

$ git clone https://huggingface.co/datasets/transformersbook/codeparrot

使用大型数据集

加载非常大的数据集通常是一项具有挑战性的任务，尤其是当数据大于机器的 RAM 时。对于大规模的预训练数据集，这是很常见的情况。在我们的示例中，我们有 50 GB 的压缩数据和大约 200 GB 的未压缩数据，这些数据很难提取并加载到标准尺寸的笔记本电脑或台式电脑的 RAM 内存中。

值得庆幸的是，Datasets 的设计从一开始就是为了克服这个问题，它具有两个特定功能，可以让您摆脱 RAM 和硬盘空间的限制：内存映射和流式传输。

     

      

       

        

       
       

        

         from datasets 
         import load_dataset, DownloadConfig
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        

         download_config = DownloadConfig(delete_extracted=
         True)
        
       
      

       

        

       
       

        

         dataset = load_dataset(
         "./codeparrot", split=
         "train",
        
       
      

       

        

       
       

        

                                download_config=download_config)
        
       
     

     

      

       

        

       
       

        

         import psutil
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        

         print(
         f"Number of python files code in dataset : {len(dataset)}")
        
       
      

       

        

       
       

        

         ds_size = 
         sum(os.stat(f[
         "filename"]).st_size 
         for f 
         in dataset.cache_files)
        
       
      

       

        

       
       

        

         # os.stat.st_size is expressed in bytes, so we convert to GB
        
       
      

       

        

       
       

        

         print(
         f"Dataset size (cache file) : {ds_size / 2**30:.2f} GB")
        
       
      

       

        

       
       

        

         # Process.memory_info is expressed in bytes, so we convert to MB
        
       
      

       

        

       
       

        

         print(
         f"RAM used: {psutil.Process(os.getpid()).memory_info().rss >> 20} MB")
        
       
     

Number of python files code in dataset : 18695559
Dataset size (cache file) : 183.68 GB
RAM memory used: 4924 MB

streamed_dataset = load_dataset('./codeparrot', split="train", streaming=True)

     

      

       

        

       
       

        

         iterator = iter(
         streamed_dataset)
        
       
      

       

        

       
       

        
 
        
       
      

       

        

       
       

        

         print(
         dataset[
         0] == next(
         iterator))
        
       
      

       

        

       
       

        

         print(
         dataset[
         1] == next(
         iterator))
        
       
     

True
True

     

      

       

        

       
       

        

         remote_dataset = load_dataset('transformersbook/codeparrot', split=
         "train",
        
       
      

       

        

       
       

        

                                       streaming=True)
        
       
     

将数据集添加到 Hugging Face Hub

将我们的数据集推送到 Hugging Face Hub 将使我们能够：

• 从我们的培训服务器轻松访问它。

• 了解流数据集如何与 Hub 中的数据集无缝协作。

• 与社区分享，包括你，亲爱的读者！

要上传数据集，我们首先需要通过在终端中运行以下命令并提供相关凭据来登录我们的 Hugging Face 帐户：

$ huggingface-cli login

这相当于notebook_login()我们在前几章中使用的辅助函数。完成后，我们可以直接在 Hub 上创建一个新数据集并上传压缩的 JSON 文件。为简化起见，我们将创建两个存储库：一个用于训练拆分，一个用于验证拆分。我们可以通过运行repo create CLI 的命令来做到这一点，如下所示：

    

     

      

       

      
      

       

        $ huggingface-cli repo create --
        type dataset --organization transformersbook \
       
      
     

      

       

      
      

       

        codeparrot-train
       
      
     

      

       

      
      

       

        $ huggingface-cli repo create --
        type dataset --organization transformersbook \
       
      
     

      

       

      
      

       

        codeparrot-valid
       
      
    

在这里，我们已经指定存储库应该是一个数据集（与用于存储权重的模型存储库相反），以及我们希望存储存储库的组织。如果您在个人帐户下运行此代码，则可以省略该--organization标志。接下来，我们需要将这些空存储库克隆到我们的本地机器，将 JSON 文件复制到它们，并将更改推送到 Hub。我们将从我们拥有的 184 个 JSON 文件中取出最后一个压缩的 JSON 文件作为验证文件（即，大约占我们数据集的 0.5%）。执行以下命令将存储库从 Hub 克隆到本地计算机：

    

     

      

       

      
      

       

        $ git clone 
        https:/
        /huggingface.co/datasets
        /transformersbook/codeparrot-train
       
      
     

      

       

      
      

       

        $ git clone 
        https:/
        /huggingface.co/datasets
        /transformersbook/codeparrot-valid
       
      
    

接下来，将除最后一个 GitHub 文件之外的所有文件复制为训练集：

    

     

      

       

      
      

       

        $ 
        cd codeparrot-train
       
      
     

      

       

      
      

       

        $ 
        cp ../codeparrot/*.json.gz 。
       
      
     

      

       

      
      

       

        $ 
        rm ./file-000000000183.json.gz
       
      
    

然后提交文件并将它们推送到 Hub：

    

     

      

       

      
      

       

        $ git add .
       
      
     

      

       

      
      

       

        $ git commit -m 
        "Adding dataset files"
       
      
     

      

       

      
      

       

        $ git push
       
      
    

现在，重复验证集的过程：

    

     

      

       

      
      

       

        $ 
        cd ../codeparrot-valid
       
      
     

      

       

      
      

       

        $ 
        cp ../codeparrot/file-000000000183.json.gz .
       
      
     

      

       

      
      

       

        $ 
        mv ./file-000000000183.json.gz ./file-000000000183_validation.json.gz
       
      
     

      

       

      
      

       

        $ git add .
       
      
     

      

       

      
      

       

        $ git commit -m 
        "Adding dataset files"
       
      
     

      

       

      
      

       

        $ git push
       
      
    

由于计算了所有文件的哈希，因此该git add .步骤可能需要几分钟。上传所有文件也需要一些时间。但是，由于这将使我们能够在本章后面使用流式传输，因此这不会浪费时间，而且这一步将使我们在其余实验中走得更快。请注意，我们_validation为验证文件名添加了后缀。这将使我们能够稍后将其加载为验证拆分。

就是这样！我们的两个数据集拆分以及完整数据集现在位于 Hugging Face Hub 上，网址如下：

• transformersbook/codeparrot · Datasets at Hugging Face

• transformersbook/codeparrot-train · Datasets at Hugging Face

• transformersbook/codeparrot-valid · Datasets at Hugging Face

笔记

训练模型涉及从给定的权重集开始，并在设计目标上使用误差信号的反向传播来最小化模型的损失并为模型找到最佳权重集以执行训练目标定义的任务。另一方面，训练分词器不涉及反向传播或权重。这是一种创建从文本字符串到可以被模型摄取的整数列表的最佳映射的方法。在今天的分词器中，最佳的字符串到整数的转换涉及一个由原子字符串列表组成的词汇表和一个相关的方法，用于将文本字符串转换、规范化、剪切或映射到具有该词汇表的索引列表。这个索引列表就是我们神经网络的输入。

分词器模型

正如您在第 4 章中看到的，分词器是一个处理管道，由四个步骤组成：规范化、预分词、分词器模型和后处理。可以在数据上训练的分词器管道部分是分词器模型。正如我们在 第 2 章中讨论的那样，可以使用几种子词标记化算法，例如 BPE、WordPiece 和 Unigram。

BPE 从基本单元（单个字符）列表开始，并通过逐步创建新标记的过程来创建词汇表，这些新标记是通过合并最常同时出现的基本单元并将它们添加到词汇表中而形成的。重复此过程，直到达到预定义的词汇量。

Unigram 从另一端开始，用语料库中的所有单词和潜在的子词初始化其基本词汇表。然后它逐步移除或拆分不太有用的标记以获得越来越小的词汇表，直到达到目标词汇表大小。WordPiece 是 Unigram 的前身，其官方实现从未被 Google 开源。

这些不同算法对下游性能的影响因任务而异，总体而言，很难确定一种算法是否明显优于其他算法。BPE 和 Unigram 在大多数情况下都具有合理的性能，但是让我们看一下在评估时要考虑的一些方面。

测量标记器性能

标记器的最优性和性能在实践中难以衡量。一些可能的指标包括：

• 子词生育率，它计算每个标记词产生的子词的平均数量

• 连续词的比例，指在一个语料库中被分词的词被分成至少两个子词的比例

• 覆盖指标，例如标记化语料库中未知单词或很少使用的标记的比例

此外，通常会估计对拼写错误或噪声的鲁棒性，以及此类域外示例的模型性能，因为这在很大程度上取决于标记化过程。

这些度量对分词器的性能给出了一组不同的看法，但它们往往忽略了分词器与模型的交互。例如，可以通过将所有可能的词包含在词汇表中来最小化子词生育率，但这会为模型产生非常大的词汇表。

最后，各种标记化方法的性能通常最好通过使用模型的下游性能作为最终指标来估计。例如，早期 BPE 方法的良好性能通过使用这些标记器和词汇而不是基于字符或单词的标记化训练的模型显示机器翻译任务的改进性能来证明。

让我们看看如何构建我们自己的针对 Python 代码优化的分词器。

Python 的分词器

我们的用例需要一个自定义标记器：标记 Python 代码。预标记化问题值得对编程语言进行一些讨论。如果我们拆分空格并删除它们，我们将丢失所有缩进信息，这在 Python 中对程序的语义很重要（只需考虑while循环或 if-then-else语句）。另一方面，换行符没有意义，可以在不影响语义的情况下添加或删除。类似地，在标点符号上进行拆分，例如下划线，用于从多个子部分组成单个变量名，可能不像在自然语言中那样有意义。因此，使用自然语言预分词器对代码进行分词似乎不是最理想的。

让我们看看集线器上提供的集合中是否有任何可能对我们有用的标记器。我们想要一个保留空格的标记器，所以一个好的候选者可能是一个字节级的标记器，就像 GPT-2 中的那个。让我们加载这个分词器并探索它的分词属性：

    

     

      

       

      
      

       

        from transformers 
        import AutoTokenizer
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        python_code = 
        r"""def say_hello():
       
      
     

      

       

      
      

       

         print("Hello, World!")
       
      
     

      

       

      
      

       

        
       
      
     

      

       

      
      

       

        # Print it
       
      
     

      

       

      
      

       

        say_hello()
       
      
     

      

       

      
      

       

        """
       
      
     

      

       

      
      

       

        tokenizer = AutoTokenizer.from_pretrained(
        "gpt2")
       
      
     

      

       

      
      

       

        print(tokenizer(python_code).tokens())
       
      
    

['def', 'Ġsay', '_', 'hello', '():', 'Ċ', 'Ġ', 'Ġ', 'Ġ', 'Ġprint', '("',
'Hello', ',', 'ĠWorld', '!"', ')', 'Ġ#', 'ĠPrint', 'Ġit', 'Ċ', 'Ċ', 'say', '_',
'hello', '()', 'Ċ']

这是一个非常奇怪的输出，所以让我们通过运行标记器管道的各个子模块来尝试了解这里发生了什么。首先让我们看看在这个分词器中应用了什么规范化：

print(tokenizer.backend_tokenizer.normalizer)

None

正如我们所见，GPT-2 分词器没有使用规范化。它直接在 原始 Unicode输入上工作，无需任何规范化步骤。现在让我们看一下 预标记：

print(tokenizer.backend_tokenizer.pre_tokenizer.pre_tokenize_str(python_code))

[('def', (0, 3)), ('Ġsay', (3, 7)), ('_', (7, 8)), ('hello', (8, 13)), ( '():',
(13, 16)), ('YYYY', (16, 20)), ('打印', (20, 26)), ('("', (26, 28)), ('Hello',
(28, 33)), (',', (33, 34)), ('GWorld', (34, 40)), ('!")', (40, 43)), ('G#' , （43，
45)), ('GPrint', (45, 51)), ('Git', (51, 54)), ('C', (54, 55)), ('C', (55, 56) ),
('say', (56, 59)), ('_', (59, 60)), ('hello', (60, 65)), ('()', (65, 67)), ( 'C'，
(67, 68))]

所有这些Ġ符号是什么，令牌附带的数字是什么？让我们解释一下，看看我们是否能更好地理解这个分词器是如何工作的。

让我们从数字开始。 Tokenizers 有一个非常有用的功能，用于在字符串和标记之间切换，称为偏移跟踪。跟踪输入字符串上的所有操作，以便准确知道标记化后的标记对应于输入字符串的哪一部分。这些数字只是表明每个标记在原始字符串中的来源；例如， 'hello'第一行中的单词对应于原始字符串中的第 8 到 13 个字符。如果在规范化步骤中删除了某些字符，我们仍然能够将每个标记与原始字符串中的相应部分相关联。

标记化文本的另一个奇怪特征是看起来很奇怪的字符，例如Ċ和Ġ。字节级意味着此标记器适用于字节而不是 Unicode 字符。每个 Unicode 字符由 1 到 4 个字节组成，具体取决于字符。字节的好处在于，虽然 Unicode 字母表中有 143,859 个 Unicode 字符，但字节字母表中只有 256 个元素，您可以将每个 Unicode 字符表示为这些字节的序列。如果我们处理字节，我们可以将所有由 UTF-8 世界组成的字符串表示为这个由 256 个值组成的字母表中的较长字符串。也就是说，我们可以有一个模型使用只有 256 个单词的字母表，并且能够处理任何 Unicode 字符串。让我们看一下某些字符的字节表示形式：

    

     

      

       

      
      

       

        a, e = 
        u"a", 
        u"€"
       
      
     

      

       

      
      

       

        byte = 
        ord(a.encode(
        "utf-8"))
       
      
     

      

       

      
      

       

        print(
        f'`{a}` is encoded as `{a.encode("utf-8")}` with a single byte: {byte}')
       
      
     

      

       

      
      

       

        byte = [
        ord(
        chr(i)) 
        for i 
        in e.encode(
        "utf-8")]
       
      
     

      

       

      
      

       

        print(
        f'`{e}` is encoded as `{e.encode("utf-8")}` with three bytes: {byte}')
       
      
    

`a` is encoded as `b'a'` with a single byte: 97
`€` is encoded as `b'\xe2\x82\xac'` with three bytes: [226, 130, 172]

此时您可能想知道：为什么要在字节级别上工作？回想一下我们在第 2 章中 关于字符和单词标记之间权衡的讨论。我们可以决定从 143,859 个 Unicode 字符构建我们的词汇表，但我们也想在我们的词汇表中包含单词——即 Unicode 字符的组合，所以这个（已经非常大的）大小只是总大小的下限的词汇。这将使我们的模型的嵌入层非常大，因为它包含每个词汇标记的一个向量。

在另一个极端，如果我们只使用 256 字节的值作为我们的词汇表，输入序列将被分割成许多小片段（每个字节构成 Unicode 字符），因此我们的模型将不得不处理长输入并花费从单独的字节重建 Unicode 字符，然后从这些字符重建单词，具有强大的计算能力。有关此开销的详细研究，请参阅 ByT5 模型版本随附的论文。6

一个中间的解决方案是通过使用最常见的字节组合扩展 256 个单词的词汇表来构建一个中等大小的词汇表。这是 BPE 算法采用的方法。这个想法是通过迭代合并词汇表中最常同时出现的一对标记来创建新的词汇标记，从而逐步构建一个预定义大小的词汇表。例如，如果t和 h经常一起出现，就像在英语中一样，我们将th在词汇表中添加一个标记来模拟这对标记，而不是将它们分开。和标记保存在词汇表t中h以标记它们不一起出现的实例。从基本单元的基本词汇开始，我们可以有效地对任何字符串进行建模。

在 NLP 中使用典型的 BPE 算法时只有一个问题。这些算法被设计为使用干净的 Unicode 字符串作为输入，而不是字节，并期望输入中的常规 ASCII 字符，没有空格或控制字符。但是在 256 个首字节对应的 Unicode 字符中，有很多控制字符（换行符、制表符、转义符、换行符和其他不可打印的字符）。为了克服这个问题，GPT-2 标记器首先将所有 256 个输入字节映射到标准 BPE 算法可以轻松消化的 Unicode 字符串——也就是说，我们将我们的 256 个基本值映射到所有对应于标准可打印的 Unicode 字符串Unicode 字符。

这些 Unicode 字符每个都用 1 个字节或更多字节编码并不是很重要；重要的是我们最后有 256 个单个值，形成我们的基本词汇表，并且这 256 个值由我们的 BPE 算法正确处理。让我们看一些使用 GPT-2 标记器的映射示例。我们可以按如下方式访问整个映射：

    

     

      

       

      
      

       

        from transformers.models.gpt2.tokenization_gpt2 
        import bytes_to_unicode
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        byte_to_unicode_map = bytes_to_unicode()
       
      
     

      

       

      
      

       

        unicode_to_byte_map = 
        dict((v, k) 
        for k, v 
        in byte_to_unicode_map.items())
       
      
     

      

       

      
      

       

        base_vocab = 
        list(unicode_to_byte_map.keys())
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        print(
        f'Size of our base vocabulary: {len(base_vocab)}')
       
      
     

      

       

      
      

       

        print(
        f'First element: `{base_vocab[0]}`, last element: `{base_vocab[-1]}`')
       
      
    

Size of our base vocabulary: 256
First element: `!`, last element: `Ń`

我们可以在表 10-1中查看一些常见的字节值和相关映射的 Unicode 字符。

表 10-1。BPE 中的字符映射示例

我们本可以使用更明确的转换，例如将换行符映射到NEWLINE字符串，但 BPE 算法通常设计用于处理字符。出于这个原因，使用开箱即用的 BPE 算法，为每个字节字符保留一个 Unicode 字符更容易处理。现在我们已经了解了 Unicode 编码的黑魔法，我们可以更好地理解我们的标记化转换：

print(tokenizer.backend_tokenizer.pre_tokenizer.pre_tokenize_str(python_code))

[('def', (0, 3)), ('Ġsay', (3, 7)), ('_', (7, 8)), ('hello', (8, 13)), ('():',
(13, 16)), ('ĊĠĠĠ', (16, 20)), ('Ġprint', (20, 26)), ('("', (26, 28)), ('Hello',
(28, 33)), (',', (33, 34)), ('ĠWorld', (34, 40)), ('!")', (40, 43)), ('Ġ#', (43,
45)), ('ĠPrint', (45, 51)), ('Ġit', (51, 54)), ('Ċ', (54, 55)), ('Ċ', (55, 56)),
('say', (56, 59)), ('_', (59, 60)), ('hello', (60, 65)), ('()', (65, 67)), ('Ċ',
(67, 68))]

我们可以识别换行符，我们现在知道映射到Ċ，而空格映射到Ġ。我们还看到：

• 空间，特别是连续空间，是守恒的（例如， 中的三个空间'ĊĠĠĠ'）。

• 连续的空格被视为一个单词。

• 单词前面的每个空格都附加到后续单词（例如 in 'Ġsay'）并被视为其一部分。

现在让我们尝试 BPE 模型。正如我们已经提到的，它负责将单词拆分为子单元，直到所有子单元都属于预定义的词汇表。

我们的 GPT-2 分词器的词汇表包含 50,257 个单词：

• 具有 256 个字节值的基本词汇表

• 50,000 个通过重复合并最常同时出现的代币创建的额外代币

• 添加到词汇表以表示文档边界的特殊字符

我们可以通过查看标记器的长度属性轻松检查：

print(f"Size of the vocabulary: {len(tokenizer)}")

Size of the vocabulary: 50257

在我们的输入代码上运行完整的管道会给我们以下输出：

print(tokenizer(python_code).tokens())

['def', 'Ġsay', '_', 'hello', '():', 'Ċ', 'Ġ', 'Ġ', 'Ġ', 'Ġprint', '("',
'Hello', ',', 'ĠWorld', '!"', ')', 'Ġ#', 'ĠPrint', 'Ġit', 'Ċ', 'Ċ', 'say', '_',
'hello', '()', 'Ċ']

正如我们所看到的，BPE 分词器保留了大部分单词，但会将我们缩进的多个空格分割成几个连续的空格。发生这种情况是因为这个标记器没有专门针对代码进行训练，而是主要针对连续空格很少的文本进行训练。因此，BPE 模型不包括缩进词汇表中的特定标记。这是分词器模型不太适合数据集域的情况。正如我们之前讨论的，解决方案是在目标语料库上重新训练分词器。所以让我们开始吧！

训练分词器

让我们在我们的语料库切片上重新训练我们的字节级 BPE 标记器，以获得更好地适应 Python 代码的词汇表。重新训练Transformers提供的分词器很简单。我们只需要：

• 指定我们的目标词汇量。

• 准备一个迭代器来提供要处理的输入字符串列表，以训练标记器的模型。

• 调用train_new_from_iterator()方法。

与通常期望从训练语料库中记住大量特定细节的深度学习模型不同，标记器实际上只是经过训练以提取主要统计数据。简而言之，标记器只是经过训练，知道哪些字母组合在我们的语料库中最常见。

因此，您不一定需要在非常大的语料库上训练分词器；语料库只需要代表您的领域并且足够大，以便标记器提取具有统计意义的度量。但是根据词汇量的大小和语料库中的确切文本，分词器最终可能会存储 意外的单词。例如，当查看 GPT-2 分词器词汇表中最长的单词时，我们可以看到这一点：

    

     

      

       

      
      

       

        tokens = 
        sorted(tokenizer.vocab.items(), key=
        lambda x: 
        len(x[
        0]), reverse=
        True)
       
      
     

      

       

      
      

       

        print([
        f'{tokenizer.convert_tokens_to_string(t)}' 
        for t, _ 
        in tokens[:
        8]]);
       
      
    

['ÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂ', '
=================================================================', '
----------------------------------------------------------------
',
'................................................................',
'ÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂÃÂ',
'
----------------------------------------------------------------
',
'================================================================',
'________________________________________________________________']

这些标记看起来像很可能在论坛上使用的分隔线。这是有道理的，因为 GPT-2 是在以 Reddit 为中心的语料库上训练的。现在让我们看看最后添加到词汇表中的单词，以及最不常见的单词：

    

     

      

       

      
      

       

        tokens = 
        sorted(tokenizer.vocab.items(), key=
        lambda x: x[
        1], reverse=
        True)
       
      
     

      

       

      
      

       

        print([
        f'{tokenizer.convert_tokens_to_string(t)}' 
        for t, _ 
        in tokens[:
        12]]);
       
      
    

['<|endoftext|>', ' gazed', ' informants', ' Collider', ' regress', 'ominated',
' amplification', 'Compar', '..."', ' (/', 'Commission', ' Hitman']

第一个标记<|endoftext|>是用于指定文本序列结尾的特殊标记，是在 BPE 词汇表构建后添加的。对于这些标记中的每一个，我们的模型都必须学习相关的词嵌入，并且我们可能不希望嵌入矩阵包含太多嘈杂的词。还要注意一些非常时间和空间特定的世界知识（例如，专有名词，如Hitman和Commission）是如何嵌入在我们的建模方法中的非常低的级别，这些单词被授予带有词汇表中相关向量的单独标记。BPE 标记器创建此类特定标记也可能表明目标词汇量太大或语料库包含特殊标记。

让我们在我们的语料库上训练一个新的分词器并检查它的学习词汇。由于我们只需要一个能够合理代表我们的数据集统计信息的语料库，让我们从我们的语料库中选择大约 1-2 GB 的数据，或大约 100,000 个文档：

    

     

      

       

      
      

       

        from tqdm.auto 
        import tqdm
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        length = 
        100000
       
      
     

      

       

      
      

       

        dataset_name = 
        'transformersbook/codeparrot-train'
       
      
     

      

       

      
      

       

        dataset = load_dataset(dataset_name, split=
        "train", streaming=
        True)
       
      
     

      

       

      
      

       

        iter_dataset = 
        iter(dataset)
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        def 
        batch_iterator(
        batch_size=10):
       
      
     

      

       

      
      

       
    
        for _ 
        in tqdm(
        range(
        0, length, batch_size)):
       
      
     

      

       

      
      

       
        
        yield [
        next(iter_dataset)[
        'content'] 
        for _ 
        in 
        range(batch_size)]
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        new_tokenizer = tokenizer.train_new_from_iterator(batch_iterator(),
       
      
     

      

       

      
      

       

                                                          vocab_size=
        12500,
       
      
     

      

       

      
      

       

                                                          initial_alphabet=base_vocab)
       
      
    

让我们研究一下我们的 BPE 算法创建的第一个和最后一个词，看看我们的词汇表有多相关。我们跳过 256 字节的标记，然后查看之后添加的第一个标记：

    

     

      

       

      
      

       

        tokens = 
        sorted(new_tokenizer.vocab.items(), key=
        lambda x: x[
        1], reverse=
        False)
       
      
     

      

       

      
      

       

        print([
        f'{tokenizer.convert_tokens_to_string(t)}' 
        for t, _ 
        in tokens[
        257:
        280]]);
       
      
    

['  ', '    ', '   ', '        ', 'se', 'in', '       ', 're', 'on', 'te', '\n
', '\n        ', 'or', 'st', 'de', '\n   ', 'th', 'le', ' =', 'lf', 'self',
'me', 'al']

在这里，我们可以看到各种标准级别的缩进和空白标记，以及简短的常见 Python 关键字，如self、or和 in。这是一个很好的迹象，表明我们的 BPE 算法正在按预期工作。现在让我们看看最后一句话：

print([f'{new_tokenizer.convert_tokens_to_string(t)}' for t,_ in tokens[-12:]]);

['def', 'Ġs', 'ay', '_', 'hello', '():', 'ĊĠĠĠ', 'Ġprint', '("', 'Hello', ',',
'ĠWor', 'ld', '!")', 'Ġ#', 'ĠPrint', 'Ġit', 'Ċ', 'Ċ', 's', 'ay', '_', 'hello',
'()', 'Ċ']

这里还有一些比较常见的词，比如 recv，还有一些比较吵的词可能来自评论。

我们还可以对 Python 代码的简单示例进行标记，以查看标记器在一个简单示例中的表现：

print(new_tokenizer(python_code).tokens())

['def', 'Gs', 'ay', '_', 'hello', '():', 'CGGGG', 'Print', '("', 'Hello', ',',
'GWor', 'ld', '!")', 'G#', 'GPrint', 'Git', 'C', 'C', 's', 'ay', '_', 'hello',
'（）'， 'C']

尽管它们不是代码关键字，但看到常见的英语单词喜欢World或被say我们的分词器拆分还是有点烦人，因为我们希望它们在语料库中出现得相当频繁。让我们检查一下是否所有的 Python 保留关键字都在词汇表中：

    

     

      

       

      
      

       

        import keyword
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        print(
        f'There are in total {len(keyword.kwlist)} Python keywords.')
       
      
     

      

       

      
      

       

        for keyw 
        in keyword.kwlist:
       
      
     

      

       

      
      

       
    
        if keyw 
        not 
        in new_tokenizer.vocab:
       
      
     

      

       

      
      

       
        
        print(
        f'No, keyword `{keyw}` is not in the vocabulary')
       
      
    

There are in total 35 Python keywords.
No, keyword `await` is not in the vocabulary
No, keyword `finally` is not in the vocabulary
No, keyword `nonlocal` is not in the vocabulary

似乎几个相当频繁的关键字，例如finally，也不在词汇表中。让我们尝试使用更大的数据集样本来构建更大的词汇表。例如，我们可以构建一个包含 32,768 个单词的词汇表（8 的倍数更适合一些高效的 GPU/TPU 计算）并在两倍大的语料库切片上训练分词器：

    

     

      

       

      
      

       

        length 
        = 
        200000
       
      
     

      

       

      
      

       

        new_tokenizer_larger 
        = tokenizer.train_new_from_iterator
        (batch_iterator
        (
        )
        ,
       
      
     

      

       

      
      

       

            vocab_size
        =
        32768
        , initial_alphabet
        =base_vocab
        )
       
      
    

我们不希望添加更多文档时最常见的标记发生太大变化，但让我们看看最后一个标记：

    

     

      

       

      
      

       

        tokens = 
        sorted(new_tokenizer_larger.vocab.items(), key=
        lambda x: x[
        1],
       
      
     

      

       

      
      

       

                        reverse=
        False)
       
      
     

      

       

      
      

       

        print([
        f'{tokenizer.convert_tokens_to_string(t)}' 
        for t, _ 
        in tokens[-
        12:]]);
       
      
    

['lineEdit', 'spik', 'BC', 'pective', 'OTA', 'theus', 'FLUSH', 'exutils',
'00000002'、'DIVISION'、'CursorPosition'、'InfoBar']

简短的检查在这里没有显示任何常规的编程关键字，这是有希望的。让我们尝试使用新的更大的分词器对我们的示例代码示例进行分 词：

print(new_tokenizer_larger(python_code).tokens())

['def', 'Ġsay', '_', 'hello', '():', 'ĊĠĠĠ', 'Ġprint', '("', 'Hello', ',',
'GWorld', '!")', 'G#', 'GPrint', 'Git', 'C', 'C', 'say', '_', 'hello', '()',
'C']

这里的缩进也很方便地保存在词汇表中，我们看到常见的英语单词，如Hello,World和say也包含在单个标记中。这似乎更符合我们对模型在下游任务中可能看到的数据的预期。让我们研究一下常见的 Python 关键字，就像我们之前所做的那样：

    

     

      

       

      
      

       

        for keyw 
        in keyword.kwlist:
       
      
     

      

       

      
      

       
    
        if keyw 
        not 
        in new_tokenizer_larger.vocab:
       
      
     

      

       

      
      

       
        
        print(
        f'No, keyword `{keyw}` is not in the vocabulary')
       
      
    

No, keyword `nonlocal` is not in the vocabulary

我们仍然缺少 nonlocal关键字，但它在实践中也很少使用，因为它使语法更加复杂。将其排除在词汇表之外似乎是合理的。在这个手动检查之后，我们更大的分词器似乎很适合我们的任务——但正如我们之前提到的，在不衡量模型性能的情况下客观地评估分词器的性能是一项具有挑战性的任务。我们将继续这个并训练一个模型，看看它在实践中的效果如何。

在集线器上保存自定义标记器

现在我们的分词器已经训练好了，我们应该保存它。保存它并能够在以后从任何地方访问它的最简单方法是将其推送到 Hugging Face Hub。当我们使用单独的训练服务器时，这将特别有用。

要创建一个私有模型存储库并将我们的分词器作为第一个文件保存在其中，我们可以直接使用分push_to_hub()词器的方法。由于我们已经使用 验证了我们的帐户 huggingface-cli login，因此我们可以简单地按如下方式推送标记器：

    

     

      

       

      
      

       

        model_ckpt = 
        "codeparrot"
       
      
     

      

       

      
      

       

        org = 
        "transformersbook"
       
      
     

      

       

      
      

       

        new_tokenizer_larger.push_to_hub(model_ckpt, organization=org)
       
      
    

如果您不想推送到某个组织，您可以简单地省略该organization参数。这将在您的命名空间中创建一个名为 的存储库codeparrot，然后任何人都可以通过运行以下命令加载该存储库：

    

     

      

       

      
      

       

        reloaded_tokenizer = AutoTokenizer.from_pretrained(org + 
        "/" + model_ckpt)
       
      
     

      

       

      
      

       

        print(reloaded_tokenizer(python_code).tokens())
       
      
    

['def', 'Ġsay', '_', 'hello', '():', 'ĊĠĠĠ', 'Ġprint', '("', 'Hello', ',',
'GWorld', '!")', 'G#', 'GPrint', 'Git', 'C', 'C', 'say', '_', 'hello', '()',
'C']

从 Hub 加载的分词器的行为与我们刚刚看到的完全一样。我们还可以在 Hub上调查其文件和保存的词汇。为了重现性，让我们也保存我们较小的标记器：

new_tokenizer.push_to_hub(model_ckpt+ "-small-vocabulary", organization=org)

这是为特定用例构建标记器的深入研究。接下来，我们将最终创建一个新模型并从头开始对其进行训练。

小费

在本节中，我们将实现一个比平常更长的脚本来在分布式基础设施上训练模型。因此，您不应单独运行每个代码片段，而应下载 Transformers 存储库中提供的脚本。按照随附的说明在您的硬件上使用Accelerate执行脚本。

预训练目标的故事

现在我们已经获得了大规模的预训练语料库和高效的分词器，我们可以开始考虑如何预训练一个 Transformer 模型。有了这样一个由如图 10-1所示的代码片段组成的大型代码库，我们可以处理多个任务。我们选择哪一个会影响我们对预训练目标的选择。让我们来看看三个常见的任务。

初始化模型

这是本书第一次不使用该 from_pretrained()方法加载模型而是初始化新模型。但是，我们将加载 的配置，gpt2-xl以便我们使用相同的超参数，并且只为新的分词器调整词汇量。然后，我们使用以下方法初始化具有此配置的新模型from_config()：

    

     

      

       

      
      

       

        from transformers import AutoConfig, AutoModelForCausalLM, AutoTokenizer
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        tokenizer = AutoTokenizer.from_pretrained(model_ckpt)
       
      
     

      

       

      
      

       

        config = AutoConfig.from_pretrained(
        "gpt2-xl", vocab_size=
        len(tokenizer))
       
      
     

      

       

      
      

       

        model = AutoModelForCausalLM.from_config(
        config)
       
      
    

让我们检查一下模型实际上有多大：

print(f'GPT-2 (xl) size: {model_size(model)/1000**2:.1f}M parameters')

GPT-2 (xl) size: 1529.6M parameters

这是1.5B参数模型！这是一个很大的容量，但我们也有一个很大的数据集。一般来说，只要数据集相当大，大型语言模型的训练效率就会更高。让我们将新初始化的模型保存在models/ 文件夹中并将其推送到 Hub：

    

     

      

       

      
      

       

        model.save_pretrained("models/" 
        + model_ckpt, push_to_hub
        =
        True,
       
      
     

      

       

      
      

       

                              organization
        =org)
       
      
    

鉴于检查点的大小 (> 5 GB)，将模型推送到 Hub 可能需要几分钟。由于这个模型非常大，我们还将创建一个较小的版本，我们可以对其进行训练，以确保在扩大规模之前一切正常。我们将以标准 GPT-2 尺寸为基础：

    

     

      

       

      
      

       

        tokenizer = AutoTokenizer.from_pretrained(model_ckpt)
       
      
     

      

       

      
      

       

        config_small = AutoConfig.from_pretrained(
        "gpt2", vocab_size=
        len(tokenizer))
       
      
     

      

       

      
      

       

        model_small = AutoModelForCausalLM.from_config(config_small)
       
      
    

print(f'GPT-2 size: {model_size(model_small)/1000**2:.1f}M parameters')

GPT-2 size: 111.0M parameters

让我们也将其保存到 Hub 以方便共享和重用：

    

     

      

       

      
      

       

        model_small.save_pretrained("models/" 
        + model_ckpt 
        + "-small", push_to_hub
        =
        True,
       
      
     

      

       

      
      

       

                                    organization
        =org)
       
      
    

现在我们有两个可以训练的模型，我们需要确保我们可以在训练期间有效地为它们提供输入数据。

实现数据加载器

为了能够以最大效率进行训练，我们将希望为我们的模型提供填充其上下文的序列。例如，如果我们模型的上下文长度是 1,024 个标记，我们总是希望在训练期间提供 1,024 个标记序列。但是我们的一些代码示例可能比 1,024 个令牌更短或更长。用完整序列喂料批次sequence_length对于我们的模型，因此我们应该删除最后一个不完整的序列或填充它。但是，这将使我们的训练效率稍低，并迫使我们处理填充和屏蔽填充标记标签。我们对计算的限制比对数据的限制要多得多，因此我们将在这里采用简单有效的方法。我们可以使用一个小技巧来确保我们不会丢失太多的尾段：我们可以标记几个示例，然后将它们连接起来，用特殊的序列结束标记分隔，以获得一个非常长的序列。最后，我们将这个序列分成大小相等的块，如图 10-5所示。使用这种方法，我们最后最多会丢失一小部分数据。

例如，我们可以通过将输入字符串字符长度定义为：

input_characters = number_of_sequences * sequence_length * characters_per_token

在哪里：

• input_characters是输入到我们的标记器的字符串中的字符数。

• number_of_sequences是我们希望从分词器中获得的（截断的）序列数，（例如，100）。

• sequence_length是标记器返回的每个序列的标记数，（例如，1,024）。

• characters_per_token是我们首先需要估计的每个输出标记的平均字符数。

如果我们输入一个带有input_characters字符的字符串，我们将获得平均number_of_sequences输出序列，并且我们可以通过删除最后一个序列轻松计算我们丢失了多少输入数据。如果number_of_sequences=100这意味着我们堆叠大约 100 个序列并且最多丢失最后一个元素，这可能太短或太长。这对应于我们最多丢失 1% 的数据集。同时，这种方法确保我们不会通过切断大部分文件结尾来引入偏差。

让我们首先估计数据集中每个标记的平均字符长度：

    

     

      

       

      
      

       

        examples, total_characters, total_tokens = 
        500, 
        0, 
        0
       
      
     

      

       

      
      

       

        dataset = load_dataset(
        'transformersbook/codeparrot-train', split=
        'train',
       
      
     

      

       

      
      

       

                               streaming=
        True)
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        for _, example 
        in tqdm(
        zip(
        range(examples), 
        iter(dataset)), total=examples):
       
      
     

      

       

      
      

       

            total_characters += 
        len(example[
        'content'])
       
      
     

      

       

      
      

       

            total_tokens += 
        len(tokenizer(example[
        'content']).tokens())
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        characters_per_token = total_characters / total_tokens
       
      
    

print(characters_per_token)

3.6233025034779565

有了这些，我们就拥有了创建自己的 IterableDataset（PyTorch 提供的辅助类）为模型准备恒定长度输入所需的一切。我们只需要继承IterableDataset并设置__iter__()产生下一个元素的函数，使用我们刚刚介绍的逻辑：

    

     

      

       

      
      

       

        import torch
       
      
     

      

       

      
      

       

        from torch.utils.data 
        import IterableDataset
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        class 
        ConstantLengthDataset(
        IterableDataset):
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       
    
        def 
        __init__(
        self, tokenizer, dataset, seq_length=1024,
       
      
     

      

       

      
      

       

         num_of_sequences=1024, chars_per_token=3.6):
       
      
     

      

       

      
      

       

                self.tokenizer = tokenizer
       
      
     

      

       

      
      

       

                self.concat_token_id = tokenizer.eos_token_id
       
      
     

      

       

      
      

       

                self.dataset = dataset
       
      
     

      

       

      
      

       

                self.seq_length = seq_length
       
      
     

      

       

      
      

       

                self.input_characters = seq_length * chars_per_token * num_of_sequences
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       
    
        def 
        __iter__(
        self):
       
      
     

      

       

      
      

       

                iterator = 
        iter(self.dataset)
       
      
     

      

       

      
      

       

                more_examples = 
        True
       
      
     

      

       

      
      

       
        
        while more_examples:
       
      
     

      

       

      
      

       

                    buffer, buffer_len = [], 
        0
       
      
     

      

       

      
      

       
            
        while 
        True:
       
      
     

      

       

      
      

       
                
        if buffer_len >= self.input_characters:
       
      
     

      

       

      
      

       

                            m=
        f"Buffer full: {buffer_len}>={self.input_characters:.0f}"
       
      
     

      

       

      
      

       
                    
        print(m)
       
      
     

      

       

      
      

       
                    
        break
       
      
     

      

       

      
      

       
                
        try:
       
      
     

      

       

      
      

       

                            m=
        f"Fill buffer: {buffer_len}<{self.input_characters:.0f}"
       
      
     

      

       

      
      

       
                    
        print(m)
       
      
     

      

       

      
      

       

                            buffer.append(
        next(iterator)[
        "content"])
       
      
     

      

       

      
      

       

                            buffer_len += 
        len(buffer[-
        1])
       
      
     

      

       

      
      

       
                
        except StopIteration:
       
      
     

      

       

      
      

       

                            iterator = 
        iter(self.dataset)
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

                    all_token_ids = []
       
      
     

      

       

      
      

       

                    tokenized_inputs = self.tokenizer(buffer, truncation=
        False)
       
      
     

      

       

      
      

       
            
        for tokenized_input 
        in tokenized_inputs[
        "input_ids'"]:
       
      
     

      

       

      
      

       
            
        for tokenized_input 
        in tokenized_inputs:
       
      
     

      

       

      
      

       

                        all_token_ids.extend(tokenized_input + [self.concat_token_id])
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       
            
        for i 
        in 
        range(
        0, 
        len(all_token_ids), self.seq_length):
       
      
     

      

       

      
      

       

                        input_ids = all_token_ids[i : i + self.seq_length]
       
      
     

      

       

      
      

       
                
        if 
        len(input_ids) == self.seq_length:
       
      
     

      

       

      
      

       
                    
        yield torch.tensor(input_ids)
       
      
    

该__iter__()函数建立一个字符串缓冲区，直到它包含足够的字符。缓冲区中的所有元素都被标记化并与 EOS 标记连接，然后长序列 in all_token_ids被分块为seq_length-size 的切片。通常，我们需要注意掩码来堆叠不同长度的填充序列，并确保在训练期间忽略填充。我们通过只提供相同（最大）长度的序列来解决这个问题，所以我们在这里不需要掩码，只返回input_ids. 让我们测试我们的可迭代数据集：

    

     

      

       

      
      

       

        shuffled_dataset = dataset.shuffle(buffer_size=
        100)
       
      
     

      

       

      
      

       

        constant_length_dataset = ConstantLengthDataset(tokenizer, shuffled_dataset,
       
      
     

      

       

      
      

       

                                                        num_of_sequences=
        10)
       
      
     

      

       

      
      

       

        dataset_iterator = 
        iter(constant_length_dataset)
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        lengths = [
        len(b) 
        for _, b 
        in 
        zip(
        range(
        5), dataset_iterator)]
       
      
     

      

       

      
      

       

        print(
        f"Lengths of the sequences: {lengths}")
       
      
    

Fill buffer: 0<36864
Fill buffer: 3311<36864
Fill buffer: 9590<36864
Fill buffer: 22177<36864
Fill buffer: 25530<36864
Fill buffer: 31098<36864
Fill buffer: 32232<36864
Fill buffer: 33867<36864
Buffer full: 41172>=36864
Lengths of the sequences: [1024, 1024, 1024, 1024, 1024]

很好，这按预期工作，我们得到了模型的恒定长度输入。现在我们有了模型的可靠数据源，是时候构建实际的训练循环了。

定义训练循环

我们现在拥有编写训练循环的所有元素。训练我们自己的语言模型的一个明显限制是我们将使用的 GPU 的内存限制。即使在现代显卡上，您也无法在合理的时间内以 GPT-2 规模训练模型。在本教程中，我们将实现数据并行，这将帮助我们利用多个 GPU 进行训练。幸运的是，我们可以使用
Accelerate 使我们的代码具有可扩展性。Accelerate库旨在简化分布式训练以及更改用于训练的底层硬件。我们也可以使用Trainer分布式训练，但Accelerate 让我们可以完全控制训练循环，这正是我们想要在这里探索的。 Accelerate 提供了一个简单的 API，可以使训练脚本以混合精度和任何类型的分布式设置（单 GPU、多 GPU 和 TPU）运行。然后，相同的代码可以在本地机器上无缝运行以进行调试，或者在强大的训练集群上无缝运行以进行最终训练。您只需对原生 PyTorch 训练循环进行少量更改：

    

     

      

       

      
      

       

        import torch
       
      
     

      

       

      
      

       

        import torch.nn.functional 
        as F
       
      
     

      

       

      
      

       

        from datasets 
        import load_dataset
       
      
     

      

       

      
      

       

        from accelerate 
        import Accelerator
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        device = 'cpu'
       
      
     

      

       

      
      

       

        accelerator = 
        Accelerator()
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        model = torch.nn.
        Transformer().to(device)
       
      
     

      

       

      
      

       

        model = torch.nn.
        Transformer()
       
      
     

      

       

      
      

       

        optimizer = torch.optim.
        Adam(model.parameters())
       
      
     

      

       

      
      

       

        dataset = load_dataset('my_dataset')
       
      
     

      

       

      
      

       

        data = torch.utils.data.DataLoader(dataset, shuffle=True)
       
      
     

      

       

      
      

       

        model, optimizer, 
        data = accelerator.prepare(model, optimizer, data)
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        model.train()
       
      
     

      

       

      
      

       

        for epoch 
        in range(
        10):
       
      
     

      

       

      
      

       

            for source, targets 
        in 
        data:
       
      
     

      

       

      
      

       

                source = source.to(device)
       
      
     

      

       

      
      

       

                targets = targets.to(device)
       
      
     

      

       

      
      

       

                optimizer.zero_grad()
       
      
     

      

       

      
      

       

                output = model(source)
       
      
     

      

       

      
      

       

                loss = 
        F.cross_entropy(output, targets)
       
      
     

      

       

      
      

       

                loss.backward()
       
      
     

      

       

      
      

       

                accelerator.backward(loss)
       
      
     

      

       

      
      

       

                optimizer.step()
       
      
    

更改的核心部分是对 的调用prepare()，它确保模型、优化器和数据加载器都准备好并分布在基础设施上。PyTorch 训练循环的这些细微更改使您能够轻松地跨不同基础架构扩展训练。考虑到这一点，让我们开始构建我们的训练脚本并定义一些辅助函数。首先，我们设置用于训练的超参数并将它们包装在 aNamespace中以便于访问：

    

     

      

       

      
      

       

        from argparse 
        import Namespace
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        # Commented parameters correspond to the small model
       
      
     

      

       

      
      

       

        config = {
        "train_batch_size": 
        2, 
        # 12
       
      
     

      

       

      
      

       
          
        "valid_batch_size": 
        2, 
        # 12
       
      
     

      

       

      
      

       
          
        "weight_decay": 
        0.1,
       
      
     

      

       

      
      

       
          
        "shuffle_buffer": 
        1000,
       
      
     

      

       

      
      

       
          
        "learning_rate": 
        2e-4, 
        # 5e-4
       
      
     

      

       

      
      

       
          
        "lr_scheduler_type": 
        "cosine",
       
      
     

      

       

      
      

       
          
        "num_warmup_steps": 
        750, 
        # 2000
       
      
     

      

       

      
      

       
          
        "gradient_accumulation_steps": 
        16, 
        # 1
       
      
     

      

       

      
      

       
          
        "max_train_steps": 
        50000, 
        # 150000
       
      
     

      

       

      
      

       
          
        "max_eval_steps": 
        -1,
       
      
     

      

       

      
      

       
          
        "seq_length": 
        1024,
       
      
     

      

       

      
      

       
          
        "seed": 
        1,
       
      
     

      

       

      
      

       
          
        "save_checkpoint_steps": 
        50000} 
        # 15000
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        args = Namespace(**config)
       
      
    

接下来，我们为训练设置日志记录。由于我们是从头开始训练模型，因此训练运行需要一段时间并且需要昂贵的基础设施。因此，我们要确保所有相关信息都已存储并易于访问。该setup_logging()方法设置了三个级别的日志记录：使用标准 Python Logger、 TensorBoard和 Weights & Biases 。根据您的偏好和用例，您可以在此处添加或删除日志框架：

    

     

      

       

      
      

       

        from torch.utils.tensorboard 
        import SummaryWriter
       
      
     

      

       

      
      

       

        import logging
       
      
     

      

       

      
      

       

        import wandb
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        def 
        setup_logging(
        project_name):
       
      
     

      

       

      
      

       

            logger = logging.getLogger(__name__)
       
      
     

      

       

      
      

       

            logging.basicConfig(
       
      
     

      

       

      
      

       
        
        format=
        "%(asctime)s - %(levelname)s - %(name)s - %(message)s",
       
      
     

      

       

      
      

       

                datefmt=
        "%m/%d/%Y %H:%M:%S", level=logging.INFO, handlers=[
       
      
     

      

       

      
      

       

                logging.FileHandler(
        f"log/debug_{accelerator.process_index}.log"),
       
      
     

      

       

      
      

       

                logging.StreamHandler()])
       
      
     

      

       

      
      

       
    
        if accelerator.is_main_process: 
        # We only want to set up logging once
       
      
     

      

       

      
      

       

                wandb.init(project=project_name, config=args)
       
      
     

      

       

      
      

       

                run_name = wandb.run.name
       
      
     

      

       

      
      

       

                tb_writer = SummaryWriter()
       
      
     

      

       

      
      

       

                tb_writer.add_hparams(
        vars(args), {
        '0': 
        0})
       
      
     

      

       

      
      

       

                logger.setLevel(logging.INFO)
       
      
     

      

       

      
      

       

                datasets.utils.logging.set_verbosity_debug()
       
      
     

      

       

      
      

       

                transformers.utils.logging.set_verbosity_info()
       
      
     

      

       

      
      

       
    
        else:
       
      
     

      

       

      
      

       

                tb_writer = 
        None
       
      
     

      

       

      
      

       

                run_name = 
        ''
       
      
     

      

       

      
      

       

                logger.setLevel(logging.ERROR)
       
      
     

      

       

      
      

       

                datasets.utils.logging.set_verbosity_error()
       
      
     

      

       

      
      

       

                transformers.utils.logging.set_verbosity_error()
       
      
     

      

       

      
      

       
    
        return logger, tb_writer, run_name
       
      
    

每个工作人员都有一个唯一的accelerator.process_index，我们使用它FileHandler来将每个工作人员的日志写入一个单独的文件。我们还使用了accel⁠erator.is_main_process仅true用于主要工作人员的属性。我们确保不会多次初始化 TensorBoard 和 Weights & Biases 记录器，并降低其他工作人员的记录级别。我们返回自动生成的 unique wandb.run.name，稍后我们用它来命名 Hub 上的实验分支。

我们还将定义一个函数来使用 TensorBoard 和 Weights & Biases 记录指标。我们再次使用 accelerator.is_main_process这里来确保我们只记录一次指标，而不是为每个工人记录：

    

     

      

       

      
      

       

        def 
        log_metrics(step, metrics):
       
      
     

      

       

      
      

       

            logger.
        info(f
        "Step {step}: {metrics}")
       
      
     

      

       

      
      

       

            if accelerator.is_main_process:
       
      
     

      

       

      
      

       

                wandb.
        log(metrics)
       
      
     

      

       

      
      

       

                [tb_writer.
        add_scalar(k, v, step) for k, v in metrics.
        items()]
       
      
    

接下来，让我们编写一个函数，使用我们全新的 ConstantLengthDataset类为训练和验证集创建数据加载器：

    

     

      

       

      
      

       

        from torch
        .utils
        .data
        .dataloader import DataLoader
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        def 
        create_dataloaders(dataset_name):
       
      
     

      

       

      
      

       

            train_data = 
        load_dataset(dataset_name+
        '-train', split=
        "train",
       
      
     

      

       

      
      

       

                                      streaming=True)
       
      
     

      

       

      
      

       

            train_data = train_data.
        shuffle(buffer_size=args.shuffle_buffer,
       
      
     

      

       

      
      

       

                                            seed=args.seed)
       
      
     

      

       

      
      

       

            valid_data = 
        load_dataset(dataset_name+
        '-valid', split=
        "validation",
       
      
     

      

       

      
      

       

                                      streaming=True)
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

            train_dataset = 
        ConstantLengthDataset(tokenizer, train_data,
       
      
     

      

       

      
      

       

                                                  seq_length=args.seq_length)
       
      
     

      

       

      
      

       

            valid_dataset = 
        ConstantLengthDataset(tokenizer, valid_data,
       
      
     

      

       

      
      

       

                                                  seq_length=args.seq_length)
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

            train_dataloader=
        DataLoader(train_dataset, batch_size=args.train_batch_size)
       
      
     

      

       

      
      

       

            eval_dataloader=
        DataLoader(valid_dataset, batch_size=args.valid_batch_size)
       
      
     

      

       

      
      

       

            return train_dataloader, eval_dataloader
       
      
    

最后，我们将数据集包装在 a 中DataLoader，它也处理批处理。​⁠ Accelerate 将负责将批次分配给每个工人。

我们需要实现的另一个方面是优化。我们将在主循环中设置优化器和学习率计划，但我们在这里定义一个辅助函数来区分应该接收权重衰减的参数。通常，偏差和 LayerNorm 权重不受权重衰减的影响：

    

     

      

       

      
      

       

        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': args.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, labels=batch)
       
      
     

      

       

      
      

       

                loss = outputs.loss.
        repeat(args.valid_batch_size)
       
      
     

      

       

      
      

       

                losses.
        append(accelerator.
        gather(loss))
       
      
     

      

       

      
      

       

                if args.max_eval_steps > 
        0 and step >= args.max_eval_steps: break
       
      
     

      

       

      
      

       

            loss = torch.
        mean(torch.
        cat(losses))
       
      
     

      

       

      
      

       

            try:
       
      
     

      

       

      
      

       

        	perplexity = torch.
        exp(loss)
       
      
     

      

       

      
      

       

            except OverflowError:
       
      
     

      

       

      
      

       

        	perplexity = torch.
        tensor(
        float(
        "inf"))
       
      
     

      

       

      
      

       

            return loss.
        item(), perplexity.
        item()
       
      
    

困惑度衡量模型的输出概率分布对目标标记的预测程度。因此，较低的困惑度对应于更好的性能。请注意，我们可以通过对从模型输出中获得的交叉熵损失求幂来计算困惑度。尤其是在开始训练的时候loss仍然很高，在计算perplexity的时候有可能出现数值溢出。在这些情况下，我们捕获了这个错误并将困惑度设置为无穷大。

在我们将它们全部放在训练脚本中之前，我们将使用另外一个函数。如您所知，Hugging Face Hub 在后台使用 Git 来存储和版本化模型和数据集。使用Repository来自huggingface_hub库的类，您可以以编程方式访问存储库并拉取、分支、提交或推送。我们将在我们的脚本中使用它来在训练期间不断地将模型检查点推送到 Hub。

现在我们已经准备好所有这些辅助函数，我们准备编写训练脚本的核心：

    

     

      

       

      
      

       

        set_seed(args.seed)
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        # Accelerator
       
      
     

      

       

      
      

       

        accelerator = Accelerator()
       
      
     

      

       

      
      

       

        samples_per_step = accelerator.state.num_processes * args.train_batch_size
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        # Logging
       
      
     

      

       

      
      

       

        logger, tb_writer, run_name = setup_logging(project_name.split(
        "/")[
        1])
       
      
     

      

       

      
      

       

        logger.info(accelerator.state)
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        # Load model and tokenizer
       
      
     

      

       

      
      

       

        if accelerator.is_main_process:
       
      
     

      

       

      
      

       

            hf_repo = Repository(
        "./", clone_from=project_name, revision=run_name)
       
      
     

      

       

      
      

       

        model = AutoModelForCausalLM.from_pretrained(
        "./", gradient_checkpointing=
        True)
       
      
     

      

       

      
      

       

        tokenizer = AutoTokenizer.from_pretrained(
        "./")
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        # Load dataset and dataloader
       
      
     

      

       

      
      

       

        train_dataloader, eval_dataloader = create_dataloaders(dataset_name)
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        # Prepare the optimizer and learning rate scheduler
       
      
     

      

       

      
      

       

        optimizer = AdamW(get_grouped_params(model), lr=args.learning_rate)
       
      
     

      

       

      
      

       

        lr_scheduler = get_scheduler(name=args.lr_scheduler_type, optimizer=optimizer,
       
      
     

      

       

      
      

       

                                     num_warmup_steps=args.num_warmup_steps,
       
      
     

      

       

      
      

       

                                     num_training_steps=args.max_train_steps,)
       
      
     

      

       

      
      

       

        def 
        get_lr():
       
      
     

      

       

      
      

       
    
        return optimizer.param_groups[
        0][
        'lr']
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        # Prepare everything with our `accelerator` (order of args is not important)
       
      
     

      

       

      
      

       

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

      

       

      
      

       

            model, optimizer, train_dataloader, eval_dataloader)
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        # Train model
       
      
     

      

       

      
      

       

        model.train()
       
      
     

      

       

      
      

       

        completed_steps = 
        0
       
      
     

      

       

      
      

       

        for step, batch 
        in 
        enumerate(train_dataloader, start=
        1):
       
      
     

      

       

      
      

       

            loss = model(batch, labels=batch).loss
       
      
     

      

       

      
      

       

            log_metrics(step, {
        'lr': get_lr(), 
        'samples': step*samples_per_step,
       
      
     

      

       

      
      

       
                       
        'steps': completed_steps, 
        'loss/train': loss.item()})
       
      
     

      

       

      
      

       

            loss = loss / args.gradient_accumulation_steps
       
      
     

      

       

      
      

       

            accelerator.backward(loss)
       
      
     

      

       

      
      

       
    
        if step % args.gradient_accumulation_steps == 
        0:
       
      
     

      

       

      
      

       

                optimizer.step()
       
      
     

      

       

      
      

       

                lr_scheduler.step()
       
      
     

      

       

      
      

       

                optimizer.zero_grad()
       
      
     

      

       

      
      

       

                completed_steps += 
        1
       
      
     

      

       

      
      

       
    
        if step % args.save_checkpoint_steps == 
        0:
       
      
     

      

       

      
      

       

                logger.info(
        'Evaluating and saving model checkpoint')
       
      
     

      

       

      
      

       

                eval_loss, perplexity = evaluate()
       
      
     

      

       

      
      

       

                log_metrics(step, {
        'loss/eval': eval_loss, 
        'perplexity': perplexity})
       
      
     

      

       

      
      

       

                accelerator.wait_for_everyone()
       
      
     

      

       

      
      

       

                unwrapped_model = accelerator.unwrap_model(model)
       
      
     

      

       

      
      

       
        
        if accelerator.is_main_process:
       
      
     

      

       

      
      

       

                    unwrapped_model.save_pretrained(
        "./")
       
      
     

      

       

      
      

       

                    hf_repo.push_to_hub(commit_message=
        f'step {step}')
       
      
     

      

       

      
      

       

                model.train()
       
      
     

      

       

      
      

       
    
        if completed_steps >= args.max_train_steps:
       
      
     

      

       

      
      

       
        
        break
       
      
     

      

       

      
      

       
 
       
      
     

      

       

      
      

       

        # Evaluate and save the last checkpoint
       
      
     

      

       

      
      

       

        logger.info(
        'Evaluating and saving model after training')
       
      
     

      

       

      
      

       

        eval_loss, perplexity = evaluate()
       
      
     

      

       

      
      

       

        log_metrics(step, {
        'loss/eval': eval_loss, 
        'perplexity': perplexity})
       
      
     

      

       

      
      

       

        accelerator.wait_for_everyone()
       
      
     

      

       

      
      

       

        unwrapped_model = accelerator.unwrap_model(model)
       
      
     

      

       

      
      

       

        if accelerator.is_main_process:
       
      
     

      

       

      
      

       

            unwrapped_model.save_pretrained(
        "./")
       
      
     

      

       

      
      

       

            hf_repo.push_to_hub(commit_message=
        f'final model')
       
      
    

这是一个相当大的代码块，但请记住，这是在分布式基础架构上训练一个花哨的大型语言模型所需的所有代码。让我们稍微解构一下脚本并突出显示最重要的部分：

模型保存

run_name我们从模型存储库中运行脚本，并在开始时检查一个以我们从 Weights & Biases 获得的 命名的新分支 。稍后，我们在每个检查点提交模型并将其推送到 Hub。通过该设置，每个实验都在一个新分支上，每个提交都代表一个模型检查点。请注意，我们需要调用wait_for_everyone()并unwrap_model()确保模型在存储时正确同步。

优化

对于模型优化，我们AdamW在线性预热期后使用余弦学习率计划。对于超参数，我们严格遵循 GPT-3 论文中描述的类似大小模型的参数。8

评估

每次保存时，我们都会在评估集上评估模型，即每次save_checkpoint_steps训练后。除了验证损失，我们还记录了验证困惑。

梯度累积和检查点

即使我们在最新的 GPU 上运行，所需的批量大小也不适合 GPU 的内存。因此，我们实现了梯度累积，它在几个反向传递中收集梯度，并在累积足够的梯度后进行优化。在第 6 章中，我们看到了如何使用Trainer. 对于大型模型，即使是单个批次也不完全适合单个 GPU。使用一种称为 梯度检查点的方法，我们可以用一些内存占用来换取大约 20% 的训练减速。9这使我们甚至可以在单个 GPU 中安装大型模型。

一个可能仍然有点模糊的方面是在多个 GPU 上训练模型意味着什么。根据模型的大小和数据量，有几种方法可以以分布式方式训练模型。Accelerate使用的方法 称为 DataDistributedParallelism (DDP)。这种方法的主要优点是它允许您使用不适合任何单个 GPU 的更大批量大小更快地训练模型。该过程如图 10-6 所示。

让我们逐步浏览管道：

1. 每个工作人员由一个 GPU 组成。在 Accelerate 中，有一个数据加载器在主进程上运行，它准备成批的数据并将它们发送给所有工作人员。

2. 每个 GPU 接收一批数据，并使用模型的本地副本计算前向和后向传递的损失和相应的累积梯度。

3. 来自每个节点的梯度使用 reduce模式进行平均，然后将平均梯度发送回每个工作人员。

4. 使用优化器分别在每个节点上应用梯度。尽管这看起来像是多余的工作，但它避免了在节点之间传输大型模型的副本。我们需要至少更新一次模型，如果没有这种方法，其他节点都需要等到他们收到更新的版本。

5. 更新完所有模型后，我们重新开始，主要工人准备新批次。

这种简单的模式允许我们通过扩展可用 GPU 的数量来极快地训练大型模型，而无需太多额外的逻辑。然而，有时这还不够。例如，如果模型不适合单个 GPU，您可能需要更复杂的 并行策略。现在我们已经拥有了培训所需的所有部件，是时候开始工作了！正如您将在下一节中看到的，这非常简单。

训练Run

我们将训练脚本保存在名为 codeparrot_training.py的文件中，以便我们可以在训练服务器上执行它。为了让生活更轻松，我们将它与 包含所有必需 Python 依赖项的requirements.txt文件一起添加到Hub上的模型存储库中。请记住，集线器上的模型本质上是 Git 存储库，因此我们可以克隆存储库，添加我们想要的任何文件，然后将它们推送回集线器。在训练服务器上，我们可以使用以下几个命令启动训练：

    

     

      

       

      
      

       

        $ git 
        clone https://huggingface.co/transformersbook/codeparrot
       
      
     

      

       

      
      

       

        $ 
        cd codeparrot
       
      
     

      

       

      
      

       

        $ pip install -r requirements.txt
       
      
     

      

       

      
      

       

        $ wandb login
       
      
     

      

       

      
      

       

        $ accelerate config
       
      
     

      

       

      
      

       

        $ accelerate launch codeparrot_training.py
       
      
    

就是这样——我们的模型现在正在训练！请注意，这 wandb login将提示您使用权重和偏差进行身份验证以进行日志记录。该accelerate config命令将指导您设置基础设施；您可以在表 10-2中看到用于此实验的设置。我们在所有实验中使用一个a2-megagpu-16g 实例，这是一个具有 16 个 A100 GPU 的工作站，每个 GPU 具有 40 GB 内存。

对于小型和大型模型，使用这些设置在该基础架构上运行训练脚本分别需要大约 24 小时和 7 天。如果您训练自己的自定义模型，请确保您的代码在较小的基础架构上顺利运行，以确保昂贵的长期运行也顺利进行。完整的训练运行成功完成后，您可以使用以下命令将 Hub 上的实验分支合并回主分支：

    

     

      

       

      
      

       

        $ git checkout main
       
      
     

      

       

      
      

       

        $ git merge <RUN_NAME>
       
      
     

      

       

      
      

       

        $ git push
       
      
    

自然，RUN_NAME应该是您要合并的 Hub 上的实验分支的名称。现在我们有了一个训练有素的模型，让我们看看如何研究它的性能。

图 10-7。训练损失和验证困惑作为小型和大型 CodeParrot 模型的已处理标记的函数