Tour rápido

¡Entra en marcha con los 🤗 Transformers! Comienza usando pipeline() para una inferencia veloz, carga un modelo preentrenado y un tokenizador con una AutoClass para resolver tu tarea de texto, visión o audio.

Pipeline

pipeline() es la forma más fácil de usar un modelo preentrenado para una tarea dada.

El pipeline() soporta muchas tareas comunes listas para usar:

Texto:

• Análisis de Sentimiento (Sentiment Analysis, en inglés): clasifica la polaridad de un texto dado.
• Generación de Texto (Text Generation, en inglés): genera texto a partir de un input dado.
• Reconocimiento de Entidades (Name Entity Recognition o NER, en inglés): etiqueta cada palabra con la entidad que representa (persona, fecha, ubicación, etc.).
• Responder Preguntas (Question answering, en inglés): extrae la respuesta del contexto dado un contexto y una pregunta.
• Rellenar Máscara (Fill-mask, en inglés): rellena el espacio faltante dado un texto con palabras enmascaradas.
• Resumir (Summarization, en inglés): genera un resumen de una secuencia larga de texto o un documento.
• Traducción (Translation, en inglés): traduce un texto a otro idioma.
• Extracción de Características (Feature Extraction, en inglés): crea una representación tensorial del texto.

Imagen:

• Clasificación de Imágenes (Image Classification, en inglés): clasifica una imagen.
• Segmentación de Imágenes (Image Segmentation, en inglés): clasifica cada pixel de una imagen.
• Detección de Objetos (Object Detection, en inglés): detecta objetos dentro de una imagen.

Audio:

• Clasificación de Audios (Audio Classification, en inglés): asigna una etiqueta a un segmento de audio.
• Reconocimiento de Voz Automático (Automatic Speech Recognition o ASR, en inglés): transcribe datos de audio a un texto.

Uso del Pipeline

En el siguiente ejemplo, usarás el pipeline() para análisis de sentimiento.

Instala las siguientes dependencias si aún no lo has hecho:

pip install torch

pip install tensorflow

Importa pipeline() y especifica la tarea que deseas completar:

>>> from transformers import pipeline

>>> clasificador = pipeline("sentiment-analysis", model="pysentimiento/robertuito-sentiment-analysis")

El pipeline descarga y almacena en caché el modelo preentrenado y tokeniza para análisis de sentimiento. Si no hubieramos elegido un modelo el pipeline habría elegido uno por defecto. Ahora puedes usar clasificador en tu texto objetivo:

>>> clasificador("Estamos muy felices de mostrarte la biblioteca de 🤗 Transformers.")
[{'label': 'POS', 'score': 0.9916}]

Para más de un enunciado, entrega una lista al pipeline() que devolverá una lista de diccionarios:

El pipeline() también puede iterar sobre un dataset entero. Comienza instalando la biblioteca 🤗 Datasets:

pip install datasets

Crea un pipeline() con la tarea que deseas resolver y el modelo que quieres usar. Coloca el parámetro device a 0 para poner los tensores en un dispositivo CUDA:

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

>>> reconocedor_de_voz = pipeline(
...     "automatic-speech-recognition", model="jonatasgrosman/wav2vec2-large-xlsr-53-spanish", device=0
... )

A continuación, carga el dataset (ve 🤗 Datasets Quick Start para más detalles) sobre el que quisieras iterar. Por ejemplo, vamos a cargar el dataset MInDS-14:

>>> from datasets import load_dataset, Audio

>>> dataset = load_dataset("PolyAI/minds14", name="es-ES", split="train")

Debemos asegurarnos de que la frecuencia de muestreo del conjunto de datos coincide con la frecuencia de muestreo con la que se entrenó jonatasgrosman/wav2vec2-large-xlsr-53-spanish.

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

Los archivos de audio se cargan y remuestrean automáticamente cuando llamamos a la columna "audio". Extraigamos las matrices de onda cruda (raw waveform, en inglés) de las primeras 4 muestras y pasémosla como una lista al pipeline:

>>> resultado = reconocedor_de_voz(dataset[:4]["audio"])
>>> print([d["text"] for d in resultado])
['ahora buenas e a ver  tengo un problema como vuestra aplicación resulta que que quiero hacer una transferencia bancaria a una cuenta conocida pero me da error la aplicación a ver que a ver que puede ser', 'la aplicación no cargue salda de mi nueva cuenta', 'hola tengo un problema con la aplicación no carga y y tampoco veo que carga el saldo de mi cuenta nueva dice que la aplicación está siendo reparada y ahora no puedo aceder a mi cuenta no necesito inmediatamente', 'ora buena la aplicación no se carga la viladad no carga el saldo de mi cuenta nueva dice que la villadenta siendo reparada y oro no puede hacer a mi cuenta']

Para un dataset más grande, donde los inputs son de mayor tamaño (como en habla/audio o visión), querrás pasar un generador en lugar de una lista que carga todos los inputs en memoria. Ve la documentación del pipeline para más información.

Usa otro modelo y otro tokenizador en el pipeline

El pipeline() puede acomodarse a cualquier modelo del Model Hub haciendo más fácil adaptar el pipeline() para otros casos de uso. Por ejemplo, si quisieras un modelo capaz de manejar texto en francés, usa los tags en el Model Hub para filtrar entre los modelos apropiados. El resultado mejor filtrado devuelve un modelo BERT multilingual fine-tuned para el análisis de sentimiento. Genial, ¡vamos a 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)

Después puedes especificar el modelo y el tokenizador en el pipeline(), y aplicar el classifier en tu texto objetivo:

>>> 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}]

Si no pudieras encontrar el modelo para tu caso respectivo de uso necesitarás ajustar un modelo preentrenado a tus datos. Mira nuestro tutorial de fine-tuning para aprender cómo. Finalmente, después de que has ajustado tu modelo preentrenado, ¡por favor considera compartirlo (ve el tutorial aquí) con la comunidad en el Model Hub para democratizar el NLP! 🤗

AutoClass

Por debajo, las clases AutoModelForSequenceClassification y AutoTokenizer trabajan juntas para dar poder al pipeline(). Una AutoClass es un atajo que automáticamente recupera la arquitectura de un modelo preentrenado con su nombre o el path. Sólo necesitarás seleccionar el AutoClass apropiado para tu tarea y tu tokenizador asociado con AutoTokenizer.

Regresemos a nuestro ejemplo y veamos cómo puedes usar el AutoClass para reproducir los resultados del pipeline().

AutoTokenizer

Un tokenizador es responsable de procesar el texto a un formato que sea entendible para el modelo. Primero, el tokenizador separará el texto en palabras llamadas tokens. Hay múltiples reglas que gobiernan el proceso de tokenización incluyendo el cómo separar una palabra y en qué nivel (aprende más sobre tokenización aquí). Lo más importante es recordar que necesitarás instanciar el tokenizador con el mismo nombre del modelo para asegurar que estás usando las mismas reglas de tokenización con las que el modelo fue preentrenado.

Carga un tokenizador con AutoTokenizer:

>>> from transformers import AutoTokenizer

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

Después, el tokenizador convierte los tokens a números para construir un tensor que servirá como input para el modelo. Esto es conocido como el vocabulario del modelo.

Pasa tu texto al tokenizador:

>>> encoding = tokenizer("Estamos muy felices de mostrarte la biblioteca de 🤗 Transformers.")
>>> print(encoding)
{'input_ids': [101, 10602, 14000, 13653, 43353, 10107, 10102, 47201, 10218, 10106, 18283, 10102, 100, 58263, 119, 102],
 'token_type_ids': [0, 0, 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, 1, 1]}

El tokenizador devolverá un diccionario conteniendo:

• input_ids: representaciones numéricas de los tokens.
• atttention_mask: indica cuáles tokens deben ser atendidos.

Como con el pipeline(), el tokenizador aceptará una lista de inputs. Además, el tokenizador también puede rellenar (pad, en inglés) y truncar el texto para devolver un lote (batch, en inglés) de longitud 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",
... )

Lee el tutorial de preprocessing para más detalles acerca de la tokenización.

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)
>>> print(tf.math.round(tf_predictions * 10**4) / 10**4)
tf.Tensor(
[[0.0021 0.0018 0.0116 0.2121 0.7725]
 [0.2084 0.1826 0.1969 0.1755  0.2365]], shape=(2, 5), dtype=float32)

Los modelos son torch.nn.Module o tf.keras.Model estándares así que podrás usarlos en tu training loop usual. Sin embargo, para facilitar las cosas, 🤗 Transformers provee una clase Trainer para PyTorch que añade funcionalidades para entrenamiento distribuido, precición mixta, y más. Para TensorFlow, puedes usar el método fit desde Keras. Consulta el tutorial de entrenamiento para más detalles.

Guarda un 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")

Una característica particularmente interesante de 🤗 Transformers es la habilidad de guardar el modelo y cargarlo como un modelo de PyTorch o TensorFlow. El parámetro from_pt o from_tf puede convertir el modelo de un framework al otro:

>>> 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)