Hugging Face's logo

Transformers documentation

Пайплайны

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

Пайплайны

Пайплайны — это удобный и простой способ использовать модели для инференса. Эти пайплайны представляют собой объекты, которые абстрагируют большую часть сложного кода библиотеки, предлагая простой API, предназначенный для выполнения ряда задач, включая распознавание именованных сущностей (Named Entity Recognition), маскированное языковое моделирование (Masked Language Modeling), анализ тональности (Sentiment Analysis), извлечение признаков (Feature Extraction) и ответы на вопросы (Question Answering). Примеры использования приведены в списке задач.

Существуют две категории абстракций пайплайнов, о которых следует знать:

Абстракция конвейера

Абстракция pipeline представляет собой обёртку над всеми остальными доступными пайплайнами. Она инициализируется так же, как и любой другой пайплайн, но может обеспечивать дополнительный комфорт в работе.

Простой вызов для одного элемента:

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

Если вы хотите использовать конкретную модель из hub, вы можете пропустить задание задачи, если модель на hub уже определяет её:

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

Чтобы вызвать конвейер для множества элементов, передайте ему list.

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

Для перебора полных наборов данных рекомендуется использовать dataset напрямую. Это означает, что вам не нужно выделять память под весь набор данных сразу, а также не нужно формировать батчи самостоятельно. Скорость работы должна быть такой же, как у пользовательских циклов на GPU. Если это не так, не стесняйтесь создать issue.

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": ....}
    # ....

Для удобства использования также можно использовать генератор:

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

Параметры

  • task (str) — Задача, определяющая, какой пайплайн будет возвращён. В настоящее время поддерживаются следующие задачи:
  • model (str или PreTrainedModel, необязательный) — Модель, которая будет использоваться конвейером для выполнения предсказаний. Это может быть идентификатор модели или фактический экземпляр предобученной модели, наследующей от PreTrainedModel.

    Если не указано, будет загружено значение по умолчанию для task.

  • config (str или PreTrainedConfig, необязательный) — Конфигурация, которую pipeline использует для создания модели. Это может быть идентификатор модели или фактическая конфигурация предобученной модели, наследующая от PreTrainedConfig.

    Если не указано, будет использован файл конфигурации по умолчанию для запрошенной модели. Это означает, что если model задан, будет использована его конфигурация по умолчанию. Однако, если model не указан, вместо этого используется конфигурация модели по умолчанию для этой task.

  • tokenizer (str или PreTrainedTokenizer, необязательный) — Токенизатор, который будет использоваться конвейером для кодирования данных для модели. Это может быть идентификатор модели или фактический предобученный токенизатор, наследующий от PreTrainedTokenizer.

    Если не указано, будет загружен токенизатор по умолчанию для заданной model (если это строка). Если model не указан или не является строкой, будет загружен токенизатор по умолчанию для config (если это строка). Однако, если config также не задан или не является строкой, будет загружен токенизатор по умолчанию для заданной task.

  • feature_extractor (str или FeatureExtractionMixin, необязательный) — Извлекатель признаков, который будет использоваться конвейером для кодирования данных для модели. Это может быть идентификатор модели или фактический предобученный извлекатель признаков, наследующий от FeatureExtractionMixin.

    Feature extractors используются для моделей, не относящихся к NLP, таких как модели обработки речи или изображений, а также мультимодальные модели. Для мультимодальных моделей также необходимо передать tokenizer.

    Если не указано, будет загружен feature extractor по умолчанию для данного model (если это строка). Если model не указан или не является строкой, то будет загружен feature extractor по умолчанию для config (если это строка). Однако, если config также не указан или не является строкой, то будет загружен feature extractor по умолчанию для данного task.

  • image_processor (str или BaseImageProcessor, необязательный) — Обработчик изображений, который будет использоваться конвейером для предобработки изображений перед передачей в модель. Это может быть идентификатор модели или фактический обработчик изображений, наследующийся от BaseImageProcessor. Обработчики изображений используются для моделей зрения и мультимодальных моделей, которым требуется вход в виде изображений. Для мультимодальных моделей также необходимо передать токенизатор. Если значение не указано, будет загружен обработчик изображений по умолчанию для данной модели (если это строка). Если модель не указана или не является строкой, будет загружен обработчик изображений по умолчанию для config (если это строка)..

    Обработчики изображений используются для моделей зрения и мультимодальных моделей, которым требуется вход в виде изображений. Для мультимодальных моделей также необходимо передать токенизатор.

    Если не указано, будет загружен процессор изображений по умолчанию для заданной model (если это строка). Если model не указан или не является строкой, то будет загружен процессор изображений по умолчанию для config (если это строка).

  • processor (str или ProcessorMixin, необязательный) — Процессор, который будет использоваться конвейером для предобработки данных для модели. Это может быть идентификатор модели или фактический процессор, наследующий от ProcessorMixin. Процессоры используются для мультимодальных моделей, требующих мультимодальных входных данных, например, модели, которая требует как текстовых, так и изображений. Если не указан, будет загружен процессор по умолчанию для данной модели (если это строка). Если model не указан или не является строкой, будет загружен процессор по умолчанию для config (если это строка)..

    Processors используются для мультимодальных моделей, которым требуются мультимодальные входные данные, например, для модели, принимающей на вход и текст, и изображения.

    Если не указано, будет загружен процессор по умолчанию для данного model (если это строка). Если model не указан или не является строкой, то будет загружен процессор по умолчанию для config (если это строка).

  • revision (str, необязательный, по умолчанию "main") — При передаче имени задачи или строкового идентификатора модели: конкретная версия модели, которую следует использовать. Это может быть имя ветки, имя тега или идентификатор коммита, поскольку для хранения моделей и других артефактов на huggingface.co используется система на базе git, поэтому revision может быть любым идентификатором, разрешённым git.
  • use_fast (bool, необязательный, по умолчанию True) — Использовать ли Fast-токенизатор, если это возможно (PreTrainedTokenizerFast).
  • token (str или bool, необязательный) — Токен, используемый в качестве HTTP bearer-авторизации для удалённых файлов. Если True, будет использован токен, сгенерированный при выполнении hf auth login.
  • device (int или str или torch.device, необязательный) — Определяет устройство (напр., "cpu", "cuda:1", "mps" или порядковый номер GPU, например 1), на котором будет размещена эта pipeline. Если параметр не задан, pipeline автоматически размещается на первом доступном ускорителе (CUDA, MPS, XPU, …) и переключается на CPU только в том случае, если ускорители отсутствуют; модель перемещается туда автоматически. Передайте device="cpu" (или -1), чтобы принудительно использовать CPU. Не может использоваться вместе с device_map.
  • device_map (str или dict[str, Union[int, str, torch.device], необязательный) — Передаётся напрямую как model_kwargs (просто более простой способ). Если библиотека accelerate присутствует, установите device_map="auto" для автоматического вычисления наиболее оптимизированного device_map (см. здесь для получения дополнительной информации).

    Не используйте device_map и device одновременно, так как они конфликтуют

  • dtype (str или torch.dtype, необязательный, по умолчанию "auto") — Точность, в которой загружается модель, передаётся в from_pretrained. По умолчанию "auto", что загружает модель в той точности, в которой она была сохранена. Передайте явное значение torch.float16, torch.bfloat16, torch.float32, … для переопределения.
  • trust_remote_code (bool, необязательный, по умолчанию False) — Определяет, разрешено ли использование пользовательского кода, определенного на Hub в собственных файлах моделирования, конфигурации, токенизации или даже пайплайнов. Этот параметр следует устанавливать в True только для репозиториев, которым вы доверяете и код которых вы изучили, поскольку он будет выполнять код, присутствующий на Hub, на вашем локальном компьютере.
  • model_kwargs (dict[str, Any], необязательный) — Дополнительный словарь аргументов, передаваемых в функцию from_pretrained(..., **model_kwargs) модели.
  • kwargs (dict[str, Any], необязательный) — Дополнительные именованные аргументы, передаваемые в инициализацию конкретного пайплайна (см. документацию соответствующего класса пайплайна для возможных значений).

Возвращает

Пайплайн

Подходящий конвейер для задачи.

Вспомогательный фабричный метод для создания Pipeline.

Пайплайн состоит из:

  • Один или несколько компонентов для предобработки входных данных модели, например tokenizer, image_processor, feature_extractor или processor.
  • Модель, которая генерирует предсказания на основе входных данных.
  • Необязательные этапы постобработки для уточнения вывода модели, которые также могут выполняться процессорами.
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.

Примеры:

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

Пакетная обработка в Pipeline

Все конвейеры поддерживают пакетную обработку. Это работает всегда, когда конвейер использует свой стриминговый режим (то есть при передаче списков, Dataset или 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

Однако это не гарантирует автоматического выигрыша в производительности. В зависимости от оборудования, данных и конкретной используемой модели результат может варьироваться от ускорения в 10 раз до замедления в 5 раз.

Пример, где в основном наблюдается ускорение:

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)

Пример, где в основном наблюдается замедление:

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

Это изредка встречающееся очень длинное предложение по сравнению с другими. В этом случае весь батч должен иметь длину 400 токенов, поэтому весь батч будет [64, 400] вместо [64, 4], что приводит к значительному замедлению. Ещё хуже, на более крупных батчах программа просто падает.

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

Не существует хороших (универсальных) решений для этой проблемы, и результат может сильно зависеть от ваших сценариев использования. Общее правило:

Для пользователей существует следующее правило:

  • Измеряйте производительность на вашей нагрузке, на вашем оборудовании. Измеряйте, измеряйте и продолжайте измерять. Реальные цифры — единственный верный путь.

  • Если вы ограничены по задержке (например, в живом продукте, выполняющем инференс), не используйте батчинг.

  • Если вы используете CPU, не используйте батчи.

  • Если вы используете throughput (то есть хотите прогнать модель по большому объёму статичных данных) на GPU, то:

    • Если вы не знаете, каков размер sequence_length («естественных» данных), по умолчанию не используйте батчинг, измерьте его и экспериментально попробуйте добавить батчинг, а также добавьте проверки OOM, чтобы восстановиться при сбое (а сбой неизбежно произойдёт, если вы не контролируете sequence_length).
    • Если ваш sequence_length очень регулярный, то батчинг с высокой вероятностью окажется очень интересным: измеряйте и увеличивайте его, пока не начнут возникать ошибки OOM.
    • Чем больше GPU, тем более интересным становится батчинг

  • Как только вы включите батчинг, убедитесь, что вы можете корректно обрабатывать ошибки OOM.

Пакетная обработка чанков в Pipeline

zero-shot-classification и question-answering имеют небольшую специфику: один вход может потребовать нескольких проходов модели. В обычных обстоятельствах это вызвало бы проблемы с аргументом batch_size.

Чтобы обойти эту проблему, оба этих конвейера немного специфичны: они являются ChunkPipeline, а не обычным Pipeline. Кратко:

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

Теперь становится:

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)

Это должно быть совершенно прозрачно для вашего кода, поскольку пайплайны используются аналогичным образом.

Это упрощённое представление, поскольку конвейер автоматически обрабатывает батчи! Это означает, что вам не нужно беспокоиться о том, сколько проходов вперёд на самом деле будут запущены вашими входными данными: вы можете оптимизировать batch_size независимо от входов. Оговорки из предыдущего раздела по-прежнему действуют.

Pipeline FP16-вывод

Модели можно запускать в FP16, что может значительно ускорить работу на GPU и сэкономить память. Большинство моделей не потеряют заметной производительности из-за этого. Чем больше модель, тем меньше вероятность, что это произойдёт.

Чтобы включить FP16-вывод, достаточно передать dtype=torch.float16 или dtype='float16' в конструктор пайплайна. Обратите внимание, что это работает только для моделей с бэкендом PyTorch. Ваши входные данные будут преобразованы во внутренний формат FP16.

Пользовательский код Pipeline

Если вы хотите переопределить конкретный конвейер.

Не стесняйтесь создавать issue для вашей задачи: цель пайплайна — быть удобным и покрывать большинство случаев, поэтому transformers, возможно, сможет поддержать ваш сценарий использования.

Если вы хотите просто попробовать, вы можете:

  • Создайте подкласс нужного вам конвейера
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)

Это позволит вам писать любой необходимый вам собственный код.

Реализация конвейера

Реализация нового конвейера

Аудио

Среди доступных конвейеров для задач обработки аудио есть следующие.

AudioClassificationPipeline

класс transformers.AudioClassificationPipeline

< >

( *args**kwargs )

Параметры

  • model (PreTrainedModel) — Модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от PreTrainedModel.
  • feature_extractor (SequenceFeatureExtractor) — объект feature extractor, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от SequenceFeatureExtractor.
  • task (str, по умолчанию "") — Идентификатор задачи для конвейера.
  • num_workers (int, необязательный, по умолчанию 8) — количество рабочих процессов, используемых, когда конвейер применяет DataLoader (при передаче набора данных, на GPU для модели PyTorch).
  • batch_size (int, необязательный, по умолчанию 1) — Когда конвейер использует DataLoader (при передаче набора данных, на GPU для модели PyTorch), размер батча, который будет использоваться. Для вывода это не всегда полезно, см. Обработка батчами в конвейерах .
  • args_parser (ArgumentHandler, необязательный) — Ссылка на объект, отвечающий за разбор переданных параметров конвейера.
  • device (int или str или torch.device, необязательный) — Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (CUDA, MPS, XPU, …), а на CPU переключается только в том случае, если ускорители отсутствуют; модель перемещается туда автоматически. Передайте device="cpu" (или -1), чтобы принудительно использовать CPU, положительный порядковый номер или "cuda:1", чтобы выбрать конкретный ускоритель, либо нативный torch.device/str. Этот аргумент нельзя использовать вместе с моделью, уже загруженной через accelerate (то есть с hf_device_map).
  • dtype (str или torch.dtype, необязательный, по умолчанию "auto") — Точность, в которой загружается модель, передаётся в from_pretrained. По умолчанию "auto", что загружает модель в той точности, в которой она была сохранена (читается из config.dtype контрольной точки, иначе выводится из весов). Передайте явное значение torch.float16, torch.bfloat16, torch.float32, … для переопределения.
  • binary_output (bool, необязательный, по умолчанию False) — Флаг, указывающий, должен ли вывод конвейера быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст.

Конвейер классификации аудио с использованием любой модели AutoModelForAudioClassification. Этот конвейер предсказывает класс для сырой звуковой волны или аудиофайла. В случае с аудиофайлом для поддержки различных форматов аудио необходимо установить ffmpeg.

Пример:

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

Подробнее о базовых принципах использования пайплайна читайте в руководстве по пайплайнам

Сейчас этот конвейер можно загрузить из pipeline(), используя следующий идентификатор задачи: "audio-classification".

Список доступных моделей можно найти на huggingface.co/models.

__call__

< >

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

Параметры

  • inputs (np.ndarray или bytes или str или dict) — inputs может быть одним из следующих:
    • str — имя файла с аудио; файл будет прочитан с правильной частотой дискретизации для получения формы волны с помощью ffmpeg. Для этого требуется, чтобы ffmpeg был установлен в системе.
    • bytes — это содержимое аудиофайла, которое ffmpeg интерпретирует аналогичным образом.
    • (np.ndarray формы (n, ) типа np.float32 или np.float64) Сырой звук с правильной частотой дискретизации (дополнительная проверка не выполняется)
    • Формат dict можно использовать для передачи необработанного аудио, оцифрованного с произвольной частотой sampling_rate, чтобы этот конвейер выполнил ресемплинг. Словарь должен иметь вид {"sampling_rate": int, "raw": np.array} или {"sampling_rate": int, "array": np.array}, где ключ "raw" или "array" обозначает необработанную аудиоволну.
  • top_k (int, необязательный, по умолчанию None) — Количество верхних меток, которые вернёт конвейер. Если указанное значение равно None или превышает количество меток, доступных в конфигурации модели, будет использовано количество меток.
  • function_to_apply (str, optional, по умолчанию “softmax”) — Функция, применяемая к выходу модели. По умолчанию конвейер применяет функцию softmax к выходу модели. Допустимые значения: [“softmax”, “sigmoid”, “none”]. Обратите внимание, что передача встроенного значения Python None приведёт к использованию “softmax” по умолчанию, поэтому для отключения любой постобработки необходимо передать строку “none”.

Возвращает

Список dict со следующими ключами

  • label (str) — Предсказанная метка.
  • score (float) — Соответствующая вероятность.

Классифицирует последовательность(и), переданные в качестве входных данных. Подробнее см. в документации AutomaticSpeechRecognitionPipeline.

AutomaticSpeechRecognitionPipeline

класс 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 )

Параметры

  • model (PreTrainedModel) — Модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от PreTrainedModel.
  • feature_extractor (SequenceFeatureExtractor, необязательный) — Извлекатель признаков, который будет использоваться конвейером для кодирования звуковой дорожки для модели.
  • tokenizer (PreTrainedTokenizer, optional) — Токенизатор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от PreTrainedTokenizer.
  • decoder (pyctcdecode.BeamSearchDecoderCTC, необязательный) — BeamSearchDecoderCTC из PyCTCDecode можно передать для декодирования с использованием языковой модели. Подробнее см. Wav2Vec2ProcessorWithLM.
  • device (Union[int, torch.device], необязательный) — Номер устройства для поддержки CPU/GPU. Если установить это значение в None, будет использоваться CPU, а положительное число запустит модель на соответствующем устройстве CUDA.

Пайплайн, предназначенный для извлечения устной речи, содержащейся в аудиофайле.

Входные данные могут представлять собой как необработанную звуковую волну, так и аудиофайл. В случае с аудиофайлом для поддержки различных форматов аудио необходимо установить ffmpeg

Если модель, которую вы используете, явно не задаёт эти параметры генерации в своих файлах конфигурации (generation_config.json), будут использованы следующие значения по умолчанию:

  • max_new_tokens: 256
  • num_beams: 5

Пример:

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

Подробнее о базовых принципах использования пайплайна читайте в руководстве по пайплайнам

__call__

< >

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

Параметры

  • inputs (np.ndarray или bytes или str или dict) — inputs — это одно из следующих значений:
    • str, содержащий имя локального аудиофайла или публичный URL-адрес для загрузки аудиофайла. Файл будет прочитан с правильной частотой дискретизации для получения формы волны с помощью ffmpeg. Для этого требуется, чтобы ffmpeg был установлен в системе.
    • bytes — это содержимое аудиофайла, которое ffmpeg интерпретирует аналогичным образом.
    • (np.ndarray формы (n, ) типа np.float32 или np.float64) Сырой звук с правильной частотой дискретизации (дополнительная проверка не выполняется)
    • Формат dict можно использовать для передачи необработанного аудио, оцифрованного с произвольной sampling_rate, чтобы пайплайн самостоятельно выполнил ресемплинг. Словарь должен иметь формат {"sampling_rate": int, "raw": np.array} и, при необходимости, включать "stride": (left: int, right: int), который указывает пайплайну игнорировать первые left и последние right сэмплы при декодировании (но использовать их на этапе инференса для предоставления модели большего контекста). Используйте stride только с моделями CTC.
  • return_timestamps (необязательный, str или bool) — Доступно только для чистых CTC-моделей (Wav2Vec2, HuBERT и т. д.) и модели Whisper. Недоступно для других sequence-to-sequence моделей.

    Для моделей CTC метки времени могут иметь один из двух форматов:

    • "char": конвейер будет возвращать временные метки для каждого символа текста. Например, если вы получаете [{"text": "h", "timestamp": (0.5, 0.6)}, {"text": "i", "timestamp": (0.7, 0.9)}], это означает, что модель предсказывает, что буква «h» была произнесена после 0.5 и до 0.6 секунды.
    • "word": конвейер будет возвращать временные метки вместе с текстом для каждого слова. Например, если вы получаете [{"text": "hi ", "timestamp": (0.5, 0.9)}, {"text": "there", "timestamp": (1.0, 1.5)}], это означает, что модель предсказывает, что слово «hi» было произнесено после 0.5 и до 0.9 секунды.

    Для модели Whisper метки времени могут иметь один из двух форматов:

    • "word": аналогично вышеописанному для временных меток на уровне слов для CTC. Временные метки на уровне слов предсказываются с помощью алгоритма динамического выравнивания (DTW), представляющего собой приближённую оценку временных меток на уровне слов путём анализа весов кросс-внимания.
    • True: конвейер будет возвращать временные метки для сегментов слов в тексте. Например, если вы получаете [{"text": " Hi there!", "timestamp": (0.5, 1.5)}], это означает, что модель предсказывает, что сегмент «Hi there!» был произнесен после 0.5 и до 1.5 секунды. Обратите внимание, что сегмент текста представляет собой последовательность из одного или нескольких слов, а не отдельные слова, как в случае с временными метками на уровне слов.
  • generate_kwargs (dict, необязательный) — Словарь для произвольной параметризации generate_config, используемой в вызове генерации. Полное описание generate см. в этом руководстве.

Возвращает

Dict

Словарь со следующими ключами:

  • text (str): распознанный текст.
  • chunks (необязательный, list[Dict]) При использовании return_timestamps параметр chunks становится списком, содержащим все различные текстовые фрагменты, идентифицированные моделью, например* [{"text": "hi ", "timestamp": (0.5, 0.9)}, {"text": "there", "timestamp": (1.0, 1.5)}]. Исходный полный текст можно приблизительно восстановить, выполнив "".join(chunk["text"] for chunk in output["chunks"]).

Транскрибируйте аудиопоследовательности, переданные в качестве входных данных, в текст. Подробнее см. в документации AutomaticSpeechRecognitionPipeline.

TextToAudioPipeline

класс transformers.TextToAudioPipeline

< >

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

Конвейер генерации аудио из текста с использованием любой модели AutoModelForTextToWaveform или AutoModelForTextToSpectrogram. Этот конвейер генерирует аудиофайл на основе входного текста и дополнительных условных входных данных (при наличии).

Если модель, которую вы используете, явно не задаёт параметры генерации в generation_config.json, будут использованы значения по умолчанию из generation.configuration_utils.py._get_default_generation_params().

  • max_new_tokens: 256

Пример:

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

Подробнее о базовых принципах использования пайплайна читайте в руководстве по пайплайнам

Вы можете указать параметры, передаваемые в модель, с помощью TextToAudioPipeline.__call__.forward_params или TextToAudioPipeline.__call__.generate_kwargs.

Пример:

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

Сейчас этот конвейер можно загрузить из pipeline(), используя следующие идентификаторы задач: "text-to-speech" или "text-to-audio".

Список доступных моделей можно найти на huggingface.co/models.

__call__

< >

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

Параметры

  • text_inputs (str, list[str], ChatType или list[ChatType]) — Один или несколько текстов для генерации. Если переданы строки или список строк, этот конвейер сгенерирует соответствующий текст. Также можно передать «чат» в виде списка словарей с ключами «role» и «content» или список таких чатов. Если переданы чаты, для их форматирования перед передачей в модель будет использован шаблон чата модели.
  • forward_params (dict, необязательный) — Параметры, передаваемые в метод генерации/forward модели. forward_params всегда передаются в базовую модель.
  • generate_kwargs (dict, необязательный) — Словарь с параметрами для настройки generate_config, используемыми при вызове генерации. Полное описание generate см. в этом руководстве. generate_kwargs передаются базовой модели только в том случае, если она является генеративной, и имеют приоритет над forward_params.

Возвращает

AudioOutput или список AudioOutput, представляющий собой TypedDict с двумя ключами

  • audio (np.ndarray формы (nb_channels, audio_length)) — Сгенерированная звуковая волна.
  • sampling_rate (int) — Частота дискретизации сгенерированной аудиоволны.

Генерирует речь/аудио на основе входных данных. Подробнее см. в документации TextToAudioPipeline.

ZeroShotAudioClassificationPipeline

класс transformers.ZeroShotAudioClassificationPipeline

< >

( **kwargs )

Параметры

  • model (PreTrainedModel) — Модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от PreTrainedModel.
  • tokenizer (PreTrainedTokenizer) — Токенизатор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от PreTrainedTokenizer.
  • feature_extractor (SequenceFeatureExtractor) — объект feature extractor, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от SequenceFeatureExtractor.
  • task (str, по умолчанию "") — Идентификатор задачи для конвейера.
  • num_workers (int, необязательный, по умолчанию 8) — количество рабочих процессов, используемых, когда конвейер применяет DataLoader (при передаче набора данных, на GPU для модели PyTorch).
  • batch_size (int, необязательный, по умолчанию 1) — Когда конвейер использует DataLoader (при передаче набора данных, на GPU для модели PyTorch), размер батча, который будет использоваться. Для вывода это не всегда полезно, см. Обработка батчами в конвейерах .
  • args_parser (ArgumentHandler, необязательный) — Ссылка на объект, отвечающий за разбор переданных параметров конвейера.
  • device (int или str или torch.device, необязательный) — Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (CUDA, MPS, XPU, …), а на CPU переключается только в том случае, если ускорители отсутствуют; модель перемещается туда автоматически. Передайте device="cpu" (или -1), чтобы принудительно использовать CPU, положительный порядковый номер или "cuda:1", чтобы выбрать конкретный ускоритель, либо нативный torch.device/str. Этот аргумент нельзя использовать вместе с моделью, уже загруженной через accelerate (то есть с hf_device_map).
  • dtype (str или torch.dtype, необязательный, по умолчанию "auto") — Точность, в которой загружается модель, передаётся в from_pretrained. По умолчанию "auto", что загружает модель в той точности, в которой она была сохранена (читается из config.dtype контрольной точки, иначе выводится из весов). Передайте явное значение torch.float16, torch.bfloat16, torch.float32, … для переопределения.
  • binary_output (bool, необязательный, по умолчанию False) — Флаг, указывающий, должен ли вывод конвейера быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст.

Конвейер классификации аудио в режиме zero shot с использованием ClapModel. Этот конвейер предсказывает класс аудио, если вы предоставляете аудио и набор candidate_labels.

По умолчанию hypothesis_template имеет вид: "This is a sound of {}.". Убедитесь, что вы обновляете его в соответствии со своим использованием.

Пример:

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

Подробнее о базовых принципах использования конвейера можно узнать в руководстве по pipeline. Данный конвейер для классификации аудио на данный момент можно загрузить из pipeline(), используя следующий идентификатор задачи: "zero-shot-audio-classification". Список доступных моделей доступен на huggingface.co/models.

__call__

< >

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

Параметры

  • audios (str, list[str], np.array или list[np.array]) — Пайплайн обрабатывает три типа входных данных:
    • Строка, содержащая http-ссылку на аудио
    • Строка, содержащая локальный путь к аудио
    • Аудио, загруженное в numpy
  • candidate_labels (list[str]) — Кандидатские метки для этого аудио. Они будут отформатированы с помощью hypothesis_template.
  • hypothesis_template (str, необязательный, по умолчанию "This is a sound of {}") — Формат, используемый вместе с candidate_labels для попытки классификации аудио путем замены плейсхолдера на candidate_labels. Передайте ”{}”, если candidate_labels уже отформатированы.

Назначьте метки аудио, переданным в качестве входных данных.

Компьютерное зрение

Среди доступных конвейеров для задач компьютерного зрения есть следующие.

DepthEstimationPipeline

класс transformers.DepthEstimationPipeline

< >

( *args**kwargs )

Параметры

  • model (PreTrainedModel) — Модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от PreTrainedModel.
  • image_processor (BaseImageProcessor) — Обработчик изображений, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от BaseImageProcessor.
  • task (str, по умолчанию "") — Идентификатор задачи для конвейера.
  • num_workers (int, необязательный, по умолчанию 8) — количество рабочих процессов, используемых, когда конвейер применяет DataLoader (при передаче набора данных, на GPU для модели PyTorch).
  • batch_size (int, необязательный, по умолчанию 1) — Когда конвейер использует DataLoader (при передаче набора данных, на GPU для модели PyTorch), размер батча, который будет использоваться. Для вывода это не всегда полезно, см. Обработка батчами в конвейерах .
  • args_parser (ArgumentHandler, необязательный) — Ссылка на объект, отвечающий за разбор переданных параметров конвейера.
  • device (int или str или torch.device, необязательный) — Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (CUDA, MPS, XPU, …), а на CPU переключается только в том случае, если ускорители отсутствуют; модель перемещается туда автоматически. Передайте device="cpu" (или -1), чтобы принудительно использовать CPU, положительный порядковый номер или "cuda:1", чтобы выбрать конкретный ускоритель, либо нативный torch.device/str. Этот аргумент нельзя использовать вместе с моделью, уже загруженной через accelerate (то есть с hf_device_map).
  • dtype (str или torch.dtype, необязательный, по умолчанию "auto") — Точность, в которой загружается модель, передаётся в from_pretrained. По умолчанию "auto", что загружает модель в той точности, в которой она была сохранена (читается из config.dtype контрольной точки, иначе выводится из весов). Передайте явное значение torch.float16, torch.bfloat16, torch.float32, … для переопределения.
  • binary_output (bool, необязательный, по умолчанию False) — Флаг, указывающий, должен ли вывод конвейера быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст.

Конвейер оценки глубины с использованием любой модели AutoModelForDepthEstimation. Этот конвейер предсказывает глубину изображения.

Пример:

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

Подробнее о базовых принципах использования пайплайна читайте в руководстве по пайплайнам

Этот конвейер оценки глубины в настоящее время можно загрузить из pipeline(), используя следующий идентификатор задачи: "depth-estimation".

Список доступных моделей можно найти на huggingface.co/models.

__call__

< >

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

Параметры

  • inputs (str, list[str], PIL.Image или list[PIL.Image]) — Пайплайн обрабатывает три типа изображений:
    • Строка, содержащая http-ссылку, указывающую на изображение
    • Строка, содержащая локальный путь к изображению
    • Изображение, загруженное непосредственно в PIL

    Пайплайн принимает как одно изображение, так и пакет изображений, которые затем должны передаваться в виде строки. Все изображения в пакете должны быть в одном формате: все в виде ссылок http, все в виде локальных путей или все в виде изображений PIL.

  • parameters (Dict, необязательный) — Словарь, сопоставляющий имена аргументов со значениями параметров, для управления поведением конвейера. Единственный доступный на данный момент параметр — timeout, определяющий время ожидания в секундах, которое конвейер тратит на попытку загрузки изображения, прежде чем отменить её.
  • timeout (float, необязательный, по умолчанию None) — Максимальное время ожидания в секундах при получении изображений из сети. Если значение равно None, таймаут не устанавливается, и вызов может блокироваться бесконечно.

Предсказать глубину переданных в качестве входных данных изображений.

ImageClassificationPipeline

класс transformers.ImageClassificationPipeline

< >

( *args**kwargs )

Параметры

  • model (PreTrainedModel) — Модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от PreTrainedModel.
  • image_processor (BaseImageProcessor) — Обработчик изображений, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от BaseImageProcessor.
  • task (str, по умолчанию "") — Идентификатор задачи для конвейера.
  • num_workers (int, необязательный, по умолчанию 8) — количество рабочих процессов, используемых, когда конвейер применяет DataLoader (при передаче набора данных, на GPU для модели PyTorch).
  • batch_size (int, необязательный, по умолчанию 1) — Когда конвейер использует DataLoader (при передаче набора данных, на GPU для модели PyTorch), размер батча, который будет использоваться. Для вывода это не всегда полезно, см. Обработка батчами в конвейерах .
  • args_parser (ArgumentHandler, необязательный) — Ссылка на объект, отвечающий за разбор переданных параметров конвейера.
  • device (int или str или torch.device, необязательный) — Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (CUDA, MPS, XPU, …), а на CPU переключается только в том случае, если ускорители отсутствуют; модель перемещается туда автоматически. Передайте device="cpu" (или -1), чтобы принудительно использовать CPU, положительный порядковый номер или "cuda:1", чтобы выбрать конкретный ускоритель, либо нативный torch.device/str. Этот аргумент нельзя использовать вместе с моделью, уже загруженной через accelerate (то есть с hf_device_map).
  • dtype (str или torch.dtype, необязательный, по умолчанию "auto") — Точность, в которой загружается модель, передаётся в from_pretrained. По умолчанию "auto", что загружает модель в той точности, в которой она была сохранена (читается из config.dtype контрольной точки, иначе выводится из весов). Передайте явное значение torch.float16, torch.bfloat16, torch.float32, … для переопределения.
  • binary_output (bool, необязательный, по умолчанию False) — Флаг, указывающий, должен ли вывод конвейера быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст.
  • function_to_apply (str, необязательный, по умолчанию "default") — Функция, применяемая к выходным данным модели для получения оценок. Принимает четыре значения:
    • "default": если у модели одна метка, к выходу применяется функция сигмоиды. Если у модели несколько меток, к выходу применяется функция softmax.
    • "sigmoid": применяет сигмоидную функцию к выходу.
    • "softmax": применяет функцию softmax к выходу.
    • "none": Не применяет никаких функций к выходным данным.

Конвейер классификации изображений с использованием любой модели AutoModelForImageClassification. Этот конвейер предсказывает класс изображения.

Пример:

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

Подробнее о базовых принципах использования пайплайна читайте в руководстве по пайплайнам

Этот конвейер классификации изображений в настоящее время можно загрузить из pipeline(), используя следующий идентификатор задачи: "image-classification".

Список доступных моделей можно найти на huggingface.co/models.

__call__

< >

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

Параметры

  • inputs (str, list[str], PIL.Image или list[PIL.Image]) — Пайплайн обрабатывает три типа изображений:
    • Строка, содержащая http-ссылку, указывающую на изображение
    • Строка, содержащая локальный путь к изображению
    • Изображение, загруженное непосредственно в PIL

    Пайплайн принимает как одно изображение, так и пакет изображений, которые затем должны передаваться в виде строки. Все изображения в пакете должны быть в одном формате: все в виде ссылок http, все в виде локальных путей или все в виде изображений PIL.

  • function_to_apply (str, необязательный, по умолчанию "default") — Функция, применяемая к выходным данным модели для получения оценок. Принимает четыре различных значения:

    Если этот аргумент не указан, то будут применены следующие функции в зависимости от количества меток:

    • Если у модели одна метка, к выходу будет применена функция сигмоиды.
    • Если у модели несколько меток, будет применена функция softmax к выходу.

    Возможные значения:

    • "sigmoid": применяет сигмоидную функцию к выходу.
    • "softmax": применяет функцию softmax к выходу.
    • "none": Не применяет никаких функций к выходным данным.
  • top_k (int, необязательный, по умолчанию 5) — Количество верхних меток, которые вернёт конвейер. Если указанное значение превышает количество меток, доступных в конфигурации модели, будет использовано количество меток.
  • timeout (float, необязательный, по умолчанию None) — Максимальное время ожидания в секундах при получении изображений из сети. Если значение равно None, таймаут не устанавливается, и вызов может блокироваться бесконечно.

Назначьте метки изображению (изображениям), переданному в качестве входных данных.

ImageSegmentationPipeline

класс transformers.ImageSegmentationPipeline

< >

( *args**kwargs )

Параметры

  • model (PreTrainedModel) — Модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от PreTrainedModel.
  • image_processor (BaseImageProcessor) — Обработчик изображений, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от BaseImageProcessor.
  • task (str, по умолчанию "") — Идентификатор задачи для конвейера.
  • num_workers (int, необязательный, по умолчанию 8) — количество рабочих процессов, используемых, когда конвейер применяет DataLoader (при передаче набора данных, на GPU для модели PyTorch).
  • batch_size (int, необязательный, по умолчанию 1) — Когда конвейер использует DataLoader (при передаче набора данных, на GPU для модели PyTorch), размер батча, который будет использоваться. Для вывода это не всегда полезно, см. Обработка батчами в конвейерах .
  • args_parser (ArgumentHandler, необязательный) — Ссылка на объект, отвечающий за разбор переданных параметров конвейера.
  • device (int или str или torch.device, необязательный) — Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (CUDA, MPS, XPU, …), а на CPU переключается только в том случае, если ускорители отсутствуют; модель перемещается туда автоматически. Передайте device="cpu" (или -1), чтобы принудительно использовать CPU, положительный порядковый номер или "cuda:1", чтобы выбрать конкретный ускоритель, либо нативный torch.device/str. Этот аргумент нельзя использовать вместе с моделью, уже загруженной через accelerate (то есть с hf_device_map).
  • dtype (str или torch.dtype, необязательный, по умолчанию "auto") — Точность, в которой загружается модель, передаётся в from_pretrained. По умолчанию "auto", что загружает модель в той точности, в которой она была сохранена (читается из config.dtype контрольной точки, иначе выводится из весов). Передайте явное значение torch.float16, torch.bfloat16, torch.float32, … для переопределения.
  • binary_output (bool, необязательный, по умолчанию False) — Флаг, указывающий, должен ли вывод конвейера быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст.

Конвейер сегментации изображений с использованием любой модели AutoModelForXXXSegmentation. Этот конвейер предсказывает маски объектов и их классы.

Пример:

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

Этот конвейер сегментации изображений в настоящее время можно загрузить из pipeline(), используя следующий идентификатор задачи: "image-segmentation".

Список доступных моделей можно найти на huggingface.co/models.

__call__

< >

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

Параметры

  • inputs (str, list[str], PIL.Image или list[PIL.Image]) — Пайплайн обрабатывает три типа изображений:
    • Строка, содержащая HTTP(S)-ссылку на изображение
    • Строка, содержащая локальный путь к изображению
    • Изображение, загруженное непосредственно в PIL

    Пайплайн принимает как одно изображение, так и пакет изображений. Все изображения в пакете должны быть в одном формате: все в виде HTTP(S)-ссылок, все в виде локальных путей или все в виде изображений PIL.

  • subtask (str, optional) — Задача сегментации, которую необходимо выполнить. Выберите [semantic, instance и panoptic] в зависимости от возможностей модели. Если не задано, конвейер попытается определить задачу в следующем порядке: panoptic, instance, semantic.
  • threshold (float, необязательный, по умолчанию 0.9) — Порог вероятности для отсечения предсказанных масок.
  • mask_threshold (float, необязательный, по умолчанию 0.5) — Порог, используемый при преобразовании предсказанных масок в бинарные значения.
  • overlap_mask_area_threshold (float, необязательный, по умолчанию 0.5) — Порог перекрытия масок для удаления мелких, несвязных сегментов.
  • timeout (float, необязательный, по умолчанию None) — Максимальное время ожидания в секундах при получении изображений из сети. Если значение равно None, таймаут не устанавливается, и вызов может блокироваться бесконечно.

Выполните сегментацию (определение масок и классов) на переданных в качестве входных данных изображении или изображениях.

KeypointMatchingPipeline

класс transformers.KeypointMatchingPipeline

< >

( *args**kwargs )

Конвейер сопоставления ключевых точек с использованием любой модели AutoModelForKeypointMatching. Этот конвейер сопоставляет ключевые точки между двумя изображениями.

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

Параметры

  • inputs (str, list[str], PIL.Image или list[PIL.Image]) — Пайплайн обрабатывает три типа изображений:
    • Строка, содержащая http-ссылку, указывающую на изображение
    • Строка, содержащая локальный путь к изображению
    • Изображение, загруженное непосредственно в PIL

    Пайплайн принимает либо одну пару изображений, либо пакет пар изображений, который в этом случае должен передаваться в виде строки. Все изображения в пакете должны быть в одном формате: все в виде ссылок http, все в виде локальных путей или все в виде изображений PIL.

  • threshold (float, необязательный, по умолчанию 0.0) — Порог, используемый для сопоставления ключевых точек. Ключевые точки, сопоставленные с более низкой оценкой совпадения, будут отфильтрованы. Значение 0 означает, что будут возвращены все сопоставленные ключевые точки.
  • kwargs — timeout (float, *optional*, defaults to None) Максимальное время ожидания в секундах при загрузке изображений из сети. Если значение равно None, таймаут не устанавливается, и вызов может блокироваться бесконечно.

Возвращает

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

Список совпадений или список, если предоставлена одна пара изображений, либо список списков совпадений, если предоставлена партия пар изображений. Каждое совпадение — это словарь, содержащий следующие ключи:

  • keypoint_image_0 (Keypoint): ключевая точка на первом изображении (координаты x, y).
  • keypoint_image_1 (Keypoint): ключевая точка на втором изображении (координаты x, y).
  • score (float): Оценка совпадения между двумя ключевыми точками.

Найдите совпадения между ключевыми точками на двух изображениях.

ObjectDetectionPipeline

класс transformers.ObjectDetectionPipeline

< >

( *args**kwargs )

Параметры

  • model (PreTrainedModel) — Модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от PreTrainedModel.
  • image_processor (BaseImageProcessor) — Обработчик изображений, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от BaseImageProcessor.
  • task (str, по умолчанию "") — Идентификатор задачи для конвейера.
  • num_workers (int, необязательный, по умолчанию 8) — количество рабочих процессов, используемых, когда конвейер применяет DataLoader (при передаче набора данных, на GPU для модели PyTorch).
  • batch_size (int, необязательный, по умолчанию 1) — Когда конвейер использует DataLoader (при передаче набора данных, на GPU для модели PyTorch), размер батча, который будет использоваться. Для вывода это не всегда полезно, см. Обработка батчами в конвейерах .
  • args_parser (ArgumentHandler, необязательный) — Ссылка на объект, отвечающий за разбор переданных параметров конвейера.
  • device (int или str или torch.device, необязательный) — Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (CUDA, MPS, XPU, …), а на CPU переключается только в том случае, если ускорители отсутствуют; модель перемещается туда автоматически. Передайте device="cpu" (или -1), чтобы принудительно использовать CPU, положительный порядковый номер или "cuda:1", чтобы выбрать конкретный ускоритель, либо нативный torch.device/str. Этот аргумент нельзя использовать вместе с моделью, уже загруженной через accelerate (то есть с hf_device_map).
  • dtype (str или torch.dtype, необязательный, по умолчанию "auto") — Точность, в которой загружается модель, передаётся в from_pretrained. По умолчанию "auto", что загружает модель в той точности, в которой она была сохранена (читается из config.dtype контрольной точки, иначе выводится из весов). Передайте явное значение torch.float16, torch.bfloat16, torch.float32, … для переопределения.
  • binary_output (bool, необязательный, по умолчанию False) — Флаг, указывающий, должен ли вывод конвейера быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст.

Конвейер обнаружения объектов с использованием любой модели AutoModelForObjectDetection. Этот конвейер предсказывает ограничивающие рамки объектов и их классы.

Пример:

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

Подробнее о базовых принципах использования пайплайна читайте в руководстве по пайплайнам

Этот конвейер обнаружения объектов в настоящее время можно загрузить из pipeline(), используя следующий идентификатор задачи: "object-detection".

Список доступных моделей можно найти на huggingface.co/models.

__call__

< >

( *args**kwargs )

Параметры

  • inputs (str, list[str], PIL.Image или list[PIL.Image]) — Пайплайн обрабатывает три типа изображений:
    • Строка, содержащая HTTP(S)-ссылку на изображение
    • Строка, содержащая локальный путь к изображению
    • Изображение, загруженное непосредственно в PIL

    Пайплайн принимает как одно изображение, так и пакет изображений. Все изображения в пакете должны быть в одном формате: все в виде HTTP(S)-ссылок, все в виде локальных путей или все в виде изображений PIL.

  • threshold (float, необязательный, по умолчанию 0.5) — Вероятность, необходимая для принятия предсказания.
  • timeout (float, необязательный, по умолчанию None) — Максимальное время ожидания в секундах при получении изображений из сети. Если значение равно None, таймаут не устанавливается, и вызов может блокироваться бесконечно.

Обнаружение объектов (ограничивающие рамки & классы) на переданных в качестве входных данных изображении или изображениях.

VideoClassificationPipeline

класс transformers.VideoClassificationPipeline

< >

( *args**kwargs )

Параметры

  • model (PreTrainedModel) — Модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от PreTrainedModel.
  • image_processor (BaseImageProcessor) — Обработчик изображений, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от BaseImageProcessor.
  • video_processor (BaseVideoProcessor) — Обработчик видео, который будет использоваться конвейером для кодирования видеоданных для модели. Этот объект наследуется от BaseVideoProcessor.
  • task (str, по умолчанию "") — Идентификатор задачи для конвейера.
  • num_workers (int, необязательный, по умолчанию 8) — количество рабочих процессов, используемых, когда конвейер применяет DataLoader (при передаче набора данных, на GPU для модели PyTorch).
  • batch_size (int, необязательный, по умолчанию 1) — Когда конвейер использует DataLoader (при передаче набора данных, на GPU для модели PyTorch), размер батча, который будет использоваться. Для вывода это не всегда полезно, см. Обработка батчами в конвейерах .
  • args_parser (ArgumentHandler, необязательный) — Ссылка на объект, отвечающий за разбор переданных параметров конвейера.
  • device (int или str или torch.device, необязательный) — Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (CUDA, MPS, XPU, …), а на CPU переключается только в том случае, если ускорители отсутствуют; модель перемещается туда автоматически. Передайте device="cpu" (или -1), чтобы принудительно использовать CPU, положительный порядковый номер или "cuda:1", чтобы выбрать конкретный ускоритель, либо нативный torch.device/str. Этот аргумент нельзя использовать вместе с моделью, уже загруженной через accelerate (то есть с hf_device_map).
  • dtype (str или torch.dtype, необязательный, по умолчанию "auto") — Точность, в которой загружается модель, передаётся в from_pretrained. По умолчанию "auto", что загружает модель в той точности, в которой она была сохранена (читается из config.dtype контрольной точки, иначе выводится из весов). Передайте явное значение torch.float16, torch.bfloat16, torch.float32, … для переопределения.
  • binary_output (bool, необязательный, по умолчанию False) — Флаг, указывающий, должен ли вывод конвейера быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст.

Конвейер классификации видео с использованием любой модели AutoModelForVideoClassification. Этот конвейер предсказывает класс видео.

Этот конвейер классификации видео в настоящее время можно загрузить из pipeline(), используя следующий идентификатор задачи: "video-classification".

Список доступных моделей можно найти на huggingface.co/models.

Пайплайн поддерживает модели, использующие либо процессор изображений (устаревшие видеомодели, такие как VideoMAE, ViViT и TimeSformer), либо процессор видео (более новые модели, такие как VJEPA2). Если присутствуют оба, приоритет отдаётся процессору видео; если ни один не найден, пайплайн выбросит ошибку.

__call__

< >

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

Параметры

  • inputs (str, list[str]) — Пайплайн обрабатывает три типа видео:
    • Строка, содержащая http-ссылку, указывающую на видео
    • Строка, содержащая локальный путь к видео

    Пайплайн принимает как одно видео, так и пакет видео, который в этом случае должен передаваться в виде строки. Все видео в пакете должны быть в одном формате: либо все в виде http-ссылок, либо все в виде локальных путей.

  • top_k (int, необязательный, по умолчанию 5) — Количество верхних меток, которые вернёт конвейер. Если указанное значение превышает количество меток, доступных в конфигурации модели, будет использовано количество меток.
  • num_frames (int, необязательный, по умолчанию self.model.config.num_frames) — Количество кадров, извлекаемых из видео для выполнения классификации. Если не указано, используется количество кадров, заданное в конфигурации модели.
  • frame_sampling_rate (int, необязательный, по умолчанию 1) — Частота выборки, используемая для отбора кадров из видео. Если не указано, по умолчанию принимается значение 1, то есть используются все кадры.
  • function_to_apply(str, optional, по умолчанию “softmax”) — Функция, применяемая к выходу модели. По умолчанию конвейер применяет функцию softmax к выходу модели. Допустимые значения: [“softmax”, “sigmoid”, “none”]. Обратите внимание, что передача встроенного значения Python None приведёт к использованию “softmax” по умолчанию, поэтому для отключения любой постобработки необходимо передать строку “none”.

Назначьте метки для видео, переданных в качестве входных данных.

ZeroShotImageClassificationPipeline

класс transformers.ZeroShotImageClassificationPipeline

< >

( **kwargs )

Параметры

  • model (PreTrainedModel) — Модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от PreTrainedModel.
  • image_processor (BaseImageProcessor) — Обработчик изображений, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от BaseImageProcessor.
  • task (str, по умолчанию "") — Идентификатор задачи для конвейера.
  • num_workers (int, необязательный, по умолчанию 8) — количество рабочих процессов, используемых, когда конвейер применяет DataLoader (при передаче набора данных, на GPU для модели PyTorch).
  • batch_size (int, необязательный, по умолчанию 1) — Когда конвейер использует DataLoader (при передаче набора данных, на GPU для модели PyTorch), размер батча, который будет использоваться. Для вывода это не всегда полезно, см. Обработка батчами в конвейерах .
  • args_parser (ArgumentHandler, необязательный) — Ссылка на объект, отвечающий за разбор переданных параметров конвейера.
  • device (int или str или torch.device, необязательный) — Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (CUDA, MPS, XPU, …), а на CPU переключается только в том случае, если ускорители отсутствуют; модель перемещается туда автоматически. Передайте device="cpu" (или -1), чтобы принудительно использовать CPU, положительный порядковый номер или "cuda:1", чтобы выбрать конкретный ускоритель, либо нативный torch.device/str. Этот аргумент нельзя использовать вместе с моделью, уже загруженной через accelerate (то есть с hf_device_map).
  • dtype (str или torch.dtype, необязательный, по умолчанию "auto") — Точность, в которой загружается модель, передаётся в from_pretrained. По умолчанию "auto", что загружает модель в той точности, в которой она была сохранена (читается из config.dtype контрольной точки, иначе выводится из весов). Передайте явное значение torch.float16, torch.bfloat16, torch.float32, … для переопределения.
  • binary_output (bool, необязательный, по умолчанию False) — Флаг, указывающий, должен ли вывод конвейера быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст.

Конвейер классификации изображений в режиме zero shot с использованием CLIPModel. Этот конвейер предсказывает класс изображения, если вы предоставляете изображение и набор candidate_labels.

Пример:

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

Подробнее о базовых принципах использования пайплайна читайте в руководстве по пайплайнам

Этот конвейер классификации изображений в настоящее время можно загрузить из pipeline(), используя следующий идентификатор задачи: "zero-shot-image-classification".

Список доступных моделей можно найти на huggingface.co/models.

__call__

< >

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

Параметры

  • image (str, list[str], PIL.Image или list[PIL.Image]) — Пайплайн обрабатывает три типа изображений:
    • Строка, содержащая http-ссылку, указывающую на изображение
    • Строка, содержащая локальный путь к изображению
    • Изображение, загруженное непосредственно в PIL
  • candidate_labels (list[str]) — Кандидатские метки для этого изображения. Они будут сформированы с помощью hypothesis_template.
  • hypothesis_template (str, необязательный, по умолчанию "This is a photo of {}") — Формат, используемый вместе с candidate_labels для попытки классификации изображения путём замены плейсхолдера на candidate_labels. Передайте ”{}”, если candidate_labels уже отформатированы.
  • timeout (float, необязательный, по умолчанию None) — Максимальное время ожидания в секундах при получении изображений из сети. Если значение равно None, таймаут не устанавливается, и вызов может блокироваться бесконечно.

Назначьте метки изображению (изображениям), переданному в качестве входных данных.

ZeroShotObjectDetectionPipeline

класс transformers.ZeroShotObjectDetectionPipeline

< >

( **kwargs )

Параметры

  • model (PreTrainedModel) — Модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от PreTrainedModel.
  • image_processor (BaseImageProcessor) — Обработчик изображений, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от BaseImageProcessor.
  • task (str, по умолчанию "") — Идентификатор задачи для конвейера.
  • num_workers (int, необязательный, по умолчанию 8) — количество рабочих процессов, используемых, когда конвейер применяет DataLoader (при передаче набора данных, на GPU для модели PyTorch).
  • batch_size (int, необязательный, по умолчанию 1) — Когда конвейер использует DataLoader (при передаче набора данных, на GPU для модели PyTorch), размер батча, который будет использоваться. Для вывода это не всегда полезно, см. Обработка батчами в конвейерах .
  • args_parser (ArgumentHandler, необязательный) — Ссылка на объект, отвечающий за разбор переданных параметров конвейера.
  • device (int или str или torch.device, необязательный) — Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (CUDA, MPS, XPU, …), а на CPU переключается только в том случае, если ускорители отсутствуют; модель перемещается туда автоматически. Передайте device="cpu" (или -1), чтобы принудительно использовать CPU, положительный порядковый номер или "cuda:1", чтобы выбрать конкретный ускоритель, либо нативный torch.device/str. Этот аргумент нельзя использовать вместе с моделью, уже загруженной через accelerate (то есть с hf_device_map).
  • dtype (str или torch.dtype, необязательный, по умолчанию "auto") — Точность, в которой загружается модель, передаётся в from_pretrained. По умолчанию "auto", что загружает модель в той точности, в которой она была сохранена (читается из config.dtype контрольной точки, иначе выводится из весов). Передайте явное значение torch.float16, torch.bfloat16, torch.float32, … для переопределения.
  • binary_output (bool, необязательный, по умолчанию False) — Флаг, указывающий, должен ли вывод конвейера быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст.

Конвейер обнаружения объектов в режиме zero shot с использованием OwlViTForObjectDetection. Этот конвейер предсказывает ограничивающие рамки объектов, когда вы предоставляете изображение и набор candidate_labels.

Пример:

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

Подробнее о базовых принципах использования пайплайна читайте в руководстве по пайплайнам

Этот конвейер обнаружения объектов в настоящее время можно загрузить из pipeline(), используя следующий идентификатор задачи: "zero-shot-object-detection".

Список доступных моделей можно найти на 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 )

Параметры

  • image (str, PIL.Image или list[dict[str, Any]]) — Пайплайн обрабатывает три типа изображений:
    • Строка, содержащая http-URL, указывающий на изображение
    • Строка, содержащая локальный путь к изображению
    • Изображение, загруженное непосредственно в PIL

    Этот параметр позволяет передавать список изображений напрямую, а также датасет или генератор, как показано ниже:

Обнаружение объектов (ограничивающие рамки & классы) на переданных в качестве входных данных изображении или изображениях.

Обработка естественного языка

Среди доступных конвейеров для задач обработки естественного языка есть следующие.

FillMaskPipeline

класс 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 )

Параметры

  • model (PreTrainedModel) — Модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от PreTrainedModel.
  • tokenizer (PreTrainedTokenizer) — Токенизатор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от PreTrainedTokenizer.
  • task (str, по умолчанию "") — Идентификатор задачи для конвейера.
  • num_workers (int, необязательный, по умолчанию 8) — количество рабочих процессов, используемых, когда конвейер применяет DataLoader (при передаче набора данных, на GPU для модели PyTorch).
  • batch_size (int, необязательный, по умолчанию 1) — Когда конвейер использует DataLoader (при передаче набора данных, на GPU для модели PyTorch), размер батча, который будет использоваться. Для вывода это не всегда полезно, см. Обработка батчами в конвейерах .
  • args_parser (ArgumentHandler, необязательный) — Ссылка на объект, отвечающий за разбор переданных параметров конвейера.
  • device (int или str или torch.device, необязательный) — Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (CUDA, MPS, XPU, …), а на CPU переключается только в том случае, если ускорители отсутствуют; модель перемещается туда автоматически. Передайте device="cpu" (или -1), чтобы принудительно использовать CPU, положительный порядковый номер или "cuda:1", чтобы выбрать конкретный ускоритель, либо нативный torch.device/str. Этот аргумент нельзя использовать вместе с моделью, уже загруженной через accelerate (то есть с hf_device_map).
  • dtype (str или torch.dtype, необязательный, по умолчанию "auto") — Точность, в которой загружается модель, передаётся в from_pretrained. По умолчанию "auto", что загружает модель в той точности, в которой она была сохранена (читается из config.dtype контрольной точки, иначе выводится из весов). Передайте явное значение torch.float16, torch.bfloat16, torch.float32, … для переопределения.
  • binary_output (bool, необязательный, по умолчанию False) — Флаг, указывающий, должен ли вывод конвейера быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст.
  • top_k (int, необязательный, по умолчанию 5) — Количество возвращаемых предсказаний.
  • targets (str или list[str], необязательный) — Если передано, модель ограничит оценки переданными целями, вместо того чтобы искать их во всей словарной базе. Если предоставленные цели отсутствуют в словарной базе модели, они будут токенизированы, и будет использован первый полученный токен (с предупреждением, что может замедлить процесс).
  • tokenizer_kwargs (dict, необязательный) — Дополнительный словарь аргументов с ключевыми словами, передаваемых в токенизатор.

__call__

< >

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

Параметры

  • inputs (str или list[str]) — Один или несколько текстов (или один список промптов) с замаскированными токенами.
  • targets (str или list[str], необязательный) — Если передано, модель ограничит оценки переданными целями, вместо того чтобы искать их во всей словарной базе. Если предоставленные цели отсутствуют в словарной базе модели, они будут токенизированы, и будет использован первый полученный токен (с предупреждением, что может замедлить процесс).
  • top_k (int, необязательный) — Если передан, переопределяет количество возвращаемых предсказаний.

Возвращает

Список или список списков dict

Каждый результат представляет собой список словарей со следующими ключами:

  • sequence (str) — Соответствующий вход с предсказанием маскированного токена.
  • score (float) — Соответствующая вероятность.
  • token (int) — Идентификатор предсказанного токена (для замены замаскированного).
  • token_str (str) — предсказанный токен (для замены замаскированного).

Заполните замаскированный токен в тексте (текстах), переданных в качестве входных данных.

TableQuestionAnsweringPipeline

класс transformers.TableQuestionAnsweringPipeline

< >

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

Параметры

  • model (PreTrainedModel) — Модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от PreTrainedModel.
  • tokenizer (PreTrainedTokenizer) — Токенизатор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от PreTrainedTokenizer.
  • task (str, по умолчанию "") — Идентификатор задачи для конвейера.
  • num_workers (int, необязательный, по умолчанию 8) — количество рабочих процессов, используемых, когда конвейер применяет DataLoader (при передаче набора данных, на GPU для модели PyTorch).
  • batch_size (int, необязательный, по умолчанию 1) — Когда конвейер использует DataLoader (при передаче набора данных, на GPU для модели PyTorch), размер батча, который будет использоваться. Для вывода это не всегда полезно, см. Обработка батчами в конвейерах .
  • args_parser (ArgumentHandler, необязательный) — Ссылка на объект, отвечающий за разбор переданных параметров конвейера.
  • device (int или str или torch.device, необязательный) — Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (CUDA, MPS, XPU, …), а на CPU переключается только в том случае, если ускорители отсутствуют; модель перемещается туда автоматически. Передайте device="cpu" (или -1), чтобы принудительно использовать CPU, положительный порядковый номер или "cuda:1", чтобы выбрать конкретный ускоритель, либо нативный torch.device/str. Этот аргумент нельзя использовать вместе с моделью, уже загруженной через accelerate (то есть с hf_device_map).
  • dtype (str или torch.dtype, необязательный, по умолчанию "auto") — Точность, в которой загружается модель, передаётся в from_pretrained. По умолчанию "auto", что загружает модель в той точности, в которой она была сохранена (читается из config.dtype контрольной точки, иначе выводится из весов). Передайте явное значение torch.float16, torch.bfloat16, torch.float32, … для переопределения.
  • binary_output (bool, необязательный, по умолчанию False) — Флаг, указывающий, должен ли вывод конвейера быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст.

Пайплайн Table Question Answering с использованием ModelForTableQuestionAnswering. Этот пайплайн доступен только в PyTorch.

Если модель, которую вы используете, явно не задаёт эти параметры генерации в своих файлах конфигурации (generation_config.json), будут использованы следующие значения по умолчанию:

  • max_new_tokens: 256

Пример:

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

Подробнее о базовых принципах использования пайплайна читайте в руководстве по пайплайнам

Этот конвейер для табличного вопросно-ответного взаимодействия в настоящее время можно загрузить из pipeline(), используя следующий идентификатор задачи: "table-question-answering".

Модели, которые может использовать этот конвейер, — это модели, дообученные на задаче табличного вопросно-ответного взаимодействия. С актуальным списком доступных моделей можно ознакомиться на huggingface.co/models.

__call__

< >

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

Параметры

  • table (pd.DataFrame или Dict) — Pandas DataFrame или словарь, который будет преобразован в DataFrame, содержащий все значения таблицы. Пример словаря приведен выше.
  • query (str или list[str]) — Запрос или список запросов, которые будут отправлены в модель вместе с таблицей.
  • sequential (bool, необязательный, по умолчанию False) — Выполнять ли инференс последовательно или батчами. Батчинг быстрее, но модели вроде SQA требуют последовательного выполнения инференса для извлечения отношений внутри последовательностей, учитывая их диалоговый характер.
  • padding (bool, str или PaddingStrategy, необязательный, по умолчанию False) — Включает и управляет выравниванием. Принимает следующие значения:
    • True или 'longest': дополнить до самой длинной последовательности в батче (или не дополнять, если предоставлена только одна последовательность).
    • 'max_length': Дополнить до максимальной длины, указанной аргументом max_length, или до максимально допустимой длины входных данных для модели, если этот аргумент не указан.
    • False или 'do_not_pad' (по умолчанию): без дополнения нулями (т. е. может выводить батч с последовательностями разной длины).
  • truncation (bool, str или TapasTruncationStrategy, необязательный, по умолчанию False) — Включает и управляет усечением. Принимает следующие значения:
    • True или 'drop_rows_to_fit': обрезать до максимальной длины, указанной аргументом max_length, или до максимально допустимой длины входа для модели, если этот аргумент не указан. Это приведёт к построчному обрезанию с удалением строк из таблицы.
    • False или 'do_not_truncate' (по умолчанию): без усечения (т.е. может выдать батч с длиной последовательности, превышающей максимальный допустимый размер входа модели).

Возвращает

Словарь или список словарей, содержащих результаты

Каждый результат представляет собой словарь со следующими ключами:

  • answer (str) — Ответ на запрос, основанный на таблице. Если используется агрегатор, ответ будет начинаться с AGGREGATOR >.
  • coordinates (list[tuple[int, int]]) — Координаты ячеек ответов.
  • cells (list[str]) — Список строк, состоящий из значений ячеек с ответами.
  • aggregator (str) — Если у модели есть агрегатор, возвращается агрегатор.

Отвечает на запросы в соответствии с таблицей. Конвейер принимает несколько типов входных данных, которые описаны ниже:

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

Аргумент table должен быть словарем или DataFrame, созданным из этого словаря, и содержать всю таблицу:

Пример:

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

Этот словарь можно передать в таком виде или преобразовать в DataFrame библиотеки pandas:

Пример:

import pandas as pd

table = pd.DataFrame.from_dict(data)

TextClassificationPipeline

класс transformers.TextClassificationPipeline

< >

( **kwargs )

Параметры

  • model (PreTrainedModel) — Модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от PreTrainedModel.
  • tokenizer (PreTrainedTokenizer) — Токенизатор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от PreTrainedTokenizer.
  • task (str, по умолчанию "") — Идентификатор задачи для конвейера.
  • num_workers (int, необязательный, по умолчанию 8) — количество рабочих процессов, используемых, когда конвейер применяет DataLoader (при передаче набора данных, на GPU для модели PyTorch).
  • batch_size (int, необязательный, по умолчанию 1) — Когда конвейер использует DataLoader (при передаче набора данных, на GPU для модели PyTorch), размер батча, который будет использоваться. Для вывода это не всегда полезно, см. Обработка батчами в конвейерах .
  • args_parser (ArgumentHandler, необязательный) — Ссылка на объект, отвечающий за разбор переданных параметров конвейера.
  • device (int или str или torch.device, необязательный) — Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (CUDA, MPS, XPU, …), а на CPU переключается только в том случае, если ускорители отсутствуют; модель перемещается туда автоматически. Передайте device="cpu" (или -1), чтобы принудительно использовать CPU, положительный порядковый номер или "cuda:1", чтобы выбрать конкретный ускоритель, либо нативный torch.device/str. Этот аргумент нельзя использовать вместе с моделью, уже загруженной через accelerate (то есть с hf_device_map).
  • dtype (str или torch.dtype, необязательный, по умолчанию "auto") — Точность, в которой загружается модель, передаётся в from_pretrained. По умолчанию "auto", что загружает модель в той точности, в которой она была сохранена (читается из config.dtype контрольной точки, иначе выводится из весов). Передайте явное значение torch.float16, torch.bfloat16, torch.float32, … для переопределения.
  • binary_output (bool, необязательный, по умолчанию False) — Флаг, указывающий, должен ли вывод конвейера быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст.
  • function_to_apply (str, необязательный, по умолчанию "default") — Функция, применяемая к выходным данным модели для получения оценок. Принимает четыре различных значения:
    • "default": если у модели одна метка, к выходу применяется функция сигмоиды. Если у модели несколько меток, к выходу применяется функция softmax. В случае задач регрессии к выходу не применяется никакая функция.
    • "sigmoid": применяет сигмоидную функцию к выходу.
    • "softmax": применяет функцию softmax к выходу.
    • "none": Не применяет никаких функций к выходным данным.

Конвейер классификации текста с использованием любой модели ModelForSequenceClassification. Подробнее см. в примерах классификации последовательностей.

Пример:

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

Подробнее о базовых принципах использования пайплайна читайте в руководстве по пайплайнам

Этот конвейер классификации текста в настоящее время можно загрузить из pipeline(), используя следующий идентификатор задачи: "sentiment-analysis" (для классификации последовательностей по положительным или отрицательным эмоциям).

Если доступно несколько меток классификации (model.config.num_labels >= 2), конвейер применяет softmax к результатам. Если метка одна, конвейер применяет sigmoid к результату. В случае задач регрессии (model.config.problem_type == "regression") к выходу не применяется никакая функция.

Модели, которые может использовать этот конвейер, — это модели, дообученные на задаче классификации последовательностей. Актуальный список доступных моделей можно найти на huggingface.co/models.

__call__

< >

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

Параметры

  • inputs (str или list[str] или dict[str], или list[dict[str]]) — Один или несколько текстов для классификации. Чтобы использовать пары текстов для классификации, можно передать словарь с ключами {"text", "text_pair"} или список таких словарей.
  • top_k (int, необязательный, по умолчанию 1) — Сколько результатов возвращать.
  • function_to_apply (str, необязательный, по умолчанию "default") — Функция, применяемая к выходным данным модели для получения оценок. Принимает четыре различных значения:

    Если этот аргумент не указан, то будут применены следующие функции в зависимости от количества меток:

    • Если тип задачи — регрессия, никакая функция не применяется к выходным данным.
    • Если у модели одна метка, к выходу будет применена функция сигмоиды.
    • Если у модели несколько меток, будет применена функция softmax к выходу.

    Возможные значения:

    • "sigmoid": применяет сигмоидную функцию к выходу.
    • "softmax": применяет функцию softmax к выходу.
    • "none": Не применяет никаких функций к выходным данным.

Возвращает

Список объектов dict

Каждый результат представляет собой список словарей со следующими ключами:

  • label (str) — Предсказанная метка.
  • score (float) — Соответствующая вероятность.

Если используется top_k, возвращается по одному такому словарю на каждую метку.

Классифицируйте текст(ы), переданные в качестве входных данных.

TextGenerationPipeline

класс transformers.TextGenerationPipeline

< >

( *args**kwargs )

Параметры

  • model (PreTrainedModel) — Модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от PreTrainedModel.
  • tokenizer (PreTrainedTokenizer) — Токенизатор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от PreTrainedTokenizer.
  • task (str, по умолчанию "") — Идентификатор задачи для конвейера.
  • num_workers (int, необязательный, по умолчанию 8) — количество рабочих процессов, используемых, когда конвейер применяет DataLoader (при передаче набора данных, на GPU для модели PyTorch).
  • batch_size (int, необязательный, по умолчанию 1) — Когда конвейер использует DataLoader (при передаче набора данных, на GPU для модели PyTorch), размер батча, который будет использоваться. Для вывода это не всегда полезно, см. Обработка батчами в конвейерах .
  • args_parser (ArgumentHandler, необязательный) — Ссылка на объект, отвечающий за разбор переданных параметров конвейера.
  • device (int или str или torch.device, необязательный) — Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (CUDA, MPS, XPU, …), а на CPU переключается только в том случае, если ускорители отсутствуют; модель перемещается туда автоматически. Передайте device="cpu" (или -1), чтобы принудительно использовать CPU, положительный порядковый номер или "cuda:1", чтобы выбрать конкретный ускоритель, либо нативный torch.device/str. Этот аргумент нельзя использовать вместе с моделью, уже загруженной через accelerate (то есть с hf_device_map).
  • dtype (str или torch.dtype, необязательный, по умолчанию "auto") — Точность, в которой загружается модель, передаётся в from_pretrained. По умолчанию "auto", что загружает модель в той точности, в которой она была сохранена (читается из config.dtype контрольной точки, иначе выводится из весов). Передайте явное значение torch.float16, torch.bfloat16, torch.float32, … для переопределения.
  • binary_output (bool, необязательный, по умолчанию False) — Флаг, указывающий, должен ли вывод конвейера быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст.

Конвейер генерации языка с использованием любой модели ModelWithLMHead или ModelForCausalLM. Этот конвейер предсказывает слова, которые будут следовать за заданным текстовым запросом. Если базовая модель является диалоговой, конвейер также может принимать один или несколько чатов. В этом случае он работает в режиме чата и продолжает диалог(и), добавляя свой ответ(ы). Каждый чат представляет собой список словарей, где каждый словарь содержит ключи “role” и “content”.

Если модель, которую вы используете, явно не задаёт эти параметры генерации в своих файлах конфигурации (generation_config.json), будут использованы следующие значения по умолчанию:

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

Примеры:

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

Подробнее о базовых принципах использования pipeline см. в руководстве по pipeline. Вы можете передавать параметры генерации текста в этот pipeline для управления критериями остановки, стратегией декодирования и другими аспектами. Подробнее о параметрах генерации текста см. в разделах Стратегии генерации текста и Генерация текста.

Этот конвейер генерации текста в настоящее время можно загрузить из pipeline(), используя следующий идентификатор задачи: "text-generation".

Модели, которые может использовать этот конвейер, — это модели, обученные с целью авторегрессионного языкового моделирования. См. список доступных моделей для завершения текста и список разговорных моделей на [huggingface.co/models].

__call__

< >

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

Параметры

  • text_inputs (str, list[str], ChatType или list[ChatType]) — Один или несколько промптов (или один список промптов) для завершения. Если переданы строки или список строк, этот пайплайн продолжит каждый промпт. Альтернативно, можно передать «чат» в виде списка словарей с ключами «role» и «content», либо список таких чатов. Если переданы чаты, шаблон чата модели будет использован для их форматирования перед передачей в модель.
  • return_tensors (bool, необязательный, по умолчанию False) — Возвращает тензоры предсказаний (в виде индексов токенов) в результатах. Если установлено в True, декодированный текст не возвращается.
  • return_text (bool, необязательный) — Возвращает декодированные тексты в результатах.
  • return_full_text (bool, необязательный, по умолчанию True) — Если установлено в False, возвращается только добавленный текст, в противном случае — полный текст. Не может быть указан одновременно с return_text.
  • clean_up_tokenization_spaces (bool, необязательный) — Удалять ли возможные лишние пробелы в текстовом выводе. По умолчанию используется значение параметра clean_up_tokenization_spaces токенизатора.
  • continue_final_message( bool, optional) — Этот параметр указывает, что вы хотите, чтобы модель продолжила последнее сообщение во входном чате, а не начала новое, что позволяет «предзаполнить» её ответ. По умолчанию он равен True, если роль последнего сообщения во входном чате — assistant, и False в противном случае, но вы можете вручную изменить это поведение, установив соответствующий флаг.
  • prefix (str, необязательный) — Префикс, добавляемый к промпту.
  • stop_sequence (str или list[str], необязательный) — Одна или несколько строк, которые останавливают генерацию, как только они будут сгенерированы. Строка остановки включается в вывод.
  • handle_long_generation (str, необязательный) — По умолчанию этот pipeline не обрабатывает длинную генерацию (ту, которая тем или иным образом превышает максимальную длину модели). Идеального способа решить эту проблему не существует (подробнее:https://github.com/huggingface/transformers/issues/14033#issuecomment-948385227). ). Здесь описаны общие стратегии обхода этой проблемы в зависимости от вашего сценария использования.
    • None : стратегия по умолчанию, при которой ничего особенного не происходит
    • "hole": Обрезает вход слева и оставляет зазор достаточной ширины для генерации (может сильно обрезать промпт и не подходит, если генерация превышает возможности модели)
  • tokenizer_encode_kwargs (dict, необязательный) — Дополнительные именованные аргументы, передаваемые на этапе кодирования токенизатора. Если входные данные представляют собой чат, они передаются в apply_chat_template. В противном случае они передаются в __call__.
  • generate_kwargs (dict, необязательный) — Дополнительные именованные аргументы, передаваемые в метод generate модели (см. метод generate здесь).

Возвращает

Список или список списков dict

Возвращает один из следующих словарей (невозможно вернуть комбинацию generated_text и generated_token_ids):

  • generated_text (str, присутствует, если return_text=True) — Сгенерированный текст.
  • generated_token_ids (torch.Tensor, присутствует, если return_tensors=True) — идентификаторы токенов сгенерированного текста.

Завершите промпт(ы), переданные в качестве входных данных.

TokenClassificationPipeline

класс transformers.TokenClassificationPipeline

< >

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

Параметры

  • model (PreTrainedModel) — Модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от PreTrainedModel.
  • tokenizer (PreTrainedTokenizer) — Токенизатор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от PreTrainedTokenizer.
  • task (str, по умолчанию "") — Идентификатор задачи для конвейера.
  • num_workers (int, необязательный, по умолчанию 8) — количество рабочих процессов, используемых, когда конвейер применяет DataLoader (при передаче набора данных, на GPU для модели PyTorch).
  • batch_size (int, необязательный, по умолчанию 1) — Когда конвейер использует DataLoader (при передаче набора данных, на GPU для модели PyTorch), размер батча, который будет использоваться. Для вывода это не всегда полезно, см. Обработка батчами в конвейерах .
  • args_parser (ArgumentHandler, необязательный) — Ссылка на объект, отвечающий за разбор переданных параметров конвейера.
  • device (int или str или torch.device, необязательный) — Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (CUDA, MPS, XPU, …), а на CPU переключается только в том случае, если ускорители отсутствуют; модель перемещается туда автоматически. Передайте device="cpu" (или -1), чтобы принудительно использовать CPU, положительный порядковый номер или "cuda:1", чтобы выбрать конкретный ускоритель, либо нативный torch.device/str. Этот аргумент нельзя использовать вместе с моделью, уже загруженной через accelerate (то есть с hf_device_map).
  • dtype (str или torch.dtype, необязательный, по умолчанию "auto") — Точность, в которой загружается модель, передаётся в from_pretrained. По умолчанию "auto", что загружает модель в той точности, в которой она была сохранена (читается из config.dtype контрольной точки, иначе выводится из весов). Передайте явное значение torch.float16, torch.bfloat16, torch.float32, … для переопределения.
  • binary_output (bool, необязательный, по умолчанию False) — Флаг, указывающий, должен ли вывод конвейера быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст.
  • ignore_labels (list[str], по умолчанию ["O"]) — Список меток, которые следует игнорировать.
  • stride (int, optional) — If stride is provided, the pipeline is applied on all the text. The text is split into chunks of size model_max_length. Works only with fast tokenizers and aggregation_strategy different from NONE. The value of this argument defines the number of overlapping tokens between chunks. In other words, the model will shift forward by tokenizer.model_max_length - stride tokens each step.
  • aggregation_strategy (str, необязательный, по умолчанию "none") — Стратегия слияния (или отсутствия слияния) токенов на основе предсказаний модели. «none»: не выполняет никакого агрегирования и просто возвращает сырые результаты модели. «simple»: пытается сгруппировать сущности согласно схеме по умолчанию. Последовательность (A, B-TAG), (B, I-TAG), (C, I-TAG), (D, B-TAG2) (E, B-TAG2) превратится в [{"word": ABC, "entity": "TAG"}, {"word": "D", "entity": "TAG2"}, {"word": "E", "entity": "TAG2"}]. Обратите внимание, что два последовательных тега B будут отнесены к разным сущностям. В языках, основанных на словах, это может привести к нежелательному разбиению слов: например, Microsoft может быть размечен как [{"word": "Micro", "entity": "ENTERPRISE"}, {"word": "soft", "entity": "NAME"}]. Используйте FIRST, MAX или AVERAGE, чтобы смягчить эту проблему и устранить неоднозначность в разметке слов (в языках, где это имеет смысл, то есть в языках, где токены разделены пробелами). Эти методы срабатывают только для реальных слов: «New york» всё равно может быть размечен как две разные сущности. «first»: (работает только с моделями, основанными на словах) Использует стратегию SIMPLE, за исключением того, что одно слово не может получить разные теги. При неоднозначности слово получает тег своего первого токена. «average»: (работает только с моделями, основанными на словах) Использует стратегию SIMPLE, за исключением того, что одно слово не может получить разные теги. Сначала усредняются оценки по токенам, затем применяется метка с максимальным значением. «max»: (работает только с моделями, основанными на словах) Использует стратегию SIMPLE, за исключением того, что одно слово не может получить разные теги. Тег слова определяется как тег токена с максимальной оценкой.
    • “none”: не выполняет никакой агрегации и просто возвращает необработанные результаты модели
    • “simple” : будет пытаться группировать сущности согласно схеме по умолчанию. Последовательность (A, B-TAG), (B, I-TAG), (C, I-TAG), (D, B-TAG2) (E, B-TAG2) в итоге превратится в [{“word”: ABC, “entity”: “TAG”}, {“word”: “D”, “entity”: “TAG2”}, {“word”: “E”, “entity”: “TAG2”}]. Обратите внимание, что два последовательных тега B будут отнесены к разным сущностям. Для языков, основанных на словах, это может привести к нежелательному разбиению слов: представьте, что Microsoft будет размечен как [{“word”: “Micro”, “entity”: “ENTERPRISE”}, {“word”: “soft”, “entity”: “NAME”}]. Используйте FIRST, MAX, AVERAGE, чтобы смягчить эту проблему и устранить неоднозначность в разметке слов (для языков, где это имеет смысл, то есть для токенов, разделённых пробелом). Эти меры сработают только для настоящих слов: «New york» всё равно может быть размечен двумя разными сущностями.
    • “first” : (работает только для моделей, основанных на словах) Использует стратегию SIMPLE, за исключением того, что слова не могут получить разные теги. При неоднозначности слова просто используют тег первого токена слова.
    • “average” : (работает только для моделей, основанных на словах) Используется стратегия SIMPLE, за исключением того, что слова не могут получить разные теги. Сначала усредняются оценки по токенам, а затем применяется метка с максимальным значением.
    • “max” : (работает только для моделей, основанных на словах) Использует стратегию SIMPLE, за исключением того, что слова не могут получать разные теги. Сущность слова будет просто токеном с максимальной оценкой.

Пайплайн распознавания именованных сущностей с использованием любой модели ModelForTokenClassification. Подробнее см. в примерах распознавания именованных сущностей.

Пример:

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

Подробнее о базовых принципах использования пайплайна читайте в руководстве по пайплайнам

Эту конвейерную линию распознавания токенов в настоящее время можно загрузить из pipeline(), используя следующий идентификатор задачи: "ner" (для предсказания классов токенов в последовательности: person, organisation, location или miscellaneous).

Модели, которые может использовать этот конвейер, — это модели, дообученные на задаче классификации токенов. Актуальный список доступных моделей можно найти на huggingface.co/models.

__call__

< >

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

Параметры

  • inputs (str или List[str]) — Один или несколько текстов (или один список текстов) для классификации токенов. Может быть предварительно токенизировано, если is_split_into_words=True.

Возвращает

Список или список списков dict

Каждый результат представляет собой список словарей (по одному для каждого токена в соответствующем входе или для каждой сущности, если этот конвейер был создан с параметром aggregation_strategy) со следующими ключами:

  • word (str) — классифицированный токен/слово. Получается путём декодирования выбранных токенов. Если вам нужна точная строка из исходного предложения, используйте start и end.
  • score (float) — соответствующая вероятность для entity.
  • entity (str) — сущность, предсказанная для данного токена/слова (называется entity_group, если aggregation_strategy не равно "none").
  • index (int, присутствует только при aggregation_strategy="none") — индекс соответствующего токена в предложении.
  • start (int, необязательный) — индекс начала соответствующей сущности в предложении. Существует только в том случае, если смещения доступны в токенизаторе
  • end (int, необязательный) — Индекс конца соответствующей сущности в предложении. Существует только в том случае, если смещения доступны в токенизаторе

Классифицируйте каждый токен текста(ов), переданного(ых) в качестве входных данных.

aggregate_words

< >

( entities: listaggregation_strategy: AggregationStrategy )

Переопределяйте токены из заданного слова, которые не совпадают, чтобы принудительно согласовать границы слов.

Пример: micro|soft| com|pany| B-ENT I-NAME I-ENT I-ENT будет переписан с использованием первой стратегии как 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 )

Объедините различные массивы numpy в словари, содержащие всю необходимую информацию для агрегации

group_entities

< >

( entities: list )

Параметры

  • entities (dict) — Сущности, предсказанные конвейером.

Найдите и сгруппируйте соседние токены, для которых предсказана одна и та же сущность.

group_sub_entities

< >

( entities: list )

Параметры

  • entities (dict) — Сущности, предсказанные конвейером.

Сгруппируйте соседние токены, для которых предсказана одна и та же сущность.

ZeroShotClassificationPipeline

класс transformers.ZeroShotClassificationPipeline

< >

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

Параметры

  • model (PreTrainedModel) — Модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от PreTrainedModel.
  • tokenizer (PreTrainedTokenizer) — Токенизатор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от PreTrainedTokenizer.
  • task (str, по умолчанию "") — Идентификатор задачи для конвейера.
  • num_workers (int, необязательный, по умолчанию 8) — количество рабочих процессов, используемых, когда конвейер применяет DataLoader (при передаче набора данных, на GPU для модели PyTorch).
  • batch_size (int, необязательный, по умолчанию 1) — Когда конвейер использует DataLoader (при передаче набора данных, на GPU для модели PyTorch), размер батча, который будет использоваться. Для вывода это не всегда полезно, см. Обработка батчами в конвейерах .
  • args_parser (ArgumentHandler, необязательный) — Ссылка на объект, отвечающий за разбор переданных параметров конвейера.
  • device (int или str или torch.device, необязательный) — Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (CUDA, MPS, XPU, …), а на CPU переключается только в том случае, если ускорители отсутствуют; модель перемещается туда автоматически. Передайте device="cpu" (или -1), чтобы принудительно использовать CPU, положительный порядковый номер или "cuda:1", чтобы выбрать конкретный ускоритель, либо нативный torch.device/str. Этот аргумент нельзя использовать вместе с моделью, уже загруженной через accelerate (то есть с hf_device_map).
  • dtype (str или torch.dtype, необязательный, по умолчанию "auto") — Точность, в которой загружается модель, передаётся в from_pretrained. По умолчанию "auto", что загружает модель в той точности, в которой она была сохранена (читается из config.dtype контрольной точки, иначе выводится из весов). Передайте явное значение torch.float16, torch.bfloat16, torch.float32, … для переопределения.
  • binary_output (bool, необязательный, по умолчанию False) — Флаг, указывающий, должен ли вывод конвейера быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст.

Пайплайн классификации без обучения на основе NLI, использующий ModelForSequenceClassification, обученный на задачах NLI (естественно-языкового вывода). Аналог пайплайнов text-classification, однако эти модели не требуют заранее заданного количества классов — их можно выбирать во время выполнения. Как правило, это работает медленнее, но значительно более гибко.

Можно передать любую комбинацию последовательностей и меток, и каждая такая комбинация будет представлена в виде пары «посылка/гипотеза» и передана в предобученную модель. Затем логит для entailment используется в качестве логита, подтверждающего корректность кандидата в метки. Можно использовать любую NLI-модель, но идентификатор метки entailment должен присутствовать в :attr:~transformers.PreTrainedConfig.label2id конфигурации модели.

Пример:

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

Подробнее о базовых принципах использования пайплайна читайте в руководстве по пайплайнам

Этот NLI-пайплайн в настоящее время можно загрузить из pipeline(), используя следующий идентификатор задачи: "zero-shot-classification".

Модели, которые может использовать этот конвейер, — это модели, дообученные на задаче NLI. Актуальный список доступных моделей можно найти на huggingface.co/models.

__call__

< >

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

Параметры

  • sequences (str или list[str]) — Последовательность(и) для классификации; если вход модели слишком велик, последовательность будет усечена.
  • candidate_labels (str или list[str]) — Набор возможных классов, в которые классифицируется каждая последовательность. Может быть одним классом, строкой с классами, разделёнными запятыми, или списком классов.
  • hypothesis_template (str, необязательный, по умолчанию "This example is {}.") — Шаблон, используемый для преобразования каждой метки в гипотезу в стиле NLI. Этот шаблон должен содержать {} или аналогичный синтаксис для вставки кандидата метки в шаблон. Например, шаблон по умолчанию — "This example is {}." При метке-кандидате "sports" в модель будет передано "<cls> sequence to classify <sep> This example is sports . <sep>". Шаблон по умолчанию хорошо работает во многих случаях, но в зависимости от настроек задачи может быть полезно поэкспериментировать с другими шаблонами.
  • multi_label (bool, необязательный, по умолчанию False) — Указывает, может ли быть истинным несколько меток. Если False, оценки нормализуются так, что сумма вероятностей меток для каждой последовательности равна 1. Если True, метки считаются независимыми, а вероятности нормализуются для каждой кандидатуры с помощью softmax от оценки подтверждения (entailment) и оценки противоречия (contradiction).

Возвращает

Словарь dict или список словарей dict

Каждый результат представляет собой словарь со следующими ключами:

  • sequence (str) — Последовательность, для которой это является выходом.
  • labels (list[str]) — Метки, отсортированные по убыванию вероятности.
  • scores (list[float]) — Вероятности для каждой из меток.

Классифицирует последовательность(и), переданные в качестве входных данных. Подробнее см. в документации ZeroShotClassificationPipeline.

Мультимодальность

Среди доступных для мультимодальных задач пайплайнов есть следующие.

DocumentQuestionAnsweringPipeline

класс transformers.DocumentQuestionAnsweringPipeline

< >

( *args**kwargs )

Параметры

  • model (PreTrainedModel) — Модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от PreTrainedModel.
  • tokenizer (PreTrainedTokenizer) — Токенизатор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от PreTrainedTokenizer.
  • image_processor (BaseImageProcessor) — Обработчик изображений, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от BaseImageProcessor.
  • task (str, по умолчанию "") — Идентификатор задачи для конвейера.
  • num_workers (int, необязательный, по умолчанию 8) — количество рабочих процессов, используемых, когда конвейер применяет DataLoader (при передаче набора данных, на GPU для модели PyTorch).
  • batch_size (int, необязательный, по умолчанию 1) — Когда конвейер использует DataLoader (при передаче набора данных, на GPU для модели PyTorch), размер батча, который будет использоваться. Для вывода это не всегда полезно, см. Обработка батчами в конвейерах .
  • args_parser (ArgumentHandler, необязательный) — Ссылка на объект, отвечающий за разбор переданных параметров конвейера.
  • device (int или str или torch.device, необязательный) — Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (CUDA, MPS, XPU, …), а на CPU переключается только в том случае, если ускорители отсутствуют; модель перемещается туда автоматически. Передайте device="cpu" (или -1), чтобы принудительно использовать CPU, положительный порядковый номер или "cuda:1", чтобы выбрать конкретный ускоритель, либо нативный torch.device/str. Этот аргумент нельзя использовать вместе с моделью, уже загруженной через accelerate (то есть с hf_device_map).
  • dtype (str или torch.dtype, необязательный, по умолчанию "auto") — Точность, в которой загружается модель, передаётся в from_pretrained. По умолчанию "auto", что загружает модель в той точности, в которой она была сохранена (читается из config.dtype контрольной точки, иначе выводится из весов). Передайте явное значение torch.float16, torch.bfloat16, torch.float32, … для переопределения.
  • binary_output (bool, необязательный, по умолчанию False) — Флаг, указывающий, должен ли вывод конвейера быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст.

Пайплайн Document Question Answering с использованием любой модели AutoModelForDocumentQuestionAnswering. Входные и выходные данные аналогичны пайплайну (экстрактивному) question answering; однако на вход пайплайн принимает изображение (и необязательные слова/рамки, полученные с помощью OCR), а не текстовый контекст.

Если модель, которую вы используете, явно не задаёт эти параметры генерации в своих файлах конфигурации (generation_config.json), будут использованы следующие значения по умолчанию:

  • max_new_tokens: 256

Пример:

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

Подробнее о базовых принципах использования пайплайна читайте в руководстве по пайплайнам

Этот конвейер для ответа на вопросы по документам в настоящее время можно загрузить из pipeline(), используя следующий идентификатор задачи: "document-question-answering".

Модели, которые может использовать этот конвейер, — это модели, дообученные на задаче вопросно-ответной обработки документов. С актуальным списком доступных моделей можно ознакомиться на 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

Параметры

  • image (str или PIL.Image) — Пайплайн обрабатывает три типа изображений:
    • Строка, содержащая http-ссылку, указывающую на изображение
    • Строка, содержащая локальный путь к изображению
    • Изображение, загруженное непосредственно в PIL

    Пайплайн принимает как одно изображение, так и пакет изображений. Если передано одно изображение, оно может быть распространено на несколько вопросов.

  • question (str) — Вопрос, который нужно задать документу.
  • word_boxes (list[str, tuple[float, float, float, float]], необязательный) — Список слов и ограничивающих прямоугольников (нормализованных в диапазоне 0->1000). Если вы укажете этот необязательный вход, пайплайн будет использовать эти слова и прямоугольники вместо запуска OCR на изображении для их получения в моделях, которым они необходимы (например, LayoutLM). Это позволяет повторно использовать результаты OCR при множественных вызовах пайплайна без необходимости запускать его заново каждый раз.
  • top_k (int, необязательный, по умолчанию 1) — Количество возвращаемых ответов (выбираются по убыванию вероятности). Обратите внимание, что если в контексте недостаточно вариантов, будет возвращено меньше, чем top_k ответов.
  • doc_stride (int, необязательный, по умолчанию 128) — Если слова в документе слишком длинные, чтобы вместе с вопросом уместиться в контекст модели, документ будет разбит на несколько фрагментов с перекрытием. Этот аргумент управляет размером перекрытия.
  • max_answer_len (int, необязательный, по умолчанию 15) — Максимальная длина предсказанных ответов (например, учитываются только ответы с меньшей длиной).
  • max_seq_len (int, необязательный, по умолчанию 384) — Максимальная длина полного предложения (контекст + вопрос) в токенах для каждого фрагмента, передаваемого в модель. При необходимости контекст будет разбит на несколько фрагментов (с перекрытием doc_stride).
  • max_question_len (int, необязательный, по умолчанию 64) — Максимальная длина вопроса после токенизации. При необходимости будет усечена.
  • handle_impossible_answer (bool, необязательный, по умолчанию False) — Определяет, принимаем ли мы «невозможно» в качестве ответа.
  • lang (str, необязательный) — Язык, используемый при выполнении OCR. По умолчанию — английский.
  • tesseract_config (str, необязательный) — Дополнительные флаги, передаваемые tesseract при выполнении OCR.
  • timeout (float, необязательный, по умолчанию None) — Максимальное время ожидания в секундах при получении изображений из сети. Если значение равно None, таймаут не устанавливается, и вызов может блокироваться бесконечно.

Возвращает

Словарь dict или список словарей dict

Каждый результат представляет собой словарь со следующими ключами:

  • score (float) — Вероятность, связанная с ответом.
  • start (int) — Индекс начального слова ответа (в версии входа, полученной с помощью OCR, или в предоставленных word_boxes).
  • end (int) — Индекс конечного слова ответа (в версии входа, полученной с помощью OCR, или в предоставленных word_boxes).
  • answer (str) — Ответ на вопрос.
  • words (list[int]) — Индекс каждой пары «слово/рамка», входящей в ответ

Ответьте на вопрос(ы), переданный(ые) в качестве входных данных, используя документ(ы). Документ определяется как изображение и необязательный список кортежей (слово, рамка), представляющих текст в документе. Если word_boxes не предоставлены, будет использоваться движок Tesseract OCR (если он доступен) для автоматического извлечения слов и рамок для моделей типа LayoutLM, которым они необходимы в качестве входных данных. Для Donut OCR не выполняется.

Вы можете вызвать конвейер несколькими способами:

  • 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

класс 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 )

Параметры

  • model (PreTrainedModel) — Модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от PreTrainedModel.
  • tokenizer (PreTrainedTokenizer) — Токенизатор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от PreTrainedTokenizer.
  • task (str, по умолчанию "") — Идентификатор задачи для конвейера.
  • num_workers (int, необязательный, по умолчанию 8) — количество рабочих процессов, используемых, когда конвейер применяет DataLoader (при передаче набора данных, на GPU для модели PyTorch).
  • batch_size (int, необязательный, по умолчанию 1) — Когда конвейер использует DataLoader (при передаче набора данных, на GPU для модели PyTorch), размер батча, который будет использоваться. Для вывода это не всегда полезно, см. Обработка батчами в конвейерах .
  • args_parser (ArgumentHandler, необязательный) — Ссылка на объект, отвечающий за разбор переданных параметров конвейера.
  • device (int или str или torch.device, необязательный) — Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (CUDA, MPS, XPU, …), а на CPU переключается только в том случае, если ускорители отсутствуют; модель перемещается туда автоматически. Передайте device="cpu" (или -1), чтобы принудительно использовать CPU, положительный порядковый номер или "cuda:1", чтобы выбрать конкретный ускоритель, либо нативный torch.device/str. Этот аргумент нельзя использовать вместе с моделью, уже загруженной через accelerate (то есть с hf_device_map).
  • dtype (str или torch.dtype, необязательный, по умолчанию "auto") — Точность, в которой загружается модель, передаётся в from_pretrained. По умолчанию "auto", что загружает модель в той точности, в которой она была сохранена (читается из config.dtype контрольной точки, иначе выводится из весов). Передайте явное значение torch.float16, torch.bfloat16, torch.float32, … для переопределения.
  • tokenize_kwargs (dict, необязательный) — Дополнительный словарь аргументов, передаваемых в токенизатор.
  • return_tensors (bool, необязательный) — Если True, возвращает тензор в соответствии с указанной фреймворком, иначе возвращает список.

Пайплайн Feature extraction не использует модельную голову. Этот пайплайн извлекает скрытые состояния из базового трансформера, которые можно использовать в качестве признаков для задач, следующих за ним.

Пример:

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

Подробнее о базовых принципах использования пайплайна читайте в руководстве по пайплайнам

Этот конвейер извлечения признаков в настоящее время можно загрузить из pipeline(), используя идентификатор задачи: "feature-extraction".

Все модели могут использоваться для этого конвейера. Список всех моделей, включая модели, предоставленные сообществом, доступен на huggingface.co/models.

__call__

< >

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

Параметры

  • args (str или list[str]) — один или несколько текстов (или один список текстов), для которых нужно получить признаки.

Возвращает

Вложенный список float

Особенности, вычисленные моделью.

Извлекайте признаки входного текста.

ImageFeatureExtractionPipeline

класс 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 )

Параметры

  • model (PreTrainedModel) — Модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от PreTrainedModel.
  • image_processor (BaseImageProcessor) — Обработчик изображений, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от BaseImageProcessor.
  • task (str, по умолчанию "") — Идентификатор задачи для конвейера.
  • num_workers (int, необязательный, по умолчанию 8) — количество рабочих процессов, используемых, когда конвейер применяет DataLoader (при передаче набора данных, на GPU для модели PyTorch).
  • batch_size (int, необязательный, по умолчанию 1) — Когда конвейер использует DataLoader (при передаче набора данных, на GPU для модели PyTorch), размер батча, который будет использоваться. Для вывода это не всегда полезно, см. Обработка батчами в конвейерах .
  • args_parser (ArgumentHandler, необязательный) — Ссылка на объект, отвечающий за разбор переданных параметров конвейера.
  • device (int или str или torch.device, необязательный) — Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (CUDA, MPS, XPU, …), а на CPU переключается только в том случае, если ускорители отсутствуют; модель перемещается туда автоматически. Передайте device="cpu" (или -1), чтобы принудительно использовать CPU, положительный порядковый номер или "cuda:1", чтобы выбрать конкретный ускоритель, либо нативный torch.device/str. Этот аргумент нельзя использовать вместе с моделью, уже загруженной через accelerate (то есть с hf_device_map).
  • dtype (str или torch.dtype, необязательный, по умолчанию "auto") — Точность, в которой загружается модель, передаётся в from_pretrained. По умолчанию "auto", что загружает модель в той точности, в которой она была сохранена (читается из config.dtype контрольной точки, иначе выводится из весов). Передайте явное значение torch.float16, torch.bfloat16, torch.float32, … для переопределения.
  • binary_output (bool, необязательный, по умолчанию False) — Флаг, указывающий, должен ли вывод конвейера быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст.
  • image_processor_kwargs (dict, необязательный) — Дополнительный словарь аргументов, передаваемых в image processor, например {“size”: {“height”: 100, “width”: 100}‌}
  • pool (bool, необязательный, по умолчанию False) — Определяет, следует ли возвращать агрегированный выход. Если False, модель вернет необработанные скрытые состояния.

Пайплайн извлечения признаков изображений не использует модельную голову. Этот пайплайн извлекает скрытые состояния из базового трансформера, которые можно использовать в качестве признаков для задач, следующих за ним.

Пример:

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

Подробнее о базовых принципах использования пайплайна читайте в руководстве по пайплайнам

Этот конвейер извлечения признаков изображений в настоящее время можно загрузить из pipeline(), используя идентификатор задачи: "image-feature-extraction".

Все модели компьютерного зрения могут использоваться в этом конвейере. Список всех моделей, включая модели, предоставленные сообществом, доступен на huggingface.co/models.

__call__

< >

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

Параметры

  • images (str, list[str], PIL.Image или list[PIL.Image]) — Пайплайн обрабатывает три типа изображений:
    • Строка, содержащая http-ссылку, указывающую на изображение
    • Строка, содержащая локальный путь к изображению
    • Изображение, загруженное непосредственно в PIL

    Пайплайн принимает как одно изображение, так и пакет изображений, которые затем должны передаваться в виде строки. Все изображения в пакете должны быть в одном формате: все в виде ссылок http, все в виде локальных путей или все в виде изображений PIL.

  • timeout (float, необязательный, по умолчанию None) — Максимальное время ожидания в секундах при загрузке изображений из сети. Если значение равно None, таймаут не устанавливается, и вызов может блокироваться бесконечно.

Возвращает

Вложенный список float

Особенности, вычисленные моделью.

Извлекайте признаки входных данных.

ImageTextToTextPipeline

класс transformers.ImageTextToTextPipeline

< >

( *args**kwargs )

Параметры

  • model (PreTrainedModel) — Модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от PreTrainedModel.
  • processor (ProcessorMixin) — обработчик, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от ProcessorMixin. Processor — это составной объект, который может содержать tokenizer, feature_extractor и image_processor.
  • task (str, по умолчанию "") — Идентификатор задачи для конвейера.
  • num_workers (int, необязательный, по умолчанию 8) — количество рабочих процессов, используемых, когда конвейер применяет DataLoader (при передаче набора данных, на GPU для модели PyTorch).
  • batch_size (int, необязательный, по умолчанию 1) — Когда конвейер использует DataLoader (при передаче набора данных, на GPU для модели PyTorch), размер батча, который будет использоваться. Для вывода это не всегда полезно, см. Обработка батчами в конвейерах .
  • args_parser (ArgumentHandler, необязательный) — Ссылка на объект, отвечающий за разбор переданных параметров конвейера.
  • device (int или str или torch.device, необязательный) — Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (CUDA, MPS, XPU, …), а на CPU переключается только в том случае, если ускорители отсутствуют; модель перемещается туда автоматически. Передайте device="cpu" (или -1), чтобы принудительно использовать CPU, положительный порядковый номер или "cuda:1", чтобы выбрать конкретный ускоритель, либо нативный torch.device/str. Этот аргумент нельзя использовать вместе с моделью, уже загруженной через accelerate (то есть с hf_device_map).
  • dtype (str или torch.dtype, необязательный, по умолчанию "auto") — Точность, в которой загружается модель, передаётся в from_pretrained. По умолчанию "auto", что загружает модель в той точности, в которой она была сохранена (читается из config.dtype контрольной точки, иначе выводится из весов). Передайте явное значение torch.float16, torch.bfloat16, torch.float32, … для переопределения.
  • binary_output (bool, необязательный, по умолчанию False) — Флаг, указывающий, должен ли вывод конвейера быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст.

Пайплайн «изображение и текст в текст» на основе AutoModelForImageTextToText. Этот пайплайн генерирует текст по заданному изображению и тексту. Если базовая модель является разговорной, пайплайн также может принимать один или несколько чатов. В этом случае пайплайн работает в режиме чата и продолжает диалог(и), добавляя свой ответ(ы). Каждый чат представляет собой список словарей, где каждый словарь содержит ключи «role» и «content».

Если модель, которую вы используете, явно не задаёт эти параметры генерации в своих файлах конфигурации (generation_config.json), будут использованы следующие значения по умолчанию:

  • max_new_tokens: 256

Пример:

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

Подробнее о базовых принципах использования пайплайна читайте в руководстве по пайплайнам

Этот пайплайн «изображение-текст в текст» в настоящее время можно загрузить с помощью pipeline(), используя следующий идентификатор задачи: “image-text-to-text”.

Список доступных моделей можно найти на 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

Параметры

  • images (str, list[str], PIL.Image, list[PIL.Image], list[dict[str, Union[str, PIL.Image]]]`) — Пайплайн обрабатывает три типа изображений:
    • Строка, содержащая HTTP(S)-ссылку на изображение
    • Строка, содержащая локальный путь к изображению
    • Изображение, загруженное непосредственно в PIL

    Пайплайн принимает как одно изображение, так и пакет изображений. Кроме того, этот пайплайн поддерживает чат-формат (см. text), содержащий изображения и текст в этом аргументе.

  • text (str, list[str], list[dict[str, Union[str, PIL.Image]]]) — Текст, используемый для генерации. Если передан список строк, его длина должна совпадать с количеством изображений. Текст также может быть представлен в формате чата: список словарей, где каждый словарь представляет собой сообщение в диалоге. Каждый словарь должен содержать два ключа: ‘role’ и ‘content’. Значение ‘role’ должно быть одним из ‘user’, ‘system’ или ‘assistant’. Значение ‘content’ должно быть списком словарей, содержащих текст сообщения и его тип. Тип сообщения может быть ‘text’ или ‘image’. Если тип — ‘image’, текст не требуется.
  • return_tensors (bool, необязательный, по умолчанию False) — Возвращает тензоры предсказаний (в виде индексов токенов) в результатах. Если установлено в True, декодированный текст не возвращается.
  • return_text (bool, необязательный) — Возвращает декодированные тексты в результатах.
  • return_full_text (bool, необязательный, по умолчанию True) — Если установлено в False, возвращается только добавленный текст, в противном случае — полный текст. Не может быть указан одновременно с return_text.
  • clean_up_tokenization_spaces (bool, необязательный) — Удалять ли возможные лишние пробелы в текстовом выводе. По умолчанию используется значение параметра clean_up_tokenization_spaces токенизатора.
  • continue_final_message( bool, optional) — Этот параметр указывает, что вы хотите, чтобы модель продолжила последнее сообщение во входном чате, а не начала новое, что позволяет «предзаполнить» её ответ. По умолчанию он равен True, если роль последнего сообщения во входном чате — assistant, и False в противном случае, но вы можете вручную изменить это поведение, установив соответствующий флаг.

Возвращает

Список или список списков dict

Каждый результат возвращается в виде словаря со следующим ключом (нельзя вернуть комбинацию generated_text и generated_token_ids):

  • generated_text (str, присутствует, если return_text=True) — Сгенерированный текст.
  • generated_token_ids (torch.Tensor, присутствует, если return_tensors=True) — идентификаторы токенов сгенерированного текста.
  • input_text (str) — Входной текст.

Сгенерировать текст на основе переданного в качестве входных данных текста и изображения(ий).

AnyToAnyPipeline

класс transformers.AnyToAnyPipeline

< >

( *args**kwargs )

Параметры

  • model (PreTrainedModel) — Модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от PreTrainedModel.
  • processor (ProcessorMixin) — обработчик, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от ProcessorMixin. Processor — это составной объект, который может содержать tokenizer, feature_extractor и image_processor.
  • task (str, по умолчанию "") — Идентификатор задачи для конвейера.
  • num_workers (int, необязательный, по умолчанию 8) — количество рабочих процессов, используемых, когда конвейер применяет DataLoader (при передаче набора данных, на GPU для модели PyTorch).
  • batch_size (int, необязательный, по умолчанию 1) — Когда конвейер использует DataLoader (при передаче набора данных, на GPU для модели PyTorch), размер батча, который будет использоваться. Для вывода это не всегда полезно, см. Обработка батчами в конвейерах .
  • args_parser (ArgumentHandler, необязательный) — Ссылка на объект, отвечающий за разбор переданных параметров конвейера.
  • device (int или str или torch.device, необязательный) — Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (CUDA, MPS, XPU, …), а на CPU переключается только в том случае, если ускорители отсутствуют; модель перемещается туда автоматически. Передайте device="cpu" (или -1), чтобы принудительно использовать CPU, положительный порядковый номер или "cuda:1", чтобы выбрать конкретный ускоритель, либо нативный torch.device/str. Этот аргумент нельзя использовать вместе с моделью, уже загруженной через accelerate (то есть с hf_device_map).
  • dtype (str или torch.dtype, необязательный, по умолчанию "auto") — Точность, в которой загружается модель, передаётся в from_pretrained. По умолчанию "auto", что загружает модель в той точности, в которой она была сохранена (читается из config.dtype контрольной точки, иначе выводится из весов). Передайте явное значение torch.float16, torch.bfloat16, torch.float32, … для переопределения.
  • binary_output (bool, необязательный, по умолчанию False) — Флаг, указывающий, должен ли вывод конвейера быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст.

Конвейер мультимодальной генерации, использующий AutoModelForMultimodalLM. Этот конвейер генерирует текст на основе любого сочетания мультимодальных данных и текста. Если базовая модель является разговорной, конвейер также может принимать один или несколько чатов; в этом случае он работает в режиме чата и продолжает диалог(и), добавляя свой ответ(ы). Каждый чат представляет собой список словарей, где каждый словарь содержит ключи “role” и “content”.

Если модель, которую вы используете, явно не задаёт эти параметры генерации в своих файлах конфигурации (generation_config.json), будут использованы следующие значения по умолчанию:

  • max_new_tokens: 256

Пример:

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

Подробнее о базовых принципах использования пайплайна читайте в руководстве по пайплайнам

Этот мультимодальный пайплайн в настоящее время можно загрузить из pipeline() с использованием следующего идентификатора задачи: “any-to-any”.

Список доступных моделей можно найти на 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

Параметры

  • text (str, list[str], list[dict]) — Текст, используемый для генерации. Если передан список строк, его длина должна совпадать с количеством изображений. Текст также может быть в формате чата: список словарей, где каждый словарь представляет сообщение в диалоге. Каждый словарь должен содержать два ключа: ‘role’ и ‘content’. Значение ‘role’ должно быть одним из ‘user’, ‘system’ или ‘assistant’. Значение ‘content’ должно быть списком словарей, содержащих текст сообщения и его тип.
  • images (str, list[str], ImageInput) — Пайплайн обрабатывает три типа изображений:
    • Строка, содержащая HTTP(S)-ссылку на изображение
    • Строка, содержащая локальный путь к изображению
    • Изображение, загруженное непосредственно в PIL

    Пайплайн принимает как одно изображение, так и пакет изображений. Кроме того, этот пайплайн поддерживает чат-формат (см. text), содержащий изображения и текст в этом аргументе.

  • videos (str, list[str], VideoInput) — Пайплайн обрабатывает три типа видео:
    • Строка, содержащая HTTP(S)-ссылку на видео
    • Строка, содержащая локальный путь к видео
    • Видео, загруженное и декодированное в формат массива

    Пайплайн принимает как одно видео, так и пакет видео. Кроме того, этот пайплайн поддерживает чат-формат (см. text), содержащий видео и текст в этом аргументе.

  • audio (str, list[str], AudioInput) — Пайплайн обрабатывает три типа аудио:
    • Строка, содержащая HTTP(S)-ссылку на аудиофайл
    • Строка, содержащая локальный путь к аудио
    • Аудио, загруженное непосредственно в PIL

    Пайплайн принимает как один объект audios, так и батч объектов audios. Кроме того, этот пайплайн поддерживает формат чата (см. text), содержащий в этом аргументе аудио и текст.

  • return_tensors (bool, необязательный, по умолчанию False) — Возвращает тензоры предсказаний (в виде индексов токенов) в результатах. Если установлено в True, декодированный текст не возвращается.
  • return_text (bool, необязательный) — Возвращает декодированные тексты в результатах.
  • return_full_text (bool, необязательный, по умолчанию True) — Если установлено в False, возвращается только добавленный текст, в противном случае — полный текст. Не может быть указан одновременно с return_text.
  • clean_up_tokenization_spaces (bool, необязательный) — Удалять ли возможные лишние пробелы в текстовом выводе. По умолчанию используется значение параметра clean_up_tokenization_spaces токенизатора.
  • continue_final_message( bool, optional) — Этот параметр указывает, что вы хотите, чтобы модель продолжила последнее сообщение во входном чате, а не начала новое, что позволяет «предзаполнить» её ответ. По умолчанию он равен True, если роль последнего сообщения во входном чате — assistant, и False в противном случае, но вы можете вручную изменить это поведение, установив соответствующий флаг.

Возвращает

Список или список списков dict

Каждый результат возвращается в виде словаря со следующим ключом (нельзя вернуть комбинацию generated_text и generated_token_ids):

  • generated_text (str, присутствует, если return_text=True и generation_mode="text") — Сгенерированный текст.
  • generated_audio (np.ndarray, присутствует при generation_mode="audio") — сгенерированный аудиосигнал.
  • generated_image (PIL.Image.Image, присутствует, если generation_mode="image") — Сгенерированное изображение.
  • generated_token_ids (torch.Tensor, присутствует, если return_tensors=True и generation_mode="text") — идентификаторы токенов сгенерированного текста.
  • input_text (str) — Входной текст.

Сгенерировать текст на основе переданного текста и, при необходимости, мультимодальных данных, переданных в качестве входных.

MaskGenerationPipeline

класс transformers.MaskGenerationPipeline

< >

( **kwargs )

Параметры

  • model (PreTrainedModel) — Модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от PreTrainedModel.
  • image_processor (BaseImageProcessor) — Обработчик изображений, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от BaseImageProcessor.
  • task (str, по умолчанию "") — Идентификатор задачи для конвейера.
  • num_workers (int, необязательный, по умолчанию 8) — количество рабочих процессов, используемых, когда конвейер применяет DataLoader (при передаче набора данных, на GPU для модели PyTorch).
  • batch_size (int, необязательный, по умолчанию 1) — Когда конвейер использует DataLoader (при передаче набора данных, на GPU для модели PyTorch), размер батча, который будет использоваться. Для вывода это не всегда полезно, см. Обработка батчами в конвейерах .
  • args_parser (ArgumentHandler, необязательный) — Ссылка на объект, отвечающий за разбор переданных параметров конвейера.
  • device (int или str или torch.device, необязательный) — Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (CUDA, MPS, XPU, …), а на CPU переключается только в том случае, если ускорители отсутствуют; модель перемещается туда автоматически. Передайте device="cpu" (или -1), чтобы принудительно использовать CPU, положительный порядковый номер или "cuda:1", чтобы выбрать конкретный ускоритель, либо нативный torch.device/str. Этот аргумент нельзя использовать вместе с моделью, уже загруженной через accelerate (то есть с hf_device_map).
  • dtype (str или torch.dtype, необязательный, по умолчанию "auto") — Точность, в которой загружается модель, передаётся в from_pretrained. По умолчанию "auto", что загружает модель в той точности, в которой она была сохранена (читается из config.dtype контрольной точки, иначе выводится из весов). Передайте явное значение torch.float16, torch.bfloat16, torch.float32, … для переопределения.
  • binary_output (bool, необязательный, по умолчанию False) — Флаг, указывающий, должен ли вывод конвейера быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст.
  • points_per_batch (необязательный, int, по умолчанию 64) — Задаёт количество точек, которые модель обрабатывает одновременно. Большие значения могут ускорить работу, но потребуют больше памяти GPU.
  • output_bboxes_mask (bool, необязательный, по умолчанию False) — Включает ли вывод предсказаний ограничивающих прямоугольников.
  • output_rle_masks (bool, необязательный, по умолчанию False) — Включает ли вывод масок в формате RLE

Автоматическая генерация масок для изображений с помощью SamForMaskGeneration. Этот конвейер предсказывает бинарные маски для изображения, получая на вход изображение. Он является ChunkPipeline, поскольку точки можно разделять на мини-батчи, чтобы избежать проблем с переполнением памяти (OOM). Используйте аргумент points_per_batch, чтобы контролировать количество точек, обрабатываемых одновременно. По умолчанию установлено значение 64.

Пайплайн работает в 3 шага:

  1. preprocess: генерируется сетка из 1024 равномерно расположенных точек, а также ограничивающие прямоугольники и метки точек. Подробнее о том, как создаются точки и ограничивающие прямоугольники, см. в функции _generate_crop_boxes. Изображение также предварительно обрабатывается с помощью image_processor. Эта функция yields мини-пакет из points_per_batch.

  2. forward: передаёт на вход модели результаты preprocess. Встраивание изображения вычисляется только один раз. Вызывает self.model.get_image_embeddings и обеспечивает, чтобы градиенты не вычислялись, а тензоры и модели находились на одном устройстве.

  3. postprocess: здесь происходит самая важная часть автоматической генерации масок. Выполняются три шага:

    • image_processor.postprocess_masks (выполняется на каждой итерации цикла по мини-батчам): принимает исходные маски, изменяет их размер в соответствии с размером изображения и преобразует в бинарные маски.
    • image_processor.filter_masks (в каждом цикле по мини-батчам): использует как pred_iou_thresh, так и stability_scores. Также применяет ряд фильтров на основе подавления не-максимумов для удаления некачественных масок.
    • image_processor.postprocess_masks_for_amg применяет NSM к маске, чтобы оставить только релевантные.

Пример:

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

Подробнее о базовых принципах использования пайплайна читайте в руководстве по пайплайнам

Этот конвейер сегментации в настоящее время можно загрузить из pipeline(), используя следующий идентификатор задачи: "mask-generation".

Список доступных моделей можно найти на huggingface.co/models.

__call__

< >

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

Параметры

  • image (str, List[str], PIL.Image or List[PIL.Image]) — Изображение или список изображений.
  • mask_threshold (float, необязательный, по умолчанию 0.0) — Порог, используемый при преобразовании предсказанных масок в бинарные значения.
  • pred_iou_thresh (float, необязательный, по умолчанию 0.88) — Порог фильтрации в диапазоне [0,1], применяемый к качеству маски, предсказанной моделью.
  • stability_score_thresh (float, необязательный, по умолчанию 0.95) — Порог фильтрации в диапазоне [0,1], основанный на стабильности маски при изменении порога, используемого для бинаризации предсказаний модели.
  • stability_score_offset (int, необязательный, по умолчанию 1) — Величина сдвига порога при вычислении оценки стабильности.
  • crops_nms_thresh (float, необязательный, по умолчанию 0.7) — Порог IoU для ящиков, используемый алгоритмом подавления не-максимумов (non-maximal suppression) для отфильтровывания дублирующихся масок.
  • crops_n_layers (int, необязательный, по умолчанию 0) — Если crops_n_layers>0, предсказание маски будет выполнено повторно на фрагментах изображения. Устанавливает количество слоёв для выполнения, где каждый слой содержит 2**i_layer фрагментов изображения.
  • crop_overlap_ratio (float, необязательный, по умолчанию 512 / 1500) — Определяет степень перекрытия кропов. На первом уровне кропов перекрытие составляет указанную долю от длины изображения. На последующих уровнях с большим количеством кропов это перекрытие уменьшается.
  • crop_n_points_downscale_factor (int, необязательный, по умолчанию 1) — Количество точек на сторону, отбираемых в слое n, уменьшается в crop_n_points_downscale_factor**n раз.
  • timeout (float, необязательный, по умолчанию None) — Максимальное время ожидания в секундах при получении изображений из сети. Если значение равно None, таймаут не устанавливается, и вызов может блокироваться бесконечно.

Возвращает

Dict

Словарь со следующими ключами:

  • mask (PIL.Image) — бинарная маска обнаруженного объекта в виде изображения PIL с размерами (width, height) исходного изображения. Если объект не обнаружен, возвращается маска, заполненная нулями.
  • score (необязательный float) — Необязательно, если модель способна оценивать уверенность в «объекте», описанном меткой и маской.

Генерирует бинарные маски сегментации

Родительский класс: Pipeline

класс 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 )

Параметры

  • model (PreTrainedModel) — Модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от PreTrainedModel.
  • tokenizer (PreTrainedTokenizer) — Токенизатор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от PreTrainedTokenizer.
  • feature_extractor (SequenceFeatureExtractor) — объект feature extractor, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от SequenceFeatureExtractor.
  • image_processor (BaseImageProcessor) — Обработчик изображений, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от BaseImageProcessor.
  • processor (ProcessorMixin) — обработчик, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от ProcessorMixin. Processor — это составной объект, который может содержать tokenizer, feature_extractor и image_processor.
  • task (str, по умолчанию "") — Идентификатор задачи для конвейера.
  • num_workers (int, необязательный, по умолчанию 8) — количество рабочих процессов, используемых, когда конвейер применяет DataLoader (при передаче набора данных, на GPU для модели PyTorch).
  • batch_size (int, необязательный, по умолчанию 1) — Когда конвейер использует DataLoader (при передаче набора данных, на GPU для модели PyTorch), размер батча, который будет использоваться. Для вывода это не всегда полезно, см. Обработка батчами в конвейерах .
  • args_parser (ArgumentHandler, необязательный) — Ссылка на объект, отвечающий за разбор переданных параметров конвейера.
  • device (int или str или torch.device, необязательный) — Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (CUDA, MPS, XPU, …), а на CPU переключается только в том случае, если ускорители отсутствуют; модель перемещается туда автоматически. Передайте device="cpu" (или -1), чтобы принудительно использовать CPU, положительный порядковый номер или "cuda:1", чтобы выбрать конкретный ускоритель, либо нативный torch.device/str. Этот аргумент нельзя использовать вместе с моделью, уже загруженной через accelerate (то есть с hf_device_map).
  • dtype (str или torch.dtype, необязательный, по умолчанию "auto") — Точность, в которой загружается модель, передаётся в from_pretrained. По умолчанию "auto", что загружает модель в той точности, в которой она была сохранена (читается из config.dtype контрольной точки, иначе выводится из весов). Передайте явное значение torch.float16, torch.bfloat16, torch.float32, … для переопределения.
  • binary_output (bool, необязательный, по умолчанию False) — Флаг, указывающий, должен ли вывод конвейера быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст.

Класс Pipeline является базовым классом, от которого наследуются все конвейеры. Обращайтесь к этому классу, чтобы ознакомиться с методами, общими для различных конвейеров.

Базовый класс, реализующий конвейерные операции. Рабочий процесс конвейера определяется как последовательность следующих

Вход -> Токенизация -> Инференс модели -> Постобработка (зависит от задачи) -> Выход

Pipeline поддерживает запуск на CPU или GPU с помощью аргумента device (см. ниже).

Некоторые конвейеры, например FeatureExtractionPipeline ('feature-extraction'), возвращают большие тензорные объекты в виде вложенных списков. Чтобы избежать сохранения таких крупных структур в текстовом виде, мы предоставляем аргумент конструктора binary_output. Если установить его значение в True, результат будет сохранён в формате pickle.

check_model_type

< >

( supported_models: list[str] | dict )

Параметры

  • supported_models (list[str] или dict) — Список моделей, поддерживаемых конвейером, или словарь со значениями классов моделей.

Проверьте, поддерживается ли класс модели в конвейере.

device_placement

< >

( )

Контекстный менеджер, позволяющий выделять тензоры на устройстве, указанном пользователем.

Примеры:

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

Параметры

  • inputs (именованные аргументы, которые должны быть torch.Tensor, остальные игнорируются) — Тензоры, которые нужно разместить на self.device.
  • Recursive для списков только. —

Возвращает

dict[str, torch.Tensor]

То же самое, что и inputs, но на соответствующем устройстве.

Убедитесь, что тензоры PyTorch находятся на указанном устройстве.

postprocess

< >

( model_outputs: ModelOutput**postprocess_parameters: dict )

Метод Postprocess получает необработанные выходные данные метода _forward, как правило, тензоры, и преобразует их в более удобный формат. Обычно он возвращает список или словарь результатов (содержащий только строки и числа).

predict

< >

( X )

Интерфейс Scikit / Keras для конвейеров transformers. Этот метод будет передавать вызов в call().

preprocess

< >

( input_: Any**preprocess_parameters: dict )

Метод Preprocess принимает input_ конкретного конвейера и возвращает словарь со всем необходимым для корректной работы _forward. Он должен содержать как минимум один тензор, но может включать и другие произвольные элементы.

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 )

Параметры

  • repo_id (str) — Имя репозитория, в который вы хотите загрузить свой pipe. При загрузке в конкретную организацию это имя должно содержать название вашей организации.
  • commit_message (str, необязательный) — Сообщение для коммита при отправке. По умолчанию — "Upload pipe".
  • commit_description (str, необязательный) — Описание коммита, который будет создан
  • private (bool, optional) — Определяет, следует ли сделать репозиторий приватным. Если None (по умолчанию), репозиторий будет публичным, если только по умолчанию для организации не задан приватный режим. Это значение игнорируется, если репозиторий уже существует.
  • token (bool или str, необязательный) — Токен, используемый в качестве HTTP bearer-авторизации для удалённых файлов. Если True (по умолчанию), будет использован токен, сгенерированный при выполнении hf auth login (хранится в ~/.huggingface).
  • revision (str, необязательный) — Ветка, в которую будут загружены файлы.
  • create_pr (bool, необязательный, по умолчанию False) — Создавать ли PR с загруженными файлами или коммитить изменения напрямую.
  • max_shard_size (int или str, необязательный, по умолчанию "50GB") — Применимо только к моделям. Максимальный размер контрольной точки перед её разбиением на части. Каждая из частей будет иметь размер, меньший этого значения. Если значение указано в виде строки, оно должно состоять из цифр, за которыми следует единица измерения (например, "5MB").
  • tags (list[str], необязательный) — Список тегов для загрузки на Hub.

Загрузите файл конвейера в 🤗 Model Hub.

Примеры:

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 )

Параметры

  • save_directory (str или os.PathLike) — Путь к каталогу, в котором будут сохранены данные. Если каталог не существует, он будет создан.
  • kwargs (dict[str, Any], необязательный) — Дополнительные именованные аргументы, передаваемые в метод push_to_hub().

Сохраните модель и токенизатор конвейера.

transform

< >

( X )

Интерфейс Scikit / Keras для конвейеров transformers. Этот метод будет передавать вызов в call().

Update on GitHub

←PEFT Процессоры→