Hugging Face's logo

Transformers documentation

Pipelines

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Pipelines

Les pipelines constituent une excellente et simple manière d'utiliser des modèles pour l'inférence. Ces pipelines sont des objets qui abstraient la majeure partie du code complexe de la bibliothèque, offrant une API simple dédiée à plusieurs tâches, notamment la reconnaissance d'entités nommées, le modélisation de langage masquée, l'analyse de sentiments, l'extraction de caractéristiques et la réponse aux questions. Consultez la liste des tâches pour des exemples d'utilisation.

Il existe deux catégories d'abstractions de pipeline à connaître :

L'abstraction de pipeline

L'abstraction pipeline est un wrapper autour de tous les autres pipelines disponibles. Elle est instanciée comme n'importe quel autre pipeline, mais peut offrir un confort d'utilisation supplémentaire.

Appel simple sur un élément :

>>> pipe = pipeline("text-classification")
>>> pipe("This restaurant is awesome")
[{'label': 'POSITIVE', 'score': 0.9998743534088135}]

Si vous souhaitez utiliser un modèle spécifique du hub, vous pouvez ignorer la tâche si le modèle sur le hub la définit déjà :

>>> pipe = pipeline(model="FacebookAI/roberta-large-mnli")
>>> pipe("This restaurant is awesome")
[{'label': 'NEUTRAL', 'score': 0.7313136458396912}]

Pour appeler un pipeline sur de nombreux éléments, vous pouvez l'appeler avec une list.

>>> pipe = pipeline("text-classification")
>>> pipe(["This restaurant is awesome", "This restaurant is awful"])
[{'label': 'POSITIVE', 'score': 0.9998743534088135},
 {'label': 'NEGATIVE', 'score': 0.9996669292449951}]

Pour parcourir des jeux de données complets, il est recommandé d’utiliser directement un dataset. Cela signifie qu’il n’est pas nécessaire d’allouer l’ensemble du jeu de données d’un coup, ni de gérer le batch processing vous-même. Cette approche devrait être aussi rapide que des boucles personnalisées sur GPU. Si ce n’est pas le cas, n’hésitez pas à ouvrir un ticket.

import datasets
from transformers import pipeline
from transformers.pipelines.pt_utils import KeyDataset
from tqdm.auto import tqdm

pipe = pipeline("automatic-speech-recognition", model="facebook/wav2vec2-base-960h", device=0)
dataset = datasets.load_dataset("s3prl/superb", name="asr", split="test")

# KeyDataset (only *pt*) will simply return the item in the dict returned by the dataset item
# as we're not interested in the *target* part of the dataset. For sentence pair use KeyPairDataset
for out in tqdm(pipe(KeyDataset(dataset, "file"))):
    print(out)
    # {"text": "NUMBER TEN FRESH NELLY IS WAITING ON YOU GOOD NIGHT HUSBAND"}
    # {"text": ....}
    # ....

Pour plus de facilité, un générateur est également possible :

from transformers import pipeline

pipe = pipeline("text-classification")


def data():
    while True:
        # This could come from a dataset, a database, a queue or HTTP request
        # in a server
        # Caveat: because this is iterative, you cannot use `num_workers > 1` variable
        # to use multiple threads to preprocess data. You can still have 1 thread that
        # does the preprocessing while the main runs the big inference
        yield "This is a test"


for out in pipe(data()):
    print(out)
    # {"text": "NUMBER TEN FRESH NELLY IS WAITING ON YOU GOOD NIGHT HUSBAND"}
    # {"text": ....}
    # ....

transformers.pipeline

< >

( task: str | None = Nonemodel: str | PreTrainedModel | None = Noneconfig: str | PreTrainedConfig | None = Nonetokenizer: str | PreTrainedTokenizer | PreTrainedTokenizerFast | None = Nonefeature_extractor: str | FeatureExtractionMixin | None = Noneimage_processor: str | BaseImageProcessor | None = Nonevideo_processor: str | BaseVideoProcessor | None = Noneprocessor: str | ProcessorMixin | None = Nonerevision: str | None = Noneuse_fast: bool = Truetoken: str | bool | None = Nonedevice: int | str | torch.device | None = Nonedevice_map: str | dict[str, int | str] | None = Nonedtype: str | torch.dtype | None = 'auto'trust_remote_code: bool | None = Nonemodel_kwargs: dict[str, Any] | None = Nonepipeline_class: Any | None = None**kwargs: Any ) → Pipeline

Paramètres

Retourne

Pipeline

Un pipeline adapté à la tâche.

Méthode d'usine utilitaire pour construire un Pipeline.

Un pipeline se compose de :

  • Un ou plusieurs composants de prétraitement des entrées du modèle, tels qu'un tokenizer, un image_processor, un feature_extractor ou un processor.
  • Un modèle qui génère des prédictions à partir des entrées.
  • Étapes de post-traitement facultatives pour affiner la sortie du modèle, qui peuvent également être gérées par des processeurs.
While there are such optional arguments as `tokenizer`, `feature_extractor`, `image_processor`, and `processor`, they shouldn't be specified all at once. If these components are not provided, `pipeline` will try to load required ones automatically. In case you want to provide these components explicitly, please refer to a specific pipeline in order to get more details regarding what components are required.

Exemples :

>>> from transformers import pipeline, AutoModelForTokenClassification, AutoTokenizer

>>> # Sentiment analysis pipeline
>>> analyzer = pipeline("sentiment-analysis")

>>> # Named entity recognition pipeline, passing in a specific model and tokenizer
>>> model = AutoModelForTokenClassification.from_pretrained("dbmdz/bert-large-cased-finetuned-conll03-english")
>>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-cased")
>>> recognizer = pipeline("ner", model=model, tokenizer=tokenizer)

Batching de pipeline

Tous les pipelines peuvent utiliser le lotissement (batching). Cela fonctionne chaque fois que le pipeline utilise sa capacité de flux (streaming) (donc lors du passage de listes ou de Dataset ou de generator).

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

dataset = datasets.load_dataset("stanfordnlp/imdb", name="plain_text", split="unsupervised")
pipe = pipeline("text-classification", device=0)
for out in pipe(KeyDataset(dataset, "text"), batch_size=8, truncation="only_first"):
    print(out)
    # [{'label': 'POSITIVE', 'score': 0.9998743534088135}]
    # Exactly the same output as before, but the content are passed
    # as batches to the model

Cependant, cela ne se traduit pas automatiquement par un gain de performance. Selon le matériel, les données et le modèle réellement utilisé, il peut s’agir d’un gain de vitesse de 10x ou d’un ralentissement de 5x.

Exemple où il s’agit principalement d’un gain de vitesse :

from transformers import pipeline
from torch.utils.data import Dataset
from tqdm.auto import tqdm

pipe = pipeline("text-classification", device=0)


class MyDataset(Dataset):
    def __len__(self):
        return 5000

    def __getitem__(self, i):
        return "This is a test"


dataset = MyDataset()

for batch_size in [1, 8, 64, 256]:
    print("-" * 30)
    print(f"Streaming batch_size={batch_size}")
    for out in tqdm(pipe(dataset, batch_size=batch_size), total=len(dataset)):
        pass
# On GTX 970
------------------------------
Streaming no batching
100%|██████████████████████████████████████████████████████████████████████| 5000/5000 [00:26<00:00, 187.52it/s]
------------------------------
Streaming batch_size=8
100%|█████████████████████████████████████████████████████████████████████| 5000/5000 [00:04<00:00, 1205.95it/s]
------------------------------
Streaming batch_size=64
100%|█████████████████████████████████████████████████████████████████████| 5000/5000 [00:02<00:00, 2478.24it/s]
------------------------------
Streaming batch_size=256
100%|█████████████████████████████████████████████████████████████████████| 5000/5000 [00:01<00:00, 2554.43it/s]
(diminishing returns, saturated the GPU)

Exemple où il s’agit principalement d’un ralentissement :

class MyDataset(Dataset):
    def __len__(self):
        return 5000

    def __getitem__(self, i):
        if i % 64 == 0:
            n = 100
        else:
            n = 1
        return "This is a test" * n

Il s’agit d’une phrase occasionnellement très longue par rapport aux autres. Dans ce cas, le lot entier devra faire 400 jetons de long, de sorte que le lot entier sera [64, 400] au lieu de [64, 4], ce qui entraîne un ralentissement important. Pire encore, sur des lots plus volumineux, le programme plante tout simplement.

------------------------------
Streaming no batching
100%|█████████████████████████████████████████████████████████████████████| 1000/1000 [00:05<00:00, 183.69it/s]
------------------------------
Streaming batch_size=8
100%|█████████████████████████████████████████████████████████████████████| 1000/1000 [00:03<00:00, 265.74it/s]
------------------------------
Streaming batch_size=64
100%|██████████████████████████████████████████████████████████████████████| 1000/1000 [00:26<00:00, 37.80it/s]
------------------------------
Streaming batch_size=256
  0%|                                                                                 | 0/1000 [00:00<?, ?it/s]
Traceback (most recent call last):
  File "/home/nicolas/src/transformers/test.py", line 42, in <module>
    for out in tqdm(pipe(dataset, batch_size=256), total=len(dataset)):
....
    q = q / math.sqrt(dim_per_head)  # (bs, n_heads, q_length, dim_per_head)
RuntimeError: CUDA out of memory. Tried to allocate 376.00 MiB (GPU 0; 3.95 GiB total capacity; 1.72 GiB already allocated; 354.88 MiB free; 2.46 GiB reserved in total by PyTorch)

Il n'existe pas de bonnes solutions (générales) à ce problème, et les résultats peuvent varier selon vos cas d'utilisation. Règle générale :

Pour les utilisateurs, une règle générale est la suivante :

  • Mesurez les performances sur votre charge, avec votre matériel. Mesurez, mesurez et continuez à mesurer. Les chiffres réels sont la seule voie à suivre.

  • Si vous êtes contraint par la latence (produit en direct effectuant de l’inférence), ne regroupez pas les données par lots.

  • Si vous utilisez le CPU, ne regroupez pas les données en lots.

  • Si vous utilisez le débit (vous souhaitez exécuter votre modèle sur un ensemble de données statiques), sur GPU, alors :

    • Si vous n’avez aucune idée de la taille de sequence_length (données « naturelles »), par défaut, ne créez pas de lots, mesurez et essayez prudemment d’en ajouter, et ajoutez des vérifications OOM pour récupérer en cas d’échec (et il y en aura un à un moment si vous ne contrôlez pas sequence_length.)
    • Si votre sequence_length est très régulier, le batching est alors très probablement très intéressant : mesurez et augmentez-le jusqu'à obtenir des erreurs OOM.
    • Plus la GPU est grande, plus le batching est susceptible d'être intéressant

  • Dès que vous activez le batching, assurez-vous de pouvoir gérer correctement les OOM.

Batching par morceaux de Pipeline

zero-shot-classification et question-answering sont légèrement spécifiques dans le sens où une seule entrée peut générer plusieurs passages en avant d'un modèle. Dans des conditions normales, cela poserait des problèmes avec l'argument batch_size.

Afin de contourner ce problème, ces deux pipelines sont un peu spécifiques : il s'agit de ChunkPipeline plutôt que de Pipeline classiques. En résumé :

preprocessed = pipe.preprocess(inputs)
model_outputs = pipe.forward(preprocessed)
outputs = pipe.postprocess(model_outputs)

Deviendrait maintenant :

all_model_outputs = []
for preprocessed in pipe.preprocess(inputs):
    model_outputs = pipe.forward(preprocessed)
    all_model_outputs.append(model_outputs)
outputs = pipe.postprocess(all_model_outputs)

Cela devrait être très transparent pour votre code, car les pipelines sont utilisés de la même manière.

Il s’agit d’une vue simplifiée, car le pipeline gère automatiquement le lot pour vous ! Autrement dit, vous n’avez pas à vous soucier du nombre de passes avant que vos entrées déclencheront réellement : vous pouvez optimiser le batch_size indépendamment des entrées. Les réserves de la section précédente restent valables.

Pipeline d'inférence FP16

Les modèles peuvent être exécutés en FP16, ce qui peut être nettement plus rapide sur GPU tout en économisant de la mémoire. La plupart des modèles ne subiront pas de perte de performance notable à cause de cela. Plus le modèle est grand, moins il est susceptible d'en souffrir.

Pour activer l'inférence en FP16, il suffit de passer dtype=torch.float16 ou dtype='float16' au constructeur du pipeline. Notez que cela ne fonctionne que pour les modèles ayant un backend PyTorch. Vos entrées seront converties en FP16 en interne.

Code personnalisé du Pipeline

Si vous souhaitez remplacer un pipeline spécifique.

N’hésitez pas à créer un ticket pour votre tâche en cours, l’objectif du pipeline étant d’être facile à utiliser et de prendre en charge la plupart des cas, il est donc possible que transformers puisse soutenir votre cas d’usage.

Si vous souhaitez simplement essayer, vous pouvez :

  • Sous-classez votre pipeline de choix
class MyPipeline(TextClassificationPipeline):
    def postprocess():
        # Your code goes here
        scores = scores * 100
        # And here


my_pipeline = MyPipeline(model=model, tokenizer=tokenizer, ...)
# or if you use *pipeline* function, then:
my_pipeline = pipeline(model="xxxx", pipeline_class=MyPipeline)

Cela devrait vous permettre d'écrire tout le code personnalisé que vous souhaitez.

Mise en œuvre d'un pipeline

Mise en œuvre d'un nouveau pipeline

Audio

Les pipelines disponibles pour les tâches audio incluent les suivants.

AudioClassificationPipeline

classe transformers.AudioClassificationPipeline

< >

( *args**kwargs )

Paramètres

  • model (PreTrainedModel) — Le modèle qui sera utilisé par le pipeline pour effectuer des prédictions. Il doit s’agir d’un modèle héritant de PreTrainedModel.
  • feature_extractor (SequenceFeatureExtractor) — L’extracteur de caractéristiques qui sera utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de SequenceFeatureExtractor.
  • task (str, par défaut "") — Identifiant de tâche pour le pipeline.
  • num_workers (int, facultatif, valeur par défaut 8) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), le nombre de workers à utiliser.
  • batch_size (int, facultatif, par défaut 1) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), la taille du lot à utiliser. Pour l'inférence, cela n'est pas toujours bénéfique, veuillez lire Batching with pipelines .
  • args_parser (ArgumentHandler, facultatif) — Référence à l'objet chargé de l'analyse des paramètres de pipeline fournis.
  • device (int ou str ou torch.device, facultatif) — Appareil sur lequel le pipeline est alloué. S'il n'est pas défini, le pipeline est placé sur le premier accélérateur disponible (CUDA, MPS, XPU, …) et ne bascule sur le CPU que si aucun n'est disponible ; le modèle y est déplacé automatiquement. Passez device="cpu" (ou -1) pour forcer le CPU, un ordinal positif ou "cuda:1" pour sélectionner un accélérateur spécifique, ou un torch.device/str natif. Cet argument ne peut pas être combiné avec un modèle déjà chargé via accelerate (c'est-à-dire un modèle ayant un hf_device_map).
  • dtype (str ou torch.dtype, facultatif, par défaut "auto") — Précision dans laquelle le modèle est chargé, transmise à from_pretrained. Par défaut, "auto", ce qui charge le modèle dans le dtype dans lequel il a été enregistré (lu depuis config.dtype du checkpoint, sinon déduit des poids). Passez un torch.float16, torch.bfloat16, torch.float32, … explicite pour l’écraser.
  • binary_output (bool, facultatif, par défaut False) — Indique si la sortie du pipeline doit être au format sérialisé (c.-à-d. pickle) ou sous forme de données brutes, par exemple du texte.

Pipeline de classification audio utilisant n’importe quel AutoModelForAudioClassification. Ce pipeline prédit la classe d’une forme d’onde brute ou d’un fichier audio. Dans le cas d’un fichier audio, ffmpeg doit être installé pour prendre en charge plusieurs formats audio.

Exemple :

>>> from transformers import pipeline

>>> classifier = pipeline(model="superb/wav2vec2-base-superb-ks")
>>> classifier("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/1.flac")
[{'score': 0.997, 'label': '_unknown_'}, {'score': 0.002, 'label': 'left'}, {'score': 0.0, 'label': 'yes'}, {'score': 0.0, 'label': 'down'}, {'score': 0.0, 'label': 'stop'}]

En savoir plus sur les bases de l'utilisation d'un pipeline dans le tutoriel sur les pipelines

Ce pipeline peut actuellement être chargé depuis pipeline() en utilisant l'identifiant de tâche suivant : "audio-classification".

Consultez la liste des modèles disponibles sur huggingface.co/models.

__call__

< >

( inputs: numpy.ndarray | bytes | str | dict**kwargs: Any ) → A list of dict with the following keys

Paramètres

  • inputs (np.ndarray ou bytes ou str ou dict) — Les entrées sont soit :
    • str qui est le nom du fichier audio, le fichier sera lu au taux d'échantillonnage correct pour obtenir la forme d'onde à l'aide de ffmpeg. Cela nécessite que ffmpeg soit installé sur le système.
    • bytes est censé contenir le contenu d'un fichier audio et est interprété par ffmpeg de la même manière.
    • (np.ndarray de forme (n, ) de type np.float32 ou np.float64) Audio brut au taux d'échantillonnage correct (aucune vérification supplémentaire ne sera effectuée)
    • La forme dict peut être utilisée pour transmettre un audio brut échantillonné à un sampling_rate arbitraire et laisser ce pipeline effectuer le rééchantillonnage. Le dictionnaire doit être au format {"sampling_rate": int, "raw": np.array} ou {"sampling_rate": int, "array": np.array}, où la clé "raw" ou "array" est utilisée pour désigner la forme d’onde audio brute.
  • top_k (int, facultatif, valeur par défaut None) — Le nombre de meilleurs libellés qui seront renvoyés par le pipeline. Si le nombre fourni est None ou supérieur au nombre de libellés disponibles dans la configuration du modèle, il prendra par défaut le nombre de libellés.
  • function_to_apply (str, facultatif, par défaut “softmax”) — La fonction à appliquer à la sortie du modèle. Par défaut, le pipeline applique la fonction softmax à la sortie du modèle. Options valides : [“softmax”, “sigmoid”, “none”]. Notez que passer la valeur intégrée None de Python revient à utiliser “softmax” par défaut ; il faut donc passer la chaîne “none” pour désactiver tout post-traitement.

Retourne

Une liste de dict avec les clés suivantes

  • label (str) — L'étiquette prédite.
  • score (float) — La probabilité correspondante.

Classifiez la ou les séquences fournies en entrée. Consultez la documentation de AutomaticSpeechRecognitionPipeline pour plus d'informations.

AutomaticSpeechRecognitionPipeline

classe transformers.AutomaticSpeechRecognitionPipeline

< >

( model: PreTrainedModelfeature_extractor: typing.Union[ForwardRef('SequenceFeatureExtractor'), str, NoneType] = Nonetokenizer: transformers.tokenization_python.PythonBackend | None = Nonedecoder: typing.Union[ForwardRef('BeamSearchDecoderCTC'), str, NoneType] = Nonedevice: typing.Union[int, ForwardRef('torch.device'), NoneType] = None**kwargs )

Paramètres

  • model (PreTrainedModel) — Le modèle qui sera utilisé par le pipeline pour effectuer des prédictions. Il doit s’agir d’un modèle héritant de PreTrainedModel.
  • feature_extractor (SequenceFeatureExtractor, facultatif) — L'extracteur de caractéristiques utilisé par le pipeline pour encoder les formes d'onde pour le modèle.
  • tokenizer (PreTrainedTokenizer, facultatif) — Le tokenizer utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de PreTrainedTokenizer.
  • decoder (pyctcdecode.BeamSearchDecoderCTC, facultatif) — BeamSearchDecoderCTC de PyCTCDecode peut être transmis pour un décodage renforcé par un modèle de langage. Voir Wav2Vec2ProcessorWithLM pour plus d’informations.
  • device (Union[int, torch.device], facultatif) — Ordinal du périphérique pour la prise en charge CPU/GPU. Définir cette valeur sur None utilisera le CPU, tandis qu'une valeur positive exécutera le modèle sur l'identifiant de périphérique CUDA associé.

Pipeline visant à extraire le texte parlé contenu dans un audio.

L'entrée peut être une forme d'onde brute ou un fichier audio. Dans le cas d'un fichier audio, ffmpeg doit être installé pour prendre en charge plusieurs formats audio

À moins que le modèle que vous utilisez ne définisse explicitement ces paramètres de génération dans ses fichiers de configuration (generation_config.json), les valeurs par défaut suivantes seront utilisées :

  • max_new_tokens: 256
  • num_beams: 5

Exemple :

>>> from transformers import pipeline

>>> transcriber = pipeline(model="openai/whisper-base")
>>> transcriber("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/1.flac")
{'text': ' He hoped there would be stew for dinner, turnips and carrots and bruised potatoes and fat mutton pieces to be ladled out in thick, peppered flour-fatten sauce.'}

En savoir plus sur les bases de l'utilisation d'un pipeline dans le tutoriel sur les pipelines

__call__

< >

( inputs: numpy.ndarray | bytes | str | dict**kwargs: Any ) → Dict

Paramètres

  • inputs (np.ndarray ou bytes ou str ou dict) — Les entrées sont soit :
    • str qui est soit le nom du fichier d'un fichier audio local, soit l'adresse URL publique pour télécharger le fichier audio. Le fichier sera lu au taux d'échantillonnage correct pour obtenir la forme d'onde à l'aide de ffmpeg. Cela nécessite que ffmpeg soit installé sur le système.
    • bytes est censé contenir le contenu d'un fichier audio et est interprété par ffmpeg de la même manière.
    • (np.ndarray de forme (n, ) de type np.float32 ou np.float64) Audio brut au taux d'échantillonnage correct (aucune vérification supplémentaire ne sera effectuée)
    • La forme dict peut être utilisée pour transmettre un audio brut échantillonné à un sampling_rate arbitraire et laisser ce pipeline effectuer le rééchantillonnage. Le dictionnaire doit être au format {"sampling_rate": int, "raw": np.array} avec éventuellement un "stride": (left: int, right: int) qui peut demander au pipeline d’ignorer les left premiers échantillons et les right derniers échantillons lors du décodage (mais utilisés lors de l’inférence pour fournir plus de contexte au modèle). N’utilisez stride qu’avec les modèles CTC.
  • return_timestamps (facultatif, str ou bool) — Uniquement disponible pour les modèles CTC purs (Wav2Vec2, HuBERT, etc.) et le modèle Whisper. Non disponible pour les autres modèles séquence-à-séquence.

    Pour les modèles CTC, les horodatages peuvent prendre l'un des deux formats suivants :

    • "char" : le pipeline renvoie des horodatages le long du texte pour chaque caractère. Par exemple, si vous obtenez [{"text": "h", "timestamp": (0.5, 0.6)}, {"text": "i", "timestamp": (0.7, 0.9)}], cela signifie que le modèle prédit que la lettre « h » a été prononcée après 0.5 et avant 0.6 secondes.
    • "word" : le pipeline renverra des horodatages le long du texte pour chaque mot du texte. Par exemple, si vous obtenez [{"text": "hi ", "timestamp": (0.5, 0.9)}, {"text": "there", "timestamp": (1.0, 1.5)}], cela signifie que le modèle prédit que le mot « hi » a été prononcé après 0.5 et avant 0.9 secondes.

    Pour le modèle Whisper, les horodatages peuvent prendre l'un des deux formats suivants :

    • "word" : identique à ce qui précède pour les horodatages au niveau des mots en CTC. Les horodatages au niveau des mots sont prédits via l'algorithme dynamic-time warping (DTW), une approximation des horodatages au niveau des mots obtenue en examinant les poids de l'attention croisée.
    • True : le pipeline renverra des horodatages avec le texte pour les segments de mots du texte. Par exemple, si vous obtenez [{"text": " Hi there!", "timestamp": (0.5, 1.5)}], cela signifie que le modèle prédit que le segment « Hi there! » a été prononcé après 0.5 et avant 1.5 secondes. Notez qu’un segment de texte désigne une séquence d’un ou plusieurs mots, et non des mots individuels comme avec les horodatages au niveau du mot.
  • generate_kwargs (dict, facultatif) — Le dictionnaire de paramétrage ad hoc de generate_config à utiliser pour l'appel de génération. Pour un aperçu complet de generate, consultez le guide suivant.

Retourne

Dict

Un dictionnaire avec les clés suivantes :

  • text (str) : le texte reconnu.
  • chunks (facultatif(, list[Dict]) Lors de l'utilisation de return_timestamps, chunks devient une liste contenant tous les différents extraits de texte identifiés par le modèle, par exemple* [{"text": "hi ", "timestamp": (0.5, 0.9)}, {"text": "there", "timestamp": (1.0, 1.5)}]. Le texte complet d'origine peut être approximativement récupéré en effectuant "".join(chunk["text"] for chunk in output["chunks"]).

Transcrire la ou les séquences audio fournies en entrée en texte. Consultez la documentation de AutomaticSpeechRecognitionPipeline pour plus d'informations.

TextToAudioPipeline

classe transformers.TextToAudioPipeline

< >

( *argsvocoder = Nonesampling_rate = Nonenoise_scheduler = None**kwargs )

Pipeline de génération de texte vers audio utilisant n'importe quel AutoModelForTextToWaveform ou AutoModelForTextToSpectrogram. Ce pipeline génère un fichier audio à partir d'un texte d'entrée et d'autres entrées conditionnelles facultatives.

À moins que le modèle que vous utilisez ne définisse explicitement les paramètres de génération dans generation_config.json, les valeurs par défaut de generation.configuration_utils.py._get_default_generation_params() seront utilisées.

  • max_new_tokens: 256

Exemple :

>>> from transformers import pipeline

>>> pipe = pipeline(model="suno/bark-small")
>>> output = pipe("Hey it's HuggingFace on the phone!")

>>> audio = output["audio"]
>>> sampling_rate = output["sampling_rate"]

En savoir plus sur les bases de l'utilisation d'un pipeline dans le tutoriel sur les pipelines

Vous pouvez spécifier les paramètres transmis au modèle en utilisant TextToAudioPipeline.__call__.forward_params ou TextToAudioPipeline.__call__.generate_kwargs.

Exemple :

>>> from transformers import pipeline

>>> music_generator = pipeline(task="text-to-audio", model="facebook/musicgen-small")

>>> # diversify the music generation by adding randomness with a high temperature and set a maximum music length
>>> generate_kwargs = {
...     "do_sample": True,
...     "temperature": 0.7,
...     "max_new_tokens": 35,
... }

>>> outputs = music_generator("Techno music with high melodic riffs", generate_kwargs=generate_kwargs)

Ce pipeline peut actuellement être chargé depuis pipeline() en utilisant les identifiants de tâche suivants : "text-to-speech" ou "text-to-audio".

Consultez la liste des modèles disponibles sur huggingface.co/models.

__call__

< >

( text_inputs**forward_params ) → AudioOutput or a list of AudioOutput, which is a TypedDict with two keys

Paramètres

  • text_inputs (str, list[str], ChatType ou list[ChatType]) — Un ou plusieurs textes à générer. Si des chaînes de caractères ou une liste de chaînes sont transmises, ce pipeline génère le texte correspondant. Sinon, un « chat », sous la forme d’une liste de dictionnaires avec les clés « role » et « content », peut être transmis, ou une liste de tels chats. Lorsque des chats sont transmis, le modèle de chat du modèle est utilisé pour les formater avant de les passer au modèle.
  • forward_params (dict, facultatif) — Paramètres transmis à la méthode de génération/forward du modèle. forward_params sont toujours transmis au modèle sous-jacent.
  • generate_kwargs (dict, facultatif) — Le dictionnaire de paramétrage ad hoc de generate_config à utiliser pour l’appel de génération. Pour un aperçu complet de generate, consultez le guide suivant. generate_kwargs ne sont transmis au modèle sous-jacent que si ce dernier est un modèle génératif, et prennent le pas sur forward_params.

Retourne

AudioOutput ou une liste de AudioOutput, qui est un TypedDict avec deux clés

  • audio (np.ndarray de forme (nb_channels, audio_length)) — La forme d'onde audio générée.
  • sampling_rate (int) — Fréquence d'échantillonnage de la forme d'onde audio générée.

Génère de la parole/du son à partir des entrées. Consultez la documentation de TextToAudioPipeline pour plus d'informations.

ZeroShotAudioClassificationPipeline

classe transformers.ZeroShotAudioClassificationPipeline

< >

( **kwargs )

Paramètres

  • model (PreTrainedModel) — Le modèle qui sera utilisé par le pipeline pour effectuer des prédictions. Il doit s’agir d’un modèle héritant de PreTrainedModel.
  • tokenizer (PreTrainedTokenizer) — Le tokenizer utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de PreTrainedTokenizer.
  • feature_extractor (SequenceFeatureExtractor) — L’extracteur de caractéristiques qui sera utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de SequenceFeatureExtractor.
  • task (str, par défaut "") — Identifiant de tâche pour le pipeline.
  • num_workers (int, facultatif, valeur par défaut 8) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), le nombre de workers à utiliser.
  • batch_size (int, facultatif, par défaut 1) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), la taille du lot à utiliser. Pour l'inférence, cela n'est pas toujours bénéfique, veuillez lire Batching with pipelines .
  • args_parser (ArgumentHandler, facultatif) — Référence à l'objet chargé de l'analyse des paramètres de pipeline fournis.
  • device (int ou str ou torch.device, facultatif) — Appareil sur lequel le pipeline est alloué. S'il n'est pas défini, le pipeline est placé sur le premier accélérateur disponible (CUDA, MPS, XPU, …) et ne bascule sur le CPU que si aucun n'est disponible ; le modèle y est déplacé automatiquement. Passez device="cpu" (ou -1) pour forcer le CPU, un ordinal positif ou "cuda:1" pour sélectionner un accélérateur spécifique, ou un torch.device/str natif. Cet argument ne peut pas être combiné avec un modèle déjà chargé via accelerate (c'est-à-dire un modèle ayant un hf_device_map).
  • dtype (str ou torch.dtype, facultatif, par défaut "auto") — Précision dans laquelle le modèle est chargé, transmise à from_pretrained. Par défaut, "auto", ce qui charge le modèle dans le dtype dans lequel il a été enregistré (lu depuis config.dtype du checkpoint, sinon déduit des poids). Passez un torch.float16, torch.bfloat16, torch.float32, … explicite pour l’écraser.
  • binary_output (bool, facultatif, par défaut False) — Indique si la sortie du pipeline doit être au format sérialisé (c.-à-d. pickle) ou sous forme de données brutes, par exemple du texte.

Pipeline de classification audio en zéro tirage utilisant ClapModel. Ce pipeline prédit la classe d'un audio lorsque vous fournissez un audio et un ensemble de candidate_labels.

Le hypothesis_template par défaut est : "This is a sound of {}.". Assurez-vous de le mettre à jour selon votre utilisation.

Exemple :

>>> from transformers import pipeline
>>> from datasets import load_dataset

>>> dataset = load_dataset("ashraq/esc50")
>>> audio = next(iter(dataset["train"]["audio"]))["array"]
>>> classifier = pipeline(task="zero-shot-audio-classification", model="laion/clap-htsat-unfused")
>>> classifier(audio, candidate_labels=["Sound of a dog", "Sound of vacuum cleaner"])
[{'score': 0.9996, 'label': 'Sound of a dog'}, {'score': 0.0004, 'label': 'Sound of vacuum cleaner'}]

En savoir plus sur les bases de l'utilisation d'un pipeline dans le tutoriel sur les pipelines. Ce pipeline de classification audio peut actuellement être chargé depuis pipeline() en utilisant l'identifiant de tâche suivant : "zero-shot-audio-classification". Consultez la liste des modèles disponibles sur huggingface.co/models.

__call__

< >

( audios: numpy.ndarray | bytes | str | dict**kwargs: Any )

Paramètres

  • audios (str, list[str], np.array ou list[np.array]) — Le pipeline gère trois types d'entrées :
    • Une chaîne de caractères contenant un lien http pointant vers un audio
    • Une chaîne de caractères contenant un chemin local vers un audio
    • Un audio chargé dans numpy
  • candidate_labels (list[str]) — Les étiquettes candidates pour cet audio. Elles seront formatées à l'aide de hypothesis_template.
  • hypothesis_template (str, facultatif, par défaut "This is a sound of {}") — Le format utilisé en conjonction avec candidate_labels pour tenter la classification audio en remplaçant le placeholder par les candidate_labels. Passez ”{}” si candidate_labels sont déjà formatés.

Attribuer des étiquettes aux audio(s) passés en entrée.

Vision par ordinateur

Les pipelines disponibles pour les tâches de vision par ordinateur incluent les suivants.

DepthEstimationPipeline

classe transformers.DepthEstimationPipeline

< >

( *args**kwargs )

Paramètres

  • model (PreTrainedModel) — Le modèle qui sera utilisé par le pipeline pour effectuer des prédictions. Il doit s’agir d’un modèle héritant de PreTrainedModel.
  • image_processor (BaseImageProcessor) — Le processeur d’images utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de BaseImageProcessor.
  • task (str, par défaut "") — Identifiant de tâche pour le pipeline.
  • num_workers (int, facultatif, valeur par défaut 8) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), le nombre de workers à utiliser.
  • batch_size (int, facultatif, par défaut 1) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), la taille du lot à utiliser. Pour l'inférence, cela n'est pas toujours bénéfique, veuillez lire Batching with pipelines .
  • args_parser (ArgumentHandler, facultatif) — Référence à l'objet chargé de l'analyse des paramètres de pipeline fournis.
  • device (int ou str ou torch.device, facultatif) — Appareil sur lequel le pipeline est alloué. S'il n'est pas défini, le pipeline est placé sur le premier accélérateur disponible (CUDA, MPS, XPU, …) et ne bascule sur le CPU que si aucun n'est disponible ; le modèle y est déplacé automatiquement. Passez device="cpu" (ou -1) pour forcer le CPU, un ordinal positif ou "cuda:1" pour sélectionner un accélérateur spécifique, ou un torch.device/str natif. Cet argument ne peut pas être combiné avec un modèle déjà chargé via accelerate (c'est-à-dire un modèle ayant un hf_device_map).
  • dtype (str ou torch.dtype, facultatif, par défaut "auto") — Précision dans laquelle le modèle est chargé, transmise à from_pretrained. Par défaut, "auto", ce qui charge le modèle dans le dtype dans lequel il a été enregistré (lu depuis config.dtype du checkpoint, sinon déduit des poids). Passez un torch.float16, torch.bfloat16, torch.float32, … explicite pour l’écraser.
  • binary_output (bool, facultatif, par défaut False) — Indique si la sortie du pipeline doit être au format sérialisé (c.-à-d. pickle) ou sous forme de données brutes, par exemple du texte.

Pipeline d'estimation de profondeur utilisant n'importe quel AutoModelForDepthEstimation. Ce pipeline prédit la profondeur d'une image.

Exemple :

>>> from transformers import pipeline

>>> depth_estimator = pipeline(task="depth-estimation", model="LiheYoung/depth-anything-base-hf")
>>> output = depth_estimator("http://images.cocodataset.org/val2017/000000039769.jpg")
>>> # This is a tensor with the values being the depth expressed in meters for each pixel
>>> output["predicted_depth"].shape
torch.Size([1, 384, 384])

En savoir plus sur les bases de l'utilisation d'un pipeline dans le tutoriel sur les pipelines

Ce pipeline d'estimation de profondeur peut actuellement être chargé depuis pipeline() en utilisant l'identifiant de tâche suivant : "depth-estimation".

Consultez la liste des modèles disponibles sur huggingface.co/models.

__call__

< >

( inputs: typing.Union[str, list[str], ForwardRef('Image.Image'), list['Image.Image']]**kwargs: Any )

Paramètres

  • inputs (str, list[str], PIL.Image ou list[PIL.Image]) — Le pipeline gère trois types d'images :
    • Une chaîne de caractères contenant un lien http pointant vers une image
    • Une chaîne de caractères contenant un chemin local vers une image
    • Une image chargée directement dans PIL

    Le pipeline accepte une image unique ou un lot d'images, qui doivent alors être passées sous forme de chaîne de caractères. Les images d'un lot doivent toutes être au même format : toutes sous forme de liens http, toutes sous forme de chemins locaux, ou toutes sous forme d'images PIL.

  • parameters (Dict, facultatif) — Un dictionnaire associant des noms d’arguments à des valeurs de paramètres, afin de contrôler le comportement du pipeline. Le seul paramètre disponible actuellement est timeout, qui correspond à la durée, en secondes, pendant laquelle le pipeline doit attendre avant d’abandonner la tentative de téléchargement d’une image.
  • timeout (float, facultatif, par défaut None) — Durée maximale en secondes à attendre pour récupérer des images depuis le web. Si None, aucun délai d’attente n’est défini et l’appel peut bloquer indéfiniment.

Prédire la ou les profondeurs de l'image ou des images passées en entrée.

ImageClassificationPipeline

classe transformers.ImageClassificationPipeline

< >

( *args**kwargs )

Paramètres

  • model (PreTrainedModel) — Le modèle qui sera utilisé par le pipeline pour effectuer des prédictions. Il doit s’agir d’un modèle héritant de PreTrainedModel.
  • image_processor (BaseImageProcessor) — Le processeur d’images utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de BaseImageProcessor.
  • task (str, par défaut "") — Identifiant de tâche pour le pipeline.
  • num_workers (int, facultatif, valeur par défaut 8) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), le nombre de workers à utiliser.
  • batch_size (int, facultatif, par défaut 1) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), la taille du lot à utiliser. Pour l'inférence, cela n'est pas toujours bénéfique, veuillez lire Batching with pipelines .
  • args_parser (ArgumentHandler, facultatif) — Référence à l'objet chargé de l'analyse des paramètres de pipeline fournis.
  • device (int ou str ou torch.device, facultatif) — Appareil sur lequel le pipeline est alloué. S'il n'est pas défini, le pipeline est placé sur le premier accélérateur disponible (CUDA, MPS, XPU, …) et ne bascule sur le CPU que si aucun n'est disponible ; le modèle y est déplacé automatiquement. Passez device="cpu" (ou -1) pour forcer le CPU, un ordinal positif ou "cuda:1" pour sélectionner un accélérateur spécifique, ou un torch.device/str natif. Cet argument ne peut pas être combiné avec un modèle déjà chargé via accelerate (c'est-à-dire un modèle ayant un hf_device_map).
  • dtype (str ou torch.dtype, facultatif, par défaut "auto") — Précision dans laquelle le modèle est chargé, transmise à from_pretrained. Par défaut, "auto", ce qui charge le modèle dans le dtype dans lequel il a été enregistré (lu depuis config.dtype du checkpoint, sinon déduit des poids). Passez un torch.float16, torch.bfloat16, torch.float32, … explicite pour l’écraser.
  • binary_output (bool, facultatif, par défaut False) — Indique si la sortie du pipeline doit être au format sérialisé (c.-à-d. pickle) ou sous forme de données brutes, par exemple du texte.
  • function_to_apply (str, facultatif, par défaut "default") — La fonction à appliquer aux sorties du modèle afin de récupérer les scores. Accepte quatre valeurs différentes :
    • "default" : si le modèle possède un seul label, la fonction sigmoïde est appliquée à la sortie. Si le modèle possède plusieurs labels, la fonction softmax est appliquée à la sortie.
    • "sigmoid" : Applique la fonction sigmoïde à la sortie.
    • "softmax" : Applique la fonction softmax à la sortie.
    • "none" : N’applique aucune fonction à la sortie.

Pipeline de classification d’images utilisant n’importe quel AutoModelForImageClassification. Ce pipeline prédit la classe d’une image.

Exemple :

>>> from transformers import pipeline

>>> classifier = pipeline(model="microsoft/beit-base-patch16-224-pt22k-ft22k")
>>> classifier("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png")
[{'score': 0.442, 'label': 'macaw'}, {'score': 0.088, 'label': 'popinjay'}, {'score': 0.075, 'label': 'parrot'}, {'score': 0.073, 'label': 'parodist, lampooner'}, {'score': 0.046, 'label': 'poll, poll_parrot'}]

En savoir plus sur les bases de l'utilisation d'un pipeline dans le tutoriel sur les pipelines

Ce pipeline de classification d’images peut actuellement être chargé depuis pipeline() en utilisant l’identifiant de tâche suivant : "image-classification".

Consultez la liste des modèles disponibles sur huggingface.co/models.

__call__

< >

( inputs: typing.Union[str, list[str], ForwardRef('Image.Image'), list['Image.Image']]**kwargs: Any )

Paramètres

  • inputs (str, list[str], PIL.Image ou list[PIL.Image]) — Le pipeline gère trois types d'images :
    • Une chaîne de caractères contenant un lien http pointant vers une image
    • Une chaîne de caractères contenant un chemin local vers une image
    • Une image chargée directement dans PIL

    Le pipeline accepte une image unique ou un lot d'images, qui doivent alors être passées sous forme de chaîne de caractères. Les images d'un lot doivent toutes être au même format : toutes sous forme de liens http, toutes sous forme de chemins locaux, ou toutes sous forme d'images PIL.

  • function_to_apply (str, facultatif, par défaut "default") — La fonction à appliquer aux sorties du modèle afin de récupérer les scores. Accepte quatre valeurs différentes :

    Si cet argument n'est pas spécifié, les fonctions suivantes sont appliquées en fonction du nombre d'étiquettes :

    • Si le modèle possède une seule étiquette, la fonction sigmoïde sera appliquée à la sortie.
    • Si le modèle possède plusieurs étiquettes, la fonction softmax sera appliquée à la sortie.

    Les valeurs possibles sont :

    • "sigmoid" : Applique la fonction sigmoïde à la sortie.
    • "softmax" : Applique la fonction softmax à la sortie.
    • "none" : N’applique aucune fonction à la sortie.
  • top_k (int, facultatif, valeur par défaut 5) — Le nombre de premiers labels qui seront renvoyés par le pipeline. Si le nombre fourni est supérieur au nombre de labels disponibles dans la configuration du modèle, il sera ramené au nombre de labels.
  • timeout (float, facultatif, par défaut None) — Durée maximale en secondes à attendre pour récupérer des images depuis le web. Si None, aucun délai d’attente n’est défini et l’appel peut bloquer indéfiniment.

Attribuer des étiquettes aux image(s) passées en entrées.

ImageSegmentationPipeline

classe transformers.ImageSegmentationPipeline

< >

( *args**kwargs )

Paramètres

  • model (PreTrainedModel) — Le modèle qui sera utilisé par le pipeline pour effectuer des prédictions. Il doit s’agir d’un modèle héritant de PreTrainedModel.
  • image_processor (BaseImageProcessor) — Le processeur d’images utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de BaseImageProcessor.
  • task (str, par défaut "") — Identifiant de tâche pour le pipeline.
  • num_workers (int, facultatif, valeur par défaut 8) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), le nombre de workers à utiliser.
  • batch_size (int, facultatif, par défaut 1) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), la taille du lot à utiliser. Pour l'inférence, cela n'est pas toujours bénéfique, veuillez lire Batching with pipelines .
  • args_parser (ArgumentHandler, facultatif) — Référence à l'objet chargé de l'analyse des paramètres de pipeline fournis.
  • device (int ou str ou torch.device, facultatif) — Appareil sur lequel le pipeline est alloué. S'il n'est pas défini, le pipeline est placé sur le premier accélérateur disponible (CUDA, MPS, XPU, …) et ne bascule sur le CPU que si aucun n'est disponible ; le modèle y est déplacé automatiquement. Passez device="cpu" (ou -1) pour forcer le CPU, un ordinal positif ou "cuda:1" pour sélectionner un accélérateur spécifique, ou un torch.device/str natif. Cet argument ne peut pas être combiné avec un modèle déjà chargé via accelerate (c'est-à-dire un modèle ayant un hf_device_map).
  • dtype (str ou torch.dtype, facultatif, par défaut "auto") — Précision dans laquelle le modèle est chargé, transmise à from_pretrained. Par défaut, "auto", ce qui charge le modèle dans le dtype dans lequel il a été enregistré (lu depuis config.dtype du checkpoint, sinon déduit des poids). Passez un torch.float16, torch.bfloat16, torch.float32, … explicite pour l’écraser.
  • binary_output (bool, facultatif, par défaut False) — Indique si la sortie du pipeline doit être au format sérialisé (c.-à-d. pickle) ou sous forme de données brutes, par exemple du texte.

Pipeline de segmentation d’images utilisant n’importe quel AutoModelForXXXSegmentation. Ce pipeline prédit les masques des objets et leurs classes.

Exemple :

>>> from transformers import pipeline

>>> segmenter = pipeline(model="facebook/detr-resnet-50-panoptic")
>>> segments = segmenter("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png")
>>> len(segments)
2

>>> segments[0]["label"]
'bird'

>>> segments[1]["label"]
'bird'

>>> type(segments[0]["mask"])  # This is a black and white mask showing where is the bird on the original image.
<class 'PIL.Image.Image'>

>>> segments[0]["mask"].size
(768, 512)

Ce pipeline de segmentation d’image peut actuellement être chargé depuis pipeline() en utilisant l’identifiant de tâche suivant : "image-segmentation".

Consultez la liste des modèles disponibles sur huggingface.co/models.

__call__

< >

( inputs: typing.Union[str, ForwardRef('Image.Image'), list[str], list['Image.Image']]**kwargs: Any )

Paramètres

  • inputs (str, list[str], PIL.Image ou list[PIL.Image]) — Le pipeline gère trois types d'images :
    • Une chaîne de caractères contenant un lien HTTP(S) pointant vers une image
    • Une chaîne de caractères contenant un chemin local vers une image
    • Une image chargée directement dans PIL

    Le pipeline accepte une image unique ou un lot d'images. Les images d'un lot doivent toutes être au même format : toutes sous forme de liens HTTP(S), toutes sous forme de chemins locaux, ou toutes sous forme d'images PIL.

  • subtask (str, facultatif) — Tâche de segmentation à effectuer, choisissez parmi [semantic, instance et panoptic] en fonction des capacités du modèle. Si non défini, le pipeline tentera de résoudre dans l'ordre suivant : panoptic, instance, semantic.
  • threshold (float, facultatif, par défaut 0.9) — Seuil de probabilité pour filtrer les masques prédits.
  • mask_threshold (float, facultatif, valeur par défaut 0.5) — Seuil à utiliser pour convertir les masques prédits en valeurs binaires.
  • overlap_mask_area_threshold (float, facultatif, valeur par défaut 0,5) — Seuil de chevauchement des masques pour éliminer les petits segments non connectés.
  • timeout (float, facultatif, par défaut None) — Durée maximale en secondes à attendre pour récupérer des images depuis le web. Si None, aucun délai d’attente n’est défini et l’appel peut bloquer indéfiniment.

Effectuer la segmentation (détection des masques et des classes) dans l'image ou les images passées en entrée.

KeypointMatchingPipeline

classe transformers.KeypointMatchingPipeline

< >

( *args**kwargs )

Pipeline d'appariement de points clés utilisant n'importe quel AutoModelForKeypointMatching. Ce pipeline apparie les points clés entre deux images.

__call__

< >

( inputs: list[collections.abc.Sequence[typing.Union[ForwardRef('Image.Image'), str]]] | collections.abc.Sequence[typing.Union[ForwardRef('Image.Image'), str]]threshold: float = 0.0**kwargs: Any ) → Union[list[Match], list[list[Match]]]

Paramètres

  • inputs (str, list[str], PIL.Image ou list[PIL.Image]) — Le pipeline gère trois types d'images :
    • Une chaîne de caractères contenant un lien http pointant vers une image
    • Une chaîne de caractères contenant un chemin local vers une image
    • Une image chargée directement dans PIL

    Le pipeline accepte soit une seule paire d'images, soit un lot de paires d'images, qui doit alors être passé sous forme de chaîne de caractères. Les images d'un lot doivent toutes être au même format : toutes sous forme de liens http, toutes sous forme de chemins locaux, ou toutes sous forme d'images PIL.

  • threshold (float, facultatif, par défaut 0.0) — Le seuil à utiliser pour l’appariement des points clés. Les points clés appariés avec un score d’appariement inférieur seront filtrés. Une valeur de 0 signifie que tous les points clés appariés seront renvoyés.
  • kwargs — timeout (float, *optional*, defaults to None) Durée maximale en secondes à attendre pour récupérer des images depuis le web. Si None, aucun délai d’attente n’est défini et l’appel peut bloquer indéfiniment.

Retourne

Union[list[Match], list[list[Match]]]

Une liste de correspondances, ou une liste si une seule paire d'images est fournie, ou une liste de listes de correspondances si un lot de paires d'images est fourni. Chaque correspondance est un dictionnaire contenant les clés suivantes :

  • keypoint_image_0 (Keypoint) : le point clé de la première image (coordonnées x, y).
  • keypoint_image_1 (Keypoint) : le point clé de la deuxième image (coordonnées x, y).
  • score (float) : Le score de correspondance entre les deux points clés.

Trouver les correspondances entre les points clés de deux images.

ObjectDetectionPipeline

classe transformers.ObjectDetectionPipeline

< >

( *args**kwargs )

Paramètres

  • model (PreTrainedModel) — Le modèle qui sera utilisé par le pipeline pour effectuer des prédictions. Il doit s’agir d’un modèle héritant de PreTrainedModel.
  • image_processor (BaseImageProcessor) — Le processeur d’images utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de BaseImageProcessor.
  • task (str, par défaut "") — Identifiant de tâche pour le pipeline.
  • num_workers (int, facultatif, valeur par défaut 8) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), le nombre de workers à utiliser.
  • batch_size (int, facultatif, par défaut 1) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), la taille du lot à utiliser. Pour l'inférence, cela n'est pas toujours bénéfique, veuillez lire Batching with pipelines .
  • args_parser (ArgumentHandler, facultatif) — Référence à l'objet chargé de l'analyse des paramètres de pipeline fournis.
  • device (int ou str ou torch.device, facultatif) — Appareil sur lequel le pipeline est alloué. S'il n'est pas défini, le pipeline est placé sur le premier accélérateur disponible (CUDA, MPS, XPU, …) et ne bascule sur le CPU que si aucun n'est disponible ; le modèle y est déplacé automatiquement. Passez device="cpu" (ou -1) pour forcer le CPU, un ordinal positif ou "cuda:1" pour sélectionner un accélérateur spécifique, ou un torch.device/str natif. Cet argument ne peut pas être combiné avec un modèle déjà chargé via accelerate (c'est-à-dire un modèle ayant un hf_device_map).
  • dtype (str ou torch.dtype, facultatif, par défaut "auto") — Précision dans laquelle le modèle est chargé, transmise à from_pretrained. Par défaut, "auto", ce qui charge le modèle dans le dtype dans lequel il a été enregistré (lu depuis config.dtype du checkpoint, sinon déduit des poids). Passez un torch.float16, torch.bfloat16, torch.float32, … explicite pour l’écraser.
  • binary_output (bool, facultatif, par défaut False) — Indique si la sortie du pipeline doit être au format sérialisé (c.-à-d. pickle) ou sous forme de données brutes, par exemple du texte.

Pipeline de détection d'objets utilisant n'importe quel AutoModelForObjectDetection. Ce pipeline prédit les boîtes englobantes des objets et leurs classes.

Exemple :

>>> from transformers import pipeline

>>> detector = pipeline(model="facebook/detr-resnet-50")
>>> detector("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png")
[{'score': 0.997, 'label': 'bird', 'box': {'xmin': 69, 'ymin': 171, 'xmax': 396, 'ymax': 507}}, {'score': 0.999, 'label': 'bird', 'box': {'xmin': 398, 'ymin': 105, 'xmax': 767, 'ymax': 507}}]

>>> # x, y  are expressed relative to the top left hand corner.

En savoir plus sur les bases de l'utilisation d'un pipeline dans le tutoriel sur les pipelines

Ce pipeline de détection d'objets peut actuellement être chargé depuis pipeline() en utilisant l'identifiant de tâche suivant : "object-detection".

Consultez la liste des modèles disponibles sur huggingface.co/models.

__call__

< >

( *args**kwargs )

Paramètres

  • inputs (str, list[str], PIL.Image ou list[PIL.Image]) — Le pipeline gère trois types d'images :
    • Une chaîne de caractères contenant un lien HTTP(S) pointant vers une image
    • Une chaîne de caractères contenant un chemin local vers une image
    • Une image chargée directement dans PIL

    Le pipeline accepte une image unique ou un lot d'images. Les images d'un lot doivent toutes être au même format : toutes sous forme de liens HTTP(S), toutes sous forme de chemins locaux, ou toutes sous forme d'images PIL.

  • threshold (float, facultatif, valeur par défaut 0.5) — La probabilité requise pour effectuer une prédiction.
  • timeout (float, facultatif, par défaut None) — Durée maximale en secondes à attendre pour récupérer des images depuis le web. Si None, aucun délai d’attente n’est défini et l’appel peut bloquer indéfiniment.

Détecter les objets (boîtes englobantes & classes) dans l'image ou les images passées en entrée.

VideoClassificationPipeline

classe transformers.VideoClassificationPipeline

< >

( *args**kwargs )

Paramètres

  • model (PreTrainedModel) — Le modèle qui sera utilisé par le pipeline pour effectuer des prédictions. Il doit s’agir d’un modèle héritant de PreTrainedModel.
  • image_processor (BaseImageProcessor) — Le processeur d’images utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de BaseImageProcessor.
  • video_processor (BaseVideoProcessor) — Le processeur vidéo qui sera utilisé par le pipeline pour encoder les données vidéo pour le modèle. Cet objet hérite de BaseVideoProcessor.
  • task (str, par défaut "") — Identifiant de tâche pour le pipeline.
  • num_workers (int, facultatif, valeur par défaut 8) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), le nombre de workers à utiliser.
  • batch_size (int, facultatif, par défaut 1) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), la taille du lot à utiliser. Pour l'inférence, cela n'est pas toujours bénéfique, veuillez lire Batching with pipelines .
  • args_parser (ArgumentHandler, facultatif) — Référence à l'objet chargé de l'analyse des paramètres de pipeline fournis.
  • device (int ou str ou torch.device, facultatif) — Appareil sur lequel le pipeline est alloué. S'il n'est pas défini, le pipeline est placé sur le premier accélérateur disponible (CUDA, MPS, XPU, …) et ne bascule sur le CPU que si aucun n'est disponible ; le modèle y est déplacé automatiquement. Passez device="cpu" (ou -1) pour forcer le CPU, un ordinal positif ou "cuda:1" pour sélectionner un accélérateur spécifique, ou un torch.device/str natif. Cet argument ne peut pas être combiné avec un modèle déjà chargé via accelerate (c'est-à-dire un modèle ayant un hf_device_map).
  • dtype (str ou torch.dtype, facultatif, par défaut "auto") — Précision dans laquelle le modèle est chargé, transmise à from_pretrained. Par défaut, "auto", ce qui charge le modèle dans le dtype dans lequel il a été enregistré (lu depuis config.dtype du checkpoint, sinon déduit des poids). Passez un torch.float16, torch.bfloat16, torch.float32, … explicite pour l’écraser.
  • binary_output (bool, facultatif, par défaut False) — Indique si la sortie du pipeline doit être au format sérialisé (c.-à-d. pickle) ou sous forme de données brutes, par exemple du texte.

Pipeline de classification vidéo utilisant n'importe quel AutoModelForVideoClassification. Ce pipeline prédit la classe d'une vidéo.

Ce pipeline de classification vidéo peut actuellement être chargé depuis pipeline() en utilisant l'identifiant de tâche suivant : "video-classification".

Consultez la liste des modèles disponibles sur huggingface.co/models.

Le pipeline prend en charge les modèles qui utilisent soit un processeur d’images (modèles vidéo legacy tels que VideoMAE, ViViT et TimeSformer), soit un processeur vidéo (modèles plus récents tels que VJEPA2). Si les deux sont présents, le processeur vidéo a la priorité ; si aucun n’est trouvé, le pipeline lève une erreur.

__call__

< >

( inputs: str | list[str] | None**kwargs )

Paramètres

  • inputs (str, list[str]) — Le pipeline gère trois types de vidéos :
    • Une chaîne de caractères contenant un lien http pointant vers une vidéo
    • Une chaîne de caractères contenant un chemin local vers une vidéo

    Le pipeline accepte une vidéo unique ou un lot de vidéos, qui doivent alors être passées sous forme de chaîne de caractères. Les vidéos d'un lot doivent toutes être au même format : soit toutes sous forme de liens http, soit toutes sous forme de chemins locaux.

  • top_k (int, facultatif, valeur par défaut 5) — Le nombre de premiers labels qui seront renvoyés par le pipeline. Si le nombre fourni est supérieur au nombre de labels disponibles dans la configuration du modèle, il sera ramené au nombre de labels.
  • num_frames (int, facultatif, par défaut self.model.config.num_frames) — Le nombre d'images échantillonnées dans la vidéo pour effectuer la classification. Si non fourni, la valeur par défaut est le nombre d'images spécifié dans la configuration du modèle.
  • frame_sampling_rate (int, facultatif, valeur par défaut 1) — Le taux d'échantillonnage utilisé pour sélectionner les images de la vidéo. S'il n'est pas fourni, la valeur par défaut est 1, c'est-à-dire que chaque image sera utilisée.
  • function_to_apply(str, optionnel, par défaut « softmax ») — La fonction à appliquer à la sortie du modèle. Par défaut, le pipeline applique la fonction softmax à la sortie du modèle. Options valides : [“softmax”, “sigmoid”, “none”]. Notez que passer la valeur intégrée None de Python revient à utiliser « softmax » par défaut ; il faut donc passer la chaîne « none » pour désactiver tout post-traitement.

Attribuer des étiquettes à la ou les vidéos passées en entrée.

ZeroShotImageClassificationPipeline

classe transformers.ZeroShotImageClassificationPipeline

< >

( **kwargs )

Paramètres

  • model (PreTrainedModel) — Le modèle qui sera utilisé par le pipeline pour effectuer des prédictions. Il doit s’agir d’un modèle héritant de PreTrainedModel.
  • image_processor (BaseImageProcessor) — Le processeur d’images utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de BaseImageProcessor.
  • task (str, par défaut "") — Identifiant de tâche pour le pipeline.
  • num_workers (int, facultatif, valeur par défaut 8) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), le nombre de workers à utiliser.
  • batch_size (int, facultatif, par défaut 1) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), la taille du lot à utiliser. Pour l'inférence, cela n'est pas toujours bénéfique, veuillez lire Batching with pipelines .
  • args_parser (ArgumentHandler, facultatif) — Référence à l'objet chargé de l'analyse des paramètres de pipeline fournis.
  • device (int ou str ou torch.device, facultatif) — Appareil sur lequel le pipeline est alloué. S'il n'est pas défini, le pipeline est placé sur le premier accélérateur disponible (CUDA, MPS, XPU, …) et ne bascule sur le CPU que si aucun n'est disponible ; le modèle y est déplacé automatiquement. Passez device="cpu" (ou -1) pour forcer le CPU, un ordinal positif ou "cuda:1" pour sélectionner un accélérateur spécifique, ou un torch.device/str natif. Cet argument ne peut pas être combiné avec un modèle déjà chargé via accelerate (c'est-à-dire un modèle ayant un hf_device_map).
  • dtype (str ou torch.dtype, facultatif, par défaut "auto") — Précision dans laquelle le modèle est chargé, transmise à from_pretrained. Par défaut, "auto", ce qui charge le modèle dans le dtype dans lequel il a été enregistré (lu depuis config.dtype du checkpoint, sinon déduit des poids). Passez un torch.float16, torch.bfloat16, torch.float32, … explicite pour l’écraser.
  • binary_output (bool, facultatif, par défaut False) — Indique si la sortie du pipeline doit être au format sérialisé (c.-à-d. pickle) ou sous forme de données brutes, par exemple du texte.

Pipeline de classification d’images en zéro tirage utilisant CLIPModel. Ce pipeline prédit la classe d’une image lorsque vous fournissez une image et un ensemble de candidate_labels.

Exemple :

>>> from transformers import pipeline

>>> classifier = pipeline(model="google/siglip-so400m-patch14-384")
>>> classifier(
...     "https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png",
...     candidate_labels=["animals", "humans", "landscape"],
... )
[{'score': 0.965, 'label': 'animals'}, {'score': 0.03, 'label': 'humans'}, {'score': 0.005, 'label': 'landscape'}]

>>> classifier(
...     "https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png",
...     candidate_labels=["black and white", "photorealist", "painting"],
... )
[{'score': 0.996, 'label': 'black and white'}, {'score': 0.003, 'label': 'photorealist'}, {'score': 0.0, 'label': 'painting'}]

En savoir plus sur les bases de l'utilisation d'un pipeline dans le tutoriel sur les pipelines

Ce pipeline de classification d'images peut actuellement être chargé depuis pipeline() en utilisant l'identifiant de tâche suivant : "zero-shot-image-classification".

Consultez la liste des modèles disponibles sur huggingface.co/models.

__call__

< >

( image: typing.Union[str, list[str], ForwardRef('Image.Image'), list['Image.Image']]candidate_labels: list**kwargs: Any )

Paramètres

  • image (str, list[str], PIL.Image ou list[PIL.Image]) — Le pipeline gère trois types d'images :
    • Une chaîne de caractères contenant un lien http pointant vers une image
    • Une chaîne de caractères contenant un chemin local vers une image
    • Une image chargée directement dans PIL
  • candidate_labels (list[str]) — Les étiquettes candidates pour cette image. Elles seront formatées à l'aide de hypothesis_template.
  • hypothesis_template (str, facultatif, par défaut "This is a photo of {}") — Le format utilisé en conjonction avec candidate_labels pour tenter la classification d’image en remplaçant le marqueur par les candidate_labels. Passez ”{}” si candidate_labels sont déjà formatés.
  • timeout (float, facultatif, par défaut None) — Durée maximale en secondes à attendre pour récupérer des images depuis le web. Si None, aucun délai d’attente n’est défini et l’appel peut bloquer indéfiniment.

Attribuer des étiquettes aux image(s) passées en entrées.

ZeroShotObjectDetectionPipeline

classe transformers.ZeroShotObjectDetectionPipeline

< >

( **kwargs )

Paramètres

  • model (PreTrainedModel) — Le modèle qui sera utilisé par le pipeline pour effectuer des prédictions. Il doit s’agir d’un modèle héritant de PreTrainedModel.
  • image_processor (BaseImageProcessor) — Le processeur d’images utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de BaseImageProcessor.
  • task (str, par défaut "") — Identifiant de tâche pour le pipeline.
  • num_workers (int, facultatif, valeur par défaut 8) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), le nombre de workers à utiliser.
  • batch_size (int, facultatif, par défaut 1) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), la taille du lot à utiliser. Pour l'inférence, cela n'est pas toujours bénéfique, veuillez lire Batching with pipelines .
  • args_parser (ArgumentHandler, facultatif) — Référence à l'objet chargé de l'analyse des paramètres de pipeline fournis.
  • device (int ou str ou torch.device, facultatif) — Appareil sur lequel le pipeline est alloué. S'il n'est pas défini, le pipeline est placé sur le premier accélérateur disponible (CUDA, MPS, XPU, …) et ne bascule sur le CPU que si aucun n'est disponible ; le modèle y est déplacé automatiquement. Passez device="cpu" (ou -1) pour forcer le CPU, un ordinal positif ou "cuda:1" pour sélectionner un accélérateur spécifique, ou un torch.device/str natif. Cet argument ne peut pas être combiné avec un modèle déjà chargé via accelerate (c'est-à-dire un modèle ayant un hf_device_map).
  • dtype (str ou torch.dtype, facultatif, par défaut "auto") — Précision dans laquelle le modèle est chargé, transmise à from_pretrained. Par défaut, "auto", ce qui charge le modèle dans le dtype dans lequel il a été enregistré (lu depuis config.dtype du checkpoint, sinon déduit des poids). Passez un torch.float16, torch.bfloat16, torch.float32, … explicite pour l’écraser.
  • binary_output (bool, facultatif, par défaut False) — Indique si la sortie du pipeline doit être au format sérialisé (c.-à-d. pickle) ou sous forme de données brutes, par exemple du texte.

Pipeline de détection d'objets en zéro tir utilisant OwlViTForObjectDetection. Ce pipeline prédit les boîtes englobantes des objets lorsque vous fournissez une image et un ensemble de candidate_labels.

Exemple :

>>> from transformers import pipeline

>>> detector = pipeline(model="google/owlvit-base-patch32", task="zero-shot-object-detection")
>>> detector(
...     "http://images.cocodataset.org/val2017/000000039769.jpg",
...     candidate_labels=["cat", "couch"],
... )
[{'score': 0.287, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}}, {'score': 0.254, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}}, {'score': 0.121, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}}]

>>> detector(
...     "https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png",
...     candidate_labels=["head", "bird"],
... )
[{'score': 0.119, 'label': 'bird', 'box': {'xmin': 71, 'ymin': 170, 'xmax': 410, 'ymax': 508}}]

En savoir plus sur les bases de l'utilisation d'un pipeline dans le tutoriel sur les pipelines

Ce pipeline de détection d'objets peut actuellement être chargé depuis pipeline() en utilisant l'identifiant de tâche suivant : "zero-shot-object-detection".

Consultez la liste des modèles disponibles sur huggingface.co/models.

__call__

< >

( image: typing.Union[str, ForwardRef('Image.Image'), list[dict[str, typing.Any]]]candidate_labels: str | list[str] | None = None**kwargs: Any )

Paramètres

  • image (str, PIL.Image ou list[dict[str, Any]]) — Le pipeline gère trois types d'images :
    • Une chaîne de caractères contenant une URL http pointant vers une image
    • Une chaîne de caractères contenant un chemin local vers une image
    • Une image chargée directement dans PIL

    Vous pouvez utiliser ce paramètre pour envoyer directement une liste d’images, ou un jeu de données ou un générateur, comme suit :

Détecter les objets (boîtes englobantes & classes) dans l'image ou les images passées en entrée.

Traitement du langage naturel

Les pipelines disponibles pour les tâches de traitement du langage naturel incluent les suivants.

FillMaskPipeline

classe transformers.FillMaskPipeline

< >

( model: PreTrainedModeltokenizer: PreTrainedTokenizer | None = Nonefeature_extractor: PreTrainedFeatureExtractor | None = Noneimage_processor: BaseImageProcessor | None = Nonevideo_processor: BaseVideoProcessor | None = Noneprocessor: ProcessorMixin | None = Nonetask: str = ''device: int | torch.device | None = Nonebinary_output: bool = False**kwargs )

Paramètres

  • model (PreTrainedModel) — Le modèle qui sera utilisé par le pipeline pour effectuer des prédictions. Il doit s’agir d’un modèle héritant de PreTrainedModel.
  • tokenizer (PreTrainedTokenizer) — Le tokenizer utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de PreTrainedTokenizer.
  • task (str, par défaut "") — Identifiant de tâche pour le pipeline.
  • num_workers (int, facultatif, valeur par défaut 8) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), le nombre de workers à utiliser.
  • batch_size (int, facultatif, par défaut 1) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), la taille du lot à utiliser. Pour l'inférence, cela n'est pas toujours bénéfique, veuillez lire Batching with pipelines .
  • args_parser (ArgumentHandler, facultatif) — Référence à l'objet chargé de l'analyse des paramètres de pipeline fournis.
  • device (int ou str ou torch.device, facultatif) — Appareil sur lequel le pipeline est alloué. S'il n'est pas défini, le pipeline est placé sur le premier accélérateur disponible (CUDA, MPS, XPU, …) et ne bascule sur le CPU que si aucun n'est disponible ; le modèle y est déplacé automatiquement. Passez device="cpu" (ou -1) pour forcer le CPU, un ordinal positif ou "cuda:1" pour sélectionner un accélérateur spécifique, ou un torch.device/str natif. Cet argument ne peut pas être combiné avec un modèle déjà chargé via accelerate (c'est-à-dire un modèle ayant un hf_device_map).
  • dtype (str ou torch.dtype, facultatif, par défaut "auto") — Précision dans laquelle le modèle est chargé, transmise à from_pretrained. Par défaut, "auto", ce qui charge le modèle dans le dtype dans lequel il a été enregistré (lu depuis config.dtype du checkpoint, sinon déduit des poids). Passez un torch.float16, torch.bfloat16, torch.float32, … explicite pour l’écraser.
  • binary_output (bool, facultatif, par défaut False) — Indique si la sortie du pipeline doit être au format sérialisé (c.-à-d. pickle) ou sous forme de données brutes, par exemple du texte.
  • top_k (int, facultatif, par défaut 5) — Le nombre de prédictions à retourner.
  • targets (str ou list[str], facultatif) — Lorsqu’il est fourni, le modèle limite les scores aux cibles transmises au lieu de les rechercher dans tout le vocabulaire. Si les cibles fournies ne figurent pas dans le vocabulaire du modèle, elles seront tokenisées et le premier jeton résultant sera utilisé (avec un avertissement, et cela peut être plus lent).
  • tokenizer_kwargs (dict, facultatif) — Dictionnaire supplémentaire d'arguments nominaux transmis au tokenizer.

__call__

< >

( inputs: str | list[str]**kwargs: Any ) → A list or a list of list of dict

Paramètres

  • inputs (str ou list[str]) — Un ou plusieurs textes (ou une liste de prompts) contenant des jetons masqués.
  • targets (str ou list[str], facultatif) — Lorsqu’il est fourni, le modèle limite les scores aux cibles transmises au lieu de les rechercher dans tout le vocabulaire. Si les cibles fournies ne figurent pas dans le vocabulaire du modèle, elles seront tokenisées et le premier jeton résultant sera utilisé (avec un avertissement, et cela peut être plus lent).
  • top_k (int, facultatif) — Lorsqu’il est fourni, il remplace le nombre de prédictions à retourner.

Retourne

Une liste ou une liste de listes de dict

Chaque résultat est fourni sous forme de liste de dictionnaires avec les clés suivantes :

  • sequence (str) — L'entrée correspondante avec la prédiction du jeton de masque.
  • score (float) — La probabilité correspondante.
  • token (int) — L'identifiant du jeton prédit (pour remplacer celui masqué).
  • token_str (str) — Le jeton prédit (pour remplacer le jeton masqué).

Remplissez le jeton masqué dans le ou les textes donnés en entrées.

TableQuestionAnsweringPipeline

classe transformers.TableQuestionAnsweringPipeline

< >

( args_parser = <transformers.pipelines.table_question_answering.TableQuestionAnsweringArgumentHandler object at 0x7f6a12674950>**kwargs )

Paramètres

  • model (PreTrainedModel) — Le modèle qui sera utilisé par le pipeline pour effectuer des prédictions. Il doit s’agir d’un modèle héritant de PreTrainedModel.
  • tokenizer (PreTrainedTokenizer) — Le tokenizer utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de PreTrainedTokenizer.
  • task (str, par défaut "") — Identifiant de tâche pour le pipeline.
  • num_workers (int, facultatif, valeur par défaut 8) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), le nombre de workers à utiliser.
  • batch_size (int, facultatif, par défaut 1) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), la taille du lot à utiliser. Pour l'inférence, cela n'est pas toujours bénéfique, veuillez lire Batching with pipelines .
  • args_parser (ArgumentHandler, facultatif) — Référence à l'objet chargé de l'analyse des paramètres de pipeline fournis.
  • device (int ou str ou torch.device, facultatif) — Appareil sur lequel le pipeline est alloué. S'il n'est pas défini, le pipeline est placé sur le premier accélérateur disponible (CUDA, MPS, XPU, …) et ne bascule sur le CPU que si aucun n'est disponible ; le modèle y est déplacé automatiquement. Passez device="cpu" (ou -1) pour forcer le CPU, un ordinal positif ou "cuda:1" pour sélectionner un accélérateur spécifique, ou un torch.device/str natif. Cet argument ne peut pas être combiné avec un modèle déjà chargé via accelerate (c'est-à-dire un modèle ayant un hf_device_map).
  • dtype (str ou torch.dtype, facultatif, par défaut "auto") — Précision dans laquelle le modèle est chargé, transmise à from_pretrained. Par défaut, "auto", ce qui charge le modèle dans le dtype dans lequel il a été enregistré (lu depuis config.dtype du checkpoint, sinon déduit des poids). Passez un torch.float16, torch.bfloat16, torch.float32, … explicite pour l’écraser.
  • binary_output (bool, facultatif, par défaut False) — Indique si la sortie du pipeline doit être au format sérialisé (c.-à-d. pickle) ou sous forme de données brutes, par exemple du texte.

Pipeline de réponse à des questions sur des tableaux utilisant un ModelForTableQuestionAnswering. Ce pipeline n'est disponible que dans PyTorch.

À moins que le modèle que vous utilisez ne définisse explicitement ces paramètres de génération dans ses fichiers de configuration (generation_config.json), les valeurs par défaut suivantes seront utilisées :

  • max_new_tokens: 256

Exemple :

>>> from transformers import pipeline

>>> oracle = pipeline(model="google/tapas-base-finetuned-wtq")
>>> table = {
...     "Repository": ["Transformers", "Datasets", "Tokenizers"],
...     "Stars": ["36542", "4512", "3934"],
...     "Contributors": ["651", "77", "34"],
...     "Programming language": ["Python", "Python", "Rust, Python and NodeJS"],
... }
>>> oracle(query="How many stars does the transformers repository have?", table=table)
{'answer': 'AVERAGE > 36542', 'coordinates': [(0, 1)], 'cells': ['36542'], 'aggregator': 'AVERAGE'}

En savoir plus sur les bases de l'utilisation d'un pipeline dans le tutoriel sur les pipelines

Ce pipeline de réponse à des questions sur des tableaux peut actuellement être chargé à partir de pipeline() en utilisant l’identifiant de tâche suivant : "table-question-answering".

Les modèles que ce pipeline peut utiliser sont des modèles qui ont été affinés sur une tâche de réponse à des questions tabulaires. Consultez la liste à jour des modèles disponibles sur huggingface.co/models.

__call__

< >

( *args**kwargs ) → A dictionary or a list of dictionaries containing results

Paramètres

  • table (pd.DataFrame ou Dict) — DataFrame Pandas ou dictionnaire qui sera converti en DataFrame contenant toutes les valeurs du tableau. Voir ci-dessus un exemple de dictionnaire.
  • query (str ou list[str]) — Requête ou liste de requêtes qui sera envoyée au modèle avec le tableau.
  • sequential (bool, facultatif, par défaut False) — Indique si l'inférence doit être effectuée séquentiellement ou par lots. Le traitement par lots est plus rapide, mais des modèles comme SQA nécessitent que l'inférence soit réalisée séquentiellement pour extraire les relations au sein des séquences, compte tenu de leur nature conversationnelle.
  • padding (bool, str ou PaddingStrategy, facultatif, défaut : False) — Active et contrôle le padding. Accepte les valeurs suivantes :
    • True ou 'longest' : Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).
    • 'max_length' : Remplir jusqu'à une longueur maximale spécifiée par l'argument max_length ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.
    • False ou 'do_not_pad' (par défaut) : aucun padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).
  • truncation (bool, str ou TapasTruncationStrategy, facultatif, par défaut False) — Active et contrôle la troncature. Accepte les valeurs suivantes :
    • True ou 'drop_rows_to_fit' : tronque à une longueur maximale spécifiée avec l'argument max_length ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela tronque ligne par ligne, en supprimant des lignes du tableau.
    • False ou 'do_not_truncate' (par défaut) : aucune troncature (c’est-à-dire, peut produire un lot avec des longueurs de séquences supérieures à la taille d’entrée maximale admissible par le modèle).

Retourne

Un dictionnaire ou une liste de dictionnaires contenant les résultats

Chaque résultat est un dictionnaire avec les clés suivantes :

  • answer (str) — La réponse à la requête donnée le tableau. S’il existe un agrégateur, la réponse sera précédée de AGGREGATOR >.
  • coordonnées (list[tuple[int, int]]) — Coordonnées des cellules des réponses.
  • cells (list[str]) — Liste de chaînes de caractères constituée des valeurs des cellules de réponse.
  • aggregator (str) — Si le modèle possède un agrégateur, cela renvoie l'agrégateur.

Répond aux requêtes en fonction d'un tableau. Le pipeline accepte plusieurs types d'entrées, détaillés ci-dessous :

  • pipeline(table, query)
  • pipeline(table, [query])
  • pipeline(table=table, query=query)
  • pipeline(table=table, query=[query])
  • pipeline({"table": table, "query": query})
  • pipeline({"table": table, "query": [query]})
  • pipeline([{"table": table, "query": query}, {"table": table, "query": query}])

L'argument table doit être un dictionnaire ou un DataFrame construit à partir de ce dictionnaire, contenant le tableau entier :

Exemple :

data = {
    "actors": ["brad pitt", "leonardo di caprio", "george clooney"],
    "age": ["56", "45", "59"],
    "number of movies": ["87", "53", "69"],
    "date of birth": ["7 february 1967", "10 june 1996", "28 november 1967"],
}

Ce dictionnaire peut être transmis tel quel, ou converti en DataFrame pandas :

Exemple :

import pandas as pd

table = pd.DataFrame.from_dict(data)

TextClassificationPipeline

classe transformers.TextClassificationPipeline

< >

( **kwargs )

Paramètres

  • model (PreTrainedModel) — Le modèle qui sera utilisé par le pipeline pour effectuer des prédictions. Il doit s’agir d’un modèle héritant de PreTrainedModel.
  • tokenizer (PreTrainedTokenizer) — Le tokenizer utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de PreTrainedTokenizer.
  • task (str, par défaut "") — Identifiant de tâche pour le pipeline.
  • num_workers (int, facultatif, valeur par défaut 8) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), le nombre de workers à utiliser.
  • batch_size (int, facultatif, par défaut 1) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), la taille du lot à utiliser. Pour l'inférence, cela n'est pas toujours bénéfique, veuillez lire Batching with pipelines .
  • args_parser (ArgumentHandler, facultatif) — Référence à l'objet chargé de l'analyse des paramètres de pipeline fournis.
  • device (int ou str ou torch.device, facultatif) — Appareil sur lequel le pipeline est alloué. S'il n'est pas défini, le pipeline est placé sur le premier accélérateur disponible (CUDA, MPS, XPU, …) et ne bascule sur le CPU que si aucun n'est disponible ; le modèle y est déplacé automatiquement. Passez device="cpu" (ou -1) pour forcer le CPU, un ordinal positif ou "cuda:1" pour sélectionner un accélérateur spécifique, ou un torch.device/str natif. Cet argument ne peut pas être combiné avec un modèle déjà chargé via accelerate (c'est-à-dire un modèle ayant un hf_device_map).
  • dtype (str ou torch.dtype, facultatif, par défaut "auto") — Précision dans laquelle le modèle est chargé, transmise à from_pretrained. Par défaut, "auto", ce qui charge le modèle dans le dtype dans lequel il a été enregistré (lu depuis config.dtype du checkpoint, sinon déduit des poids). Passez un torch.float16, torch.bfloat16, torch.float32, … explicite pour l’écraser.
  • binary_output (bool, facultatif, par défaut False) — Indique si la sortie du pipeline doit être au format sérialisé (c.-à-d. pickle) ou sous forme de données brutes, par exemple du texte.
  • function_to_apply (str, facultatif, par défaut "default") — La fonction à appliquer aux sorties du modèle afin de récupérer les scores. Accepte quatre valeurs différentes :
    • "default" : si le modèle possède un seul label, la fonction sigmoïde est appliquée à la sortie. Si le modèle possède plusieurs labels, la fonction softmax est appliquée à la sortie. Dans le cas de tâches de régression, aucune fonction n’est appliquée à la sortie.
    • "sigmoid" : Applique la fonction sigmoïde à la sortie.
    • "softmax" : Applique la fonction softmax à la sortie.
    • "none" : N’applique aucune fonction à la sortie.

Pipeline de classification de texte utilisant n'importe quel ModelForSequenceClassification. Consultez les exemples de classification de séquences pour plus d'informations.

Exemple :

>>> from transformers import pipeline

>>> classifier = pipeline(model="distilbert/distilbert-base-uncased-finetuned-sst-2-english")
>>> classifier("This movie is disgustingly good !")
[{'label': 'POSITIVE', 'score': 1.0}]

>>> classifier("Director tried too much.")
[{'label': 'NEGATIVE', 'score': 0.996}]

En savoir plus sur les bases de l'utilisation d'un pipeline dans le tutoriel sur les pipelines

Ce pipeline de classification de texte peut actuellement être chargé depuis pipeline() en utilisant l'identifiant de tâche suivant : "sentiment-analysis" (pour classifier les séquences selon des sentiments positifs ou négatifs).

Si plusieurs étiquettes de classification sont disponibles (model.config.num_labels >= 2), le pipeline applique un softmax aux résultats. S’il n’y a qu’une seule étiquette, le pipeline applique une sigmoïde au résultat. Dans le cas des tâches de régression (model.config.problem_type == "regression"), aucune fonction n’est appliquée à la sortie.

Les modèles que ce pipeline peut utiliser sont des modèles ayant été affinés sur une tâche de classification de séquences. Consultez la liste à jour des modèles disponibles sur huggingface.co/models.

__call__

< >

( inputs: str | list[str] | dict[str, str] | list[dict[str, str]]**kwargs: Any ) → A list of dict

Paramètres

  • inputs (str ou list[str] ou dict[str], ou list[dict[str]]) — Un ou plusieurs textes à classifier. Pour utiliser des paires de textes pour votre classification, vous pouvez envoyer un dictionnaire contenant les clés {"text", "text_pair"}, ou une liste de ceux-ci.
  • top_k (int, facultatif, par défaut 1) — Nombre de résultats à retourner.
  • function_to_apply (str, facultatif, par défaut "default") — La fonction à appliquer aux sorties du modèle afin de récupérer les scores. Accepte quatre valeurs différentes :

    Si cet argument n'est pas spécifié, les fonctions suivantes sont appliquées en fonction du nombre d'étiquettes :

    • Si le type de problème est la régression, aucune fonction ne sera appliquée à la sortie.
    • Si le modèle possède une seule étiquette, la fonction sigmoïde sera appliquée à la sortie.
    • Si le modèle possède plusieurs étiquettes, la fonction softmax sera appliquée à la sortie.

    Les valeurs possibles sont :

    • "sigmoid" : Applique la fonction sigmoïde à la sortie.
    • "softmax" : Applique la fonction softmax à la sortie.
    • "none" : N’applique aucune fonction à la sortie.

Retourne

Une liste de dict

Chaque résultat est fourni sous forme de liste de dictionnaires avec les clés suivantes :

  • label (str) — L'étiquette prédite.
  • score (float) — La probabilité correspondante.

Si top_k est utilisé, un tel dictionnaire est renvoyé pour chaque étiquette.

Classifiez le ou les textes fournis en entrée.

TextGenerationPipeline

classe transformers.TextGenerationPipeline

< >

( *args**kwargs )

Paramètres

  • model (PreTrainedModel) — Le modèle qui sera utilisé par le pipeline pour effectuer des prédictions. Il doit s’agir d’un modèle héritant de PreTrainedModel.
  • tokenizer (PreTrainedTokenizer) — Le tokenizer utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de PreTrainedTokenizer.
  • task (str, par défaut "") — Identifiant de tâche pour le pipeline.
  • num_workers (int, facultatif, valeur par défaut 8) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), le nombre de workers à utiliser.
  • batch_size (int, facultatif, par défaut 1) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), la taille du lot à utiliser. Pour l'inférence, cela n'est pas toujours bénéfique, veuillez lire Batching with pipelines .
  • args_parser (ArgumentHandler, facultatif) — Référence à l'objet chargé de l'analyse des paramètres de pipeline fournis.
  • device (int ou str ou torch.device, facultatif) — Appareil sur lequel le pipeline est alloué. S'il n'est pas défini, le pipeline est placé sur le premier accélérateur disponible (CUDA, MPS, XPU, …) et ne bascule sur le CPU que si aucun n'est disponible ; le modèle y est déplacé automatiquement. Passez device="cpu" (ou -1) pour forcer le CPU, un ordinal positif ou "cuda:1" pour sélectionner un accélérateur spécifique, ou un torch.device/str natif. Cet argument ne peut pas être combiné avec un modèle déjà chargé via accelerate (c'est-à-dire un modèle ayant un hf_device_map).
  • dtype (str ou torch.dtype, facultatif, par défaut "auto") — Précision dans laquelle le modèle est chargé, transmise à from_pretrained. Par défaut, "auto", ce qui charge le modèle dans le dtype dans lequel il a été enregistré (lu depuis config.dtype du checkpoint, sinon déduit des poids). Passez un torch.float16, torch.bfloat16, torch.float32, … explicite pour l’écraser.
  • binary_output (bool, facultatif, par défaut False) — Indique si la sortie du pipeline doit être au format sérialisé (c.-à-d. pickle) ou sous forme de données brutes, par exemple du texte.

Pipeline de génération de langage utilisant n’importe quel ModelWithLMHead ou ModelForCausalLM. Ce pipeline prédit les mots qui suivront un prompt de texte spécifié. Lorsque le modèle sous-jacent est un modèle conversationnel, il peut également accepter une ou plusieurs conversations, auquel cas le pipeline fonctionnera en mode conversation et poursuivra la ou les conversations en ajoutant sa ou ses réponses. Chaque conversation prend la forme d’une liste de dictionnaires, où chaque dictionnaire contient les clés « role » et « content ».

À moins que le modèle que vous utilisez ne définisse explicitement ces paramètres de génération dans ses fichiers de configuration (generation_config.json), les valeurs par défaut suivantes seront utilisées :

  • max_new_tokens: 256
  • do_sample: True
  • temperature: 0.7

Exemples :

>>> from transformers import pipeline

>>> generator = pipeline(model="openai-community/gpt2")
>>> generator("I can't believe you did such a ", do_sample=False)
[{'generated_text': "I can't believe you did such a icky thing to me. I'm so sorry. I'm so sorry. I'm so sorry. I'm so sorry. I'm so sorry. I'm so sorry. I'm so sorry. I"}]

>>> # These parameters will return suggestions, and only the newly created text making it easier for prompting suggestions.
>>> outputs = generator("My tart needs some", num_return_sequences=4, return_full_text=False)
>>> from transformers import pipeline

>>> generator = pipeline(model="HuggingFaceH4/zephyr-7b-beta")
>>> # Zephyr-beta is a conversational model, so let's pass it a chat instead of a single string
>>> generator([{"role": "user", "content": "What is the capital of France? Answer in one word."}], do_sample=False, max_new_tokens=2)
[{'generated_text': [{'role': 'user', 'content': 'What is the capital of France? Answer in one word.'}, {'role': 'assistant', 'content': 'Paris'}]}]

En savoir plus sur les bases de l'utilisation d'un pipeline dans le tutoriel sur les pipelines. Vous pouvez passer des paramètres de génération de texte à ce pipeline pour contrôler les critères d'arrêt, la stratégie de décodage et plus encore. En savoir plus sur les paramètres de génération de texte dans Stratégies de génération de texte et Génération de texte.

Ce pipeline de génération de langage peut actuellement être chargé depuis pipeline() en utilisant l'identifiant de tâche suivant : "text-generation".

Les modèles que ce pipeline peut utiliser sont des modèles entraînés avec un objectif de modélisation de langage autorégressif. Consultez la liste des modèles de complétion de texte et la liste des modèles conversationnels sur [huggingface.co/models].

__call__

< >

( text_inputs**kwargs ) → A list or a list of lists of dict

Paramètres

  • text_inputs (str, list[str], ChatType ou list[ChatType]) — Un ou plusieurs prompts (ou une liste de prompts) à compléter. Si des chaînes de caractères ou une liste de chaînes sont transmises, ce pipeline poursuivra chaque prompt. Sinon, un « chat », sous la forme d’une liste de dictionnaires avec les clés « role » et « content », peut être transmis, ou une liste de tels chats. Lorsque des chats sont transmis, le modèle de chat du modèle sera utilisé pour les formater avant de les passer au modèle.
  • return_tensors (bool, facultatif, par défaut False) — Retourne les tenseurs des prédictions (sous forme d’indices de jetons) dans les sorties. Si défini sur True, le texte décodé n’est pas retourné.
  • return_text (bool, facultatif) — Retourne les textes décodés dans les sorties.
  • return_full_text (bool, facultatif, par défaut True) — Si défini sur False, seul le texte ajouté est renvoyé, sinon le texte complet est renvoyé. Ne peut pas être spécifié en même temps que return_text.
  • clean_up_tokenization_spaces (bool, facultatif) — Indique s'il faut nettoyer les espaces supplémentaires potentiels dans la sortie texte. Par défaut, utilise le paramètre clean_up_tokenization_spaces du tokenizer.
  • continue_final_message( bool, optionnel) — Indique que vous souhaitez que le modèle poursuive le dernier message de la conversation d’entrée plutôt que d’en démarrer un nouveau, ce qui permet de « préremplir » sa réponse. Par défaut, cette valeur est True si le dernier message de la conversation d’entrée a le rôle assistant et False dans le cas contraire, mais vous pouvez outrepasser ce comportement en définissant manuellement ce drapeau.
  • prefix (str, facultatif) — Préfixe ajouté au prompt.
  • stop_sequence (str ou list[str], facultatif) — Une ou plusieurs chaînes qui arrêtent la génération une fois générées. La chaîne d’arrêt est incluse dans la sortie.
  • handle_long_generation (str, facultatif) — Par défaut, ce pipeline ne gère pas les générations longues (celles qui dépassent, d'une manière ou d'une autre, la longueur maximale du modèle). Il n'existe pas de solution parfaite pour y remédier (plus d'informationshttps://github.com/huggingface/transformers/issues/14033#issuecomment-948385227). Cela fournit des stratégies courantes pour contourner ce problème en fonction de votre cas d'utilisation.
    • None : stratégie par défaut où rien de particulier ne se produit
    • "hole" : Tronque à gauche de l’entrée et laisse un espace assez large pour permettre la génération (peut tronquer une grande partie du prompt et n’est pas adapté lorsque la génération dépasse la capacité du modèle)
  • tokenizer_encode_kwargs (dict, facultatif) — Arguments supplémentaires à transmettre à l'étape d'encodage du tokenizer. Si l'entrée texte est une conversation, ils sont passés à apply_chat_template. Sinon, ils sont passés à __call__.
  • generate_kwargs (dict, facultatif) — Arguments supplémentaires à passer à la méthode generate du modèle (voir la méthode generate ici).

Retourne

Une liste ou une liste de listes de dict

Retourne l'un des dictionnaires suivants (ne peut pas retourner une combinaison de generated_text et generated_token_ids) :

  • generated_text (str, présent lorsque return_text=True) — Le texte généré.
  • generated_token_ids (torch.Tensor, présent lorsque return_tensors=True) — Les identifiants de jetons du texte généré.

Complétez le ou les prompts fournis en tant qu'entrées.

TokenClassificationPipeline

classe transformers.TokenClassificationPipeline

< >

( args_parser = <transformers.pipelines.token_classification.TokenClassificationArgumentHandler object at 0x7f6a12e05a50>**kwargs )

Paramètres

  • model (PreTrainedModel) — Le modèle qui sera utilisé par le pipeline pour effectuer des prédictions. Il doit s’agir d’un modèle héritant de PreTrainedModel.
  • tokenizer (PreTrainedTokenizer) — Le tokenizer utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de PreTrainedTokenizer.
  • task (str, par défaut "") — Identifiant de tâche pour le pipeline.
  • num_workers (int, facultatif, valeur par défaut 8) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), le nombre de workers à utiliser.
  • batch_size (int, facultatif, par défaut 1) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), la taille du lot à utiliser. Pour l'inférence, cela n'est pas toujours bénéfique, veuillez lire Batching with pipelines .
  • args_parser (ArgumentHandler, facultatif) — Référence à l'objet chargé de l'analyse des paramètres de pipeline fournis.
  • device (int ou str ou torch.device, facultatif) — Appareil sur lequel le pipeline est alloué. S'il n'est pas défini, le pipeline est placé sur le premier accélérateur disponible (CUDA, MPS, XPU, …) et ne bascule sur le CPU que si aucun n'est disponible ; le modèle y est déplacé automatiquement. Passez device="cpu" (ou -1) pour forcer le CPU, un ordinal positif ou "cuda:1" pour sélectionner un accélérateur spécifique, ou un torch.device/str natif. Cet argument ne peut pas être combiné avec un modèle déjà chargé via accelerate (c'est-à-dire un modèle ayant un hf_device_map).
  • dtype (str ou torch.dtype, facultatif, par défaut "auto") — Précision dans laquelle le modèle est chargé, transmise à from_pretrained. Par défaut, "auto", ce qui charge le modèle dans le dtype dans lequel il a été enregistré (lu depuis config.dtype du checkpoint, sinon déduit des poids). Passez un torch.float16, torch.bfloat16, torch.float32, … explicite pour l’écraser.
  • binary_output (bool, facultatif, par défaut False) — Indique si la sortie du pipeline doit être au format sérialisé (c.-à-d. pickle) ou sous forme de données brutes, par exemple du texte.
  • ignore_labels (list[str], par défaut ["O"]) — Une liste d'étiquettes à ignorer.
  • stride (int, facultatif) — Si stride est fourni, le pipeline est appliqué à l'ensemble du texte. Le texte est découpé en blocs de taille model_max_length. Fonctionne uniquement avec les tokenizers rapides et aggregation_strategy différent de NONE. La valeur de cet argument définit le nombre de jetons superposés entre les blocs. Autrement dit, le modèle avance de tokenizer.model_max_length - stride jetons à chaque étape.
  • aggregation_strategy (str, facultatif, par défaut "none") — La stratégie à utiliser pour fusionner (ou non) les jetons en fonction de la prédiction du modèle. « none » : n'effectue aucune agrégation et renvoie simplement les résultats bruts du modèle. « simple » : tente de regrouper les entités selon le schéma par défaut. (A, B-TAG), (B, I-TAG), (C, I-TAG), (D, B-TAG2) (E, B-TAG2) aboutiront à [{“word”: ABC, “entity”: “TAG”}, {“word”: “D”, “entity”: “TAG2”}, {“word”: “E”, “entity”: “TAG2”}]. Notez que deux étiquettes B consécutives aboutiront à des entités distinctes. Pour les langues basées sur les mots, il est possible de scinder des mots de manière indésirable : imaginez que Microsoft soit étiqueté comme [{“word”: “Micro”, “entity”: “ENTERPRISE”}, {“word”: “soft”, “entity”: “NAME”}]. Consultez FIRST, MAX et AVERAGE pour des méthodes permettant d'atténuer ce problème et de désambiguïser les mots (pour les langues qui supportent ce sens, c'est-à-dire les jetons séparés par un espace). Ces atténuations ne fonctionneront que sur les mots réels ; « New york » pourrait toujours être étiqueté avec deux entités différentes. « first » : (fonctionne uniquement avec les modèles basés sur les mots) Utilise la stratégie SIMPLE, à l'exception que les mots ne peuvent pas recevoir des étiquettes différentes. En cas d'ambiguïté, les mots utiliseront simplement l'étiquette du premier jeton du mot. « average » : (fonctionne uniquement avec les modèles basés sur les mots) Utilise la stratégie SIMPLE, à l'exception que les mots ne peuvent pas recevoir des étiquettes différentes. Les scores sont d'abord moyennés entre les jetons, puis l'étiquette maximale est appliquée. « max » : (fonctionne uniquement avec les modèles basés sur les mots) Utilise la stratégie SIMPLE, à l'exception que les mots ne peuvent pas recevoir des étiquettes différentes. L'entité du mot sera simplement le jeton ayant le score maximal.
    • “none” : ne réalise aucune agrégation et renvoie simplement les résultats bruts du modèle
    • “simple” : Tentera de regrouper les entités selon le schéma par défaut. (A, B-TAG), (B, I-TAG), (C, I-TAG), (D, B-TAG2) (E, B-TAG2) aboutiront à [{“word”: ABC, “entity”: “TAG”}, {“word”: “D”, “entity”: “TAG2”}, {“word”: “E”, “entity”: “TAG2”}] Notez que deux étiquettes B consécutives aboutiront à des entités distinctes. Pour les langues basées sur les mots, nous risquons de scinder les mots de manière indésirable : imaginez Microsoft étiqueté comme [{“word”: “Micro”, “entity”: “ENTERPRISE”}, {“word”: “soft”, “entity”: “NAME”}]. Consultez FIRST, MAX, AVERAGE pour des moyens d’atténuer ce problème et de désambiguïser les mots (dans les langues qui supportent ce sens, c’est-à-dire essentiellement les jetons séparés par un espace). Ces atténuations ne fonctionneront que sur les mots réels, “New york” pourrait toujours être étiqueté avec deux entités différentes.
    • “first” : (fonctionne uniquement sur les modèles basés sur les mots) Utilise la stratégie SIMPLE, à l’exception que les mots ne peuvent pas se retrouver avec des étiquettes différentes. En cas d’ambiguïté, les mots utilisent simplement l’étiquette du premier jeton du mot.
    • “average” : (fonctionne uniquement sur les modèles basés sur les mots) Utilisera la stratégie SIMPLE, à l’exception du fait que les mots ne peuvent pas se voir attribuer des étiquettes différentes. Les scores sont d’abord moyennés sur les jetons, puis l’étiquette maximale est appliquée.
    • “max” : (fonctionne uniquement sur les modèles basés sur les mots) Utilise la stratégie SIMPLE, à l’exception du fait que les mots ne peuvent pas se retrouver avec des étiquettes différentes. L’entité mot sera simplement le jeton ayant le score maximal.

Pipeline de reconnaissance d'entités nommées utilisant n'importe quel ModelForTokenClassification. Consultez les exemples de reconnaissance d'entités nommées pour plus d'informations.

Exemple :

>>> from transformers import pipeline

>>> token_classifier = pipeline(model="Jean-Baptiste/camembert-ner", aggregation_strategy="simple")
>>> sentence = "Je m'appelle jean-baptiste et je vis à montréal"
>>> tokens = token_classifier(sentence)
>>> tokens
[{'entity_group': 'PER', 'score': 0.9931, 'word': 'jean-baptiste', 'start': 12, 'end': 26}, {'entity_group': 'LOC', 'score': 0.998, 'word': 'montréal', 'start': 38, 'end': 47}]

>>> token = tokens[0]
>>> # Start and end provide an easy way to highlight words in the original text.
>>> sentence[token["start"] : token["end"]]
' jean-baptiste'

>>> # Some models use the same idea to do part of speech.
>>> syntaxer = pipeline(model="vblagoje/bert-english-uncased-finetuned-pos", aggregation_strategy="simple")
>>> syntaxer("My name is Sarah and I live in London")
[{'entity_group': 'PRON', 'score': 0.999, 'word': 'my', 'start': 0, 'end': 2}, {'entity_group': 'NOUN', 'score': 0.997, 'word': 'name', 'start': 3, 'end': 7}, {'entity_group': 'AUX', 'score': 0.994, 'word': 'is', 'start': 8, 'end': 10}, {'entity_group': 'PROPN', 'score': 0.999, 'word': 'sarah', 'start': 11, 'end': 16}, {'entity_group': 'CCONJ', 'score': 0.999, 'word': 'and', 'start': 17, 'end': 20}, {'entity_group': 'PRON', 'score': 0.999, 'word': 'i', 'start': 21, 'end': 22}, {'entity_group': 'VERB', 'score': 0.998, 'word': 'live', 'start': 23, 'end': 27}, {'entity_group': 'ADP', 'score': 0.999, 'word': 'in', 'start': 28, 'end': 30}, {'entity_group': 'PROPN', 'score': 0.999, 'word': 'london', 'start': 31, 'end': 37}]

En savoir plus sur les bases de l'utilisation d'un pipeline dans le tutoriel sur les pipelines

Ce pipeline de reconnaissance de jetons peut actuellement être chargé depuis pipeline() en utilisant l'identifiant de tâche suivant : "ner" (pour prédire les classes des jetons dans une séquence : personne, organisation, lieu ou divers).

Les modèles que ce pipeline peut utiliser sont des modèles ayant été affinés sur une tâche de classification de jetons. Consultez la liste à jour des modèles disponibles sur huggingface.co/models.

__call__

< >

( inputs: str | list[str]**kwargs: Any ) → A list or a list of list of dict

Paramètres

  • inputs (str ou List[str]) — Un ou plusieurs textes (ou une liste de textes) pour la classification de jetons. Peut être pré-tokenisé lorsque is_split_into_words=True.

Retourne

Une liste ou une liste de listes de dict

Chaque résultat est fourni sous forme d'une liste de dictionnaires (un pour chaque jeton de l'entrée correspondante, ou pour chaque entité si ce pipeline a été instancié avec un aggregation_strategy) avec les clés suivantes :

  • word (str) — Le jeton/mot classifié. Il est obtenu en décodant les jetons sélectionnés. Si vous souhaitez obtenir la chaîne exacte dans la phrase d’origine, utilisez start et end.
  • score (float) — La probabilité correspondante pour entity.
  • entity (str) — L’entité prédite pour ce jeton/mot (elle est nommée entity_group lorsque aggregation_strategy n’est pas "none".
  • index (int, présent uniquement lorsque aggregation_strategy="none") — L'index du jeton correspondant dans la phrase.
  • début (int, facultatif) — L'index du début de l'entité correspondante dans la phrase. N'existe que si les décalages sont disponibles dans le tokeniseur
  • end (int, facultatif) — L'index de la fin de l'entité correspondante dans la phrase. N'existe que si les décalages sont disponibles dans le tokenizer

Classifiez chaque jeton des textes donnés en entrées.

aggregate_words

< >

( entities: listaggregation_strategy: AggregationStrategy )

Remplacez les jetons d'un mot donné qui ne sont pas d'accord pour forcer l'accord sur les limites de mots.

Exemple : micro|soft| com|pany| B-ENT I-NAME I-ENT I-ENT sera réécrit avec la première stratégie en microsoft| company| B-ENT I-ENT

gather_pre_entities

< >

( sentence: strinput_ids: ndarrayscores: ndarrayoffset_mapping: list[tuple[int, int]] | Nonespecial_tokens_mask: ndarrayaggregation_strategy: AggregationStrategyword_ids: list[int | None] | None = Noneword_to_chars_map: list[tuple[int, int]] | None = None )

Fusionne divers tableaux numpy en dictionnaires contenant toutes les informations nécessaires pour l'agrégation

group_entities

< >

( entities: list )

Paramètres

  • entities (dict) — Les entités prédites par le pipeline.

Trouver et regrouper les jetons adjacents ayant la même entité prédite.

group_sub_entities

< >

( entities: list )

Paramètres

  • entities (dict) — Les entités prédites par le pipeline.

Regrouper les jetons adjacents ayant la même entité prédite.

ZeroShotClassificationPipeline

classe transformers.ZeroShotClassificationPipeline

< >

( args_parser = <transformers.pipelines.zero_shot_classification.ZeroShotClassificationArgumentHandler object at 0x7f6a126906d0>**kwargs )

Paramètres

  • model (PreTrainedModel) — Le modèle qui sera utilisé par le pipeline pour effectuer des prédictions. Il doit s’agir d’un modèle héritant de PreTrainedModel.
  • tokenizer (PreTrainedTokenizer) — Le tokenizer utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de PreTrainedTokenizer.
  • task (str, par défaut "") — Identifiant de tâche pour le pipeline.
  • num_workers (int, facultatif, valeur par défaut 8) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), le nombre de workers à utiliser.
  • batch_size (int, facultatif, par défaut 1) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), la taille du lot à utiliser. Pour l'inférence, cela n'est pas toujours bénéfique, veuillez lire Batching with pipelines .
  • args_parser (ArgumentHandler, facultatif) — Référence à l'objet chargé de l'analyse des paramètres de pipeline fournis.
  • device (int ou str ou torch.device, facultatif) — Appareil sur lequel le pipeline est alloué. S'il n'est pas défini, le pipeline est placé sur le premier accélérateur disponible (CUDA, MPS, XPU, …) et ne bascule sur le CPU que si aucun n'est disponible ; le modèle y est déplacé automatiquement. Passez device="cpu" (ou -1) pour forcer le CPU, un ordinal positif ou "cuda:1" pour sélectionner un accélérateur spécifique, ou un torch.device/str natif. Cet argument ne peut pas être combiné avec un modèle déjà chargé via accelerate (c'est-à-dire un modèle ayant un hf_device_map).
  • dtype (str ou torch.dtype, facultatif, par défaut "auto") — Précision dans laquelle le modèle est chargé, transmise à from_pretrained. Par défaut, "auto", ce qui charge le modèle dans le dtype dans lequel il a été enregistré (lu depuis config.dtype du checkpoint, sinon déduit des poids). Passez un torch.float16, torch.bfloat16, torch.float32, … explicite pour l’écraser.
  • binary_output (bool, facultatif, par défaut False) — Indique si la sortie du pipeline doit être au format sérialisé (c.-à-d. pickle) ou sous forme de données brutes, par exemple du texte.

Pipeline de classification zéro-tir basée sur le NLI, utilisant un ModelForSequenceClassification entraîné sur des tâches de NLI (inférence de langage naturel). Équivalent des pipelines text-classification, mais ces modèles n’exigent pas un nombre de classes potentielles prédéfini, celui-ci pouvant être choisi à l’exécution. Cela signifie généralement que c’est plus lent, mais c’est beaucoup plus flexible.

Toute combinaison de séquences et d'étiquettes peut être transmise, et chaque combinaison sera présentée comme une paire prémisse/hypothèse et transmise au modèle pré-entraîné. Ensuite, le logit de entailment est pris comme logit de validité de l'étiquette candidate. Tout modèle NLI peut être utilisé, mais l'identifiant de l'étiquette entailment doit être inclus dans :attr:~transformers.PreTrainedConfig.label2id de la configuration du modèle.

Exemple :

>>> from transformers import pipeline

>>> oracle = pipeline(model="facebook/bart-large-mnli")
>>> oracle(
...     "I have a problem with my iphone that needs to be resolved asap!!",
...     candidate_labels=["urgent", "not urgent", "phone", "tablet", "computer"],
... )
{'sequence': 'I have a problem with my iphone that needs to be resolved asap!!', 'labels': ['urgent', 'phone', 'computer', 'not urgent', 'tablet'], 'scores': [0.504, 0.479, 0.013, 0.003, 0.002]}

>>> oracle(
...     "I have a problem with my iphone that needs to be resolved asap!!",
...     candidate_labels=["english", "german"],
... )
{'sequence': 'I have a problem with my iphone that needs to be resolved asap!!', 'labels': ['english', 'german'], 'scores': [0.814, 0.186]}

En savoir plus sur les bases de l'utilisation d'un pipeline dans le tutoriel sur les pipelines

Ce pipeline NLI peut actuellement être chargé depuis pipeline() en utilisant l'identifiant de tâche suivant : "zero-shot-classification".

Les modèles que ce pipeline peut utiliser sont des modèles qui ont été affinés sur une tâche de NLI. Consultez la liste à jour des modèles disponibles sur huggingface.co/models.

__call__

< >

( sequences: str | list[str]*args**kwargs ) → A dict or a list of dict

Paramètres

  • sequences (str ou list[str]) — La ou les séquences à classifier. Elles seront tronquées si l’entrée du modèle est trop volumineuse.
  • candidate_labels (str ou list[str]) — L'ensemble des étiquettes de classes possibles pour classifier chaque séquence. Peut être une étiquette unique, une chaîne de caractères d'étiquettes séparées par des virgules, ou une liste d'étiquettes.
  • hypothesis_template (str, facultatif, par défaut "This example is {}.") — Le modèle utilisé pour transformer chaque étiquette en hypothèse de type NLI. Ce modèle doit inclure une syntaxe {} ou similaire pour insérer l'étiquette candidate dans le modèle. Par exemple, le modèle par défaut est "This example is {}." Avec l'étiquette candidate "sports", cela serait transmis au modèle comme "<cls> sequence to classify <sep> This example is sports . <sep>". Le modèle par défaut fonctionne bien dans de nombreux cas, mais il peut être utile d'expérimenter avec différents modèles en fonction du contexte de la tâche.
  • multi_label (bool, facultatif, par défaut False) — Indique si plusieurs étiquettes candidates peuvent être vraies. Si False, les scores sont normalisés de sorte que la somme des probabilités des étiquettes pour chaque séquence est égale à 1. Si True, les étiquettes sont considérées comme indépendantes et les probabilités sont normalisées pour chaque candidat en effectuant un softmax du score d’entailment par rapport au score de contradiction.

Retourne

Un dict ou une liste de dict

Chaque résultat est fourni sous forme de dictionnaire avec les clés suivantes :

  • sequence (str) — La séquence pour laquelle il s'agit de la sortie.
  • labels (list[str]) — Les étiquettes triées par ordre de probabilité.
  • scores (list[float]) — Les probabilités pour chacun des étiquettes.

Classifiez la ou les séquences fournies en entrée. Consultez la documentation de ZeroShotClassificationPipeline pour plus d'informations.

Multimodal

Les pipelines disponibles pour les tâches multimodales incluent les suivants.

DocumentQuestionAnsweringPipeline

classe transformers.DocumentQuestionAnsweringPipeline

< >

( *args**kwargs )

Paramètres

  • model (PreTrainedModel) — Le modèle qui sera utilisé par le pipeline pour effectuer des prédictions. Il doit s’agir d’un modèle héritant de PreTrainedModel.
  • tokenizer (PreTrainedTokenizer) — Le tokenizer utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de PreTrainedTokenizer.
  • image_processor (BaseImageProcessor) — Le processeur d’images utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de BaseImageProcessor.
  • task (str, par défaut "") — Identifiant de tâche pour le pipeline.
  • num_workers (int, facultatif, valeur par défaut 8) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), le nombre de workers à utiliser.
  • batch_size (int, facultatif, par défaut 1) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), la taille du lot à utiliser. Pour l'inférence, cela n'est pas toujours bénéfique, veuillez lire Batching with pipelines .
  • args_parser (ArgumentHandler, facultatif) — Référence à l'objet chargé de l'analyse des paramètres de pipeline fournis.
  • device (int ou str ou torch.device, facultatif) — Appareil sur lequel le pipeline est alloué. S'il n'est pas défini, le pipeline est placé sur le premier accélérateur disponible (CUDA, MPS, XPU, …) et ne bascule sur le CPU que si aucun n'est disponible ; le modèle y est déplacé automatiquement. Passez device="cpu" (ou -1) pour forcer le CPU, un ordinal positif ou "cuda:1" pour sélectionner un accélérateur spécifique, ou un torch.device/str natif. Cet argument ne peut pas être combiné avec un modèle déjà chargé via accelerate (c'est-à-dire un modèle ayant un hf_device_map).
  • dtype (str ou torch.dtype, facultatif, par défaut "auto") — Précision dans laquelle le modèle est chargé, transmise à from_pretrained. Par défaut, "auto", ce qui charge le modèle dans le dtype dans lequel il a été enregistré (lu depuis config.dtype du checkpoint, sinon déduit des poids). Passez un torch.float16, torch.bfloat16, torch.float32, … explicite pour l’écraser.
  • binary_output (bool, facultatif, par défaut False) — Indique si la sortie du pipeline doit être au format sérialisé (c.-à-d. pickle) ou sous forme de données brutes, par exemple du texte.

Pipeline de réponse à des questions sur des documents à l’aide de n’importe quel AutoModelForDocumentQuestionAnswering. Les entrées/sorties sont similaires à celles du pipeline de réponse à des questions (extractive) ; toutefois, le pipeline prend en entrée une image (et des mots/boîtes OCR facultatifs) au lieu d’un contexte texte.

À moins que le modèle que vous utilisez ne définisse explicitement ces paramètres de génération dans ses fichiers de configuration (generation_config.json), les valeurs par défaut suivantes seront utilisées :

  • max_new_tokens: 256

Exemple :

>>> from transformers import pipeline

>>> document_qa = pipeline(model="impira/layoutlm-document-qa")
>>> document_qa(
...     image="https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/invoice_docquery_a.png",
...     question="What is the invoice number?",
... )
[{'score': 0.425, 'answer': 'us-001', 'start': 16, 'end': 16}]

En savoir plus sur les bases de l'utilisation d'un pipeline dans le tutoriel sur les pipelines

Ce pipeline de question-réponse sur documents peut actuellement être chargé depuis pipeline() en utilisant l'identifiant de tâche suivant : "document-question-answering".

Les modèles que ce pipeline peut utiliser sont des modèles qui ont été affinés sur une tâche de question-réponse sur documents. Consultez la liste à jour des modèles disponibles sur huggingface.co/models.

__call__

< >

( image: typing.Union[ForwardRef('Image.Image'), str, list[dict[str, typing.Any]]]question: str | None = Noneword_boxes: tuple[str, list[float]] | None = None**kwargs: Any ) → A dict or a list of dict

Paramètres

  • image (str ou PIL.Image) — Le pipeline gère trois types d'images :
    • Une chaîne de caractères contenant un lien http pointant vers une image
    • Une chaîne de caractères contenant un chemin local vers une image
    • Une image chargée directement dans PIL

    Le pipeline accepte une image unique ou un lot d'images. Si une image unique est fournie, elle peut être diffusée à plusieurs questions.

  • question (str) — Une question à poser au document.
  • word_boxes (list[str, tuple[float, float, float, float]], facultatif) — Une liste de mots et de boîtes englobantes (normalisées 0->1000). Si vous fournissez cette entrée facultative, le pipeline utilisera ces mots et ces boîtes au lieu d’exécuter l’OCR sur l’image pour les dériver, pour les modèles qui en ont besoin (par ex. LayoutLM). Cela vous permet de réutiliser les résultats d’OCR à travers de nombreuses invocations du pipeline sans avoir à le relancer à chaque fois.
  • top_k (int, facultatif, valeur par défaut 1) — Le nombre de réponses à retourner (choisies par ordre de probabilité). Notez que nous retournons moins de réponses que top_k s'il n'y a pas suffisamment d'options disponibles dans le contexte.
  • doc_stride (int, facultatif, valeur par défaut 128) — Si les mots du document sont trop longs pour tenir avec la question pour le modèle, il sera divisé en plusieurs morceaux avec un certain chevauchement. Cet argument contrôle la taille de ce chevauchement.
  • max_answer_len (int, facultatif, valeur par défaut 15) — La longueur maximale des réponses prédites (par exemple, seules les réponses d’une longueur inférieure sont prises en compte).
  • max_seq_len (int, facultatif, valeur par défaut 384) — La longueur maximale de la phrase totale (contexte + question) en jetons de chaque fragment transmis au modèle. Le contexte sera divisé en plusieurs fragments (en utilisant doc_stride comme chevauchement) si nécessaire.
  • max_question_len (int, facultatif, valeur par défaut 64) — La longueur maximale de la question après tokenisation. Elle sera tronquée si nécessaire.
  • handle_impossible_answer (bool, facultatif, par défaut False) — Indique si « impossible » est accepté comme réponse.
  • lang (str, facultatif) — Langue à utiliser lors de l'exécution de l'OCR. La valeur par défaut est english.
  • tesseract_config (str, facultatif) — Drapeaux supplémentaires à passer à tesseract lors de l’exécution de l’OCR.
  • timeout (float, facultatif, par défaut None) — Durée maximale en secondes à attendre pour récupérer des images depuis le web. Si None, aucun délai d’attente n’est défini et l’appel peut bloquer indéfiniment.

Retourne

Un dict ou une liste de dict

Chaque résultat est fourni sous forme de dictionnaire avec les clés suivantes :

  • score (float) — La probabilité associée à la réponse.
  • start (int) — L'indice du mot de début de la réponse (dans la version OCR de l'entrée ou les word_boxes fournis).
  • end (int) — L'indice du mot de fin de la réponse (dans la version OCR de l'entrée ou les word_boxes fournis).
  • answer (str) — La réponse à la question.
  • words (list[int]) — L'index de chaque paire mot/boîte qui se trouve dans la réponse

Répondez à la ou aux questions fournies en entrées à l'aide du ou des documents. Un document est défini comme une image et une liste facultative de tuples (mot, boîte) représentant le texte du document. Si les word_boxes ne sont pas fournies, le moteur OCR Tesseract (s'il est disponible) est utilisé pour extraire automatiquement les mots et les boîtes pour les modèles de type LayoutLM qui les nécessitent en entrée. Pour Donut, aucun OCR n'est exécuté.

Vous pouvez invoquer le pipeline de plusieurs manières :

  • pipeline(image=image, question=question)
  • pipeline(image=image, question=question, word_boxes=word_boxes)
  • pipeline([{"image": image, "question": question}])
  • pipeline([{"image": image, "question": question, "word_boxes": word_boxes}])

FeatureExtractionPipeline

classe transformers.FeatureExtractionPipeline

< >

( model: PreTrainedModeltokenizer: PreTrainedTokenizer | None = Nonefeature_extractor: PreTrainedFeatureExtractor | None = Noneimage_processor: BaseImageProcessor | None = Nonevideo_processor: BaseVideoProcessor | None = Noneprocessor: ProcessorMixin | None = Nonetask: str = ''device: int | torch.device | None = Nonebinary_output: bool = False**kwargs )

Paramètres

  • model (PreTrainedModel) — Le modèle qui sera utilisé par le pipeline pour effectuer des prédictions. Il doit s’agir d’un modèle héritant de PreTrainedModel.
  • tokenizer (PreTrainedTokenizer) — Le tokenizer utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de PreTrainedTokenizer.
  • task (str, par défaut "") — Identifiant de tâche pour le pipeline.
  • num_workers (int, facultatif, valeur par défaut 8) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), le nombre de workers à utiliser.
  • batch_size (int, facultatif, par défaut 1) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), la taille du lot à utiliser. Pour l'inférence, cela n'est pas toujours bénéfique, veuillez lire Batching with pipelines .
  • args_parser (ArgumentHandler, facultatif) — Référence à l'objet chargé de l'analyse des paramètres de pipeline fournis.
  • device (int ou str ou torch.device, facultatif) — Appareil sur lequel le pipeline est alloué. S'il n'est pas défini, le pipeline est placé sur le premier accélérateur disponible (CUDA, MPS, XPU, …) et ne bascule sur le CPU que si aucun n'est disponible ; le modèle y est déplacé automatiquement. Passez device="cpu" (ou -1) pour forcer le CPU, un ordinal positif ou "cuda:1" pour sélectionner un accélérateur spécifique, ou un torch.device/str natif. Cet argument ne peut pas être combiné avec un modèle déjà chargé via accelerate (c'est-à-dire un modèle ayant un hf_device_map).
  • dtype (str ou torch.dtype, facultatif, par défaut "auto") — Précision dans laquelle le modèle est chargé, transmise à from_pretrained. Par défaut, "auto", ce qui charge le modèle dans le dtype dans lequel il a été enregistré (lu depuis config.dtype du checkpoint, sinon déduit des poids). Passez un torch.float16, torch.bfloat16, torch.float32, … explicite pour l’écraser.
  • tokenize_kwargs (dict, facultatif) — Dictionnaire supplémentaire d'arguments par mot-clé transmis au tokenizer.
  • return_tensors (bool, facultatif) — Si True, renvoie un tenseur selon le framework spécifié, sinon renvoie une liste.

Le pipeline d'extraction de caractéristiques n'utilise pas de tête de modèle. Ce pipeline extrait les états cachés du transformeur de base, qui peuvent être utilisés comme caractéristiques dans des tâches en aval.

Exemple :

>>> from transformers import pipeline

>>> extractor = pipeline(model="google-bert/bert-base-uncased", task="feature-extraction")
>>> result = extractor("This is a simple test.", return_tensors=True)
>>> result.shape  # This is a tensor of shape [1, sequence_length, hidden_dimension] representing the input string.
torch.Size([1, 8, 768])

En savoir plus sur les bases de l'utilisation d'un pipeline dans le tutoriel sur les pipelines

Ce pipeline d'extraction de caractéristiques peut actuellement être chargé depuis pipeline() en utilisant l'identifiant de tâche : "feature-extraction".

Tous les modèles peuvent être utilisés pour ce pipeline. Consultez la liste de tous les modèles, y compris les modèles contributés par la communauté sur huggingface.co/models.

__call__

< >

( *args: str | list[str]**kwargs: Any ) → A nested list of float

Paramètres

  • args (str ou list[str]) — Un ou plusieurs textes (ou une liste de textes) pour lesquels extraire les caractéristiques.

Retourne

Une liste imbriquée de float

Les caractéristiques calculées par le modèle.

Extrait les caractéristiques du ou des textes d'entrée.

ImageFeatureExtractionPipeline

classe transformers.ImageFeatureExtractionPipeline

< >

( model: PreTrainedModeltokenizer: PreTrainedTokenizer | None = Nonefeature_extractor: PreTrainedFeatureExtractor | None = Noneimage_processor: BaseImageProcessor | None = Nonevideo_processor: BaseVideoProcessor | None = Noneprocessor: ProcessorMixin | None = Nonetask: str = ''device: int | torch.device | None = Nonebinary_output: bool = False**kwargs )

Paramètres

  • model (PreTrainedModel) — Le modèle qui sera utilisé par le pipeline pour effectuer des prédictions. Il doit s’agir d’un modèle héritant de PreTrainedModel.
  • image_processor (BaseImageProcessor) — Le processeur d’images utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de BaseImageProcessor.
  • task (str, par défaut "") — Identifiant de tâche pour le pipeline.
  • num_workers (int, facultatif, valeur par défaut 8) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), le nombre de workers à utiliser.
  • batch_size (int, facultatif, par défaut 1) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), la taille du lot à utiliser. Pour l'inférence, cela n'est pas toujours bénéfique, veuillez lire Batching with pipelines .
  • args_parser (ArgumentHandler, facultatif) — Référence à l'objet chargé de l'analyse des paramètres de pipeline fournis.
  • device (int ou str ou torch.device, facultatif) — Appareil sur lequel le pipeline est alloué. S'il n'est pas défini, le pipeline est placé sur le premier accélérateur disponible (CUDA, MPS, XPU, …) et ne bascule sur le CPU que si aucun n'est disponible ; le modèle y est déplacé automatiquement. Passez device="cpu" (ou -1) pour forcer le CPU, un ordinal positif ou "cuda:1" pour sélectionner un accélérateur spécifique, ou un torch.device/str natif. Cet argument ne peut pas être combiné avec un modèle déjà chargé via accelerate (c'est-à-dire un modèle ayant un hf_device_map).
  • dtype (str ou torch.dtype, facultatif, par défaut "auto") — Précision dans laquelle le modèle est chargé, transmise à from_pretrained. Par défaut, "auto", ce qui charge le modèle dans le dtype dans lequel il a été enregistré (lu depuis config.dtype du checkpoint, sinon déduit des poids). Passez un torch.float16, torch.bfloat16, torch.float32, … explicite pour l’écraser.
  • binary_output (bool, facultatif, par défaut False) — Indique si la sortie du pipeline doit être au format sérialisé (c.-à-d. pickle) ou sous forme de données brutes, par exemple du texte.
  • image_processor_kwargs (dict, facultatif) — Dictionnaire supplémentaire d'arguments nominaux transmis au processeur d'images, par exemple {“size”: {“height”: 100, “width”: 100}‌}
  • pool (bool, facultatif, par défaut False) — Indique s'il faut ou non retourner la sortie agrégée. Si False, le modèle retournera les états cachés bruts.

Le pipeline d’extraction de caractéristiques d’images n’utilise pas de tête de modèle. Ce pipeline extrait les états cachés du transformeur de base, qui peuvent être utilisés comme caractéristiques dans des tâches en aval.

Exemple :

>>> from transformers import pipeline

>>> extractor = pipeline(model="google/vit-base-patch16-224", task="image-feature-extraction")
>>> result = extractor("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png", return_tensors=True)
>>> result.shape  # This is a tensor of shape [1, sequence_length, hidden_dimension] representing the input image.
torch.Size([1, 197, 768])

En savoir plus sur les bases de l'utilisation d'un pipeline dans le tutoriel sur les pipelines

Ce pipeline d’extraction de caractéristiques d’image peut actuellement être chargé depuis pipeline() en utilisant l’identifiant de tâche : "image-feature-extraction".

Tous les modèles de vision peuvent être utilisés pour ce pipeline. Consultez la liste de tous les modèles, y compris les modèles contributés par la communauté, sur huggingface.co/models.

__call__

< >

( *args: typing.Union[str, ForwardRef('Image.Image'), list['Image.Image'], list[str]]**kwargs: Any ) → A nested list of float

Paramètres

  • images (str, list[str], PIL.Image ou list[PIL.Image]) — Le pipeline gère trois types d'images :
    • Une chaîne de caractères contenant un lien http pointant vers une image
    • Une chaîne de caractères contenant un chemin local vers une image
    • Une image chargée directement dans PIL

    Le pipeline accepte une image unique ou un lot d'images, qui doivent alors être passées sous forme de chaîne de caractères. Les images d'un lot doivent toutes être au même format : toutes sous forme de liens http, toutes sous forme de chemins locaux, ou toutes sous forme d'images PIL.

  • timeout (float, facultatif, par défaut None) — Durée maximale en secondes à attendre pour récupérer des images depuis le web. Si None, aucun délai d’attente n’est appliqué et l’appel peut bloquer indéfiniment.

Retourne

Une liste imbriquée de float

Les caractéristiques calculées par le modèle.

Extrait les caractéristiques des entrées.

ImageTextToTextPipeline

classe transformers.ImageTextToTextPipeline

< >

( *args**kwargs )

Paramètres

  • model (PreTrainedModel) — Le modèle qui sera utilisé par le pipeline pour effectuer des prédictions. Il doit s’agir d’un modèle héritant de PreTrainedModel.
  • processor (ProcessorMixin) — Le processeur utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de ProcessorMixin. Le processeur est un objet composite qui peut contenir tokenizer, feature_extractor et image_processor.
  • task (str, par défaut "") — Identifiant de tâche pour le pipeline.
  • num_workers (int, facultatif, valeur par défaut 8) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), le nombre de workers à utiliser.
  • batch_size (int, facultatif, par défaut 1) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), la taille du lot à utiliser. Pour l'inférence, cela n'est pas toujours bénéfique, veuillez lire Batching with pipelines .
  • args_parser (ArgumentHandler, facultatif) — Référence à l'objet chargé de l'analyse des paramètres de pipeline fournis.
  • device (int ou str ou torch.device, facultatif) — Appareil sur lequel le pipeline est alloué. S'il n'est pas défini, le pipeline est placé sur le premier accélérateur disponible (CUDA, MPS, XPU, …) et ne bascule sur le CPU que si aucun n'est disponible ; le modèle y est déplacé automatiquement. Passez device="cpu" (ou -1) pour forcer le CPU, un ordinal positif ou "cuda:1" pour sélectionner un accélérateur spécifique, ou un torch.device/str natif. Cet argument ne peut pas être combiné avec un modèle déjà chargé via accelerate (c'est-à-dire un modèle ayant un hf_device_map).
  • dtype (str ou torch.dtype, facultatif, par défaut "auto") — Précision dans laquelle le modèle est chargé, transmise à from_pretrained. Par défaut, "auto", ce qui charge le modèle dans le dtype dans lequel il a été enregistré (lu depuis config.dtype du checkpoint, sinon déduit des poids). Passez un torch.float16, torch.bfloat16, torch.float32, … explicite pour l’écraser.
  • binary_output (bool, facultatif, par défaut False) — Indique si la sortie du pipeline doit être au format sérialisé (c.-à-d. pickle) ou sous forme de données brutes, par exemple du texte.

Pipeline image-texte-vers-texte utilisant un AutoModelForImageTextToText. Ce pipeline génère du texte à partir d’une image et d’un texte. Lorsque le modèle sous-jacent est un modèle conversationnel, il peut également accepter une ou plusieurs conversations, auquel cas le pipeline fonctionnera en mode conversation et poursuivra la ou les conversations en ajoutant sa ou ses réponses. Chaque conversation prend la forme d’une liste de dictionnaires, où chaque dictionnaire contient les clés « role » et « content ».

À moins que le modèle que vous utilisez ne définisse explicitement ces paramètres de génération dans ses fichiers de configuration (generation_config.json), les valeurs par défaut suivantes seront utilisées :

  • max_new_tokens: 256

Exemple :

>>> from transformers import pipeline

>>> pipe = pipeline(task="image-text-to-text", model="Salesforce/blip-image-captioning-base")
>>> pipe("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png", text="A photo of")
[{'generated_text': 'a photo of two birds'}]
>>> from transformers import pipeline

>>> pipe = pipeline("image-text-to-text", model="llava-hf/llava-interleave-qwen-0.5b-hf")
>>> messages = [
>>>     {
>>>         "role": "user",
>>>         "content": [
>>>             {
>>>                 "type": "image",
>>>                 "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/qwen_vl_demo.jpeg",
>>>             },
>>>             {"type": "text", "text": "Describe this image."},
>>>         ],
>>>     },
>>>     {
>>>         "role": "assistant",
>>>         "content": [
>>>             {"type": "text", "text": "There is a dog and"},
>>>         ],
>>>     },
>>> ]
>>> pipe(text=messages, max_new_tokens=20, return_full_text=False)
[{'input_text': [{'role': 'user',
    'content': [{'type': 'image',
    'url': 'https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/qwen_vl_demo.jpeg'},
    {'type': 'text', 'text': 'Describe this image.'}]},
{'role': 'assistant',
    'content': [{'type': 'text', 'text': 'There is a dog and'}]}],
'generated_text': ' a person in the image. The dog is sitting on the sand, and the person is sitting on'}]

En savoir plus sur les bases de l'utilisation d'un pipeline dans le tutoriel sur les pipelines

Ce pipeline image-texte vers texte peut actuellement être chargé à partir de pipeline() en utilisant l’identifiant de tâche suivant : “image-text-to-text”.

Consultez la liste des modèles disponibles sur huggingface.co/models.

__call__

< >

( images: typing.Union[str, list[str], list[list[str]], ForwardRef('Image.Image'), list['Image.Image'], list[list['Image.Image']], list[dict], NoneType] = Nonetext: str | list[str] | list[dict] | None = None**kwargs ) → A list or a list of list of dict

Paramètres

  • images (str, list[str], PIL.Image, list[PIL.Image], list[dict[str, Union[str, PIL.Image]]]`) — Le pipeline gère trois types d'images :
    • Une chaîne de caractères contenant un lien HTTP(s) pointant vers une image
    • Une chaîne de caractères contenant un chemin local vers une image
    • Une image chargée directement dans PIL

    Le pipeline accepte une image unique ou un lot d'images. Enfin, ce pipeline prend également en charge le format de chat (voir text) contenant des images et du texte dans cet argument.

  • text (str, list[str], list[dict[str, Union[str, PIL.Image]]]) — The text to be used for generation. If a list of strings is passed, the length of the list should be the same as the number of images. Text can also follow the chat format: a list of dictionaries where each dictionary represents a message in a conversation. Each dictionary should have two keys: ‘role’ and ‘content’. ‘role’ should be one of ‘user’, ‘system’ or ‘assistant’. ‘content’ should be a list of dictionary containing the text of the message and the type of the message. The type of the message can be either ‘text’ or ‘image’. If the type is ‘image’, no text is needed.
  • return_tensors (bool, facultatif, par défaut False) — Retourne les tenseurs des prédictions (sous forme d’indices de jetons) dans les sorties. Si défini sur True, le texte décodé n’est pas retourné.
  • return_text (bool, facultatif) — Retourne les textes décodés dans les sorties.
  • return_full_text (bool, facultatif, par défaut True) — Si défini sur False, seul le texte ajouté est renvoyé, sinon le texte complet est renvoyé. Ne peut pas être spécifié en même temps que return_text.
  • clean_up_tokenization_spaces (bool, facultatif) — Indique s'il faut nettoyer les espaces supplémentaires potentiels dans la sortie texte. Par défaut, utilise le paramètre clean_up_tokenization_spaces du tokenizer.
  • continue_final_message( bool, optionnel) — Indique que vous souhaitez que le modèle poursuive le dernier message de la conversation d’entrée plutôt que d’en démarrer un nouveau, ce qui permet de « préremplir » sa réponse. Par défaut, cette valeur est True si le dernier message de la conversation d’entrée a le rôle assistant et False dans le cas contraire, mais vous pouvez outrepasser ce comportement en définissant manuellement ce drapeau.

Retourne

Une liste ou une liste de listes de dict

Chaque résultat est renvoyé sous forme de dictionnaire avec la clé suivante (il est impossible de renvoyer une combinaison de generated_text et generated_token_ids) :

  • generated_text (str, présent lorsque return_text=True) — Le texte généré.
  • generated_token_ids (torch.Tensor, présent lorsque return_tensors=True) — Les identifiants de jetons du texte généré.
  • input_text (str) — Le texte d'entrée.

Générer un texte à partir du texte et des images passés en entrée.

AnyToAnyPipeline

classe transformers.AnyToAnyPipeline

< >

( *args**kwargs )

Paramètres

  • model (PreTrainedModel) — Le modèle qui sera utilisé par le pipeline pour effectuer des prédictions. Il doit s’agir d’un modèle héritant de PreTrainedModel.
  • processor (ProcessorMixin) — Le processeur utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de ProcessorMixin. Le processeur est un objet composite qui peut contenir tokenizer, feature_extractor et image_processor.
  • task (str, par défaut "") — Identifiant de tâche pour le pipeline.
  • num_workers (int, facultatif, valeur par défaut 8) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), le nombre de workers à utiliser.
  • batch_size (int, facultatif, par défaut 1) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), la taille du lot à utiliser. Pour l'inférence, cela n'est pas toujours bénéfique, veuillez lire Batching with pipelines .
  • args_parser (ArgumentHandler, facultatif) — Référence à l'objet chargé de l'analyse des paramètres de pipeline fournis.
  • device (int ou str ou torch.device, facultatif) — Appareil sur lequel le pipeline est alloué. S'il n'est pas défini, le pipeline est placé sur le premier accélérateur disponible (CUDA, MPS, XPU, …) et ne bascule sur le CPU que si aucun n'est disponible ; le modèle y est déplacé automatiquement. Passez device="cpu" (ou -1) pour forcer le CPU, un ordinal positif ou "cuda:1" pour sélectionner un accélérateur spécifique, ou un torch.device/str natif. Cet argument ne peut pas être combiné avec un modèle déjà chargé via accelerate (c'est-à-dire un modèle ayant un hf_device_map).
  • dtype (str ou torch.dtype, facultatif, par défaut "auto") — Précision dans laquelle le modèle est chargé, transmise à from_pretrained. Par défaut, "auto", ce qui charge le modèle dans le dtype dans lequel il a été enregistré (lu depuis config.dtype du checkpoint, sinon déduit des poids). Passez un torch.float16, torch.bfloat16, torch.float32, … explicite pour l’écraser.
  • binary_output (bool, facultatif, par défaut False) — Indique si la sortie du pipeline doit être au format sérialisé (c.-à-d. pickle) ou sous forme de données brutes, par exemple du texte.

Pipeline de génération multimodale utilisant un AutoModelForMultimodalLM. Ce pipeline génère du texte à partir de toute combinaison de données multimodales et de texte. Lorsque le modèle sous-jacent est un modèle conversationnel, il peut également accepter une ou plusieurs conversations, auquel cas le pipeline fonctionnera en mode conversation et poursuivra la ou les conversations en ajoutant sa ou ses réponses. Chaque conversation prend la forme d'une liste de dictionnaires, où chaque dictionnaire contient les clés « role » et « content ».

À moins que le modèle que vous utilisez ne définisse explicitement ces paramètres de génération dans ses fichiers de configuration (generation_config.json), les valeurs par défaut suivantes seront utilisées :

  • max_new_tokens: 256

Exemple :

>>> from transformers import pipeline

>>> pipe = pipeline(task="any-to-any", model="google/gemma-3n-E4B-it")
>>> pipe("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png", text="A photo of")
[{'generated_text': 'a photo of two birds'}]
>>> from transformers import pipeline

>>> pipe = pipeline("any-to-any", model="google/gemma-3n-E4B-it")
>>> messages = [
>>>     {
>>>         "role": "user",
>>>         "content": [
>>>             {
>>>                 "type": "image",
>>>                 "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/qwen_vl_demo.jpeg",
>>>             },
>>>             {"type": "text", "text": "Describe this image."},
>>>         ],
>>>     },
>>>     {
>>>         "role": "assistant",
>>>         "content": [
>>>             {"type": "text", "text": "There is a dog and"},
>>>         ],
>>>     },
>>> ]
>>> pipe(text=messages, max_new_tokens=20, return_full_text=False)
[{'input_text': [{'role': 'user',
    'content': [{'type': 'image',
    'url': 'https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/qwen_vl_demo.jpeg'},
    {'type': 'text', 'text': 'Describe this image.'}]},
{'role': 'assistant',
    'content': [{'type': 'text', 'text': 'There is a dog and'}]}],
'generated_text': ' a person in the image. The dog is sitting on the sand, and the person is sitting on'}]

En savoir plus sur les bases de l'utilisation d'un pipeline dans le tutoriel sur les pipelines

Ce pipeline multimodal peut actuellement être chargé à partir de pipeline() en utilisant l'identifiant de tâche suivant : “any-to-any”.

Consultez la liste des modèles disponibles sur huggingface.co/models.

__call__

< >

( text: str | list[str] | list[dict]images: typing.Union[str, list[str], list[list[str]], ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonevideos: typing.Union[str, list[str], list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = Noneaudio: typing.Union[str, list[str], numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None**kwargs ) → A list or a list of list of dict

Paramètres

  • text (str, list[str], list[dict]) — The text to be used for generation. If a list of strings is passed, the length of the list should be the same as the number of images. Text can also follow the chat format: a list of dictionaries where each dictionary represents a message in a conversation. Each dictionary should have two keys: ‘role’ and ‘content’. ‘role’ should be one of ‘user’, ‘system’ or ‘assistant’. ‘content’ should be a list of dictionary containing the text of the message and the type of the message.
  • images (str, list[str], ImageInput) — Le pipeline gère trois types d'images :
    • Une chaîne de caractères contenant un lien HTTP(s) pointant vers une image
    • Une chaîne de caractères contenant un chemin local vers une image
    • Une image chargée directement dans PIL

    Le pipeline accepte une image unique ou un lot d'images. Enfin, ce pipeline prend également en charge le format de chat (voir text) contenant des images et du texte dans cet argument.

  • videos (str, list[str], VideoInput) — Le pipeline gère trois types de vidéos :
    • Une chaîne de caractères contenant un lien HTTP(s) pointant vers une vidéo
    • Une chaîne de caractères contenant un chemin local vers une vidéo
    • Une vidéo chargée et décodée au format tableau

    Le pipeline accepte une vidéo unique ou un lot de vidéos. Enfin, ce pipeline prend également en charge le format de chat (voir text) contenant des vidéos et du texte dans cet argument.

  • audio (str, list[str], AudioInput) — Le pipeline gère trois types d'audio :
    • Une chaîne de caractères contenant un lien HTTP(s) pointant vers un audio
    • Une chaîne de caractères contenant un chemin local vers un audio
    • Un audio chargé directement dans PIL

    Le pipeline accepte soit un seul audio, soit un lot d'audios. Enfin, ce pipeline prend également en charge le format de chat (voir text) contenant des audios et du texte dans cet argument.

  • return_tensors (bool, facultatif, par défaut False) — Retourne les tenseurs des prédictions (sous forme d’indices de jetons) dans les sorties. Si défini sur True, le texte décodé n’est pas retourné.
  • return_text (bool, facultatif) — Retourne les textes décodés dans les sorties.
  • return_full_text (bool, facultatif, par défaut True) — Si défini sur False, seul le texte ajouté est renvoyé, sinon le texte complet est renvoyé. Ne peut pas être spécifié en même temps que return_text.
  • clean_up_tokenization_spaces (bool, facultatif) — Indique s'il faut nettoyer les espaces supplémentaires potentiels dans la sortie texte. Par défaut, utilise le paramètre clean_up_tokenization_spaces du tokenizer.
  • continue_final_message( bool, optionnel) — Indique que vous souhaitez que le modèle poursuive le dernier message de la conversation d’entrée plutôt que d’en démarrer un nouveau, ce qui permet de « préremplir » sa réponse. Par défaut, cette valeur est True si le dernier message de la conversation d’entrée a le rôle assistant et False dans le cas contraire, mais vous pouvez outrepasser ce comportement en définissant manuellement ce drapeau.

Retourne

Une liste ou une liste de listes de dict

Chaque résultat est renvoyé sous forme de dictionnaire avec la clé suivante (il est impossible de renvoyer une combinaison de generated_text et generated_token_ids) :

  • generated_text (str, présent lorsque return_text=True et generation_mode="text") — Le texte généré.
  • generated_audio (np.ndarray, présent lorsque generation_mode="audio") — L’audio généré.
  • generated_image (PIL.Image.Image, présent lorsque generation_mode="image") — L'image générée.
  • generated_token_ids (torch.Tensor, présent lorsque return_tensors=True et generation_mode="text") — Les identifiants de jetons du texte généré.
  • input_text (str) — Le texte d'entrée.

Générer un texte à partir d'un texte et, le cas échéant, de données multimodales passées en entrées.

MaskGenerationPipeline

classe transformers.MaskGenerationPipeline

< >

( **kwargs )

Paramètres

  • model (PreTrainedModel) — Le modèle qui sera utilisé par le pipeline pour effectuer des prédictions. Il doit s’agir d’un modèle héritant de PreTrainedModel.
  • image_processor (BaseImageProcessor) — Le processeur d’images utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de BaseImageProcessor.
  • task (str, par défaut "") — Identifiant de tâche pour le pipeline.
  • num_workers (int, facultatif, valeur par défaut 8) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), le nombre de workers à utiliser.
  • batch_size (int, facultatif, par défaut 1) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), la taille du lot à utiliser. Pour l'inférence, cela n'est pas toujours bénéfique, veuillez lire Batching with pipelines .
  • args_parser (ArgumentHandler, facultatif) — Référence à l'objet chargé de l'analyse des paramètres de pipeline fournis.
  • device (int ou str ou torch.device, facultatif) — Appareil sur lequel le pipeline est alloué. S'il n'est pas défini, le pipeline est placé sur le premier accélérateur disponible (CUDA, MPS, XPU, …) et ne bascule sur le CPU que si aucun n'est disponible ; le modèle y est déplacé automatiquement. Passez device="cpu" (ou -1) pour forcer le CPU, un ordinal positif ou "cuda:1" pour sélectionner un accélérateur spécifique, ou un torch.device/str natif. Cet argument ne peut pas être combiné avec un modèle déjà chargé via accelerate (c'est-à-dire un modèle ayant un hf_device_map).
  • dtype (str ou torch.dtype, facultatif, par défaut "auto") — Précision dans laquelle le modèle est chargé, transmise à from_pretrained. Par défaut, "auto", ce qui charge le modèle dans le dtype dans lequel il a été enregistré (lu depuis config.dtype du checkpoint, sinon déduit des poids). Passez un torch.float16, torch.bfloat16, torch.float32, … explicite pour l’écraser.
  • binary_output (bool, facultatif, par défaut False) — Indique si la sortie du pipeline doit être au format sérialisé (c.-à-d. pickle) ou sous forme de données brutes, par exemple du texte.
  • points_per_batch (facultatif, int, par défaut 64) — Définit le nombre de points traités simultanément par le modèle. Des valeurs plus élevées peuvent être plus rapides mais utilisent plus de mémoire GPU.
  • output_bboxes_mask (bool, facultatif, par défaut False) — Indique s'il faut ou non afficher les prédictions des boîtes englobantes.
  • output_rle_masks (bool, facultatif, par défaut False) — Indique s'il faut ou non afficher les masques au format RLE

Génération automatique de masques pour les images à l'aide de SamForMaskGeneration. Ce pipeline prédit des masques binaires pour une image, à partir d'une image. Il s'agit d'un ChunkPipeline car vous pouvez séparer les points en mini-lots afin d'éviter les problèmes de mémoire insuffisante (OOM). Utilisez l'argument points_per_batch pour contrôler le nombre de points traités simultanément. La valeur par défaut est 64.

Le pipeline fonctionne en 3 étapes :

  1. preprocess : une grille de 1024 points régulièrement espacés est générée, accompagnée de boîtes englobantes et d'étiquettes de points. Pour plus de détails sur la création des points et des boîtes englobantes, consultez la fonction _generate_crop_boxes. L'image est également prétraitée à l'aide de image_processor. Cette fonction yields un mini-lot de points_per_batch.

  2. forward : transmet les sorties de preprocess au modèle. L’embedding d’image est calculé une seule fois. Appelle à la fois self.model.get_image_embeddings et s’assure que les gradients ne sont pas calculés, et que les tenseurs et les modèles sont sur le même appareil.

  3. postprocess : C'est ici que se déroule la partie la plus importante de la génération automatique des masques. Trois étapes sont induites :

    • image_processor.postprocess_masks (exécuté à chaque itération de la boucle sur les mini-lots) : prend les masques de sortie bruts, les redimensionne en fonction de la taille de l'image et les transforme en masques binaires.
    • image_processor.filter_masks (dans chaque boucle de mini-lot) : utilise à la fois pred_iou_thresh et stability_scores. Applique également une variété de filtres basés sur la suppression du maximum non pour éliminer les mauvais masques.
    • image_processor.postprocess_masks_for_amg applique le NSM sur le masque afin de ne conserver que les masques pertinents.

Exemple :

>>> from transformers import pipeline

>>> generator = pipeline(model="facebook/sam-vit-base", task="mask-generation")
>>> outputs = generator(
...     "http://images.cocodataset.org/val2017/000000039769.jpg",
... )

>>> outputs = generator(
...     "https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png", points_per_batch=128
... )

En savoir plus sur les bases de l'utilisation d'un pipeline dans le tutoriel sur les pipelines

Ce pipeline de segmentation peut actuellement être chargé depuis pipeline() en utilisant l'identifiant de tâche suivant : "mask-generation".

Consultez la liste des modèles disponibles sur huggingface.co/models.

__call__

< >

( image: typing.Union[str, ForwardRef('Image.Image'), list[str], list['Image.Image']]*args: Any**kwargs: Any ) → Dict

Paramètres

  • image (str, List[str], PIL.Image ou List[PIL.Image]) — Image ou liste d'images.
  • mask_threshold (float, facultatif, valeur par défaut 0.0) — Seuil à utiliser pour convertir les masques prédits en valeurs binaires.
  • pred_iou_thresh (float, facultatif, valeur par défaut 0.88) — Seuil de filtrage dans [0,1] appliqué à la qualité des masques prédits par le modèle.
  • stability_score_thresh (float, facultatif, valeur par défaut 0,95) — Seuil de filtrage dans [0,1], basé sur la stabilité du masque face aux modifications du seuil utilisé pour binariser les prédictions de masque du modèle.
  • stability_score_offset (int, facultatif, valeur par défaut 1) — La quantité à ajouter au seuil lors du calcul du score de stabilité.
  • crops_nms_thresh (float, facultatif, valeur par défaut 0.7) — Seuil d'IoU des boîtes utilisé par la suppression non maximale pour filtrer les masques en double.
  • crops_n_layers (int, facultatif, valeur par défaut 0) — Si crops_n_layers>0, la prédiction du masque sera exécutée à nouveau sur des recadrages de l’image. Définit le nombre de couches à exécuter, où chaque couche comporte 2**i_layer recadrages de l’image.
  • crop_overlap_ratio (float, facultatif, par défaut 512 / 1500) — Définit le degré de chevauchement des recadrages. Dans la première couche de recadrage, les recadrages se chevauchent de cette fraction de la longueur de l'image. Les couches suivantes, contenant plus de recadrages, réduisent ce chevauchement.
  • crop_n_points_downscale_factor (int, facultatif, par défaut 1) — Le nombre de points par côté échantillonnés dans la couche n est réduit par crop_n_points_downscale_factor**n.
  • timeout (float, facultatif, par défaut None) — Durée maximale en secondes à attendre pour récupérer des images depuis le web. Si None, aucun délai d’attente n’est défini et l’appel peut bloquer indéfiniment.

Retourne

Dict

Un dictionnaire avec les clés suivantes :

  • mask (PIL.Image) — Un masque binaire de l'objet détecté, sous forme d'image PIL de forme (width, height) correspondant à l'image d'origine. Renvoie un masque rempli de zéros si aucun objet n'est trouvé.
  • score (facultatif float) — Facultatif, lorsque le modèle est capable d’estimer la confiance de l’« objet » décrit par l’étiquette et le masque.

Génère des masques de segmentation binaire

Classe parente : Pipeline

classe transformers.Pipeline

< >

( model: PreTrainedModeltokenizer: PreTrainedTokenizer | None = Nonefeature_extractor: PreTrainedFeatureExtractor | None = Noneimage_processor: BaseImageProcessor | None = Nonevideo_processor: BaseVideoProcessor | None = Noneprocessor: ProcessorMixin | None = Nonetask: str = ''device: int | torch.device | None = Nonebinary_output: bool = False**kwargs )

Paramètres

  • model (PreTrainedModel) — Le modèle qui sera utilisé par le pipeline pour effectuer des prédictions. Il doit s’agir d’un modèle héritant de PreTrainedModel.
  • tokenizer (PreTrainedTokenizer) — Le tokenizer utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de PreTrainedTokenizer.
  • feature_extractor (SequenceFeatureExtractor) — L’extracteur de caractéristiques qui sera utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de SequenceFeatureExtractor.
  • image_processor (BaseImageProcessor) — Le processeur d’images utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de BaseImageProcessor.
  • processor (ProcessorMixin) — Le processeur utilisé par le pipeline pour encoder les données destinées au modèle. Cet objet hérite de ProcessorMixin. Le processeur est un objet composite qui peut contenir tokenizer, feature_extractor et image_processor.
  • task (str, par défaut "") — Identifiant de tâche pour le pipeline.
  • num_workers (int, facultatif, valeur par défaut 8) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), le nombre de workers à utiliser.
  • batch_size (int, facultatif, par défaut 1) — Lorsque le pipeline utilise DataLoader (lors du passage d'un jeu de données, sur GPU pour un modèle Pytorch), la taille du lot à utiliser. Pour l'inférence, cela n'est pas toujours bénéfique, veuillez lire Batching with pipelines .
  • args_parser (ArgumentHandler, facultatif) — Référence à l'objet chargé de l'analyse des paramètres de pipeline fournis.
  • device (int ou str ou torch.device, facultatif) — Appareil sur lequel le pipeline est alloué. S'il n'est pas défini, le pipeline est placé sur le premier accélérateur disponible (CUDA, MPS, XPU, …) et ne bascule sur le CPU que si aucun n'est disponible ; le modèle y est déplacé automatiquement. Passez device="cpu" (ou -1) pour forcer le CPU, un ordinal positif ou "cuda:1" pour sélectionner un accélérateur spécifique, ou un torch.device/str natif. Cet argument ne peut pas être combiné avec un modèle déjà chargé via accelerate (c'est-à-dire un modèle ayant un hf_device_map).
  • dtype (str ou torch.dtype, facultatif, par défaut "auto") — Précision dans laquelle le modèle est chargé, transmise à from_pretrained. Par défaut, "auto", ce qui charge le modèle dans le dtype dans lequel il a été enregistré (lu depuis config.dtype du checkpoint, sinon déduit des poids). Passez un torch.float16, torch.bfloat16, torch.float32, … explicite pour l’écraser.
  • binary_output (bool, facultatif, par défaut False) — Indique si la sortie du pipeline doit être au format sérialisé (c.-à-d. pickle) ou sous forme de données brutes, par exemple du texte.

La classe Pipeline est la classe dont héritent tous les pipelines. Reportez-vous à cette classe pour les méthodes partagées entre les différents pipelines.

Classe de base implémentant des opérations pipelinées. Le flux de travail du pipeline est défini comme une séquence des opérations suivantes :

Entrée -> Tokenisation -> Inférence du modèle -> Post-traitement (dépendant de la tâche) -> Sortie

Pipeline prend en charge l'exécution sur CPU ou GPU via l'argument device (voir ci-dessous).

Certains pipelines, comme par exemple FeatureExtractionPipeline ('feature-extraction'), produisent de grands objets tensoriels sous forme de listes imbriquées. Afin d’éviter de déverser une telle structure volumineuse en données textuelles, nous fournissons l’argument de constructeur binary_output. S’il est défini sur True, la sortie sera stockée au format pickle.

check_model_type

< >

( supported_models: list[str] | dict )

Paramètres

  • supported_models (list[str] ou dict) — La liste des modèles pris en charge par le pipeline, ou un dictionnaire avec des valeurs de classes de modèles.

Vérifiez si la classe de modèle est prise en charge par le pipeline.

device_placement

< >

( )

Gestionnaire de contexte permettant l'allocation de tenseurs sur l'appareil spécifié par l'utilisateur.

Exemples :

# Explicitly ask for tensor allocation on CUDA device :0
pipe = pipeline(..., device=0)
with pipe.device_placement():
    # Every tensor allocation will be done on the request device
    output = pipe(...)

ensure_tensor_on_device

< >

( **inputs ) → dict[str, torch.Tensor]

Paramètres

  • inputs (arguments par mot-clé qui doivent être des torch.Tensor, le reste est ignoré) — Les tenseurs à placer sur self.device.
  • Recursive sur les listes uniquement. —

Retourne

dict[str, torch.Tensor]

Identique à inputs mais sur le bon appareil.

Vérifiez que les tenseurs PyTorch sont sur l'appareil spécifié.

postprocess

< >

( model_outputs: ModelOutput**postprocess_parameters: dict )

Postprocess reçoit les sorties brutes de la méthode _forward, généralement des tenseurs, et les reformate en quelque chose de plus lisible. En général, elle renvoie une liste ou un dictionnaire de résultats (contenant uniquement des chaînes de caractères et des nombres).

predict

< >

( X )

Interface Scikit / Keras pour les pipelines de Transformers. Cette méthode transmet l’appel à call().

prétraiter

< >

( input_: Any**preprocess_parameters: dict )

Preprocess prend l'input_ d'un pipeline spécifique et renvoie un dictionnaire contenant tout ce qui est nécessaire pour que _forward s'exécute correctement. Il doit contenir au moins un tenseur, mais peut inclure d'autres éléments arbitraires.

push_to_hub

< >

( repo_id: strcommit_message: str | None = Nonecommit_description: str | None = Noneprivate: bool | None = Nonetoken: bool | str | None = Nonerevision: str | None = Nonecreate_pr: bool = Falsemax_shard_size: int | str | None = '50GB'tags: list[str] | None = None )

Paramètres

  • repo_id (str) — Le nom du dépôt vers lequel vous souhaitez pousser votre pipe. Il doit contenir le nom de votre organisation lors d’une poussée vers une organisation donnée.
  • commit_message (str, facultatif) — Message à committer lors de la poussée. La valeur par défaut est "Upload pipe".
  • commit_description (str, facultatif) — La description du commit qui sera créé
  • private (bool, facultatif) — Indique s'il faut rendre le dépôt privé. Si None (par défaut), le dépôt sera public sauf si le paramètre par défaut de l'organisation est privé. Cette valeur est ignorée si le dépôt existe déjà.
  • token (bool ou str, facultatif) — Le jeton à utiliser comme autorisation bearer HTTP pour les fichiers distants. Si True (par défaut), le jeton généré lors de l’exécution de hf auth login (stocké dans ~/.huggingface) sera utilisé.
  • revision (str, facultatif) — Branche vers laquelle pousser les fichiers téléversés.
  • create_pr (bool, facultatif, par défaut False) — Indique s'il faut créer une PR avec les fichiers téléversés ou effectuer un commit direct.
  • max_shard_size (int ou str, facultatif, par défaut "50GB") — Applicable uniquement aux modèles. La taille maximale d'un point de contrôle avant son fractionnement. Les points de contrôle fractionnés auront chacun une taille inférieure à cette valeur. S'il est exprimé sous forme de chaîne, il doit être composé de chiffres suivis d'une unité (comme "5MB").
  • tags (list[str], facultatif) — Liste des tags à pousser sur le Hub.

Téléchargez le fichier de pipeline sur le 🤗 Model Hub.

Exemples :

from transformers import pipeline

pipe = pipeline("google-bert/bert-base-cased")

# Push the pipe to your namespace with the name "my-finetuned-bert".
pipe.push_to_hub("my-finetuned-bert")

# Push the pipe to an organization with the name "my-finetuned-bert".
pipe.push_to_hub("huggingface/my-finetuned-bert")

save_pretrained

< >

( save_directory: str | os.PathLike**kwargs: Any )

Paramètres

  • save_directory (str ou os.PathLike) — Chemin du répertoire où enregistrer. Il sera créé s'il n'existe pas.
  • kwargs (dict[str, Any], facultatif) — Arguments supplémentaires passés à la méthode push_to_hub().

Enregistrez le modèle et le tokeniseur du pipeline.

transform

< >

( X )

Interface Scikit / Keras pour les pipelines de Transformers. Cette méthode transmet l’appel à call().

Update on GitHub

←PEFT Processeurs→