Hugging Face Course-Introduction学习小记 (part1)

最新推荐文章于 2024-05-31 13:51:08 发布

爱睡觉的Raki

最新推荐文章于 2024-05-31 13:51:08 发布

阅读量1.3k

点赞数

分类专栏： NLP 文章标签： nlp 自然语言处理人工智能深度学习 transformer

本文链接：https://blog.csdn.net/Raki_J/article/details/121947545

版权

NLP 专栏收录该内容

82 篇文章 10 订阅

订阅专栏

在这里插入图片描述

1.Transformer models

首先介绍了 - what is NLP？

Classifying whole sentences: Getting the sentiment of a review, detecting if an email is spam, determining if a sentence is grammatically correct or whether two sentences are logically related or not
Classifying each word in a sentence: Identifying the grammatical components of a sentence (noun, verb, adjective), or the named entities (person, location, organization)
Generating text content: Completing a prompt with auto-generated text, filling in the blanks in a text with masked words
Extracting an answer from a text: Given a question and a context, extracting the answer to the question based on the information provided in the context
Generating a new sentence from an input text: Translating a text into another language, summarizing a text
NLP isn’t limited to written text though. It also tackles complex challenges in speech recognition and computer vision, such as generating a transcript of an audio sample or a description of an image.

然后介绍了transformer模型的架构和它的衍生模型：

encoder model

编码器模型仅使用 Transformer 模型的编码器。在每个阶段，注意力层都可以访问初始句子中的所有单词。这些模型通常具有“双向”注意力的特征，通常称为自动编码模型。

这些模型的预训练通常围绕着以某种方式破坏给定的句子（例如，通过屏蔽其中的随机单词）并让模型找到或重建初始句子。

编码器模型最适合需要理解完整句子的任务，例如句子分类、命名实体识别（以及更一般的单词分类）和提取式问答。

一些主要的encoder模型：

decoder model

解码器模型仅使用 Transformer 模型的解码器。在每个阶段，对于给定的单词，注意力层只能访问句子中位于它之前的单词。这些模型通常称为自回归模型。

解码器模型的预训练通常围绕预测句子中的下一个单词。

这些模型最适合涉及文本生成的任务。

一些主要的decoder模型：

seq2seq model

编码器-解码器模型（也称为序列到序列模型）使用 Transformer 架构的两个部分。在每个阶段，编码器的注意力层可以访问初始句子中的所有单词，而解码器的注意力层只能访问输入中位于给定单词之前的单词。

这些模型的预训练可以使用编码器或解码器模型的目标来完成，但通常涉及更复杂的事情。例如，T5是通过用单个掩码特殊词替换随机文本跨度（可以包含多个词）来预训练的，然后目标是预测这个掩码词替换的文本。

序列到序列模型最适合围绕根据给定输入生成新句子的任务，例如摘要、翻译或生成式问答。

一些主要的seq2seq模型：

总结：
在这里插入图片描述

2.Using Transformers

首先介绍了transformer库的一些特点：

易于使用：只需两行代码即可下载、加载和使用最先进的 NLP 模型进行推理。
灵活性：从本质上讲，所有模型都是简单的 PyTorchnn.Module或 TensorFlowtf.keras.Model类，并且可以像其各自机器学习 (ML) 框架中的任何其他模型一样进行处理。
简单性：在整个库中几乎没有任何抽象。“一体化文件”是一个核心概念：模型的前向传递完全定义在单个文件中，因此代码本身是可理解和可破解的。

然后以一些完整的例子来介绍：

from transformers import pipeline

classifier = pipeline("sentiment-analysis")
classifier(
    [
        "I've been waiting for a HuggingFace course my whole life.",
        "I hate this so much!",
    ]
)

输出：

[{'label': 'POSITIVE', 'score': 0.9598047137260437},
 {'label': 'NEGATIVE', 'score': 0.9994558095932007}]

Preprocessing with a tokenizer

正如我们在第 1 章中看到的，这个pipeline将三个步骤组合在一起：预处理、通过模型传递输入和后处理：

在这里插入图片描述
与其他神经网络一样，Transformer 模型不能直接处理原始文本，因此我们pipeline的第一步是将文本输入转换为模型可以理解的数字。为此，我们使用了一个tokenizer，它将负责：

将输入拆分为称为标记的单词、子词或符号（如标点符号）
将每个标记映射到一个整数
添加可能对模型有用的其他输入

所有这些预处理都需要以与模型预训练时完全相同的方式完成，因此我们首先需要从Model Hub下载该信息。为此，我们使用AutoTokenizer类及其from_pretrained()方法。

from transformers import AutoTokenizer

checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)

一旦我们有了tokenizer，我们就可以直接将我们的句子传递给它，我们将得到一个准备好提供给我们模型的字典！唯一要做的就是将输入 ID 列表转换为张量。

raw_inputs = [
    "I've been waiting for a HuggingFace course my whole life.",
    "I hate this so much!",
]
inputs = tokenizer(raw_inputs, padding=True, truncation=True, return_tensors="pt") #pt代表pytorch
print(inputs)

输出：

{
    'input_ids': tensor([
        [  101,  1045,  1005,  2310,  2042,  3403,  2005,  1037, 17662, 12172, 2607,  2026,  2878,  2166,  1012,   102],
        [  101,  1045,  5223,  2023,  2061,  2172,   999,   102,     0,     0,     0,     0,     0,     0,     0,     0]
    ]), 
    'attention_mask': tensor([
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    ])
}

然后载入模型：

from transformers import AutoModel

checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
model = AutoModel.from_pretrained(checkpoint)

The vector output by the Transformer module is usually large. It generally has three dimensions:

Batch size: The number of sequences processed at a time (2 in our example).
Sequence length: The length of the numerical representation of the sequence (16 in our example).
Hidden size: The vector dimension of each model input.

outputs = model(**inputs)
print(outputs.last_hidden_state.shape)

输出

torch.Size([2, 16, 768])

Model heads: 从数字中寻找意义

The model heads将隐藏状态的高维向量作为输入，并将它们投影到不同的维度上。它们通常由一个或几个线性层组成：
在这里插入图片描述

Transformer 模型的输出直接送到模型头进行处理。

在此图中，模型由其嵌入层和后续层表示。嵌入层将标记化输入中的每个输入 ID 转换为表示相关标记的向量。随后的层使用注意力机制操纵这些向量以产生句子的最终表示。

对于我们的示例，我们需要一个带有序列分类头的模型（能够将句子分类为正面或负面）。所以，我们实际上不会使用这个AutoModel类，而是AutoModelForSequenceClassification：

from transformers import AutoModelForSequenceClassification

checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
outputs = model(**inputs)

print(outputs.logits.shape)

输出维度

torch.Size([2, 2])

Postprocessing the output 将输出处理为我们需要的类型

我们从模型中获得的作为输出的值本身并不一定有意义。让我们来看看：

print(outputs.logits)

输出：

tensor([[-1.5607,  1.6123],
        [ 4.1692, -3.3464]], grad_fn=<AddmmBackward>)

我们的模型预测[-1.5607, 1.6123]了第一句话和[ 4.1692, -3.3464]第二句话。这些不是概率，而是一些实数，即模型最后一层输出的原始非标准化分数。要转换为概率，它们需要经过一个SoftMax层（所有🤗 Transformers 模型都输出 logits，因为训练的损失函数通常会将最后一个激活函数（例如 SoftMax）与实际的损失函数（例如 cross熵）：

import torch

predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
print(predictions)

输出：

tensor([[4.0195e-02, 9.5980e-01],
        [9.9946e-01, 5.4418e-04]], grad_fn=<SoftmaxBackward>)

现在我们可以看到模型预测[0.0402, 0.9598]了第一个句子和[0.9995, 0.0005]第二个句子。这些是可识别的概率分数。

要获得每个位置对应的标签，我们可以检查id2label模型配置的属性（下一节将详细介绍）：

>>>model.config.id2label
>>>{0: 'NEGATIVE', 1: 'POSITIVE'}

Now we can conclude that the model predicted the following:

First sentence: NEGATIVE: 0.0402, POSITIVE: 0.9598
Second sentence: NEGATIVE: 0.9995, POSITIVE: 0.0005

We have successfully reproduced the three steps of the pipeline:
preprocessing with tokenizers,
passing the inputs through the model,
and postprocessing!
Now let’s take some time to dive deeper into each of those steps.

Models

在本节中，我们将仔细研究创建和使用模型。我们将使用AutoModel该类，当您想从检查点实例化任何模型时，该类非常方便。

本AutoModel类及其所有亲属的实际上是在各种各样的库中的现有模式的简单wrappers。这是一个聪明的wrappers，因为它可以自动为您的检查点猜测合适的模型架构，然后使用该架构实例化模型。

但是，如果您知道要使用的模型类型，则可以直接使用定义其架构的类。让我们来看看它是如何与 BERT 模型配合使用的。

构造一个transformer

初始化 BERT 模型需要做的第一件事是加载配置对象：

from transformers import BertConfig, BertModel

# Building the config
config = BertConfig()

# Building the model from the config
model = BertModel(config)

The configuration contains many attributes that are used to build the model:

>>>print(config)
>>>BertConfig {
  [...]
  "hidden_size": 768,
  "intermediate_size": 3072,
  "max_position_embeddings": 512,
  "num_attention_heads": 12,
  "num_hidden_layers": 12,
  [...]
}

不同的载入方法：

from transformers import BertModel

model = BertModel.from_pretrained("bert-base-cased")

正如之前看到的，我们可以替换BertModel为等效的AutoModel类。我们将从现在开始这样做，因为这会产生与checkpoint无关的代码；如果您的代码适用于一个checkpoint，它应该可以与另一个无缝协作。即使架构不同，只要checkpoint是针对类似任务（例如，情感分析任务）训练的，这也适用。

保存模型

model.save_pretrained("directory_on_my_computer")

将会存在该目录下：

ls directory_on_my_computer

config.json pytorch_model.bin

Tokenizers

Tokenizers是 NLP 管道的核心组件之一。它们有一个目的：将文本转换为模型可以处理的数据。模型只能处理数字，因此Tokenizers需要将我们的文本输入转换为数字数据。在本节中，我们将确切地探讨tokenization pipeline中发生的事情。

在 NLP 任务中，通常处理的数据是原始文本。这是此类文本的示例：

Jim Henson was a puppeteer

Word-based 基于单词的分词

想到的第一种标记器是基于单词的。它通常很容易设置和使用，只需几条规则，并且通常会产生不错的结果。例如，在下图中，目标是将原始文本拆分为单词并为每个单词找到一个数字表示：
在这里插入图片描述

>>>tokenized_text = "Jim Henson was a puppeteer".split()
>>>print(tokenized_text)
['Jim', 'Henson', 'was', 'a', 'puppeteer']

每个单词都分配了一个 ID，从 0 开始一直到词汇表的大小。该模型使用这些 ID 来识别每个单词。
如果我们想用基于单词的分词器完全覆盖一种语言，我们需要为语言中的每个词都有一个标识符，这将生成大量的标记。例如，英语中有超过 500,000 个单词，因此要构建从每个单词到输入 ID 的映射，我们需要跟踪这么多 ID。此外，像“dog”这样的词与“dogs”这样的词的表示方式不同，模型最初无法知道“dog”和“dogs”是相似的：它会将这两个词识别为不相关。这同样适用于其他相似的词，例如“run”和“running”，模型最初不会认为它们是相似的。

最后，我们需要一个自定义标记来表示不在我们词汇表中的单词。这被称为“未知”标记，通常表示为“[UNK]”或“”。如果您看到分词器正在生成大量这样的标记，这通常是一个不好的迹象，因为它无法检索单词的合理表示，并且您在此过程中会丢失信息。制作词汇表的目标是使分词器将尽可能少的单词分词成未知标记。

减少未知标记数量的一种方法是使用基于字符的标记器更深一层。

Character-based 基于字符

这是一种非常简单粗暴的方法，
优点是字符集会很小，词汇外（未知）标记要少得多，因为每个单词都可以从字符构建。
缺点是每个字符本身并没有多大意义，而单词就是这种情况。然而，这又因语言而异；例如，在中文中，每个字符比拉丁语言中的字符包含更多的信息。

为了两全其美，我们可以使用结合这两种方法的第三种技术：subword tokenization 子词标记化。

Subword Tokenization 子词标记化

子词分词算法依赖于这样一个原则，即不应将常用词拆分为更小的子词，而应将稀有词分解为有意义的子词。

例如，“annoyingly”可能被认为是一个罕见的词，可以分解为“annoying”和“ly”。这两者都可能作为独立的子词出现得更频繁，同时“annoyingly”的含义由“annoying”和“ly”的复合含义保持。

这是一个示例，展示了子词标记化算法如何标记序列“让我们做标记化！：
在这里插入图片描述
这些子词最终提供了很多语义含义：例如，在上面的示例中，“tokenization”被拆分为“token”和“ization”，这两个具有语义意义同时节省空间的令牌（只需要两个tokens代表一个长词）。这使我们能够对较小的词汇表进行相对较好的覆盖，并且几乎没有未知的标记。

这种方法在土耳其语等粘着语言中特别有用，您可以通过将子词串在一起来形成（几乎）任意长的复杂词。

And more!

Unsurprisingly, there are many more techniques out there. To name a few:

Byte-level BPE, as used in GPT-2
WordPiece, as used in BERT
SentencePiece or Unigram, as used in several multilingual models

Loading and saving

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")

>>>tokenizer("Using a Transformer network is simple")
{'input_ids': [101, 7993, 170, 11303, 1200, 2443, 1110, 3014, 102],
 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0],
 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1]}

保存模型：

tokenizer.save_pretrained("directory_on_my_computer")

encoding

将文本转换为数字称为encoding。encoding分两步完成：标记化，然后转换为输入 ID。

正如我们所见，第一步是将文本拆分为单词（或单词的一部分、标点符号等），通常称为标记。有多个规则可以管理该过程，这就是为什么我们需要使用模型名称来实例化分词器，以确保我们使用模型预训练时使用的相同规则。

第二步是将这些标记转换为数字，这样我们就可以用它们构建一个张量并将它们提供给模型。为此，分词器有一个词汇表，这是我们在使用from_pretrained()方法实例化它时下载的部分。同样，我们需要使用模型预训练时使用的相同词汇。

Tokenization

The tokenization process is done by the tokenize() method of the tokenizer:

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")

sequence = "Using a Transformer network is simple"
tokens = tokenizer.tokenize(sequence)

print(tokens)

输出

['Using', 'a', 'transform', '##er', 'network', 'is', 'simple']

从token到输入 ID的转换由convert_tokens_to_ids()tokenizer 方法处理：

>>>ids = tokenizer.convert_tokens_to_ids(tokens)
>>>print(ids)
[7993, 170, 11303, 1200, 2443, 1110, 3014]

Decoding

Decoding是相反的：从词汇索引中，我们想要得到一个字符串。这可以通过以下decode()方法完成：

decoded_string = tokenizer.decode([7993, 170, 11303, 1200, 2443, 1110, 3014])
print(decoded_string)

输出：

'Using a Transformer network is simple'

注意该decode方法不仅将索引转换回标记，还将属于相同单词的标记组合在一起以生成可读的句子。当我们使用预测新文本的模型（根据提示生成的文本，或序列到序列问题（如翻译或摘要））时，这种行为将非常有用。

到现在为止，您应该了解标记器可以处理的原子操作：标记化、转换为 ID 以及将 ID 转换回字符串。然而，我们只是刮了冰山一角。在下一节中，我们将采用我们的方法来克服它的限制，并看看如何克服它们。

Handling multiple sequences 处理多个序列

在上一节中，我们探讨了最简单的用例：对单个小长度序列进行推理。然而，一些问题已经出现：

我们如何处理多个序列？
我们如何处理不同长度的多个序列？
词汇索引是唯一能让模型正常工作的输入吗？
有没有序列太长这样的事情？

Putting it all together

学习了 Transformer 模型的基本构建块。
了解了tokenization pipeline的组成部分。
了解如何在实践中使用 Transformer 模型。
学习了如何利用tokenizer将文本转换为模型可理解的张量。
一起设置tokenizer和模型以从文本到预测。
了解了输入 ID 的局限性，并了解了注意力掩码。
使用多功能和可配置的 tokenizer 方法。

爱睡觉的Raki

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Hugging Face Course-Introduction学习小记 (part1)

1.Transformer models首先介绍了 - what is NLP？Classifying whole sentences: Getting the sentiment of a review, detecting if an email is spam, determining if a sentence is grammatically correct or whether two sentences are logically related or notClassifyi.
复制链接

扫一扫