Transformers Pipeline：NLP 任务的全面指南

原文：towardsdatascience.com/transformers-pipeline-a-comprehensive-guide-for-nlp-tasks-e4ae260a13db

，利用🤗 Transformers 库的力量。

https://github.com/OpenDocCN/towardsdatascience-blog-zh-2024/raw/master/docs/img/116d16da9a940ee6f6637e6c30f12820.png

照片由Simon Kadula在Unsplash提供

简介

人类语言以不同的形式和方式产生大量信息，但却是无结构的。人们的天性就是沟通和表达他们的观点和看法，尤其是在如今有这么多途径可以这样做的情况下。这导致了大量非结构化数据的增长，到目前为止，这些数据在商业上被最小化或未得到利用。

然而，近年来，发生了一个显著的转变。

人工智能（AI）领域的快速发展，尤其是在自然语言处理（NLP）领域，使我们能够以编程方式理解和交互这些信息，促使许多企业重新审视这一知识来源，将其作为新产品的燃料。

这种紧迫感随着 ChatGPT 的发布而产生，它向世界展示了 transformer 模型的有效性，并且总的来说，向大众介绍了大型语言模型（LLMs）这一领域。

该产品的简洁性和通用性使得每个人都可以使用这些 AI 流程在 NLP 领域执行各种任务，而无需理解复杂的数学方程式或学习如何训练和维护机器学习模型。只需打开聊天机器人（或调用 API），用你的母语编写一个合适的提示，然后神奇地你就拥有了一个 AI 产品。

然而，正如所有伟大的产品一样，这个产品也有其成本。在某些工具中，这种成本可能以订阅的形式出现，或者更常见的是根据工具的使用情况收费，费用按使用的单词/标记计费。

虽然大多数情况下每标记的费率可能看起来很小（0.03 美元每 1K 标记能做什么？），[1]想象一下使用这个工具从一本几百页的书中提取信息；费用可能在几秒钟内飙升，如果公司没有正确理解和监控，可能会反过来咬他们。

所有这些真的太好了，以至于不可能是真的吗？不一定。

如果我告诉你，你只需用几行代码就可以免费找到并使用这些强大的预训练模型，你会怎么想？

再次强调，不需要特定的统计数据或数据科学知识。只需对 Python 有基本的了解，并对一些 NLP 任务有一个高级的概念。如果你有这些最低要求，Hugging Face和开源社区将提供你需要的其余工具，以开放 LLM 的形式。

什么是 Hugging Face？

Hugging Face 是一个开源的数据科学社区，通过其平台使成员能够自由地使用、开发和托管社区提供的预训练模型和数据集。

它的主要关注点是预训练并准备好用于各种任务的开源 LLMs 的分布和发展，这些任务几乎不需要最终用户的干预。

因此，从研究人员和 LLM 爱好者到像微软、Meta 和 OpenAI 这样的大型企业，都可以找到一个地方公开发布他们的模型，并寻找适合他们不断增长需求的新模型。

那我们为什么不亲自看看这些模型呢？

模型库

要找到你需要的模型，你只需浏览 Hugging Face 网站，导航到 模型库。在那里，任何人都可以找到超过 480k 个预训练模型，这些模型经过微调以执行特定任务。任务不仅限于特定领域，你还可以找到训练用于处理文本、音频、计算机视觉任务等的模型，以及针对这些领域中的每个特定子任务更加专业化的模型。

https://huggingface.co/models 的截图](…/Images/b5762bf96b13d1d77861aca4afd4f097.png)

Hugging Face 模型接口：huggingface.co/models的截图

数据集库

此外，如果你仍然找不到一个完全符合你用例的现成模型，你可以使用预训练模型，并通过使用包含标记数据的各种数据集进行微调（重新训练其一小部分）来调整它。你可以在 Hugging Face 网站上再次找到这些数据集，但这次是在 数据集库。这些数据集涵盖了不同的领域，旨在为模型库中展示的大多数任务或子任务提供数据。

https://huggingface.co/datasets 的截图](…/Images/574d131d136eb5c3336ce35060be2d2e.png)

Hugging Face 数据集接口：huggingface.co/datasets的截图

但如果你没有使用这些模型的方法，你能做什么呢？

因此，Hugging Face 创建了一个非常直观的高级 Python 库，名为 🤗 Transformers。这个库允许每个人通过利用其最基本的对象，即 pipeline()函数，在其本地机器上使用这些模型。这个函数可以将端到端 NLP 过程所需的全部步骤封装为一行代码，正如我们将在下一节中看到的那样。

Transformers Pipeline() 函数

在这里，我们将检查 🤗 Transformer 库中最强大的功能之一：pipeline() 函数。

这是一个用户友好的 API，它在上层提供了一个抽象层，覆盖了 transformer 库的复杂代码，通过提供特定的管道名称或模型来简化各种 NLP 任务的推理。正如其名称所暗示的，它是一个包装了多个步骤的包装器，这些步骤需要按顺序执行，以便用户输入原始文本并使用模型从中获取推理。[2]

这些必要的步骤可以分为以下三个类别：

• 预处理接收到的原始文本以使其适合模型将用户提供的文本转换为模型可以理解的数值表示，这个过程称为编码，与用于训练的模型相同的形式和方式。

• 使用你选择的模型进行推理在本地机器上下载一个预训练的模型，该模型可用于特定任务，它接受预处理后的文本作为输入，并根据所选任务预测输出。（例如，文本分类，文本生成）

• 后处理结果以使其可读通过将模型的未归一化结果转换为所选任务的预期输出，来理解模型的结果，通常是通过将生成的标记转换回可读文本或将模型的 logits 归一化为分类任务中每个类别的概率来实现（例如，情感分析）

要使用此管道函数，你首先需要安装 transformer 库以及创建模型所使用的深度学习库（主要是Pytorch，Tensorflow，或Jax），只需在终端中使用 pip install 命令即可，然后你就可以开始了。（对于这一点，我们假设你的机器上已经安装了 Python 3.10 或更高版本。否则，你可以从这里安装。）

# To run inference with most of the available modelpip install torch==2.1.0torchvision==0.16.0torchaudio==2.1.0pip install jax==0.4.23# For this article you only need these librariespip install tensorflow==2.15.0pip install transformers==4.35.2# For the post-processing step you will also needpip install numpy==1.23.5

如果你认为这很简单，那就等着看看如何使用它来设置一个端到端的管道，以在每个给定的文本中找到情感。

# import the pipeline functionfromtransformersimportpipeline# Initialize the text classifier for sentiment analysis using only the taskclassifier=pipeline(task='sentiment-analysis')

你就完成了。使用这两行代码，你创建了一个可以执行所需任务的步骤管道，包括为该任务完全训练和微调的模型。

那么剩下的唯一事情就是用它来进行推理。

# Make inference from the model in one line of codesingle_result=classifier('This movie is awesome')print(single_result)# Or multiple sentencesmultiple_results=classifier(["This movie is awesome","This movie is awful"])print(multiple_results)

# Results# >>> [{'label': 'POSITIVE', 'score': 0.9998761415481567}]# >>> [{'label': 'POSITIVE', 'score': 0.9998761415481567}, {'label': 'NEGATIVE', 'score': 0.9998006224632263}]

这很酷吗？

我们只需一行代码就能准备好解决方案，而不是花费漫漫长夜来编写和调试冗长的脚本，从头开始训练和微调不同的模型（我的大学时代的自己刚刚流下了眼泪）

不需要具备广泛的统计学或机器学习知识。你甚至不需要知道现有哪些模型。只需指定你想要完成的任务，然后让管道确定所需的最佳模型和工具。

然而，如果你不希望停留在默认模型和设置中，而是利用 Hugging Face 社区开发和共享的所有 Open LLM 的可用功能，让我们看看你可以在这一行代码中调整哪些其他内容。

pipeline() 函数的关键特性

正如其他所有对象一样，这个对象也有一些额外的参数，可以通过提供适当的参数来进一步定制其功能。一些重要的参数如下：

task (字符串参数)

此参数使得该函数对初学者友好。只需将任务名称作为字符串参数传递给函数，你就可以定义你想要为所选任务初始化哪个管道。

可用于 NLP 任务的可用任务名称，如 官方文档 所示，如下所示：

• "question-answering"将返回一个QuestionAnsweringPipeline。

• "summarization"将返回一个SummarizationPipeline。

• "table-question-answering"将返回一个TableQuestionAnsweringPipeline。

• "text2text-generation"将返回一个Text2TextGenerationPipeline。

• "text-classification"（或使用别名"sentiment-analysis") 将返回一个TextClassificationPipeline。

• "text-generation"将返回一个TextGenerationPipeline：。

• "token-classification"（或使用别名"ner"): 将返回一个TokenClassificationPipeline。

• "translation"将返回一个TranslationPipeline。

• "translation_xx_to_yy"将返回一个TranslationPipeline。

• "zero-shot-classification"将返回一个ZeroShotClassificationPipeline。

如果只指定此参数，此对象将通过从模型中心选择和加载默认模型来初始化一个端到端管道，为所选任务选择相应的分词器以执行预处理，在某些情况下，还会执行后处理步骤。

尽管我相信这些任务已经足够让您开始 NLP 领域的学习，但这里还有许多其他领域的任务，例如计算机视觉、音频和多模态任务，您可以在文档中探索。有关支持的任务的更多信息，请在此处查看。

模型（字符串参数）

在此参数中，您可以指定您的管道将用于进行预测的模型。这可以与任务参数一起使用，替换默认模型，或者您可以直接指定针对特定用途微调的模型。要在管道中指示模型，您需要提供一个checkpoint字符串，这是模型的唯一标识符。此标识符可以在 Hugging Face 模型中心找到，或者通过提供您自己的预训练模型的路径来获取。

例如，模型中心的某个检查点可能看起来像这样：“nlptown/bert-base-multilingual-uncased-sentiment”，这是一个基于 Bert 的多语言模型，针对情感分析进行了微调。

分词器（字符串参数）

与模型参数类似，您也可以指定您想要用于管道的预处理和后处理部分的分词器。在这里，您可以使用模型检查点字符串作为参数，或者使用您自己的实际预训练分词器。如果您想要将分词器微调到特定的数据集，这一点很重要。

设备（序数整数参数）

此参数允许您定义您的管道将在其上分配的处理器的类型。它接受从-1开始的序数排名的整数作为参数，将CPU设置为主要资源，而≥ 0的值将在与提供的 CUDA 设备 ID 关联的GPU上运行您的模型。在这里，利用 GPU 作为机器学习和 LLM 模型的硬件标准选择，因为它们针对内存分配和并行性进行了优化。这可以显著加快您的模型推理速度。

这些是一些您可以在您的第一个管道中轻松使用的的重要参数。然而，您可以在这里找到所有可用的参数。

通过这些附加参数，您可以根据自己的独特需求和数据集定制默认管道，并创建一个精确匹配的定制管道。对于那些想要进一步细化此过程的人，让我们深入了解一下这个管道在幕后是如何工作的。

内部管道

在这里，我们将解释流水线函数的每个步骤中发生的事情，并且通过单独运行每一个步骤，我们将复制这一行神奇代码的结果。

这是一个不是必须阅读的章节，因为在大多数用例中，一个合适的流水线或模型就足以实现非常好的结果。然而，我认为理解这个函数的工作原理对于进一步修改它并适应你的特定需求是很重要的。

因此，正如我们在前面的章节中解释的，流水线函数在每个调用中执行以下步骤[3]：

• 原始文本的预处理

• 使用模型进行推理。

• 模型输出的后处理

让我们更详细地检查每一个。在这个例子中，我们将使用 TensorFlow 深度学习库进行这个过程。使用 Pytorch 或 Jax 可能会有一些小的变化。

预处理：原始文本的分词

虽然这些模型被称为语言模型，但实际上它们无法处理以原始文本形式输入。预期的输入形状可能因模型而异，但在所有情况下，它将是数字的。这个过程称为分词，它由一个分词对象按照以下步骤执行：

1. 标准化文本输入，移除任何格式。

2. 将输入文本拆分为单词、子词或称为标记的符号。

3. 如果模型需要，在文本中添加特殊标记。

4. 将每个标记映射到模型在训练期间使用的词汇表中的唯一 ID。

5. 将这些 ID 列表转换为模型可以接受的张量（类似于 numpy 数组）。

这些步骤可以在下面的图片中找到：

https://github.com/OpenDocCN/towardsdatascience-blog-zh-2024/raw/master/docs/img/5a117d820d4cf8194a248666d2506715.png

分词步骤：图片由作者提供，灵感来源于huggingface.co/learn/nlp-course/chapter6/4

如你所见，这个过程中的许多步骤都依赖于所使用的模型。原因是，为了使模型能够从某些数据中做出推断，它需要以与训练时相同的形式接收它们。

这样，为了获得最佳的推理结果，你需要下载与所使用的模型具有相同步骤和词汇的分词器类。为此，我们导入AutoTokenizer类，通过在**from_pretrained()**方法中提供其检查点来下载和缓存与模型关联的分词器配置和词汇，如下所示。

fromtransformersimportAutoTokenizer# Specifying the model checkpoint for the Hugging Face model hubmodel_checkpoint='distilbert-base-uncased-finetuned-sst-2-english'# Providing the checkpoint to demonstrate the tokenization algorithm and the vocabulary for the tokenizertokenizer=AutoTokenizer.from_pretrained(model_checkpoint)

这将初始化分词器，然后你可以提供原始文本，并且——你猜对了——在一行代码中就可以得到它的分词表示，以便模型使用。

# A' way - You can have the results in one linemodel_inputs_one=tokenizer('This movie is awesome',return_tensors="tf")print(model_inputs_one)

# Results# >>> {'input_ids': <tf.Tensor: shape=(1, 6), dtype=int32, numpy=array([[ 101, 2023, 3185, 2003, 12476, 102]], dtype=int32)>, 'attention_mask': <tf.Tensor: shape=(1, 6), dtype=int32, numpy=array([[1, 1, 1, 1, 1, 1]], dtype=int32)>}

然而，我们也可以将这一行代码分解成其特定的任务。

正如我们在本节开头所说，分词器的第一个两个任务是通过对文本进行格式化去除和分割成单个标记来规范化文本。为了实现这一点，我们将文本字符串传递到分词器的**tokenize()**方法中。

# Split the string into tokenstokens=tokenizer.tokenize('This movie is awesome')print(tokens)

#Results# >>> ['this', 'movie', 'is', 'awesome']

这将返回一个包含标记的列表，这些标记可以是单词、子词、标点符号和符号。然后它使用 convert_tokens_to_ids()方法将这些标记转换为数字，通过将每个标记分配给分词器词汇表中的相应 id。这个词汇表与模型使用的相同。

# Convert the tokens into IDs using the tokenizer's dictionaryinput_ids=tokenizer.convert_tokens_to_ids(tokens)print(input_ids)

# Results# >>> [2023, 3185, 2003, 12476]

因此，我们现在几乎完成了；我们有了数字，这很好，但一些模型需要一些特殊的标记来运行，例如，指定句子的开始和结束等。

你可以通过使用分词器的all_special_tokens属性来查看每个模型需要的标记，以及它们的词汇 ID，使用all_special_ids属性。

# Find the special tokens needed for the modelprint('Special tokens map:',tokenizer.all_special_tokens)print('Special tokens ids:',tokenizer.all_special_ids)

# Results# >>> Special tokens map: ['[UNK]', '[SEP]', '[PAD]', '[CLS]', '[MASK]']# >>> Special tokens ids: [100, 102, 0, 101, 103]

为了将这些标记包含到我们的标记列表中，并以模型可以处理的方式格式化输入，我们使用 prepare_for_model()方法。这将创建一个包含模型数值输入的字典，以及一个注意力掩码来指示模型在推理期间应考虑哪些标记；将其标记为 1。

# Adding special tokens need for the modelfinal_inputs=tokenizer.prepare_for_model(input_ids)

# Results# >>> {'input_ids': [101, 2023, 3185, 2003, 12476, 102], 'attention_mask': [1, 1, 1, 1, 1, 1]}

最后，既然我们已经有了我们的 ID 列表和这个注意力掩码，我们需要将其转换成深度学习模型可以接受的张量。这可以通过使用 TensorFlow 的 constant()方法来完成。（或者你也可以使用 PyTorch。）

# Convert the input IDs into tensors to add to the modelmodel_inputs=tf.constant([final_inputs['input_ids']])

# Results# >>> tf.Tensor([[ 101 2023 3185 2003 12476 102]], shape=(1, 6), dtype=int32)

如你所见，我们成功地复制了直接将原始文本传递给分词器所给出的相同输出，但采用了更详细的方法。

因此，我们现在已经准备好下载并使用我们的模型对这些数据进行推理。

推理和预测模型

这个部分在每一个数据科学项目中传统上都是最具挑战性的。这是知识渊博的数据科学家卷起袖子，在经过多次迭代和资源消耗后，为特定用例创建、训练和验证模型的时候。

幸运的是，如今这些步骤已经从创建一个全新的模型转变为只是选择并实现一个预训练的、可用于使用的模型。为此，我们需要加载模型的架构以及其预训练产生的参数权重。

然而，在这里重要的是要理解，这些模型有两个不同的部分——模型的主体或基础和其头部。[2]

• LLM 模型的主体或基础是出现在 transformer 架构中的多个隐藏层，这些层专门用于理解自然语言，并将其及其上下文翻译成机器可读格式。这些模型的输出是一个高维向量，表示文本的上下文理解。

这种对文本的理解，尽管对于 NLP 过程很重要，但本身并不能解决任何特定的 NLP 任务。

• 为了解决这些不同的任务，我们需要在模型中添加一个额外的层，称为头部。这个头部在模型的末尾包含一些额外的层，这些层将这个高维向量作为输入，并将其投影到适合每个任务或用例的不同维度。

下面，你可以看到一个完整的开放型 LLM 模型的典型表示。

https://github.com/OpenDocCN/towardsdatascience-blog-zh-2024/raw/master/docs/img/176723a4320aeb7127f43829e39128e3.png

LLM 模型架构：灵感来源于huggingface.co/learn/nlp-course/chapter2/2

与基模型一起工作

要加载和初始化一个不带任何头部的基预训练模型，我们可以遵循与 tokenize 相同的过程，只需将模型的检查点提供给**from_pretrained()**方法。现在唯一的区别是，我们将使用 transformers 库中的 TFAutoModel 类，而不是 AutoTokenizer（我们在前面使用 TF 是因为我们在 Tensorflow 之上使用 transformers 库）。这将下载并缓存模型的配置和权重，同时在初始化其实例。

然后，为了使用我们刚刚提供的基模型，我们只需从上一节提供预处理后的张量并打印结果。

# Importing the TFAutoModel to load the base modelfromtransformersimportTFAutoModel# Providing the checkpoint to denote the model architecture and the pre-trained weightsbase_model=TFAutoModel.from_pretrained('distilbert-base-uncased-finetuned-sst-2-english')# Create a high-dimensional vector with a contextual understanding of the textmodel_results=base_model(model_inputs)print('Model results:',model_results)

# Result# >>> Model results: TFBaseModelOutput(last_hidden_state=<tf.Tensor: shape=(1, 6, 768), dtype=float32, numpy=# array([[[ 0.7164141, 0.13687831, 0.18230182, ..., 0.42986768,# 0.9575808, -0.5615794 ],# [ 0.82266235, 0.11453596, 0.09670142, ..., 0.33378035,# 1.0659671, -0.44736785],# ...# [ 1.1498686, 0.18695728, 0.77936405, ..., 0.5333732,# 0.7962912 , -0.9428895 ]]], dtype=float32)>, hidden_states=None, attentions=None)

如你所见，从结果形状来看，输出是一个高维向量，其中每一行包含输入中每个标记的一个向量。

如果我们想将其作为输入提供给另一个更传统的机器或深度学习模型，这个结果可能非常有帮助，但就其本身而言，它不能帮助我们回答手头的问题。

“这个句子是积极的还是消极的？”

为了回答这个问题，我们需要使用这种对语言的理解，并找出这两种选项中的每一种成为真的可能性。这是一个典型的序列数据的分类任务，为了解决这个问题，我们需要向我们的模型添加适当的头部来完成这个任务，将这个向量转换为两个分数。

与带头部的完整模型一起工作

因此，为了做到这一点，你需要使用 TFAutoModelForSequenceClassification 类而不是 TFAutoModel 类来初始化模型。这个 ForSequenceClassification 部分将下载并初始化你将提供的作为检查点的模型，并将其附加到**from_pretrained()**方法中的序列分类头部。

可以使用不同的头部来完成不同的任务，你可以通过从 transformers 库中导入适当的类并为此任务提供微调后的模型检查点来加载它们。（例如，使用 TFAutoModelForQuestionAnswering来加载一个带有问答头部的模型）

所以，正如你所看到的那样，我们以前的方式下载并初始化我们的模型实例。我们将模型的检查点提供给 from_pretrained()方法，这样我们就下载并缓存了序列分类模型。然后我们再次传递预处理后的输入，让模型施展其魔法。

# Importing the TFAutoModelForSequenceClassification to load the model with a fine-tuned head for sequence classificationfromtransformersimportTFAutoModelForSequenceClassification# Providing the checkpoint to denote the model architecture and the pre-trained weightsmodel=TFAutoModelForSequenceClassification.from_pretrained('distilbert-base-uncased-finetuned-sst-2-english')# Make inferences using the modelmodel_results=model(model_inputs)print('Model results:',model_results)# Take model's outputed logits for each classoutputed_logits=model_results.logitsprint('Output Logits:',outputed_logits)

# Results# >>> Model results: TFSequenceClassifierOutput(loss=None, logits=<tf.Tensor: shape=(1, 2), dtype=float32, numpy=array([[-4.3079815, 4.6880302]], dtype=float32)>, hidden_states=None, attentions=None)# >>> Output Logits: tf.Tensor([[-4.3079815 4.6880302]], shape=(1, 2), dtype=float32)

如我们现在所看到的，我们得到了一个更易于管理的响应。这同样以张量的形式出现，包含各种信息，其中最重要的一个是 logits。这些 logits 是模型头部输出的原始、未归一化的分数，对应于我们想要分类的每个类别。因此，对于“这句话是积极的”和“这句话是消极的”这两个答案，我们都有一个分数。然而，对我来说，这些信息并没有提供一个易于理解的答案。

为了理解这些 logits，我们需要应用管道函数的最后一步。对这些结果进行后处理，使其更符合人类阅读习惯。

后处理

在本节中，后处理步骤可能根据任务的不同而略有差异。

在我们的案例中，如果模型执行分类任务（如序列分类，这也应用于标记分类），结果将是每个被检查类别的 logits，即未归一化的分数。

为了将这些值归一化并转换为每个类别的对应概率，我们可以使用 Tensorflow 库中的 softmax 函数。

# Convert these logits into probabilitiesprediction=tf.nn.softmax(outputed_logits)

# Results# >>> tf.Tensor([[1.2388763e-04 9.9987614e-01]], shape=(1, 2), dtype=float32)

然后，你可以使用模型类中的这种方法看到对应这些概率的类别。这可以在模型的配置中通过 id2label 属性找到。

# To find the label positions to see the label for the corresponding probabilityprint(model.config.id2label)

# Results# >>> {0: 'NEGATIVE', 1: 'POSITIVE'}

因此，现在我们已经有了每个类别的概率以及这些类别的位置，我们可以找到给定文本的预测情感。要做到这一点，我们可以找到模型推导出的最大概率，然后找到对应这个概率的类别。

# Importing the numpy function to perform some post-processing stepsimportnumpyasnp# Finding the max probabilityscore=max(prediction.numpy()[0])print(score)# Finding the position of the max probabilitylabel_position=np.argmax(prediction.numpy()[0])print(label_position)# Find the label corresponding to the max probabilitylabel=model.config.id2label[label_position]print(label)

# Results# >>> 0.99987614# >>> 1# >>> 'POSITIVE'

有这些信息，我们可以重建管道的输出，以符合一行管道函数推导出的格式。

# Reconstacting the output formatoutput=[{'label':label,'score':score}]print(output)

# Results# >>> [{'label': 'POSITIVE', 'score': 0.99987614}]

如你所见，我们通过深入这个函数实现了与之前相同的结果，但深入了一层。

这些是一些针对分类模型的后处理步骤。对于不同的 NLP 任务，可能遵循不同的步骤。例如，对于输出文本的模型，如问答、文本生成和摘要，模型通常会返回代表生成文本单词的标记。在这种情况下，主要的后处理步骤是将这些标记转换回人类可读的文本，这个过程称为解码，由分词器再次执行。

# If the inputs were the outputs of a text-generated modelhypothetical_outputs=final_inputs['input_ids']print(hypothetical_outputs)# Decode the tokens created if the model resulted in a text generationprint(tokenizer.decode(hypothetical_outputs))

# Results# >>> [2023, 3185, 2003, 12476]# >>> 'this movie is awesome'

我知道这有点技术性，但仍然不是那么复杂。然而，正如你所看到的，你可以使用一行管道函数和稍微长一点但更可修改的代码来推导出相同的结果。你可以在我的 GitHub 仓库这里找到完整的示例代码。

结论

总之，随着各种 AI 解决方案的广泛讨论，许多人将急于尝试利用它们。因此，我希望这篇文章能帮助你理解，这些解决方案不仅可以通过 ChatGPT API 或界面找到，而且任何人只要对 Python 有点了解，并使用开源的 LLMs，都可以找到。

随着这个领域的社区不断壮大，将会有越来越多的模型被共享，并针对不同的需求和任务进行定制。在某些情况下，这些模型已经超越了强大的 Chat GPT，并且可以免费使用，没有任何使用成本。

最好的是，你只需一行代码就可以开始利用它们来构建你的第一个 AI 解决方案，如果你想更深入地研究并调整以达到更好的效果，可能还需要几行额外的代码。这些解决方案将不仅限于文本输入，还将能够与其他非结构化数据形式进行交互和理解，例如图像、音频和视频。

📖 参考文献：

1. openai.com/pricing

2. huggingface.co/docs/transformers/main_classes/pipelines

3. huggingface.co/learn/nlp-course/chapter2/2

4. huggingface.co/learn/nlp-course/chapter1/1