Hugging Face Transformers – a super biblioteca de deep learning
No cenário em constante evolução da inteligência artificial, a biblioteca Hugging Face Transformers emergiu como uma virada de jogo. Ela fornece aos desenvolvedores e cientistas de dados diversas ferramentas poderosas para lidar com tarefas complexas.
Bibliotecas como PyTorch, TensorFlow, Keras e JAX são excelentes para desenvolver e treinar modelos de redes neurais e deep learning. Já a biblioteca Hugging Face Transformers tem uma capacidade diferente. O seu forte é contar com milhares de modelos pré-treinados facilmente disponibilizados por meio de pipelines.
Modelos pré-treinados aceleram brutalmente o desenvolvimento de aplicações com deep learning e também reduzem significativamente seus custos computacionais.
Outra vantagem da Hugging Face Transformers é contar com modelos pré-treinados do tipo transformer. Transformers são muito populares para tarefas de processamento de linguagem natural (natural languagem processing, NLP).
Até pouco tempo atrás, modelos de deep learning e redes neurais para tarefas de NLP eram feitos com redes neurais recorrentes. Esses modelos ainda são bastante usados. No entanto, a arquitetura transformer é a mais moderna para aplicações de NLP. Seu desempenho é bem superior ao das redes recorrentes tradicionais. Note, porém, que os modelos transformers não são usados apenas para tarefas de NLP.
Modelos Transformers - alguns detalhes técnicos
Transformers são treinados de forma autossupervisionada. A aprendizagem autossupervisionada é um tipo de treinamento no qual o que deve ser aprendido é calculado automaticamente a partir das entradas do modelo. Isso significa que não são necessários dados rotulados por humanos como em tarefas de aprendizagem supervisionada.
Um modelo transformer desenvolve uma compreensão estatística da tarefa para qual foi treinado, mas ele não é muito útil para tarefas práticas específicas. Por causa disso, o modelo geral pré-treinado passa então por um processo chamado aprendizagem por transferência. Durante esse processo, o modelo é ajustado de forma supervisionada — ou seja, usando rótulos anotados por humanos — para realizar tarefas específicas.
Modelos transformers costumam ser muito grandes. Por isso, o uso de modelos pré-treinados é essencial.
Objetivos
Nesse post, exploraremos algumas das aplicações da biblioteca Hugging Face Transformers. Como essa biblioteca é imensa, cobriremos uma parte minúscula de suas funcionalidades. Portanto, use nosso material apenas como um aperitivo da Hugging Face.
Instalação
A Hugging Face Transformers precisa ser instalada em conjunto com um framework de deep learning. As opções são PyTorch, TensorFlow ou JAX. Porém, o PyTorch é o mais compatível com os modelos disponíveis nas pipelines da Hugging Face (imagem abaixo). Por isso, ele será nossa escolha. É possível usar vários modelos da Hugging Face sem saber PyTorch.
Clique aqui para acessar a fonte original.
Para instalar com pip:
pip install transformers datasets
pip install torch
Além desses pacotes, outras instalações são necessárias apenas para tarefas específicas. Se você quiser acompanhar o post, instale também: accelarate, protobuf, sentencepiece. Existem outras bibliotecas que podem ser necessárias como bibliotecas de apoio como NumPy. Se elas não estiverem instaladas no seu sistema, as mensagens de erro indicarão isso.
pip install accelerate protobuf sentencepiece
Hugging face Transformers: pipelines
O objeto mais básico da biblioteca Hugging Face Transformers é a função pipeline(). Ela se conecta diretamente com um modelo pré-treinado.
A forma mais fácil de usar uma pipeline é simplesmente indicar qual tarefas desejamos executar. A quantidade de tarefas disponíveis é impressionante. Abaixo mostramos uma imagem com um resumo das principais.
Clique aqui para acessar a fonte original.
Começaremos com um exemplo de análise de sentimentos. A análise sentimental é uma tarefa de NLP e tem várias aplicações, incluindo a criação de chatbots.
O código para realizar a análise sentimental consiste em importar a função pipeline, definir a tarefa, indicar uma sentença ou mais para ser analisada e imprimir o resultado.
from transformers import pipeline
classifier = pipeline("sentiment-analysis")
data = classifier("Eu amo tutoriais sobre Hugging Face Transformers.")
print(data)
O resultado obtido mostrado abaixo indica que nossa sentença, claramente positiva, foi classificada como negativa.
[{'label': 'NEGATIVE', 'score': 0.980222761631012}]
A razão para isso é simples: para tarefas de processamento de linguagem natural, a língua default é o inglês e textos em português, obviamente, não funcionam nesse caso. A solução para isso é especificar qual modelo deve ser usado na pipeline.
Hugging face Transformers: pipelines com especificação do modelo
A Hugging Face conta com uma variedade gigante de modelos. Por isso é importante entender como buscar exatamente o que queremos. Existem vários filtros na página dos modelos disponíveis (imagem abaixo). Eles podem ser usados em combinação. No nosso caso, é preciso selecionar um filtro para modelos com linguagem em português e outro para a tarefa que queremos (sentiment analysis).
Clique aqui para acessar a fonte original.
A Hugging Face disponibiliza poucos modelos específicos para português, mas tem vários modelos multilínguas. É um desses que utilizamos no código abaixo.
O modelo que selecionamos é do tipo DistilBERT. Esse é um modelo transformer pequeno, rápido, barato e leve baseado na arquitetura BERT. O termo Distil presente no seu nome significa que ele é um modelo destilado, ou seja, reduzido a partir de um modelo maior. A destilação do conhecimento do DistilBERT foi realizada para reduzir o tamanho de um modelo BERT em 40%.
Nosso código para usar o DistilBert ficou assim:
from transformers import pipeline
model = pipeline(model="lxyuan/distilbert-base-multilingual-cased-sentiments-student", return_all_scores=True)
data = model("Eu amo tutoriais sobre Hugging Face Transformers.")
print(data)
O resultado mostra três rótulos possíveis para a sentença (positivo, neutro e negativo) com o score obtido para cada um deles. O resultado correto é o rótulo com maior valor. Nesse caso, o modelo classificou corretamente nossa sentença como positiva.
[[{'label': 'positive', 'score': 0.5394024848937988}, {'label': 'neutral', 'score': 0.17410773038864136}, {'label': 'negative', 'score': 0.28648972511291504}]]
Zero-shot learning para classificação de textos
A próxima tarefa que vamos mostrar com a Hugging Face Transformers se chama zero-shot-learning ou zero-shot classification.
Zero-shot learning é um tipo de tarefa de deep learning. Nessa tarefa, um modelo observa amostras de dados pertencentes a classes que não foram observadas durante o treinamento e ele precisa prevê-las.
Os métodos zero-shot geralmente funcionam associando classes observadas e não observadas por meio de alguma forma de informação auxiliar. A pipeline zero-shot da Hugging Face realiza esse processo através da especificação de rótulos que atuam como candidatos para a classificação.
Abaixo mostramos um exemplo desse tipo de tarefa. Primeiro, selecionamos a pipeline que será usada e o modelo. Depois, definimos a sentença que será analisada. Em seguida, fornecemos ao modelo três rótulos possíveis para a classificação da sentença. Por fim, aplicamos o classificador na nossa sentença.
from transformers import pipeline
classifier = pipeline("zero-shot-classification", model="MoritzLaurer/mDeBERTa-v3-base-mnli-xnli")
sequence_to_classify = "Esse tutorial fala sobre a biblioteca Hugging face Transformers."
candidate_labels=["educação", "política", "negócios"]
output = classifier(sequence_to_classify, candidate_labels, multi_label=False)
print(output)
Nosso resultado abaixo mostra que o modelo classificou corretamente nossa sentença como pertencente a classe educação. É essa a classe com o maior score.
{'sequence': 'Esse tutorial fala sobre a biblioteca Hugging Face Transformers.', 'labels': ['educação', 'negócios', 'política'], 'scores': [0.9861090183258057, 0.0071269008331000805, 0.0067640938796103]}
Zero-shot learning para detecção de objetos em imagens
Além da classificação de textos, a Hugging Face tem vários modelos para tarefas de classificação com imagens. No exemplo mostrado abaixo, retirado diretamente da Hugging Face, usamos zero-shot para fazer a detecção dos objetos de uma imagem fornecendo rótulos como feito anteriormente. Primeiro, selecionamos o modelo e a pipeline. Depois abrimos a imagem, a convertemos para o formato correto e fazemos a predição dos objetos presentes nela fornecendo alguns rótulos como candidatos. Por fim, um loop é usado para marcar cada objeto identificado na imagem com seu rótulo correto. Veja que estamos usando três bibliotecas adicionais: NumPy, Pillow e scikit-image.
from transformers import pipeline
import skimage
import numpy as np
from PIL import Image, ImageDraw
checkpoint = "google/owlvit-base-patch32"
detector = pipeline(model=checkpoint, task="zero-shot-object-detection")
image = skimage.data.astronaut()
image = Image.fromarray(np.uint8(image)).convert("RGB")
predictions = detector(
image,
candidate_labels=["human face", "rocket", "nasa badge", "star-spangled banner"],
)
draw = ImageDraw.Draw(image)
for prediction in predictions:
box = prediction["box"]
label = prediction["label"]
score = prediction["score"]
xmin, ymin, xmax, ymax = box.values()
draw.rectangle((xmin, ymin, xmax, ymax), outline="red", width=1)
draw.text((xmin, ymin), f"{label}: {round(score,2)}", fill="white")
O resultado da execução do código está abaixo. A primeira imagem é a que foi usada para a detecção de objetos, a segunda contém os objetos reconhecidos com os rótulos que haviam sido indicados.
Inferência de linguagem natural
Nossa próxima tarefa será a inferência de linguagem natural (natural language inference, NLI). Essa tarefa consiste em determinar se uma “hipótese” é verdadeira (implicação), falsa (contradição) ou indeterminada (neutra) dada uma “premissa”.
No exemplo mostrado abaixo, usamos duas funções. Primeiro utilizamos a função tokenizer. Modelos grandes de linguagem como os presentes na Hugging Face processam texto usando tokens. Depois de usar a função tokenizer, aplicamos a função AutoModelForSequenceClassification para verificar a veracidade da hipótese a partir da premissa fornecida. Como o modelo que usamos é multilínguas, a premissa é uma sentença em alemão. A hipótese é em português. O resultado precisa ser convertido em uma distribuição de probabilidades com a aplicação de uma função de ativação do tipo softmax (linha 14).
from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch
device = if torch.cuda.is_available() else torch.device("cpu")
model_name = "MoritzLaurer/mDeBERTa-v3-base-xnli-multilingual-nli-2mil7"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name)
premise = "Angela Merkel ist eine Politikerin in Deutschland und Vorsitzende der CDU"
hypothesis = "Lula é o presidente do Brasil"
input = tokenizer(premise, hypothesis, truncation=True, return_tensors="pt")
output = model(input["input_ids"].to(device))
prediction = torch.softmax(output["logits"][0], -1).tolist()
label_names = ["entailment", "neutral", "contradiction"]
prediction = {name: round(float(pred) * 100, 1) for pred, name in zip(prediction, label_names)}
print(prediction)
O resultado indica que o modelo classificou a hipótese como correta: Lula é o presidente do Brasil.
{'entailment': 92.5, 'neutral': 6.8, 'contradiction': 0.7}
Resposta a perguntas
A próxima tarefa que realizaremos é chamada de resposta a perguntas. Ela consiste em fornecer um texto a um modelo e depois fazer perguntas relacionadas para ele responder. Ele também pode indicar corretamente a posição das respostas no texto original.
O modelo que utilizaremos é específico para português. Para saber mais sobre ele, clique aqui.
No código abaixo, primeiro definimos o modelo e a pipeline que será usada. Depois, fornecemos um texto, uma pergunta e aplicamos a pipeline.
model_name = 'pierreguillou/bert-large-cased-squad-v1.1-portuguese'
nlp = pipeline("question-answering", model=model_name)
context = r"""
A jabuticaba ou jaboticaba é o fruto da jaboticabeira ou jabuticabeira,
uma árvore frutífera brasileira da família das mirtáceas, nativa da Mata Atlântica.
Com a recente mudança na nomenclatura botânica, há divergências sobre a classificação da espécie:
Myrciaria cauliflora, Plinia trunciflora ou Plinia cauliflora. Espécies relacionadas no gênero Myrciaria,
frequentemente referidas pelos mesmos nomes comuns, são nativas da América do Sul, encontrada em países como Brasil,
México, Bolívia, Uruguai, Paraguai e Argentina.Segundo Lorenzi et al., Plinia trunciflora seria outra espécie,
a jabuticaba-café. A cidade de Jaboticabal, em São Paulo, foi nomeada em homenagem a essa planta.
Descrita inicialmente em 1828 a partir de material cultivado, sua origem é desconhecida.
Outros nomes populares: jabuticabeira-preta, jabuticabeira-rajada, jabuticabeira-rósea,
jabuticabeira-vermelho-branca, jabuticaba-paulista, jabuticaba-ponhema, jabuticaba-açu.
Outra espécie de jabuticabeira é a Myrciaria jaboticaba, conhecida como jabuticaba-sabará
e encontrada com mais frequência nos estados de Goiás, Minas Gerais e São Paulo, no Brasil.
"""
question = "O que é jabuticaba?"
result = nlp(question=question, context=context)
print(f"Answer: '{result['answer']}', lang='pt', score: {round(result['score'], 4)}, start: {result['start']}, end: {result['end']}")
Essa foi a resposta fornecida pelo modelo para a execução do código acima.
Answer: 'uma árvore frutífera brasileira da família das mirtáceas', lang='pt', score: 0.0776, start: 74, end: 130
Depois testamos outra questão.
question = "Em que países a jabuticaba é encontrada?"
E o modelo respondeu de forma correta.
México, Bolívia, Uruguai, Paraguai e Argentina', lang='pt', score: 0.9479, start: 475, end: 530
E com essa resposta, encerramos nossas explorações da Hugging Face Transformers para esse post.
Conclusões
Nesse post, testamos algumas das aplicações da biblioteca da Hugging Face Transformers. As pipelines que mostramos são uma amostra minúscula da Hugging Face. Deixamos de fora várias tarefas super legais como geração de textos, processamento de áudios, entre outras. Se você tem interesse, consulte o site da Hugging Face. Considere também usar o Colab para rodar os modelos com GPUs potentes.
