【NLP】第 5 章 ：使用Hugging Face的任务_roberta-base-squad2

到目前为止，我们已经了解了如何在非常初级的层面上将 transformers 与 huggingface Transformers 库一起使用。我们现在将开始了解如何使用该库来完成与文本、音频和图像相关的不同任务。

但在我们继续之前，我们将向您介绍 Gradio，这是一个用于在 huggingface 之上构建 UI 的库。

Gradio：简介

Gradio 是一个专门为部署和推理机器学习模型而构建的Web 框架 。Gradio 使我们能够通过 Web 界面快速公开我们的 ML 模型，而无需学习太多编码。通过收购 Gradio，Hugging Face 向前迈进了一步，为 huggingface 社区提供了一个简单的界面，可以在 huggingface 模型上部署和提供 UI。

在本章中，我们将使用huggingface spaces ，它为我们提供了一个接口来快速部署和提供我们的应用程序（使用 huggingface API 构建），一个 Web 前端，最终用户可以使用它与我们的应用程序进行交互。

在Hugging Face上创造空间

要在huggingface infra 上创建一个空间，我们需要有一个 huggingface 的帐户。这可以通过导航到https://huggingface.co/并在那里创建一个帐户来完成。创建账户后，我们可以点击最右边 的彩色圆圈，如图5-1所示。

图 5-1登录 后Hugging Face屏幕

点击新建空间，我们看到如图5-2所示的画面。

图 5-2 创造一个新的空间

为您的空间命名并选择 Gradio 作为SDK 。现在保持默认公开以提高可见性，最后单击“Create Space”按钮。

您将看到如图5-3所示的以下菜单。

图 5-3

huggingface 网页上显示的菜单

对于本章中的大多数应用程序，我们将使用文件和版本以及应用程序选项卡。

单击文件和版本选项卡，在右侧，我们看到添加文件。单击它我们可以添加我们的应用程序所需的文件。

对于我们的应用程序，我们只需要创建两个文件 ：

1. app.py：这是 Gradio 应用程序的主要代码文件。

2. requirements.txt：此文件包含应用程序所需的 Python 依赖项。

Hugging Face任务

我们将从问答任务开始。

问答

模型的输入将是一个段落和该段落中的一个问题。模型推理的输出将是问题的答案。

我们使用的模型是在 SQuAD数据集 上训练的。

斯坦福问答数据集，也称为SQuAD ，是一个阅读理解数据集，由众包人员针对一组维基百科文章提出的问题组成。每个问题的答案都是来自相应阅读文章的一段文本，也称为span ，否则问题可能无法回答。

SQuAD 1.1 包含超过 100,000 个问答对，涵盖 500 多篇不同的文章。

首先，使用 RoBERTa基础 模型 ，使用SQuAD 2. 0数据集进行微调。它接受 了问答对的训练，包括无法回答的问题，用于问答任务。

模型使用的一些超参数是

• batch_size：96

• n_epochs：2

• max_seq_len：386

• max_query_length：64

首先使用huggingface UI 创建一个新空间，如上一节中的步骤所述。

单击 UI 上的文件和版本选项卡。使用以下内容创建文件 requirements.txt：

requirements.txt

gradio

transformers

torch

创建另一个文件 app.py 并复制 清单5-1中的内容。

from transformers import AutoModelForQuestionAnswering, AutoTokenizer, pipeline
import gradio as grad
import ast
mdl_name = "deepset/roberta-base-squad2"
my_pipeline = pipeline('question-answering', model=mdl_name, tokenizer=mdl_name)
def answer_question(question,context):
    text= "{"+"'question': '"+question+"','context': '"+context+"'}"
    di=ast.literal_eval(text)
    response = my_pipeline(di)
    return response
grad.Interface(answer_question, inputs=["text","text"], outputs="text").launch()

清单 5-1 app.py 的代码

单击 Commit changes 按钮提交更改，如图5-4所示。

图 5-4 提交 app.py 文件

这将触发构建和部署 过程，并且可以单击图5-5中的“查看日志”按钮来查看活动。

图 5-5 显示各种选项卡，包括“查看日志”按钮

初始阶段将是构建阶段，如图5-6所示。

图 5-6 应用程序的部署状态

点击See logs我们可以看到如图5-7所示的活动 。

图 5-7 显示应用程序的构建进度 。在这里，它正在加载用于创建容器的 Docker 映像

可以看到这里正在构建Docker 镜像 ，然后将部署它。如果一切 运行成功，我们将在 UI 上看到一个绿色的阶段，状态为 Running，如图5-8所示。

图 5-8 应用程序的状态更改为正在运行

完成后，单击“文件和版本”选项卡左侧的“应用程序”选项 卡。这将为您呈现用于键入输入的 UI。提供输入后，请单击提交按钮，如图5-9所示。

图 5-9 通过 Gradio 问答 UI。在标有上下文的输入框中为该段落提供您选择的输入，该段落中的问题应放入标有问题的输入框中

在清单5-2中，我们将在不同的模型上尝试相同的段落 和问题。我们将使用的模型是distilbert-base-cased-distilled-squad：

requirements.txt

gradio

transformers

torch

from transformers import AutoModelForQuestionAnswering, AutoTokenizer, pipeline
import gradio as grad
import ast
mdl_name = "distilbert-base-cased-distilled-squad"
my_pipeline = pipeline('question-answering', model=mdl_name, tokenizer=mdl_name)
def answer_question(question,context):
    text= "{"+"'question': '"+question+"','context': '"+context+"'}"
    di=ast.literal_eval(text)
    response = my_pipeline(di)
    return response
grad.Interface(answer_question, inputs=["text","text"], outputs="text").launch()

清单 5-2 app.py 的代码

提交更改并等待 部署状态变为绿色。发布单击菜单中的 App 选项卡以启动应用程序。

向 UI 提供输入并单击提交按钮以查看结果，如图5-10所示。

图 5-10 显示用于基于BERT 的问答 的基于 Gradio 的问答 UI

翻译

我们要处理 的下一个任务是语言翻译。这背后的想法是采用一种语言输入，然后根据通过 huggingface 库加载的预训练模型将其翻译成另一种语言。

我们在这里探索的第一个模型是Helsinki-NLP/opus-mt-en-de 模型 ，它接受英语输入并将其翻译成德语。

Code

app.py

from transformers import pipeline
import gradio as grad
mdl_name = "Helsinki-NLP/opus-mt-en-de"
opus_translator = pipeline("translation", model=mdl_name)
def translate(text):
    response = opus_translator(text)
    return response
grad.Interface(translate, inputs=["text",], outputs="text").launch()

清单 5-3 app.py 的代码

requirements.txt

gradio

transformers

torch

transformers[sentencepiece]

Output

提交更改 并等待部署状态变为绿色。发布单击菜单中的 App 选项卡以启动应用程序。

向 UI 提供输入并单击提交按钮以查看结果，如图5-11所示。

图 5-11 用于翻译任务的 Gradio UI

我们现在将在清单5-4中看到我们是否可以在不使用管道抽象的情况下编写相同的代码。如果我们还记得我们之前使用 AutoTokenizer 和AutoModel 等Auto 类做过同样的事情 。让我们继续。

Code

app.py

from transformers import AutoModelForSeq2SeqLM,AutoTokenizer
import gradio as grad
mdl_name = "Helsinki-NLP/opus-mt-en-de"
mdl = AutoModelForSeq2SeqLM.from_pretrained(mdl_name)
my_tkn = AutoTokenizer.from_pretrained(mdl_name)
#opus_translator = pipeline("translation", model=mdl_name)
def translate(text):
    inputs = my_tkn(text, return_tensors="pt")
    trans_output = mdl.generate(**inputs)
    response = my_tkn.decode(trans_output[0], skip_special_tokens=True)
    #response = opus_translator(text)
    return response
grad.Interface(translate, inputs=["text",], outputs="text").launch()

清单 5-4 app.py 的代码

requirements.txt

gradio

transformers

torch

transformers[sentencepiece]

提交更改 并等待部署状态变为绿色。发布单击菜单中的 App 选项卡以启动应用程序。

向 UI 提供输入并单击提交按钮以查看结果，如图5-12所示。

图 5-12 基于 Gradio 的翻译 UI

为了给你一种幸福 的感觉，当我们尝试通过谷歌翻译 同样的翻译时，我们得到了如下结果，如图5-13所示。

图 5-13 显示 Google 翻译如何翻译我们用于翻译应用程序的相同文本

我们可以看到我们与谷歌的结果有多接近 。这就是抱脸模型的力量。

为了强化这个概念，我们将用不同的语言翻译重复这个练习。这次我们以英法翻译为例。

这次我们采用Helsinki-NLP/opus-mt-en-fr 模型 并尝试翻译我们在前面示例中采用的相同句子，但这次是法语。

首先，我们使用管道抽象编写代码。

Code

app.py

from transformers import pipeline
import gradio as grad
mdl_name = "Helsinki-NLP/opus-mt-en-fr"
opus_translator = pipeline("translation", model=mdl_name)
def translate(text):
    response = opus_translator(text)
    return response
txt=grad.Textbox(lines=1, label="English", placeholder="English Text here")
out=grad.Textbox(lines=1, label="French")
grad.Interface(translate, inputs=txt, outputs=out).launch()

清单 5-5 app.py 的代码

requirements.txt

gradio

transformers

torch

transformers[sentencepiece]

提交更改 并等待部署状态变为绿色。发布单击菜单中的 App 选项卡以启动应用程序。

向 UI 提供输入并单击提交按钮以查看结果，如图5-14所示。

图 5-14 使用 Gradio 的翻译 UI

我们得到以下输出。

接下来，我们尝试在清单5-6中没有管道 API 的情况下进行相同的操作。

Code

app.py

from transformers import AutoModel,AutoTokenizer,AutoModelForSeq2SeqLM
import gradio as grad
mdl_name = "Helsinki-NLP/opus-mt-en-fr"
mdl = AutoModelForSeq2SeqLM.from_pretrained(mdl_name)
my_tkn = AutoTokenizer.from_pretrained(mdl_name)
#opus_translator = pipeline("translation", model=mdl_name)
def translate(text):
    inputs = my_tkn(text, return_tensors="pt")
    trans_output = mdl.generate(**inputs)
    response = my_tkn.decode(trans_output[0], skip_special_tokens=True)
    #response = opus_translator(text)
    return response
txt=grad.Textbox(lines=1, label="English", placeholder="English Text here")
out=grad.Textbox(lines=1, label="French")
grad.Interface(translate, inputs=txt, outputs=out).launch()

清单 5-6 app.py 的代码

requirements.txt

gradio

transformers

torch

transformers[sentencepiece]

提交更改 并等待部署状态变为绿色。发布单击菜单中的 App 选项卡以启动应用程序。

向 UI 提供输入并单击提交按钮以查看结果，如图5-15所示。

图 5-15 用于翻译任务的 Gradio UI，无需直接使用管道 API

再次将结果与Google Translate 的结果进行比较，如图5-16所示。

图 5-16 Google 翻译 我们用于 Gradio 应用程序的相同文本

正如我们所见，结果 完全匹配。有什么值得欢呼的。

概括

如果要阅读冗长的文档，我们的自然倾向是要么根本不阅读它们，要么只浏览最重要的要点。因此，对信息进行总结以节省时间和脑力处理能力将非常有帮助。

然而，在过去，自动总结文本是一项不可能完成的任务。更具体地说，做一个抽象的总结是一件非常困难的事情。抽象摘要比提取摘要更难，后者从文档中提取关键句子并将它们组合起来形成“摘要”。因为abstractive summarization涉及释义词，所以也比较费时；但是，它有可能产生更加优美和连贯的摘要。

我们将首先查看google/pegasus-xsum 模型 以生成一些文本的摘要。

这是代码。

app.py

from transformers import PegasusForConditionalGeneration, PegasusTokenizer
import gradio as grad
mdl_name = "google/pegasus-xsum"
pegasus_tkn = PegasusTokenizer.from_pretrained(mdl_name)
mdl = PegasusForConditionalGeneration.from_pretrained(mdl_name)
def summarize(text):
    tokens = pegasus_tkn(text, truncation=True, padding="longest", return_tensors="pt")
    txt_summary = mdl.generate(**tokens)
    response = pegasus_tkn.batch_decode(txt_summary, skip_special_tokens=True)
    return response
txt=grad.Textbox(lines=10, label="English", placeholder="English Text here")
out=grad.Textbox(lines=10, label="Summary")
grad.Interface(summarize, inputs=txt, outputs=out).launch()

清单 5-7 app.py 的代码

requirements.txt

gradio

transformers

torch

transformers[sentencepiece]

提交更改并等待部署状态变为绿色。发布单击菜单中的 App 选项卡以启动应用程序。

向 UI 提供输入并单击提交按钮以查看结果，如图5-17所示。

图 5-17 使用 Gradio 的摘要应用程序 。在标有英文的框中粘贴段落，提交后，标有摘要的框将显示段落文本的摘要

接下来，我们使用另一个文本，并使用一些参数对模型进行一些调整。

from transformers import PegasusForConditionalGeneration, PegasusTokenizer
import gradio as grad
mdl_name = "google/pegasus-xsum"
pegasus_tkn = PegasusTokenizer.from_pretrained(mdl_name)
mdl = PegasusForConditionalGeneration.from_pretrained(mdl_name)
def summarize(text):
    tokens = pegasus_tkn(text, truncation=True, padding="longest", return_tensors="pt")
    translated_txt = mdl.generate(**tokens,num_return_sequences=5,max_length=200,temperature=1.5,num_beams=10)
    response = pegasus_tkn.batch_decode(translated_txt, skip_special_tokens=True)
    return response
txt=grad.Textbox(lines=10, label="English", placeholder="English Text here")
out=grad.Textbox(lines=10, label="Summary")
grad.Interface(summarize, inputs=txt, outputs=out).launch()

清单 5-8 app.py 的代码

提交更改并等待部署状态变为绿色。发布单击菜单中的 App 选项卡以启动应用程序。

向 UI 提供输入并单击提交按钮以查看结果，如图5-18所示。

图 5-18 通过 Gradio 应用程序总结文本

图 5-19 用于总结文本的Google Pegasus 模型 Imagsource： https ://1.bp.blogspot.com/-TSor4o51jGI/Xt50lkj6blI/AAAAAAAAGDs/

我们可以看到我们在代码中提供了以下参数：

translated_txt = mdl.generate(**tokens,num_return_sequences=5,max_length=200,temperature=1.5,num_beams=10)

文本生成 是通过使用波束搜索来完成的，这就是 num beams 所指的。与只返回最有可能找到的下一个单词的贪婪搜索相反，此方法返回最有可能找到的 n 个单词。

Num_return_sequences 返回返回的输出数。在前面的示例中，我们给出了 5 作为序列数。

改变由神经网络计算的输出分布是使用温度函数 的一个理由。根据公式 5-1（温度函数），它被添加到 logits 向量中：

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】