Pipeline

El Pipeline es una API de inferencia simple pero potente, disponible de inmediato para una amplia variedad de tareas de aprendizaje automático con cualquier modelo del Hub de Hugging Face.

Adapta el Pipeline a tu tarea mediante parámetros específicos, como añadir marcas de tiempo a un pipeline de reconocimiento automático de voz (ASR) para transcribir notas de reuniones. Pipeline admite GPUs, Apple Silicon y pesos de media precisión para acelerar la inferencia y ahorrar memoria.

Transformers tiene dos clases de pipeline: el Pipeline genérico y muchos pipelines específicos para cada tarea, como TextGenerationPipeline. Cargue estos pipelines individuales estableciendo el identificador de la tarea en el parámetro task de Pipeline. Puede encontrar el identificador de la tarea de cada pipeline en su documentación de la API.

Cada tarea se configura para usar un modelo y un preprocesador preentrenados por defecto, pero esto se puede sobrescribir con el parámetro model si se desea utilizar un modelo diferente.

Por ejemplo, para usar TextGenerationPipeline con Gemma 2, establece task="text-generation" y model="google/gemma-2-2b".

from transformers import pipeline

pipeline = pipeline(task="text-generation", model="google/gemma-2-2b")
pipeline("the secret to baking a really good cake is ")
[{'generated_text': 'the secret to baking a really good cake is 1. the right ingredients 2. the'}]

Cuando tiene más de una entrada, páselas como una lista.

from transformers import pipeline
from accelerate import Accelerator

device = Accelerator().device

pipeline = pipeline(task="text-generation", model="google/gemma-2-2b", device=device)
pipeline(["the secret to baking a really good cake is ", "a baguette is "])
[[{'generated_text': 'the secret to baking a really good cake is 1. the right ingredients 2. the'}],
 [{'generated_text': 'a baguette is 100% bread.\n\na baguette is 100%'}]]

Esta guía le presentará el Pipeline, le mostrará sus características y le explicará cómo configurar sus diversos parámetros.

Tareas

Pipeline es compatible con muchas tareas de aprendizaje automático en distintas modalidades. Pasa una entrada adecuada a la pipeline y esta se encargará del resto.

A continuación se muestran algunos ejemplos de cómo usar Pipeline para diferentes tareas y modalidades.

reconocimiento automático del habla

clasificación de imágenes

visual question answering

Parámetros

Como mínimo, Pipeline solo requiere un identificador de tarea, un modelo y la entrada adecuada. Sin embargo, hay muchos parámetros disponibles para configurar el pipeline, desde parámetros específicos de la tarea hasta la optimización del rendimiento.

Esta sección le presenta algunos de los parámetros más importantes.

Dispositivo

Pipeline es compatible con muchos tipos de hardware, incluidas GPUs, CPUs, Apple Silicon y más. Configure el tipo de hardware con el parámetro device. De forma predeterminada, cuando device no se establece, Pipeline coloca automáticamente el modelo en el primer acelerador disponible (GPU CUDA, Apple Silicon MPS, XPU, …) y solo recurre a una CPU si no hay ninguno disponible. Pase device="cpu" para forzar su ejecución en una CPU.

GPU

Apple silicon

Inferencia por lotes

Pipeline también puede procesar lotes de entradas con el parámetro batch_size. La inferencia por lotes puede mejorar la velocidad, especialmente en una GPU, pero no está garantizado. Otras variables, como el hardware, los datos y el propio modelo, pueden influir en si la inferencia por lotes mejora la velocidad. Por esta razón, la inferencia por lotes está desactivada de forma predeterminada.

En el ejemplo siguiente, cuando hay 4 entradas y batch_size está establecido en 2, Pipeline pasa al modelo un lote de 2 entradas a la vez.

from transformers import pipeline
from accelerate import Accelerator

device = Accelerator().device

pipeline = pipeline(task="text-generation", model="google/gemma-2-2b", device=device, batch_size=2)
pipeline(["the secret to baking a really good cake is", "a baguette is", "paris is the", "hotdogs are"])
[[{'generated_text': 'the secret to baking a really good cake is to use a good cake mix.\n\ni’'}],
 [{'generated_text': 'a baguette is'}],
 [{'generated_text': 'paris is the most beautiful city in the world.\n\ni’ve been to paris 3'}],
 [{'generated_text': 'hotdogs are a staple of the american diet. they are a great source of protein and can'}]]

Otro buen caso de uso para la inferencia por lotes es el streaming de datos en Pipeline.

from transformers import pipeline
from accelerate import Accelerator
from transformers.pipelines.pt_utils import KeyDataset
import datasets

device = Accelerator().device

# KeyDataset is a utility that returns the item in the dict returned by the dataset
dataset = load_dataset("stanfordnlp/imdb", name="plain_text", split="unsupervised")
pipeline = pipeline(task="text-classification", model="distilbert/distilbert-base-uncased-finetuned-sst-2-english", device=device)
for out in pipeline(KeyDataset(dataset, "text"), batch_size=8, truncation="only_first"):
    print(out)

Tenga en cuenta las siguientes reglas generales para determinar si la inferencia por lotes puede ayudar a mejorar el rendimiento.

La única forma de estar seguro es medir el rendimiento en tu modelo, tus datos y tu hardware.
No realices inferencia por lotes si tienes restricciones de latencia (por ejemplo, un producto de inferencia en vivo).
No realices inferencias por lotes si estás usando una CPU.
No realices inferencia por lotes si no conoces el sequence_length de tus datos. Mide el rendimiento, aumenta sequence_length de forma iterativa e incluye comprobaciones de memoria insuficiente (OOM) para recuperarte de los fallos.
Realiza inferencia por lotes si tu sequence_length es regular y sigue aumentándola hasta que aparezca un error de OOM. Cuanto mayor sea la GPU, más útil resulta la inferencia por lotes.
Asegúrate de poder manejar errores de OOM si decides realizar inferencia por lotes.

Parámetros específicos de la tarea

Pipeline acepta cualquier parámetro que sea compatible con cada pipeline de tarea individual. Asegúrate de consultar cada pipeline de tarea individual para ver qué tipo de parámetros están disponibles. Si no encuentras un parámetro que sea útil para tu caso de uso, no dudes en abrir un issue en GitHub para solicitarlo.

Los ejemplos a continuación demuestran algunos de los parámetros específicos de la tarea disponibles.

reconocimiento automático del habla

generación de texto

Lote de fragmentos

Hay casos en los que necesitas procesar los datos en bloques.

para algunos tipos de datos, una única entrada (por ejemplo, un archivo de audio muy largo) puede necesitar dividirse en varias partes antes de poder procesarse
para algunas tareas, como la clasificación zero-shot o la respuesta a preguntas, una sola entrada puede requerir múltiples pases hacia adelante, lo que puede causar problemas con el parámetro batch_size

La clase ChunkPipeline está diseñada para manejar estos casos de uso. Ambas clases de pipeline se utilizan de la misma manera, pero como ChunkPipeline puede manejar el batching de forma automática, no es necesario preocuparse por el número de pases hacia adelante que provocan las entradas. En su lugar, se puede optimizar batch_size de forma independiente a las entradas.

El siguiente ejemplo muestra en qué se diferencia de Pipeline.

# ChunkPipeline
all_model_outputs = []
for preprocessed in pipeline.preprocess(inputs):
    model_outputs = pipeline.model_forward(preprocessed)
    all_model_outputs.append(model_outputs)
outputs =pipeline.postprocess(all_model_outputs)

# Pipeline
preprocessed = pipeline.preprocess(inputs)
model_outputs = pipeline.forward(preprocessed)
outputs = pipeline.postprocess(model_outputs)

Conjuntos de datos grandes

Para la inferencia con conjuntos de datos grandes, puedes iterar directamente sobre el propio conjunto de datos. Esto evita asignar memoria de inmediato para todo el conjunto de datos y no necesitas preocuparte por crear lotes por tu cuenta. Prueba inferencia por lotes con el parámetro batch_size para ver si mejora el rendimiento.

from transformers.pipelines.pt_utils import KeyDataset
from transformers import pipeline
from accelerate import Accelerator
from datasets import load_dataset

device = Accelerator().device

dataset = load_dataset("stanfordnlp/imdb", name="plain_text", split="unsupervised")
pipeline = pipeline(task="text-classification", model="distilbert/distilbert-base-uncased-finetuned-sst-2-english", device=device)
for out in pipeline(KeyDataset(dataset, "text"), batch_size=8, truncation="only_first"):
    print(out)

Otras formas de ejecutar inferencia en conjuntos de datos grandes con Pipeline incluyen el uso de un iterador o un generador.

def data():
    for i in range(1000):
        yield f"My example {i}"

pipeline = pipeline(model="openai-community/gpt2", device=0)
generated_characters = 0
for out in pipeline(data()):
    generated_characters += len(out[0]["generated_text"])

Modelos grandes

Accelerate habilita algunas optimizaciones para ejecutar modelos grandes con Pipeline. Asegúrate de que Accelerate esté instalado primero.

!pip install -U accelerate

La configuración device_map="auto" es útil para distribuir automáticamente el modelo primero en los dispositivos más rápidos (GPUs) y, si están disponibles, en otros dispositivos más lentos (CPU, disco duro).

Pipeline admite pesos de media precisión (torch.float16), lo que puede ser significativamente más rápido y ahorrar memoria. La pérdida de rendimiento es despreciable para la mayoría de los modelos, especialmente para los más grandes. Si tu hardware lo permite, puedes habilitar torch.bfloat16 en su lugar para obtener un mayor rango.

Las entradas se convierten internamente a torch.float16 y solo funciona con modelos que tienen un backend de PyTorch.

Por último, Pipeline también acepta modelos cuantizados para reducir aún más el uso de memoria. Asegúrate de tener instalada la biblioteca bitsandbytes primero y, a continuación, añade quantization_config a model_kwargs en el pipeline.

import torch
from transformers import pipeline, BitsAndBytesConfig

pipeline = pipeline(model="google/gemma-7b", dtype=torch.bfloat16, device_map="auto", model_kwargs={"quantization_config": BitsAndBytesConfig(load_in_8bit=True)})
pipeline("the secret to baking a good cake is ")
[{'generated_text': 'the secret to baking a good cake is 1. the right ingredients 2. the right'}]

Update on GitHub