Tour rápido

Comece a trabalhar com 🤗 Transformers! Comece usando pipeline() para rápida inferência e facilmente carregue um modelo pré-treinado e um tokenizer com AutoClass para resolver tarefas de texto, visão ou áudio.

Pipeline

pipeline() é a maneira mais fácil de usar um modelo pré-treinado para uma dada tarefa.

A pipeline() apoia diversas tarefas fora da caixa:

Texto:

• Análise sentimental: classifica a polaridade de um texto.
• Geração de texto (em Inglês): gera texto a partir de uma entrada.
• Reconhecimento de entidade mencionada: legenda cada palavra com uma classe que a representa (pessoa, data, local, etc…)
• Respostas: extrai uma resposta dado algum contexto e uma questão
• Máscara de preenchimento: preenche o espaço, dado um texto com máscaras de palavras.
• Sumarização: gera o resumo de um texto longo ou documento.
• Tradução: traduz texto para outra língua.
• Extração de características: cria um tensor que representa o texto.

Imagem:

• Classificação de imagens: classifica uma imagem.
• Segmentação de imagem: classifica cada pixel da imagem.
• Detecção de objetos: detecta objetos em uma imagem.

Audio:

• Classficação de áudio: legenda um trecho de áudio fornecido.
• Reconhecimento de fala automático: transcreve audio em texto.

Uso da pipeline

No exemplo a seguir, você usará pipeline() para análise sentimental.

Instale as seguintes dependências se você ainda não o fez:

pip install torch

pip install tensorflow

Importe pipeline() e especifique a tarefa que deseja completar:

>>> from transformers import pipeline

>>> classifier = pipeline("sentiment-analysis")

A pipeline baixa and armazena um modelo pré-treinado padrão e tokenizer para análise sentimental. Agora você pode usar classifier no texto alvo:

>>> classifier("We are very happy to show you the 🤗 Transformers library.")
[{'label': 'POSITIVE', 'score': 0.9998}]

Para mais de uma sentença, passe uma lista para a pipeline(), a qual retornará uma lista de dicionários:

>>> results = classifier(["We are very happy to show you the 🤗 Transformers library.", "We hope you don't hate it."])
>>> for result in results:
...     print(f"label: {result['label']}, with score: {round(result['score'], 4)}")
label: POSITIVE, with score: 0.9998
label: NEGATIVE, with score: 0.5309

A pipeline() também pode iterar sobre um Dataset inteiro. Comece instalando a biblioteca de 🤗 Datasets:

pip install datasets 

Crie uma pipeline() com a tarefa que deseja resolver e o modelo que deseja usar.

>>> import torch
>>> from transformers import pipeline

>>> speech_recognizer = pipeline("automatic-speech-recognition", model="facebook/wav2vec2-base-960h")

A seguir, carregue uma base de dados (confira a 🤗 Iniciação em Datasets para mais detalhes) que você gostaria de iterar sobre. Por exemplo, vamos carregar o dataset MInDS-14:

>>> from datasets import load_dataset, Audio

>>> dataset = load_dataset("PolyAI/minds14", name="en-US", split="train")

Precisamos garantir que a taxa de amostragem do conjunto de dados corresponda à taxa de amostragem em que o facebook/wav2vec2-base-960h foi treinado.

>>> dataset = dataset.cast_column("audio", Audio(sampling_rate=speech_recognizer.feature_extractor.sampling_rate))

Os arquivos de áudio são carregados e re-amostrados automaticamente ao chamar a coluna "audio". Vamos extrair as arrays de formas de onda originais das primeiras 4 amostras e passá-las como uma lista para o pipeline:

>>> result = speech_recognizer(dataset[:4]["audio"])
>>> print([d["text"] for d in result])
['I WOULD LIKE TO SET UP A JOINT ACCOUNT WITH MY PARTNER HOW DO I PROCEED WITH DOING THAT', "FONDERING HOW I'D SET UP A JOIN TO HET WITH MY WIFE AND WHERE THE AP MIGHT BE", "I I'D LIKE TOY SET UP A JOINT ACCOUNT WITH MY PARTNER I'M NOT SEEING THE OPTION TO DO IT ON THE APSO I CALLED IN TO GET SOME HELP CAN I JUST DO IT OVER THE PHONE WITH YOU AND GIVE YOU THE INFORMATION OR SHOULD I DO IT IN THE AP AND I'M MISSING SOMETHING UQUETTE HAD PREFERRED TO JUST DO IT OVER THE PHONE OF POSSIBLE THINGS", 'HOW DO I TURN A JOIN A COUNT']

Para um conjunto de dados maior onde as entradas são maiores (como em fala ou visão), será necessário passar um gerador em vez de uma lista que carregue todas as entradas na memória. Consulte a documentação do pipeline para mais informações.

Use outro modelo e tokenizer na pipeline

A pipeline() pode acomodar qualquer modelo do Model Hub, facilitando sua adaptação para outros casos de uso. Por exemplo, se você quiser um modelo capaz de lidar com texto em francês, use as tags no Model Hub para filtrar um modelo apropriado. O principal resultado filtrado retorna um modelo BERT bilíngue ajustado para análise de sentimentos. Ótimo, vamos usar este modelo!

>>> model_name = "nlptown/bert-base-multilingual-uncased-sentiment"

>>> from transformers import AutoTokenizer, AutoModelForSequenceClassification

>>> model = AutoModelForSequenceClassification.from_pretrained(model_name)
>>> tokenizer = AutoTokenizer.from_pretrained(model_name)

>>> from transformers import AutoTokenizer, TFAutoModelForSequenceClassification

>>> model = TFAutoModelForSequenceClassification.from_pretrained(model_name)
>>> tokenizer = AutoTokenizer.from_pretrained(model_name)

Então você pode especificar o modelo e o tokenizador na pipeline() e aplicar o classifier no seu texto alvo:

>>> classifier = pipeline("sentiment-analysis", model=model, tokenizer=tokenizer)
>>> classifier("Nous sommes très heureux de vous présenter la bibliothèque 🤗 Transformers.")
[{'label': '5 stars', 'score': 0.7273}]

Se você não conseguir achar um modelo para o seu caso de uso, precisará usar fine-tune em um modelo pré-treinado nos seus dados. Veja nosso tutorial de fine-tuning para descobrir como. Finalmente, depois que você tiver usado esse processo em seu modelo, considere compartilhá-lo conosco (veja o tutorial aqui) na plataforma Model Hub afim de democratizar NLP! 🤗

AutoClass

Por baixo dos panos, as classes AutoModelForSequenceClassification e AutoTokenizer trabalham juntas para fortificar o pipeline(). Um AutoClass é um atalho que automaticamente recupera a arquitetura de um modelo pré-treinado a partir de seu nome ou caminho. Basta selecionar a AutoClass apropriada para sua tarefa e seu tokenizer associado com AutoTokenizer.

Vamos voltar ao nosso exemplo e ver como você pode usar a AutoClass para replicar os resultados do pipeline().

AutoTokenizer

Um tokenizer é responsável por pré-processar o texto em um formato que seja compreensível para o modelo. Primeiro, o tokenizer dividirá o texto em palavras chamadas tokens. Existem várias regras que regem o processo de tokenização, incluindo como dividir uma palavra e em que nível (saiba mais sobre tokenização aqui). A coisa mais importante a lembrar, porém, é que você precisa instanciar o tokenizer com o mesmo nome do modelo para garantir que está usando as mesmas regras de tokenização com as quais um modelo foi pré-treinado.

Carregue um tokenizer com AutoTokenizer:

>>> from transformers import AutoTokenizer

>>> model_name = "nlptown/bert-base-multilingual-uncased-sentiment"
>>> tokenizer = AutoTokenizer.from_pretrained(model_name)

Em seguida, o tokenizer converte os tokens em números para construir um tensor como entrada para o modelo. Isso é conhecido como o vocabulário do modelo.

Passe o texto para o tokenizer:

>>> encoding = tokenizer("We are very happy to show you the 🤗 Transformers library.")
>>> print(encoding)
{'input_ids': [101, 11312, 10320, 12495, 19308, 10114, 11391, 10855, 10103, 100, 58263, 13299, 119, 102],
 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}

O tokenizer retornará um dicionário contendo:

• input_ids: representações numéricas de seus tokens.
• atttention_mask: indica quais tokens devem ser atendidos.

Assim como o pipeline(), o tokenizer aceitará uma lista de entradas. Além disso, o tokenizer também pode preencher e truncar o texto para retornar um lote com comprimento uniforme:

>>> pt_batch = tokenizer(
...     ["We are very happy to show you the 🤗 transformers library.", "We hope you don't hate it."],
...     padding=True,
...     truncation=True,
...     max_length=512,
...     return_tensors="pt",
... )

>>> tf_batch = tokenizer(
...     ["We are very happy to show you the 🤗 Transformers library.", "We hope you don't hate it."],
...     padding=True,
...     truncation=True,
...     max_length=512,
...     return_tensors="tf",
... )

Leia o tutorial de pré-processamento para obter mais detalhes sobre tokenização.

AutoModel

>>> from transformers import AutoModelForSequenceClassification

>>> model_name = "nlptown/bert-base-multilingual-uncased-sentiment"
>>> pt_model = AutoModelForSequenceClassification.from_pretrained(model_name)

>>> pt_outputs = pt_model(**pt_batch)

>>> from torch import nn

>>> pt_predictions = nn.functional.softmax(pt_outputs.logits, dim=-1)
>>> print(pt_predictions)
tensor([[0.0021, 0.0018, 0.0115, 0.2121, 0.7725],
        [0.2084, 0.1826, 0.1969, 0.1755, 0.2365]], grad_fn=<SoftmaxBackward0>)

>>> from transformers import TFAutoModelForSequenceClassification

>>> model_name = "nlptown/bert-base-multilingual-uncased-sentiment"
>>> tf_model = TFAutoModelForSequenceClassification.from_pretrained(model_name)

>>> tf_outputs = tf_model(tf_batch)

>>> import tensorflow as tf

>>> tf_predictions = tf.nn.softmax(tf_outputs.logits, axis=-1)
>>> tf_predictions

Os modelos são um standard torch.nn.Module ou um tf.keras.Model para que você possa usá-los em seu loop de treinamento habitual. No entanto, para facilitar as coisas, 🤗 Transformers fornece uma classe Trainer para PyTorch que adiciona funcionalidade para treinamento distribuído, precisão mista e muito mais. Para o TensorFlow, você pode usar o método fit de Keras. Consulte o tutorial de treinamento para obter mais detalhes.

Salvar um modelo

>>> pt_save_directory = "./pt_save_pretrained"
>>> tokenizer.save_pretrained(pt_save_directory)
>>> pt_model.save_pretrained(pt_save_directory)

>>> pt_model = AutoModelForSequenceClassification.from_pretrained("./pt_save_pretrained")

>>> tf_save_directory = "./tf_save_pretrained"
>>> tokenizer.save_pretrained(tf_save_directory)
>>> tf_model.save_pretrained(tf_save_directory)

>>> tf_model = TFAutoModelForSequenceClassification.from_pretrained("./tf_save_pretrained")

Um recurso particularmente interessante dos 🤗 Transformers é a capacidade de salvar um modelo e recarregá-lo como um modelo PyTorch ou TensorFlow. Use from_pt ou from_tf para converter o modelo de um framework para outro:

>>> from transformers import AutoModel

>>> tokenizer = AutoTokenizer.from_pretrained(tf_save_directory)
>>> pt_model = AutoModelForSequenceClassification.from_pretrained(tf_save_directory, from_tf=True)

>>> from transformers import TFAutoModel

>>> tokenizer = AutoTokenizer.from_pretrained(pt_save_directory)
>>> tf_model = TFAutoModelForSequenceClassification.from_pretrained(pt_save_directory, from_pt=True)