Pipeline

Pipeline este un API de inferență simplu, dar puternic, disponibil imediat pentru o varietate de task-uri de machine learning cu orice model din Hugging Face Hub.

Adaptează Pipeline la task-ul tău cu parametri specifici task-ului, precum adăugarea de timestamp-uri la un pipeline de automatic speech recognition (ASR) pentru transcrierea notițelor de ședință. Pipeline suportă GPU-uri, Apple Silicon și weights cu precizie redusă (half-precision) pentru a accelera inferența și a economisi memorie.

Transformers are două clase de pipeline, un Pipeline generic și multe pipeline-uri individuale specifice task-ului precum TextGenerationPipeline. Încarcă aceste pipeline-uri individuale setând identificatorul task-ului în parametrul task din Pipeline. Poți găsi identificatorul task-ului pentru fiecare pipeline în documentația lor API.

Fiecare task este configurat să folosească un model preantrenat și un preprocesor implicit, dar acest lucru poate fi suprascris cu parametrul model dacă vrei să folosești un alt model.

De exemplu, pentru a folosi TextGenerationPipeline cu [Gemma 2], setează task="text-generation" și 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'}]

Când ai mai mult de un input, transmite-le ca listă.

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

Acest ghid îți va prezenta Pipeline, îți va demonstra funcționalitățile sale și îți va arăta cum să configurezi diferiții săi parametri.

Task-uri

Pipeline este compatibil cu multe task-uri de machine learning din diferite modalități. Transmite un input potrivit către pipeline și acesta se va ocupa de restul.

Iată câteva exemple despre cum să folosești Pipeline pentru diferite task-uri și modalități.

automatic speech recognition

image classification

visual question answering

Parametri

La minimum, Pipeline necesită doar un identificator de task, un model și input-ul potrivit. Dar există mulți parametri disponibili pentru a configura pipeline-ul, de la parametri specifici task-ului până la optimizarea performanței.

Această secțiune îți prezintă câțiva dintre cei mai importanți parametri.

Device

Pipeline este compatibil cu multe tipuri de hardware, inclusiv GPU-uri, CPU-uri, Apple Silicon și altele. Configurează tipul de hardware cu parametrul device. Implicit, Pipeline rulează pe un CPU, ceea ce este indicat de device=-1.

GPU

Apple silicon

Inferență în batch-uri

Pipeline poate procesa și batch-uri de input-uri cu parametrul batch_size. Inferența în batch-uri poate îmbunătăți viteza, în special pe un GPU, dar acest lucru nu este garantat. Alte variabile precum hardware-ul, datele și modelul în sine pot afecta dacă inferența în batch-uri îmbunătățește viteza. Din acest motiv, inferența în batch-uri este dezactivată implicit.

În exemplul de mai jos, când există 4 input-uri și batch_size este setat la 2, Pipeline transmite modelului câte un batch de 2 input-uri pe rând.

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

Un alt caz de utilizare bun pentru inferența în batch-uri este transmiterea de date în flux (streaming) în Pipeline.

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

device = Accelerator().device

# KeyDataset este un utilitar care returnează elementul din dict-ul returnat de dataset
dataset = datasets.load_dataset("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)

Ține cont de următoarele reguli generale pentru a determina dacă inferența în batch-uri poate ajuta la îmbunătățirea performanței.

Singura modalitate de a ști sigur este să măsori performanța pe modelul, datele și hardware-ul tău.
Nu folosi inferența în batch-uri dacă ești constrâns de latență (de exemplu, un produs de inferență live).
Nu folosi inferența în batch-uri dacă folosești un CPU.
Nu folosi inferența în batch-uri dacă nu cunoști sequence_length al datelor tale. Măsoară performanța, crește iterativ sequence_length și include verificări out-of-memory (OOM) pentru a te recupera din eșecuri.
Folosește inferența în batch-uri dacă sequence_length este regulat și continuă să îl crești până când ajungi la o eroare OOM. Cu cât GPU-ul este mai mare, cu atât inferența în batch-uri este mai utilă.
Asigură-te că poți gestiona erorile OOM dacă decizi să folosești inferența în batch-uri.

Parametri specifici task-ului

Pipeline acceptă orice parametri care sunt suportați de fiecare pipeline individual de task. Asigură-te că verifici fiecare pipeline individual de task pentru a vedea ce tip de parametri sunt disponibili. Dacă nu găsești un parametru util pentru cazul tău de utilizare, nu ezita să deschizi un issue pe GitHub pentru a-l solicita!

Exemplele de mai jos demonstrează unii dintre parametrii specifici task-ului disponibili.

automatic speech recognition

text generation

Chunk batching

Există unele situații în care trebuie să procesezi datele în chunk-uri.

pentru unele tipuri de date, un singur input (de exemplu, un fișier audio foarte lung) poate fi nevoie să fie împărțit în mai multe părți (chunk-uri) înainte de a putea fi procesat
pentru unele task-uri, precum clasificarea zero-shot sau question answering, un singur input poate necesita mai multe forward pass-uri, ceea ce poate cauza probleme cu parametrul batch_size

Clasa ChunkPipeline este concepută pentru a gestiona aceste cazuri de utilizare. Ambele clase de pipeline sunt folosite în același mod, dar deoarece ChunkPipeline poate gestiona automat batching-ul, nu trebuie să-ți faci griji cu privire la numărul de forward pass-uri pe care le declanșează input-urile tale. În schimb, poți optimiza batch_size independent de input-uri.

Exemplul de mai jos arată cum diferă 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)

Seturi de date mari

Pentru inferență cu seturi de date mari, poți itera direct peste setul de date în sine. Acest lucru evită alocarea imediată de memorie pentru întregul set de date și nu trebuie să-ți faci griji cu privire la crearea de batch-uri manual. Încearcă Inferența în batch-uri cu parametrul batch_size pentru a vedea dacă îmbunătățește performanța.

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

device = Accelerator().device

dataset = datasets.load_dataset("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)

Alte modalități de a rula inferența pe seturi de date mari cu Pipeline includ folosirea unui iterator sau generator.

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

Modele mari

Accelerate activează câteva optimizări pentru rularea modelelor mari cu Pipeline. Asigură-te mai întâi că Accelerate este instalat.

!pip install -U accelerate

Setarea device_map="auto" este utilă pentru a distribui automat modelul mai întâi pe cele mai rapide device-uri (GPU-uri) înainte de a-l trimite către alte device-uri mai lente, dacă sunt disponibile (CPU, hard drive).

Pipeline suportă weights cu precizie redusă (torch.float16), care pot fi semnificativ mai rapide și economisesc memorie. Pierderea de performanță este neglijabilă pentru majoritatea modelelor, în special pentru cele mai mari. Dacă hardware-ul tău suportă acest lucru, poți activa în schimb torch.bfloat16 pentru un interval mai mare.

Input-urile sunt convertite intern la torch.float16 și funcționează doar pentru modele cu un backend PyTorch.

În cele din urmă, Pipeline acceptă și modele cuantizate pentru a reduce și mai mult utilizarea memoriei. Asigură-te mai întâi că ai instalată biblioteca bitsandbytes, iar apoi adaugă quantization_config în model_kwargs în 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