# Пайплайны Пайплайны — это удобный и простой способ использовать модели для инференса. Эти пайплайны представляют собой объекты, которые абстрагируют большую часть сложного кода из библиотеки, предлагая простой API, предназначенный для выполнения ряда задач, включая Named Entity Recognition, Masked Language Modeling, Sentiment Analysis, Feature Extraction и Question Answering. Примеры использования приведены в [списке задач](https://huggingface.co/tasks). Существуют две категории абстракций пайплайнов, о которых следует знать: - [pipeline()](/docs/transformers/main/ru/main_classes/pipelines#transformers.pipeline) — самый мощный объект, инкапсулирующий все остальные пайплайны. - Специализированные конвейеры доступны для задач [аудио](#audio), [компьютерного зрения](#computer-vision), [обработки естественного языка](#natural-language-processing) и [мультимодальных](#multimodal) задач. ## Абстракция конвейера[[transformers.pipeline]] Абстракция *pipeline* представляет собой обёртку над всеми остальными доступными конвейерами. Она инициализируется так же, как и любой другой конвейер, но может обеспечивать дополнительные удобства. Простой вызов для одного элемента: ```python >>> pipe = pipeline("text-classification") >>> pipe("This restaurant is awesome") [{'label': 'POSITIVE', 'score': 0.9998743534088135}] ``` Если вы хотите использовать конкретную модель из [hub](https://huggingface.co), вы можете пропустить задание задачи, если модель на hub уже определяет её: ```python >>> pipe = pipeline(model="FacebookAI/roberta-large-mnli") >>> pipe("This restaurant is awesome") [{'label': 'NEUTRAL', 'score': 0.7313136458396912}] ``` Чтобы вызвать конвейер для множества элементов, передайте ему *list*. ```python >>> 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. ```python 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": ....} # .... ``` Для удобства использования также можно использовать генератор: ```python 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[[transformers.pipeline]] ```python transformers.pipeline(task: str | None = None, model: str | PreTrainedModel | None = None, config: str | PreTrainedConfig | None = None, tokenizer: str | PreTrainedTokenizer | PreTrainedTokenizerFast | None = None, feature_extractor: str | FeatureExtractionMixin | None = None, image_processor: str | BaseImageProcessor | None = None, video_processor: str | BaseVideoProcessor | None = None, processor: str | ProcessorMixin | None = None, revision: str | None = None, use_fast: bool = True, token: str | bool | None = None, device: int | str | torch.device | None = None, device_map: str | dict[str, int | str] | None = None, dtype: str | torch.dtype | None = 'auto', trust_remote_code: bool | None = None, model_kwargs: dict[str, Any] | None = None, pipeline_class: Any | None = None, **kwargs: Any) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/__init__.py#L745) **Параметры:** task (`str`) : Задача, определяющая, какой конвейер будет возвращён. В настоящее время поддерживаются следующие задачи: - `"audio-classification"`: будет возвращён [AudioClassificationPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.AudioClassificationPipeline). - `"automatic-speech-recognition"`: будет возвращён [AutomaticSpeechRecognitionPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.AutomaticSpeechRecognitionPipeline). - `"depth-estimation"`: будет возвращён [DepthEstimationPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.DepthEstimationPipeline). - `"document-question-answering"`: будет возвращён [DocumentQuestionAnsweringPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.DocumentQuestionAnsweringPipeline). - `"feature-extraction"`: будет возвращён [FeatureExtractionPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.FeatureExtractionPipeline). - `"fill-mask"`: будет возвращён [FillMaskPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.FillMaskPipeline):. - `"image-classification"`: будет возвращён [ImageClassificationPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.ImageClassificationPipeline). - `"image-feature-extraction"`: будет возвращён [ImageFeatureExtractionPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.ImageFeatureExtractionPipeline). - `"image-segmentation"`: будет возвращён [ImageSegmentationPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.ImageSegmentationPipeline). - `"image-text-to-text"`: будет возвращён [ImageTextToTextPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.ImageTextToTextPipeline). - `"keypoint-matching"`: будет возвращён [KeypointMatchingPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.KeypointMatchingPipeline). - `"mask-generation"`: будет возвращён [MaskGenerationPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.MaskGenerationPipeline). - `"object-detection"`: будет возвращён [ObjectDetectionPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.ObjectDetectionPipeline). - `"table-question-answering"`: будет возвращён [TableQuestionAnsweringPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.TableQuestionAnsweringPipeline). - `"text-classification"` (доступен псевдоним `"sentiment-analysis"`): будет возвращён [TextClassificationPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.TextClassificationPipeline). - `"text-generation"`: будет возвращён [TextGenerationPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.TextGenerationPipeline):. - `"text-to-audio"` (доступен псевдоним `"text-to-speech"`): будет возвращён [TextToAudioPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.TextToAudioPipeline):. - `"token-classification"` (доступен псевдоним `"ner"`): будет возвращён [TokenClassificationPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.TokenClassificationPipeline). - `"video-classification"`: будет возвращён [VideoClassificationPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.VideoClassificationPipeline). - `"zero-shot-classification"`: будет возвращён [ZeroShotClassificationPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.ZeroShotClassificationPipeline). - `"zero-shot-image-classification"`: будет возвращён [ZeroShotImageClassificationPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.ZeroShotImageClassificationPipeline). - `"zero-shot-audio-classification"`: будет возвращён [ZeroShotAudioClassificationPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.ZeroShotAudioClassificationPipeline). - `"zero-shot-object-detection"`: будет возвращён [ZeroShotObjectDetectionPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.ZeroShotObjectDetectionPipeline). model (`str` или [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel), *optional*) : Модель, которая будет использоваться конвейером для выполнения предсказаний. Это может быть идентификатор модели или фактический экземпляр предобученной модели, наследующейся от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). Если не указано, будет загружена модель по умолчанию для `task`. config (`str` или [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig), *optional*) : Конфигурация, которая будет использована конвейером для создания модели. Это может быть идентификатор модели или фактическая конфигурация предобученной модели, наследующаяся от [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig). Если не указано, будет использован файл конфигурации по умолчанию для запрошенной модели. Это означает, что если `model` задан, будет использована его конфигурация по умолчанию. Однако, если `model` не указан, вместо этого будет использована конфигурация модели по умолчанию для этой `task`. tokenizer (`str` или [PreTrainedTokenizer](/docs/transformers/main/ru/main_classes/tokenizer#transformers.PythonBackend), *optional*) : Токенизатор, который будет использоваться конвейером для кодирования данных для модели. Это может быть идентификатор модели или фактический предобученный токенизатор, наследующийся от [PreTrainedTokenizer](/docs/transformers/main/ru/main_classes/tokenizer#transformers.PythonBackend). Если не указан, будет загружен токенизатор по умолчанию для данного `model` (если это строка). Если `model` не указан или не является строкой, будет загружен токенизатор по умолчанию для `config` (если это строка). Однако, если `config` также не указан или не является строкой, будет загружен токенизатор по умолчанию для данного `task`. feature_extractor (`str` или [FeatureExtractionMixin](/docs/transformers/main/ru/main_classes/feature_extractor#transformers.FeatureExtractionMixin), *необязательный*) : Извлекатель признаков, который будет использоваться конвейером для кодирования данных для модели. Это может быть идентификатор модели или фактический предобученный извлекатель признаков, наследующий от [FeatureExtractionMixin](/docs/transformers/main/ru/main_classes/feature_extractor#transformers.FeatureExtractionMixin). Извлекатели признаков используются для моделей, не относящихся к NLP, таких как модели обработки речи или зрения, а также для мультимодальных моделей. Для мультимодальных моделей также необходимо передать токенизатор. Если значение не указано, будет загружен извлекатель признаков по умолчанию для заданного `model` (если это строка). Если `model` не указан или не является строкой, будет загружен извлекатель признаков по умолчанию для `config` (если это строка). Однако, если `config` также не задан или не является строкой, будет загружен извлекатель признаков по умолчанию для заданной `task`. image_processor (`str` или [BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor), *необязательный*) : Обработчик изображений, который будет использоваться конвейером для предварительной обработки изображений для модели. Это может быть идентификатор модели или фактический обработчик изображений, наследующийся от [BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor). Обработчики изображений используются для моделей зрения и мультимодальных моделей, требующих входных данных в виде изображений. Для мультимодальных моделей также необходимо передать токенизатор. Если значение не указано, будет загружен обработчик изображений по умолчанию для заданного `model` (если это строка). Если `model` не указан или не является строкой, будет загружен обработчик изображений по умолчанию для `config` (если это строка). processor (`str` или [ProcessorMixin](/docs/transformers/main/ru/main_classes/processors#transformers.ProcessorMixin), *необязательный*) : Процессор, который будет использоваться конвейером для предварительной обработки данных для модели. Это может быть идентификатор модели или фактический процессор, наследующийся от [ProcessorMixin](/docs/transformers/main/ru/main_classes/processors#transformers.ProcessorMixin). Процессоры используются для мультимодальных моделей, требующих мультимодальные входные данные, например, модели, которым нужны как текстовые, так и графические входные данные. Если не указан, будет загружен процессор по умолчанию для заданного `model` (если это строка). Если `model` не указан или не является строкой, будет загружен процессор по умолчанию для `config` (если это строка). revision (`str`, *необязательный*, по умолчанию `"main"`) : При передаче имени задачи или строкового идентификатора модели: конкретная версия модели, которую следует использовать. Это может быть имя ветки, имя тега или идентификатор коммита, поскольку для хранения моделей и других артефактов на huggingface.co используется система на базе git, поэтому `revision` может быть любым идентификатором, разрешённым git. use_fast (`bool`, *необязательный*, по умолчанию `True`) : Использовать ли быстрый токенизатор, если это возможно ([PreTrainedTokenizerFast](/docs/transformers/main/ru/main_classes/tokenizer#transformers.TokenizersBackend)). token (`str` или *bool*, *необязательный*) : Токен, используемый в качестве HTTP bearer-авторизации для удалённых файлов. Если `True`, будет использован токен, сгенерированный при выполнении `hf auth login`. device (`int` или `str` или `torch.device`, *optional*) : Определяет устройство (*напр.*, `"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` (см. [здесь](https://huggingface.co/docs/accelerate/main/en/package_reference/big_modeling#accelerate.cpu_offload) для получения дополнительной информации). Не используйте `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](/docs/transformers/main/ru/main_classes/pipelines#transformers.Pipeline) Подходящий конвейер для задачи. Вспомогательный фабричный метод для создания [Pipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.Pipeline). Пайплайн состоит из: - Один или несколько компонентов для предобработки входных данных модели, например [токенизатор](tokenizer), [image_processor](image_processor), [feature_extractor](feature_extractor) или [processor](processors). - [Модель](model), которая генерирует предсказания на основе входных данных. - Необязательные этапы постобработки для уточнения вывода модели, которые также могут выполняться процессорами. Хотя существуют такие необязательные аргументы, как `tokenizer`, `feature_extractor`, `image_processor` и `processor`, их не следует указывать все сразу. Если эти компоненты не предоставлены, `pipeline` попытается загрузить необходимые автоматически. Если вы хотите указать эти компоненты явно, обратитесь к документации конкретного пайплайна, чтобы узнать, какие компоненты требуются. Примеры: ```python >>> 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`). ```python 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 раз. Пример, где в основном наблюдается ускорение: ```python 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 ``` ```text # 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) ``` Пример, где в основном наблюдается замедление: ```python 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], что приводит к значительному замедлению. Ещё хуже, на более крупных батчах программа просто падает. ```text ------------------------------ 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 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`. Кратко: ```python preprocessed = pipe.preprocess(inputs) model_outputs = pipe.forward(preprocessed) outputs = pipe.postprocess(model_outputs) ``` Теперь становится: ```python 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`, возможно, сможет поддержать ваш сценарий использования. Если вы хотите просто попробовать, вы можете: - Создайте подкласс нужного вам конвейера ```python 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) ``` Это позволит вам писать любой необходимый вам собственный код. ## Реализация конвейера [Реализация нового конвейера](../add_new_pipeline) ## Аудио Среди доступных конвейеров для задач обработки аудио есть следующие. ### AudioClassificationPipeline[[transformers.AudioClassificationPipeline]] #### transformers.AudioClassificationPipeline[[transformers.AudioClassificationPipeline]] ```python transformers.AudioClassificationPipeline(*args, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/audio_classification.py#L67) **Параметры:** model ([PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel)): модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). feature_extractor ([SequenceFeatureExtractor](/docs/transformers/main/ru/main_classes/feature_extractor#transformers.SequenceFeatureExtractor)) : экстрактор признаков, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [SequenceFeatureExtractor](/docs/transformers/main/ru/main_classes/feature_extractor#transformers.SequenceFeatureExtractor). task (`str`, по умолчанию `""`) : Идентификатор задачи для конвейера. num_workers (`int`, *необязательный*, по умолчанию 8) : Количество рабочих процессов, используемых, когда конвейер применяет *DataLoader* (при передаче набора данных, на GPU для модели PyTorch). batch_size (`int`, *optional*, defaults to 1) : When the pipeline will use *DataLoader* (when passing a dataset, on GPU for a Pytorch model), the size of the batch to use, for inference this is not always beneficial, please read [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/ru/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *optional*) : Ссылка на объект, отвечающий за разбор переданных параметров конвейера. device (`int` или `str` или `torch.device`, *optional*) : Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (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"`, что загружает модель в том типе данных (dtype), в котором она была сохранена (читается из `config.dtype` контрольной точки, иначе выводится из весов). Передайте явное значение `torch.float16`, `torch.bfloat16`, `torch.float32`, ... для переопределения. binary_output (`bool`, *необязательный*, по умолчанию `False`) : Флаг, указывающий, должен ли вывод пайплайна быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст. Конвейер классификации аудио с использованием любой модели `AutoModelForAudioClassification`. Этот конвейер предсказывает класс для сырой звуковой волны или аудиофайла. В случае с аудиофайлом для поддержки различных форматов аудио необходимо установить ffmpeg. Пример: ```python >>> 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_tutorial) Сейчас этот конвейер можно загрузить из [pipeline()](/docs/transformers/main/ru/main_classes/pipelines#transformers.pipeline), используя следующий идентификатор задачи: `"audio-classification"`. Список доступных моделей можно найти на [huggingface.co/models](https://huggingface.co/models?filter=audio-classification). #### __call__[[transformers.AudioClassificationPipeline.__call__]] ```python __call__(inputs: numpy.ndarray | bytes | str | dict, **kwargs: Any) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/audio_classification.py#L109) **Параметры:** inputs (`np.ndarray` или `bytes` или `str` или `dict`) : Входные данные могут быть: - `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`, *optional*, по умолчанию None) : Количество верхних меток, которые вернёт конвейер. Если указанное значение равно `None` или превышает количество меток, доступных в конфигурации модели, будет использовано количество меток по умолчанию. function_to_apply (`str`, *optional*, по умолчанию "softmax") : функция, применяемая к выходу модели. По умолчанию конвейер применяет функцию softmax к выходу модели. Допустимые значения: ["softmax", "sigmoid", "none"]. Обратите внимание, что передача встроенного значения `None` в Python приведёт к использованию "softmax" по умолчанию, поэтому для отключения любой постобработки необходимо передать строку "none". **Возвращает:** список `dict` со следующими ключами - **label** (`str`) -- Предсказанная метка. - **score** (`float`) — соответствующая вероятность. Классифицирует последовательность(и), переданные в качестве входных данных. Подробнее см. в документации [AutomaticSpeechRecognitionPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.AutomaticSpeechRecognitionPipeline). ### AutomaticSpeechRecognitionPipeline[[transformers.AutomaticSpeechRecognitionPipeline]] #### transformers.AutomaticSpeechRecognitionPipeline[[transformers.AutomaticSpeechRecognitionPipeline]] ```python transformers.AutomaticSpeechRecognitionPipeline(model: PreTrainedModel, feature_extractor: typing.Union[ForwardRef('SequenceFeatureExtractor'), str, NoneType] = None, tokenizer: transformers.tokenization_python.PythonBackend | None = None, decoder: typing.Union[ForwardRef('BeamSearchDecoderCTC'), str, NoneType] = None, device: typing.Union[int, ForwardRef('torch.device'), NoneType] = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/automatic_speech_recognition.py#L146) **Параметры:** model ([PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel)): модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). feature_extractor ([SequenceFeatureExtractor](/docs/transformers/main/ru/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), *optional*) : Извлекатель признаков, который будет использоваться конвейером для кодирования формы волны для модели. tokenizer ([PreTrainedTokenizer](/docs/transformers/main/ru/main_classes/tokenizer#transformers.PythonBackend), *optional*) : Токенизатор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [PreTrainedTokenizer](/docs/transformers/main/ru/main_classes/tokenizer#transformers.PythonBackend). decoder (`pyctcdecode.BeamSearchDecoderCTC`, *необязательный*) : [BeamSearchDecoderCTC из PyCTCDecode](https://github.com/kensho-technologies/pyctcdecode/blob/2fd33dc37c4111417e08d89ccd23d28e9b308d19/pyctcdecode/decoder.py#L180) можно передать для декодирования с использованием языковой модели. Подробнее см. в [Wav2Vec2ProcessorWithLM](/docs/transformers/main/ru/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM). device (Union[`int`, `torch.device`], *optional*) : Порядковый номер устройства для поддержки CPU/GPU. Установка значения `None` приведет к использованию CPU, а положительное число запустит модель на соответствующем устройстве CUDA. Пайплайн, предназначенный для извлечения устной речи, содержащейся в аудиофайле. Входные данные могут представлять собой как необработанную звуковую волну, так и аудиофайл. В случае с аудиофайлом для поддержки различных форматов аудио необходимо установить ffmpeg Если модель, которую вы используете, явно не задаёт эти параметры генерации в своих файлах конфигурации (`generation_config.json`), будут использованы следующие значения по умолчанию: - max_new_tokens: 256 - num_beams: 5 Пример: ```python >>> 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.'} ``` Подробнее о базовых принципах использования пайплайна читайте в [руководстве по пайплайнам](../pipeline_tutorial) #### __call__[[transformers.AutomaticSpeechRecognitionPipeline.__call__]] ```python __call__(inputs: numpy.ndarray | bytes | str | dict, **kwargs: Any) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/automatic_speech_recognition.py#L231) **Параметры:** inputs (`np.ndarray` или `bytes` или `str` или `dict`) : Входные данные могут быть одним из следующих: - `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 см. [следующее руководство](https://huggingface.co/docs/transformers/en/main_classes/text_generation). **Возвращает:** `Dict` Словарь со следующими ключами: - **text** (`str`): распознанный текст. - **chunks** (*optional(, `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](/docs/transformers/main/ru/main_classes/pipelines#transformers.AutomaticSpeechRecognitionPipeline). ### TextToAudioPipeline[[transformers.TextToAudioPipeline]] #### transformers.TextToAudioPipeline[[transformers.TextToAudioPipeline]] ```python transformers.TextToAudioPipeline(*args, vocoder = None, sampling_rate = None, noise_scheduler = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/text_to_audio.py#L46) Конвейер генерации аудио из текста с использованием любой модели `AutoModelForTextToWaveform` или `AutoModelForTextToSpectrogram`. Этот конвейер генерирует аудиофайл на основе входного текста и дополнительных условных входных данных (при наличии). Если используемая вами модель явно не задаёт параметры генерации в `generation_config.json`, будут применены значения по умолчанию из `generation.configuration_utils.py._get_default_generation_params()`. - max_new_tokens: 256 Пример: ```python >>> 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"] ``` Подробнее о базовых принципах использования пайплайна читайте в [руководстве по пайплайнам](../pipeline_tutorial) Вы можете указать параметры, передаваемые в модель, с помощью `TextToAudioPipeline.__call__.forward_params` или `TextToAudioPipeline.__call__.generate_kwargs`. Пример: ```python >>> 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()](/docs/transformers/main/ru/main_classes/pipelines#transformers.pipeline), используя следующие идентификаторы задач: `"text-to-speech"` или `"text-to-audio"`. Список доступных моделей можно найти на [huggingface.co/models](https://huggingface.co/models?filter=text-to-speech). #### __call__[[transformers.TextToAudioPipeline.__call__]] ```python __call__(text_inputs, **forward_params) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/text_to_audio.py#L260) **Параметры:** text_inputs (`str`, `list[str]`, `ChatType` или `list[ChatType]`) : Один или несколько текстов для генерации. Если переданы строки или список строк, этот конвейер сгенерирует соответствующий текст. Альтернативно, можно передать «чат» в виде списка словарей с ключами "role" и "content", либо список таких чатов. Если переданы чаты, шаблон чата модели будет использован для их форматирования перед передачей в модель. forward_params (`dict`, *необязательный*) : Параметры, передаваемые в метод генерации/forward модели. `forward_params` всегда передаются в базовую модель. generate_kwargs (`dict`, *необязательный*) : Словарь для произвольной параметризации `generate_config`, используемой в вызове генерации. Полное описание generate см. в [этом руководстве](https://huggingface.co/docs/transformers/en/main_classes/text_generation). `generate_kwargs` передаются базовой модели только в том случае, если она является генеративной, и имеют приоритет над `forward_params`. **Возвращает:** `AudioOutput` или список `AudioOutput`, представляющий собой `TypedDict` с двумя ключами - **audio** (`np.ndarray` формы `(nb_channels, audio_length)`) -- Сгенерированная звуковая волна. - **sampling_rate** (`int`) -- Частота дискретизации сгенерированной аудиоволны. Генерирует речь/аудио на основе входных данных. Подробнее см. в документации [TextToAudioPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.TextToAudioPipeline). ### ZeroShotAudioClassificationPipeline[[transformers.ZeroShotAudioClassificationPipeline]] #### transformers.ZeroShotAudioClassificationPipeline[[transformers.ZeroShotAudioClassificationPipeline]] ```python transformers.ZeroShotAudioClassificationPipeline(**kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/zero_shot_audio_classification.py#L32) **Параметры:** model ([PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel)): модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/ru/main_classes/tokenizer#transformers.PythonBackend)) : токенизатор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [PreTrainedTokenizer](/docs/transformers/main/ru/main_classes/tokenizer#transformers.PythonBackend). feature_extractor ([SequenceFeatureExtractor](/docs/transformers/main/ru/main_classes/feature_extractor#transformers.SequenceFeatureExtractor)) : экстрактор признаков, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [SequenceFeatureExtractor](/docs/transformers/main/ru/main_classes/feature_extractor#transformers.SequenceFeatureExtractor). task (`str`, по умолчанию `""`) : Идентификатор задачи для конвейера. num_workers (`int`, *необязательный*, по умолчанию 8) : Количество рабочих процессов, используемых, когда конвейер применяет *DataLoader* (при передаче набора данных, на GPU для модели PyTorch). batch_size (`int`, *optional*, defaults to 1) : When the pipeline will use *DataLoader* (when passing a dataset, on GPU for a Pytorch model), the size of the batch to use, for inference this is not always beneficial, please read [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/ru/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *optional*) : Ссылка на объект, отвечающий за разбор переданных параметров конвейера. device (`int` или `str` или `torch.device`, *optional*) : Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (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"`, что загружает модель в том типе данных (dtype), в котором она была сохранена (читается из `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 {}."`. Убедитесь, что вы обновляете его в соответствии со своим использованием. Пример: ```python >>> 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_tutorial). Данный конвейер для классификации аудио на данный момент можно загрузить из [pipeline()](/docs/transformers/main/ru/main_classes/pipelines#transformers.pipeline), используя следующий идентификатор задачи: `"zero-shot-audio-classification"`. Список доступных моделей доступен на [huggingface.co/models](https://huggingface.co/models?filter=zero-shot-audio-classification). #### __call__[[transformers.ZeroShotAudioClassificationPipeline.__call__]] ```python __call__(audios: numpy.ndarray | bytes | str | dict, **kwargs: Any) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/zero_shot_audio_classification.py#L70) **Параметры:** 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* уже отформатированы. **Возвращаемое значение:** Список словарей, содержащих по одной записи на каждое предложенное метку. Каждый словарь содержит следующие ключи: - **label** (`str`) -- Одно из предложенных *candidate_labels*. - **score** (`float`) — Оценка, которую модель присваивает данной метке. Это значение от 0 до 1, вычисленное как `softmax` от `logits_per_audio`. Назначьте метки аудио, переданным в качестве входных данных. ## Компьютерное зрение Среди доступных конвейеров для задач компьютерного зрения есть следующие. ### DepthEstimationPipeline[[transformers.DepthEstimationPipeline]] #### transformers.DepthEstimationPipeline[[transformers.DepthEstimationPipeline]] ```python transformers.DepthEstimationPipeline(*args, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/depth_estimation.py#L25) **Параметры:** model ([PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel)): модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor)) : процессор изображений, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, по умолчанию `""`) : Идентификатор задачи для конвейера. num_workers (`int`, *необязательный*, по умолчанию 8) : Количество рабочих процессов, используемых, когда конвейер применяет *DataLoader* (при передаче набора данных, на GPU для модели PyTorch). batch_size (`int`, *optional*, defaults to 1) : When the pipeline will use *DataLoader* (when passing a dataset, on GPU for a Pytorch model), the size of the batch to use, for inference this is not always beneficial, please read [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/ru/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *optional*) : Ссылка на объект, отвечающий за разбор переданных параметров конвейера. device (`int` или `str` или `torch.device`, *optional*) : Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (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"`, что загружает модель в том типе данных (dtype), в котором она была сохранена (читается из `config.dtype` контрольной точки, иначе выводится из весов). Передайте явное значение `torch.float16`, `torch.bfloat16`, `torch.float32`, ... для переопределения. binary_output (`bool`, *необязательный*, по умолчанию `False`) : Флаг, указывающий, должен ли вывод пайплайна быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст. Конвейер оценки глубины с использованием любой модели `AutoModelForDepthEstimation`. Этот конвейер предсказывает глубину изображения. Пример: ```python >>> 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_tutorial) Этот конвейер оценки глубины в настоящее время можно загрузить из [pipeline()](/docs/transformers/main/ru/main_classes/pipelines#transformers.pipeline), используя следующий идентификатор задачи: `"depth-estimation"`. Список доступных моделей можно найти на [huggingface.co/models](https://huggingface.co/models?filter=depth-estimation). #### __call__[[transformers.DepthEstimationPipeline.__call__]] ```python __call__(inputs: typing.Union[str, list[str], ForwardRef('Image.Image'), list['Image.Image']], **kwargs: Any) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/depth_estimation.py#L66) **Параметры:** inputs (`str`, `list[str]`, `PIL.Image` or `list[PIL.Image]`) : Пайплайн обрабатывает три типа изображений: - строка, содержащая http-ссылку на изображение - строка, содержащая локальный путь к изображению - изображение, загруженное непосредственно в PIL Пайплайн принимает как одно изображение, так и пакет изображений, который в этом случае должен передаваться в виде строки. Все изображения в пакете должны быть в одном формате: либо все в виде http-ссылок, либо все в виде локальных путей, либо все в виде изображений PIL. parameters (`Dict`, *необязательный*) : Словарь, сопоставляющий имена аргументов со значениями параметров, для управления поведением конвейера. На данный момент доступен только параметр `timeout`, который определяет время ожидания в секундах, после которого конвейер прекращает попытки загрузки изображения. timeout (`float`, *optional*, по умолчанию None) : Максимальное время ожидания в секундах при загрузке изображений из сети. Если значение равно None, таймаут не устанавливается, и вызов может блокироваться бесконечно. **Возвращаемое значение:** Словарь или список словарей, содержащих результат. Если на вход подана одна картинка, возвращается словарь; если на вход подан список из нескольких картинок, возвращается список словарей, соответствующих этим картинкам. Словари содержат следующие ключи: - **predicted_depth** (`torch.Tensor`) -- Прогнозируемая моделью глубина в виде `torch.Tensor`. - **depth** (`PIL.Image`) — предсказанная моделью глубина в формате `PIL.Image`. Предсказать глубину переданных в качестве входных данных изображений. ### ImageClassificationPipeline[[transformers.ImageClassificationPipeline]] #### transformers.ImageClassificationPipeline[[transformers.ImageClassificationPipeline]] ```python transformers.ImageClassificationPipeline(*args, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/image_classification.py#L73) **Параметры:** model ([PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel)): модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor)) : процессор изображений, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, по умолчанию `""`) : Идентификатор задачи для конвейера. num_workers (`int`, *необязательный*, по умолчанию 8) : Количество рабочих процессов, используемых, когда конвейер применяет *DataLoader* (при передаче набора данных, на GPU для модели PyTorch). batch_size (`int`, *optional*, defaults to 1) : When the pipeline will use *DataLoader* (when passing a dataset, on GPU for a Pytorch model), the size of the batch to use, for inference this is not always beneficial, please read [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/ru/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *optional*) : Ссылка на объект, отвечающий за разбор переданных параметров конвейера. device (`int` или `str` или `torch.device`, *optional*) : Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (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"`, что загружает модель в том типе данных (dtype), в котором она была сохранена (читается из `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`. Этот конвейер предсказывает класс изображения. Пример: ```python >>> 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_tutorial) Этот конвейер классификации изображений в настоящее время можно загрузить из [pipeline()](/docs/transformers/main/ru/main_classes/pipelines#transformers.pipeline), используя следующий идентификатор задачи: `"image-classification"`. Список доступных моделей можно найти на [huggingface.co/models](https://huggingface.co/models?filter=image-classification). #### __call__[[transformers.ImageClassificationPipeline.__call__]] ```python __call__(inputs: typing.Union[str, list[str], ForwardRef('Image.Image'), list['Image.Image']], **kwargs: Any) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/image_classification.py#L127) **Параметры:** inputs (`str`, `list[str]`, `PIL.Image` or `list[PIL.Image]`) : Пайплайн обрабатывает три типа изображений: - строка, содержащая http-ссылку на изображение - строка, содержащая локальный путь к изображению - изображение, загруженное непосредственно в PIL Пайплайн принимает как одно изображение, так и пакет изображений, который в этом случае должен передаваться в виде строки. Все изображения в пакете должны быть в одном формате: либо все в виде http-ссылок, либо все в виде локальных путей, либо все в виде изображений PIL. function_to_apply (`str`, *необязательный*, по умолчанию `"default"`) : Функция, применяемая к выходным данным модели для получения оценок. Принимает четыре различных значения: Если этот аргумент не указан, то в зависимости от количества меток будут применены следующие функции: - Если у модели одна метка, к выходным данным применяется функция сигмоиды. - Если у модели несколько меток, к выходным данным применяется функция softmax. Возможные значения: - `"sigmoid"`: Применяет функцию сигмоиды к выходным данным. - `"softmax"`: Применяет функцию softmax к выходным данным. - `"none"`: Не применяет никаких функций к выходным данным. top_k (`int`, *optional*, по умолчанию 5) : Количество верхних меток, которые вернёт конвейер. Если указанное значение превышает количество меток, доступных в конфигурации модели, будет использовано количество меток. timeout (`float`, *optional*, по умолчанию None) : Максимальное время ожидания в секундах при загрузке изображений из сети. Если значение равно None, таймаут не устанавливается, и вызов может блокироваться бесконечно. **Возвращаемое значение:** Словарь или список словарей, содержащих результат. Если на вход подана одна картинка, возвращается словарь; если на вход подан список из нескольких картинок, возвращается список словарей, соответствующих этим картинкам. Словари содержат следующие ключи: - **label** (`str`) — метка, идентифицированная моделью. - **score** (`int`) — оценка, присвоенная моделью данной метке. Назначьте метки изображению (изображениям), переданному в качестве входных данных. ### ImageSegmentationPipeline[[transformers.ImageSegmentationPipeline]] #### transformers.ImageSegmentationPipeline[[transformers.ImageSegmentationPipeline]] ```python transformers.ImageSegmentationPipeline(*args, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/image_segmentation.py#L27) **Параметры:** model ([PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel)): модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor)) : процессор изображений, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, по умолчанию `""`) : Идентификатор задачи для конвейера. num_workers (`int`, *необязательный*, по умолчанию 8) : Количество рабочих процессов, используемых, когда конвейер применяет *DataLoader* (при передаче набора данных, на GPU для модели PyTorch). batch_size (`int`, *optional*, defaults to 1) : When the pipeline will use *DataLoader* (when passing a dataset, on GPU for a Pytorch model), the size of the batch to use, for inference this is not always beneficial, please read [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/ru/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *optional*) : Ссылка на объект, отвечающий за разбор переданных параметров конвейера. device (`int` или `str` или `torch.device`, *optional*) : Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (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"`, что загружает модель в том типе данных (dtype), в котором она была сохранена (читается из `config.dtype` контрольной точки, иначе выводится из весов). Передайте явное значение `torch.float16`, `torch.bfloat16`, `torch.float32`, ... для переопределения. binary_output (`bool`, *необязательный*, по умолчанию `False`) : Флаг, указывающий, должен ли вывод пайплайна быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст. Конвейер сегментации изображений с использованием любой модели `AutoModelForXXXSegmentation`. Этот конвейер предсказывает маски объектов и их классы. Пример: ```python >>> 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. >>> segments[0]["mask"].size (768, 512) ``` Этот конвейер сегментации изображений в настоящее время можно загрузить из [pipeline()](/docs/transformers/main/ru/main_classes/pipelines#transformers.pipeline), используя следующий идентификатор задачи: `"image-segmentation"`. Список доступных моделей можно найти на [huggingface.co/models](https://huggingface.co/models?filter=image-segmentation). #### __call__[[transformers.ImageSegmentationPipeline.__call__]] ```python __call__(inputs: typing.Union[str, ForwardRef('Image.Image'), list[str], list['Image.Image']], **kwargs: Any) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/image_segmentation.py#L101) **Параметры:** 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`, *optional*, по умолчанию 0.9) : Порог вероятности для отсечения предсказанных масок. mask_threshold (`float`, *optional*, по умолчанию 0.5) : Порог, используемый при преобразовании предсказанных масок в бинарные значения. overlap_mask_area_threshold (`float`, *optional*, по умолчанию 0.5) : Порог перекрытия маски для удаления небольших, несвязанных сегментов. timeout (`float`, *optional*, по умолчанию None) : Максимальное время ожидания в секундах при загрузке изображений из сети. Если значение равно None, таймаут не устанавливается, и вызов может блокироваться бесконечно. **Возвращаемое значение:** Если на вход подаётся одно изображение, возвращается список словарей; если на вход подаётся список из нескольких изображений, возвращается список списков словарей, соответствующих каждому изображению. Словари содержат маску, метку и оценку (где применимо) каждого обнаруженного объекта и включают следующие ключи: - **label** (`str`) -- Метка класса, определенная моделью. - **mask** (`PIL.Image`) — бинарная маска обнаруженного объекта в виде изображения Pil Image с размерами (width, height) исходного изображения. Если объект не обнаружен, возвращается маска, заполненная нулями. - **score** (*необязательный* `float`) -- Необязательно, если модель способна оценивать уверенность в «объекте», описанном меткой и маской. Выполните сегментацию (определение масок и классов) на переданных в качестве входных данных изображении или изображениях. ### KeypointMatchingPipeline[[transformers.KeypointMatchingPipeline]] #### transformers.KeypointMatchingPipeline[[transformers.KeypointMatchingPipeline]] ```python transformers.KeypointMatchingPipeline(*args, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/keypoint_matching.py#L67) Конвейер сопоставления ключевых точек с использованием любой модели `AutoModelForKeypointMatching`. Этот конвейер сопоставляет ключевые точки между двумя изображениями. #### __call__[[transformers.KeypointMatchingPipeline.__call__]] ```python __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) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/keypoint_matching.py#L96) **Параметры:** inputs (`str`, `list[str]`, `PIL.Image` or `list[PIL.Image]`) : Пайплайн обрабатывает три типа изображений: - строка, содержащая http-ссылку на изображение - строка, содержащая локальный путь к изображению - изображение, загруженное непосредственно в PIL Пайплайн принимает либо одну пару изображений, либо батч пар изображений, который в этом случае должен передаваться в виде строки. Все изображения в батче должны быть в одном формате: все в виде http-ссылок, все в виде локальных путей или все в виде изображений PIL. threshold (`float`, *optional*, по умолчанию 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]] #### transformers.ObjectDetectionPipeline[[transformers.ObjectDetectionPipeline]] ```python transformers.ObjectDetectionPipeline(*args, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/object_detection.py#L26) **Параметры:** model ([PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel)): модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor)) : процессор изображений, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, по умолчанию `""`) : Идентификатор задачи для конвейера. num_workers (`int`, *необязательный*, по умолчанию 8) : Количество рабочих процессов, используемых, когда конвейер применяет *DataLoader* (при передаче набора данных, на GPU для модели PyTorch). batch_size (`int`, *optional*, defaults to 1) : When the pipeline will use *DataLoader* (when passing a dataset, on GPU for a Pytorch model), the size of the batch to use, for inference this is not always beneficial, please read [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/ru/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *optional*) : Ссылка на объект, отвечающий за разбор переданных параметров конвейера. device (`int` или `str` или `torch.device`, *optional*) : Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (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"`, что загружает модель в том типе данных (dtype), в котором она была сохранена (читается из `config.dtype` контрольной точки, иначе выводится из весов). Передайте явное значение `torch.float16`, `torch.bfloat16`, `torch.float32`, ... для переопределения. binary_output (`bool`, *необязательный*, по умолчанию `False`) : Флаг, указывающий, должен ли вывод пайплайна быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст. Конвейер обнаружения объектов с использованием любой модели `AutoModelForObjectDetection`. Этот конвейер предсказывает ограничивающие рамки объектов и их классы. Пример: ```python >>> 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_tutorial) Этот конвейер обнаружения объектов в настоящее время можно загрузить из [pipeline()](/docs/transformers/main/ru/main_classes/pipelines#transformers.pipeline), используя следующий идентификатор задачи: `"object-detection"`. Список доступных моделей можно найти на [huggingface.co/models](https://huggingface.co/models?filter=object-detection). #### __call__[[transformers.ObjectDetectionPipeline.__call__]] ```python __call__(*args, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/object_detection.py#L81) **Параметры:** inputs (`str`, `list[str]`, `PIL.Image` или `list[PIL.Image]`) : Пайплайн обрабатывает три типа изображений: - строка, содержащая HTTP(S)-ссылку на изображение - строка, содержащая локальный путь к изображению - изображение, загруженное непосредственно в PIL Пайплайн принимает как одно изображение, так и пакет изображений. Все изображения в пакете должны быть в одном формате: все в виде HTTP(S)-ссылок, все в виде локальных путей или все в виде изображений PIL. threshold (`float`, *optional*, по умолчанию 0.5) : Вероятность, необходимая для принятия предсказания. timeout (`float`, *optional*, по умолчанию None) : Максимальное время ожидания в секундах при загрузке изображений из сети. Если значение равно None, таймаут не устанавливается, и вызов может блокироваться бесконечно. **Возвращаемое значение:** Список словарей или список списков словарей, содержащий результат. Если на вход подана одиночная картинка, возвращается список словарей; если на вход подан список из нескольких картинок, возвращается список списков словарей, соответствующих каждой картинке. Словари содержат следующие ключи: - **label** (`str`) -- Метка класса, определенная моделью. - **score** (`float`) — оценка, присвоенная моделью данной метке. - **box** (`list[dict[str, int]]`) -- Координаты ограничивающего прямоугольника (bounding box) обнаруженного объекта в исходном размере изображения. Обнаружение объектов (ограничивающие рамки & классы) на переданных в качестве входных данных изображении или изображениях. ### VideoClassificationPipeline[[transformers.VideoClassificationPipeline]] #### transformers.VideoClassificationPipeline[[transformers.VideoClassificationPipeline]] ```python transformers.VideoClassificationPipeline(*args, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/video_classification.py#L41) **Параметры:** model ([PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel)): модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor)) : процессор изображений, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor). video_processor ([BaseVideoProcessor](/docs/transformers/main/ru/main_classes/video_processor#transformers.BaseVideoProcessor)) : процессор видео, который будет использоваться конвейером для кодирования видеоданных для модели. Этот объект наследуется от [BaseVideoProcessor](/docs/transformers/main/ru/main_classes/video_processor#transformers.BaseVideoProcessor). task (`str`, по умолчанию `""`) : Идентификатор задачи для конвейера. num_workers (`int`, *необязательный*, по умолчанию 8) : Количество рабочих процессов, используемых, когда конвейер применяет *DataLoader* (при передаче набора данных, на GPU для модели PyTorch). batch_size (`int`, *optional*, defaults to 1) : When the pipeline will use *DataLoader* (when passing a dataset, on GPU for a Pytorch model), the size of the batch to use, for inference this is not always beneficial, please read [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/ru/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *optional*) : Ссылка на объект, отвечающий за разбор переданных параметров конвейера. device (`int` или `str` или `torch.device`, *optional*) : Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (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"`, что загружает модель в том типе данных (dtype), в котором она была сохранена (читается из `config.dtype` контрольной точки, иначе выводится из весов). Передайте явное значение `torch.float16`, `torch.bfloat16`, `torch.float32`, ... для переопределения. binary_output (`bool`, *необязательный*, по умолчанию `False`) : Флаг, указывающий, должен ли вывод пайплайна быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст. Конвейер классификации видео с использованием любой модели `AutoModelForVideoClassification`. Этот конвейер предсказывает класс видео. Этот конвейер классификации видео в настоящее время можно загрузить из [pipeline()](/docs/transformers/main/ru/main_classes/pipelines#transformers.pipeline), используя следующий идентификатор задачи: `"video-classification"`. Список доступных моделей можно найти на [huggingface.co/models](https://huggingface.co/models?filter=video-classification). Пайплайн поддерживает модели, использующие либо процессор изображений (устаревшие видеомодели, такие как VideoMAE, ViViT и TimeSformer), либо процессор видео (более новые модели, такие как VJEPA2). Если присутствуют оба, приоритет отдается процессору видео; если ни один не найден, пайплайн вызовет ошибку. #### __call__[[transformers.VideoClassificationPipeline.__call__]] ```python __call__(inputs: str | list[str] | None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/video_classification.py#L105) **Параметры:** inputs (`str`, `list[str]`) : Пайплайн обрабатывает три типа видео: - строка, содержащая http-ссылку на видео - строка, содержащая локальный путь к видео Пайплайн принимает как одно видео, так и пакет видео, который в этом случае должен передаваться в виде строки. Все видео в пакете должны быть в одном формате: либо все в виде http-ссылок, либо все в виде локальных путей. top_k (`int`, *optional*, по умолчанию 5) : Количество верхних меток, которые вернёт конвейер. Если указанное значение превышает количество меток, доступных в конфигурации модели, будет использовано количество меток. num_frames (`int`, *optional*, по умолчанию `self.model.config.num_frames`) : Количество кадров, извлекаемых из видео для выполнения классификации. Если не указано, используется количество кадров, заданное в конфигурации модели. frame_sampling_rate (`int`, *optional*, по умолчанию 1) : Частота выборки, используемая для отбора кадров из видео. Если не указано, по умолчанию принимается значение 1, то есть используются все кадры. function_to_apply(`str`, *optional*, по умолчанию "softmax") : функция, применяемая к выходу модели. По умолчанию конвейер применяет функцию softmax к выходу модели. Допустимые значения: ["softmax", "sigmoid", "none"]. Обратите внимание, что передача встроенного значения Python `None` приведёт к использованию "softmax" по умолчанию, поэтому для отключения любой постобработки необходимо передать строку "none". **Возвращаемое значение:** Список словарей или список списков словарей, содержащих результат. Если на вход подан один видеоролик, возвращается список из `top_k` словарей; если на вход подан список из нескольких видеороликов, возвращается список списков из `top_k` словарей, соответствующих видеороликам. Словари содержат следующие ключи: - **label** (`str`) — метка, идентифицированная моделью. - **score** (`int`) — оценка, присвоенная моделью данной метке. Назначьте метки для видео, переданных в качестве входных данных. ### ZeroShotImageClassificationPipeline[[transformers.ZeroShotImageClassificationPipeline]] #### transformers.ZeroShotImageClassificationPipeline[[transformers.ZeroShotImageClassificationPipeline]] ```python transformers.ZeroShotImageClassificationPipeline(**kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/zero_shot_image_classification.py#L29) **Параметры:** model ([PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel)): модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor)) : процессор изображений, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, по умолчанию `""`) : Идентификатор задачи для конвейера. num_workers (`int`, *необязательный*, по умолчанию 8) : Количество рабочих процессов, используемых, когда конвейер применяет *DataLoader* (при передаче набора данных, на GPU для модели PyTorch). batch_size (`int`, *optional*, defaults to 1) : When the pipeline will use *DataLoader* (when passing a dataset, on GPU for a Pytorch model), the size of the batch to use, for inference this is not always beneficial, please read [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/ru/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *optional*) : Ссылка на объект, отвечающий за разбор переданных параметров конвейера. device (`int` или `str` или `torch.device`, *optional*) : Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (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"`, что загружает модель в том типе данных (dtype), в котором она была сохранена (читается из `config.dtype` контрольной точки, иначе выводится из весов). Передайте явное значение `torch.float16`, `torch.bfloat16`, `torch.float32`, ... для переопределения. binary_output (`bool`, *необязательный*, по умолчанию `False`) : Флаг, указывающий, должен ли вывод пайплайна быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст. Конвейер классификации изображений в режиме zero shot с использованием `CLIPModel`. Этот конвейер предсказывает класс изображения, если вы предоставляете изображение и набор `candidate_labels`. Пример: ```python >>> 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_tutorial) Этот конвейер классификации изображений в настоящее время можно загрузить из [pipeline()](/docs/transformers/main/ru/main_classes/pipelines#transformers.pipeline), используя следующий идентификатор задачи: `"zero-shot-image-classification"`. Список доступных моделей можно найти на [huggingface.co/models](https://huggingface.co/models?filter=zero-shot-image-classification). #### __call__[[transformers.ZeroShotImageClassificationPipeline.__call__]] ```python __call__(image: typing.Union[str, list[str], ForwardRef('Image.Image'), list['Image.Image']], candidate_labels: list, **kwargs: Any) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/zero_shot_image_classification.py#L83) **Параметры:** 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`, *optional*, по умолчанию None) : Максимальное время ожидания в секундах при загрузке изображений из сети. Если значение равно None, таймаут не устанавливается, и вызов может блокироваться бесконечно. **Возвращаемое значение:** Список словарей, содержащих по одной записи на каждое предложенное метку. Каждый словарь содержит следующие ключи: - **label** (`str`) -- Одно из предложенных *candidate_labels*. - **score** (`float`) — Оценка, которую модель присваивает данной метке. Это значение от 0 до 1, вычисленное как `softmax` от `logits_per_image`. Назначьте метки изображению (изображениям), переданному в качестве входных данных. ### ZeroShotObjectDetectionPipeline[[transformers.ZeroShotObjectDetectionPipeline]] #### transformers.ZeroShotObjectDetectionPipeline[[transformers.ZeroShotObjectDetectionPipeline]] ```python transformers.ZeroShotObjectDetectionPipeline(**kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/zero_shot_object_detection.py#L23) **Параметры:** model ([PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel)): модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor)) : процессор изображений, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, по умолчанию `""`) : Идентификатор задачи для конвейера. num_workers (`int`, *необязательный*, по умолчанию 8) : Количество рабочих процессов, используемых, когда конвейер применяет *DataLoader* (при передаче набора данных, на GPU для модели PyTorch). batch_size (`int`, *optional*, defaults to 1) : When the pipeline will use *DataLoader* (when passing a dataset, on GPU for a Pytorch model), the size of the batch to use, for inference this is not always beneficial, please read [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/ru/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *optional*) : Ссылка на объект, отвечающий за разбор переданных параметров конвейера. device (`int` или `str` или `torch.device`, *optional*) : Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (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"`, что загружает модель в том типе данных (dtype), в котором она была сохранена (читается из `config.dtype` контрольной точки, иначе выводится из весов). Передайте явное значение `torch.float16`, `torch.bfloat16`, `torch.float32`, ... для переопределения. binary_output (`bool`, *необязательный*, по умолчанию `False`) : Флаг, указывающий, должен ли вывод пайплайна быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст. Конвейер обнаружения объектов в режиме zero shot с использованием `OwlViTForObjectDetection`. Этот конвейер предсказывает ограничивающие рамки объектов, когда вы предоставляете изображение и набор `candidate_labels`. Пример: ```python >>> 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_tutorial) Этот конвейер обнаружения объектов в настоящее время можно загрузить из [pipeline()](/docs/transformers/main/ru/main_classes/pipelines#transformers.pipeline), используя следующий идентификатор задачи: `"zero-shot-object-detection"`. Список доступных моделей можно найти на [huggingface.co/models](https://huggingface.co/models?filter=zero-shot-object-detection). #### __call__[[transformers.ZeroShotObjectDetectionPipeline.__call__]] ```python __call__(image: typing.Union[str, ForwardRef('Image.Image'), list[dict[str, typing.Any]]], candidate_labels: str | list[str] | None = None, **kwargs: Any) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/zero_shot_object_detection.py#L75) **Параметры:** image (`str`, `PIL.Image` or `list[dict[str, Any]]`) : Пайплайн обрабатывает три типа изображений: - строка, содержащая http-URL, указывающий на изображение - строка, содержащая локальный путь к изображению - изображение, загруженное непосредственно в PIL С помощью этого параметра можно передать список изображений, датасет или генератор, как показано ниже: ```python >>> from transformers import pipeline >>> detector = pipeline(model="google/owlvit-base-patch32", task="zero-shot-object-detection") >>> detector( ... [ ... { ... "image": "http://images.cocodataset.org/val2017/000000039769.jpg", ... "candidate_labels": ["cat", "couch"], ... }, ... { ... "image": "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.25, '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}}], [{'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}}]] ``` candidate_labels (`str` или `list[str]` или `list[list[str]]`) : Что модель должна распознать на изображении. threshold (`float`, *необязательный*, по умолчанию 0.1) : Вероятность, необходимая для принятия предсказания. top_k (`int`, *optional*, по умолчанию None) : Количество верхних предсказаний, которые вернёт конвейер. Если указанное значение равно `None` или превышает количество доступных предсказаний, будет использовано количество доступных предсказаний. timeout (`float`, *optional*, по умолчанию None) : Максимальное время ожидания в секундах при загрузке изображений из сети. Если значение равно None, таймаут не устанавливается, и вызов может блокироваться бесконечно. **Возвращаемое значение:** Список списков, содержащих результаты предсказаний, по одному списку на входное изображение. Каждый список содержит словари со следующими ключами: - **label** (`str`) -- Текстовый запрос, соответствующий найденному объекту. - **score** (`float`) — Оценка, соответствующая объекту (от 0 до 1). - **box** (`dict[str,int]`) -- Ограничивающая рамка обнаруженного объекта в исходном размере изображения. Это словарь с ключами `x_min`, `x_max`, `y_min`, `y_max`. Обнаружение объектов (ограничивающие рамки & классы) на переданных в качестве входных данных изображении или изображениях. ## Обработка естественного языка Среди доступных конвейеров для задач обработки естественного языка есть следующие. ### FillMaskPipeline[[transformers.FillMaskPipeline]] #### transformers.FillMaskPipeline[[transformers.FillMaskPipeline]] ```python transformers.FillMaskPipeline(model: PreTrainedModel, tokenizer: PreTrainedTokenizer | None = None, feature_extractor: PreTrainedFeatureExtractor | None = None, image_processor: BaseImageProcessor | None = None, video_processor: BaseVideoProcessor | None = None, processor: ProcessorMixin | None = None, task: str = '', device: int | torch.device | None = None, binary_output: bool = False, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/fill_mask.py#L28) **Параметры:** model ([PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel)): модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/ru/main_classes/tokenizer#transformers.PythonBackend)) : токенизатор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [PreTrainedTokenizer](/docs/transformers/main/ru/main_classes/tokenizer#transformers.PythonBackend). task (`str`, по умолчанию `""`) : Идентификатор задачи для конвейера. num_workers (`int`, *необязательный*, по умолчанию 8) : Количество рабочих процессов, используемых, когда конвейер применяет *DataLoader* (при передаче набора данных, на GPU для модели PyTorch). batch_size (`int`, *optional*, defaults to 1) : When the pipeline will use *DataLoader* (when passing a dataset, on GPU for a Pytorch model), the size of the batch to use, for inference this is not always beneficial, please read [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/ru/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *optional*) : Ссылка на объект, отвечающий за разбор переданных параметров конвейера. device (`int` или `str` или `torch.device`, *optional*) : Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (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"`, что загружает модель в том типе данных (dtype), в котором она была сохранена (читается из `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__[[transformers.FillMaskPipeline.__call__]] ```python __call__(inputs: str | list[str], **kwargs: Any) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/fill_mask.py#L234) **Параметры:** inputs (`str` или `list[str]`) : Один или несколько текстов (или один список промптов) с замаскированными токенами. targets (`str` или `list[str]`, *необязательный*) : Если передано, модель ограничит оценки переданными целями, вместо того чтобы искать их во всей лексиконе. Если предоставленные цели отсутствуют в лексиконе модели, они будут токенизированы, и будет использован первый полученный токен (с предупреждением, что может замедлить процесс). top_k (`int`, *optional*) : Если передано, переопределяет количество возвращаемых предсказаний. **Возвращает:** список или список списков `dict` Каждый результат представляет собой список словарей со следующими ключами: - **sequence** (`str`) — соответствующий вход с предсказанием маскированного токена. - **score** (`float`) — соответствующая вероятность. - **token** (`int`) -- Идентификатор предсказанного токена (для замены замаскированного). - **token_str** (`str`) -- Предсказанный токен (для замены замаскированного). Заполните замаскированный токен в тексте (текстах), переданных в качестве входных данных. ### TableQuestionAnsweringPipeline[[transformers.TableQuestionAnsweringPipeline]] #### transformers.TableQuestionAnsweringPipeline[[transformers.TableQuestionAnsweringPipeline]] ```python transformers.TableQuestionAnsweringPipeline(args_parser = , **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/table_question_answering.py#L78) **Параметры:** model ([PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel)): модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/ru/main_classes/tokenizer#transformers.PythonBackend)) : токенизатор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [PreTrainedTokenizer](/docs/transformers/main/ru/main_classes/tokenizer#transformers.PythonBackend). task (`str`, по умолчанию `""`) : Идентификатор задачи для конвейера. num_workers (`int`, *необязательный*, по умолчанию 8) : Количество рабочих процессов, используемых, когда конвейер применяет *DataLoader* (при передаче набора данных, на GPU для модели PyTorch). batch_size (`int`, *optional*, defaults to 1) : When the pipeline will use *DataLoader* (when passing a dataset, on GPU for a Pytorch model), the size of the batch to use, for inference this is not always beneficial, please read [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/ru/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *optional*) : Ссылка на объект, отвечающий за разбор переданных параметров конвейера. device (`int` или `str` или `torch.device`, *optional*) : Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (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"`, что загружает модель в том типе данных (dtype), в котором она была сохранена (читается из `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 Пример: ```python >>> 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_tutorial) Этот конвейер для табличного вопросно-ответного взаимодействия в настоящее время можно загрузить из [pipeline()](/docs/transformers/main/ru/main_classes/pipelines#transformers.pipeline), используя следующий идентификатор задачи: `"table-question-answering"`. Модели, которые может использовать этот конвейер, — это модели, дообученные на задаче табличного вопросно-ответного взаимодействия. Актуальный список доступных моделей можно найти на [huggingface.co/models](https://huggingface.co/models?filter=table-question-answering). #### __call__[[transformers.TableQuestionAnsweringPipeline.__call__]] ```python __call__(*args, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/table_question_answering.py#L208) **Параметры:** table (`pd.DataFrame` или `Dict`) : DataFrame Pandas или словарь, который будет преобразован в DataFrame, содержащий все значения таблицы. Пример словаря приведен выше. query (`str` или `list[str]`) : Запрос или список запросов, которые будут отправлены в модель вместе с таблицей. sequential (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли выполнять инференс последовательно или батчами. Батчинг быстрее, но модели, такие как SQA, требуют последовательного выполнения инференса для извлечения отношений внутри последовательностей, учитывая их диалоговый характер. padding (`bool`, `str` или [PaddingStrategy](/docs/transformers/main/ru/internal/file_utils#transformers.utils.PaddingStrategy), *необязательный*, по умолчанию `False`) : Включает и управляет выравниванием. Принимает следующие значения: - `True` или `'longest'`: Выравнивание до самой длинной последовательности в батче (или без выравнивания, если предоставлена только одна последовательность). - `'max_length'`: Выравнивание до максимальной длины, указанной в аргументе `max_length`, или до максимально допустимой входной длины для модели, если этот аргумент не указан. - `False` или `'do_not_pad'` (по умолчанию): Без выравнивания (т. е. может выдать батч с последовательностями разной длины). truncation (`bool`, `str` или `TapasTruncationStrategy`, *optional*, по умолчанию `False`) : Включает и управляет усечением. Принимает следующие значения: - `True` или `'drop_rows_to_fit'`: Усечение до максимальной длины, указанной аргументом `max_length`, или до максимально допустимой длины входных данных для модели, если этот аргумент не указан. Усечение выполняется построчно, удаляя строки из таблицы. - `False` или `'do_not_truncate'` (по умолчанию): Усечение не выполняется (т. е. может быть выведен батч с длиной последовательности, превышающей максимально допустимый размер входных данных модели). **Возвращает:** `A dictionary or a list of dictionaries containing results` Каждый результат представляет собой словарь со следующими ключами: - **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, созданным из этого словаря, и содержать всю таблицу: Пример: ```python 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: Пример: ```python import pandas as pd table = pd.DataFrame.from_dict(data) ``` ### TextClassificationPipeline[[transformers.TextClassificationPipeline]] #### transformers.TextClassificationPipeline[[transformers.TextClassificationPipeline]] ```python transformers.TextClassificationPipeline(**kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/text_classification.py#L43) **Параметры:** model ([PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel)): модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/ru/main_classes/tokenizer#transformers.PythonBackend)) : токенизатор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [PreTrainedTokenizer](/docs/transformers/main/ru/main_classes/tokenizer#transformers.PythonBackend). task (`str`, по умолчанию `""`) : Идентификатор задачи для конвейера. num_workers (`int`, *необязательный*, по умолчанию 8) : Количество рабочих процессов, используемых, когда конвейер применяет *DataLoader* (при передаче набора данных, на GPU для модели PyTorch). batch_size (`int`, *optional*, defaults to 1) : When the pipeline will use *DataLoader* (when passing a dataset, on GPU for a Pytorch model), the size of the batch to use, for inference this is not always beneficial, please read [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/ru/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *optional*) : Ссылка на объект, отвечающий за разбор переданных параметров конвейера. device (`int` или `str` или `torch.device`, *optional*) : Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (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"`, что загружает модель в том типе данных (dtype), в котором она была сохранена (читается из `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`. Подробнее см. в [примерах классификации последовательностей](../task_summary#sequence-classification). Пример: ```python >>> 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_tutorial) Этот конвейер классификации текста в настоящее время можно загрузить из [pipeline()](/docs/transformers/main/ru/main_classes/pipelines#transformers.pipeline), используя следующий идентификатор задачи: `"sentiment-analysis"` (для классификации последовательностей по положительным или отрицательным эмоциям). Если доступно несколько меток классификации (`model.config.num_labels >= 2`), конвейер применяет softmax к результатам. Если метка одна, конвейер применяет sigmoid к результату. В случае задач регрессии (`model.config.problem_type == "regression"`) никакая функция к выходу не применяется. Модели, которые может использовать этот конвейер, — это модели, дообученные на задаче классификации последовательностей. Актуальный список доступных моделей можно найти на [huggingface.co/models](https://huggingface.co/models?filter=text-classification). #### __call__[[transformers.TextClassificationPipeline.__call__]] ```python __call__(inputs: str | list[str] | dict[str, str] | list[dict[str, str]], **kwargs: Any) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/text_classification.py#L105) **Параметры:** 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]] #### transformers.TextGenerationPipeline[[transformers.TextGenerationPipeline]] ```python transformers.TextGenerationPipeline(*args, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/text_generation.py#L23) **Параметры:** model ([PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel)): модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/ru/main_classes/tokenizer#transformers.PythonBackend)) : токенизатор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [PreTrainedTokenizer](/docs/transformers/main/ru/main_classes/tokenizer#transformers.PythonBackend). task (`str`, по умолчанию `""`) : Идентификатор задачи для конвейера. num_workers (`int`, *необязательный*, по умолчанию 8) : Количество рабочих процессов, используемых, когда конвейер применяет *DataLoader* (при передаче набора данных, на GPU для модели PyTorch). batch_size (`int`, *optional*, defaults to 1) : When the pipeline will use *DataLoader* (when passing a dataset, on GPU for a Pytorch model), the size of the batch to use, for inference this is not always beneficial, please read [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/ru/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *optional*) : Ссылка на объект, отвечающий за разбор переданных параметров конвейера. device (`int` или `str` или `torch.device`, *optional*) : Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (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"`, что загружает модель в том типе данных (dtype), в котором она была сохранена (читается из `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 Примеры: ```python >>> 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) ``` ```python >>> 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_tutorial). Вы можете передавать параметры генерации текста в этот pipeline для управления критериями остановки, стратегией декодирования и другими аспектами. Подробнее о параметрах генерации текста см. в разделах [Стратегии генерации текста](../generation_strategies) и [Генерация текста](text_generation). Этот конвейер генерации текста в настоящее время можно загрузить из [pipeline()](/docs/transformers/main/ru/main_classes/pipelines#transformers.pipeline), используя следующий идентификатор задачи: `"text-generation"`. Модели, которые может использовать этот конвейер, — это модели, обученные с целью авторегрессионного языкового моделирования. См. список доступных [моделей для завершения текста](https://huggingface.co/models?filter=text-generation) и список [разговорных моделей](https://huggingface.co/models?other=conversational) на [huggingface.co/models]. #### __call__[[transformers.TextGenerationPipeline.__call__]] ```python __call__(text_inputs, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/text_generation.py#L251) **Параметры:** 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`, *optional*) : По умолчанию этот конвейер не обрабатывает длинную генерацию (ту, которая тем или иным образом превышает максимальную длину модели). Идеального способа решить эту проблему не существует (подробнее: https://github.com/huggingface/transformers/issues/14033#issuecomment-948385227). Здесь описаны общие стратегии обхода этой проблемы в зависимости от вашего сценария использования. - `None` : стратегия по умолчанию, при которой ничего особенного не происходит - `"hole"`: Обрезает вход слева и оставляет зазор достаточной ширины для генерации (может сильно обрезать промпт и не подходит, если генерация превышает возможности модели) tokenizer_encode_kwargs (`dict`, *необязательный*) : Дополнительные именованные аргументы, передаваемые на этапе кодирования токенизатора. Если входной текст представляет собой чат, он передается в `apply_chat_template`. В противном случае он передается в `__call__`. generate_kwargs (`dict`, *необязательный*) : Дополнительные именованные аргументы, передаваемые в метод generate модели (см. метод generate [здесь](./text_generation)). **Возвращает:** список или список списков `dict` Возвращает один из следующих словарей (невозможно вернуть комбинацию `generated_text` и `generated_token_ids`): - **generated_text** (`str`, присутствует, если `return_text=True`) -- Сгенерированный текст. - **generated_token_ids** (`torch.Tensor`, присутствует при `return_tensors=True`) -- Идентификаторы токенов сгенерированного текста. Завершите промпт(ы), переданные в качестве входных данных. ### TokenClassificationPipeline[[transformers.TokenClassificationPipeline]] #### transformers.TokenClassificationPipeline[[transformers.TokenClassificationPipeline]] ```python transformers.TokenClassificationPipeline(args_parser = , **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/token_classification.py#L91) **Параметры:** model ([PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel)): модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/ru/main_classes/tokenizer#transformers.PythonBackend)) : токенизатор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [PreTrainedTokenizer](/docs/transformers/main/ru/main_classes/tokenizer#transformers.PythonBackend). task (`str`, по умолчанию `""`) : Идентификатор задачи для конвейера. num_workers (`int`, *необязательный*, по умолчанию 8) : Количество рабочих процессов, используемых, когда конвейер применяет *DataLoader* (при передаче набора данных, на GPU для модели PyTorch). batch_size (`int`, *optional*, defaults to 1) : When the pipeline will use *DataLoader* (when passing a dataset, on GPU for a Pytorch model), the size of the batch to use, for inference this is not always beneficial, please read [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/ru/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *optional*) : Ссылка на объект, отвечающий за разбор переданных параметров конвейера. device (`int` или `str` или `torch.device`, *optional*) : Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (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"`, что загружает модель в том типе данных (dtype), в котором она была сохранена (читается из `config.dtype` контрольной точки, иначе выводится из весов). Передайте явное значение `torch.float16`, `torch.bfloat16`, `torch.float32`, ... для переопределения. binary_output (`bool`, *необязательный*, по умолчанию `False`) : Флаг, указывающий, должен ли вывод пайплайна быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст. ignore_labels (`list[str]`, по умолчанию `["O"]`) : список меток, которые следует игнорировать. stride (`int`, *optional*) : Если указан stride, конвейер применяется ко всему тексту. Текст разбивается на фрагменты размером model_max_length. Работает только с быстрыми токенизаторами и `aggregation_strategy`, отличным от `NONE`. Значение этого аргумента определяет количество перекрывающихся токенов между фрагментами. Иными словами, на каждом шаге модель сдвигается вперёд на `tokenizer.model_max_length - stride` токенов. 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`, за исключением того, что слова не могут получить разные теги. Сущность слова будет просто токеном с максимальной оценкой. Конвейер распознавания именованных сущностей с использованием любой модели `ModelForTokenClassification`. Подробнее см. в [примерах распознавания именованных сущностей](../task_summary#named-entity-recognition). Пример: ```python >>> 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_tutorial) Эту конвейерную линию распознавания токенов в настоящее время можно загрузить из [pipeline()](/docs/transformers/main/ru/main_classes/pipelines#transformers.pipeline), используя следующий идентификатор задачи: `"ner"` (для предсказания классов токенов в последовательности: person, organisation, location или miscellaneous). Модели, которые может использовать этот конвейер, — это модели, дообученные на задаче классификации токенов. Актуальный список доступных моделей можно найти на [huggingface.co/models](https://huggingface.co/models?filter=token-classification). #### __call__[[transformers.TokenClassificationPipeline.__call__]] ```python __call__(inputs: str | list[str], **kwargs: Any) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/token_classification.py#L210) **Параметры:** 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[[transformers.TokenClassificationPipeline.aggregate_words]] ```python aggregate_words(entities: list, aggregation_strategy: AggregationStrategy) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/token_classification.py#L522) Переопределяйте токены из заданного слова, которые не совпадают, чтобы принудительно согласовать границы слов. Пример: micro|soft| com|pany| B-ENT I-NAME I-ENT I-ENT будет переписан с использованием первой стратегии как microsoft| company| B-ENT I-ENT #### gather_pre_entities[[transformers.TokenClassificationPipeline.gather_pre_entities]] ```python gather_pre_entities(sentence: str, input_ids: ndarray, scores: ndarray, offset_mapping: list[tuple[int, int]] | None, special_tokens_mask: ndarray, aggregation_strategy: AggregationStrategy, word_ids: list[int | None] | None = None, word_to_chars_map: list[tuple[int, int]] | None = None) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/token_classification.py#L398) Объедините различные массивы numpy в словари, содержащие всю необходимую информацию для агрегации #### group_entities[[transformers.TokenClassificationPipeline.group_entities]] ```python group_entities(entities: list) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/token_classification.py#L585) **Параметры:** entities (`dict`) : Сущности, предсказанные конвейером. Найдите и сгруппируйте соседние токены, для которых предсказана одна и та же сущность. #### group_sub_entities[[transformers.TokenClassificationPipeline.group_sub_entities]] ```python group_sub_entities(entities: list) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/token_classification.py#L550) **Параметры:** entities (`dict`) : Сущности, предсказанные конвейером. Сгруппируйте соседние токены, для которых предсказана одна и та же сущность. ### ZeroShotClassificationPipeline[[transformers.ZeroShotClassificationPipeline]] #### transformers.ZeroShotClassificationPipeline[[transformers.ZeroShotClassificationPipeline]] ```python transformers.ZeroShotClassificationPipeline(args_parser = , **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/zero_shot_classification.py#L44) **Параметры:** model ([PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel)): модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/ru/main_classes/tokenizer#transformers.PythonBackend)) : токенизатор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [PreTrainedTokenizer](/docs/transformers/main/ru/main_classes/tokenizer#transformers.PythonBackend). task (`str`, по умолчанию `""`) : Идентификатор задачи для конвейера. num_workers (`int`, *необязательный*, по умолчанию 8) : Количество рабочих процессов, используемых, когда конвейер применяет *DataLoader* (при передаче набора данных, на GPU для модели PyTorch). batch_size (`int`, *optional*, defaults to 1) : When the pipeline will use *DataLoader* (when passing a dataset, on GPU for a Pytorch model), the size of the batch to use, for inference this is not always beneficial, please read [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/ru/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *optional*) : Ссылка на объект, отвечающий за разбор переданных параметров конвейера. device (`int` или `str` или `torch.device`, *optional*) : Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (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"`, что загружает модель в том типе данных (dtype), в котором она была сохранена (читается из `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* конфигурации модели. Пример: ```python >>> 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]} ``` Подробнее о базовых принципах использования пайплайна читайте в [руководстве по пайплайнам](../pipeline_tutorial) Этот NLI-пайплайн в настоящее время можно загрузить из [pipeline()](/docs/transformers/main/ru/main_classes/pipelines#transformers.pipeline), используя следующий идентификатор задачи: `"zero-shot-classification"`. Модели, которые может использовать этот конвейер, — это модели, дообученные на задаче NLI. Актуальный список доступных моделей можно найти на [huggingface.co/models](https://huggingface.co/models?search=nli). #### __call__[[transformers.ZeroShotClassificationPipeline.__call__]] ```python __call__(sequences: str | list[str], *args, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/zero_shot_classification.py#L159) **Параметры:** sequences (`str` или `list[str]`) : Последовательность(и) для классификации; если вход модели слишком велик, последовательность будет усечена. candidate_labels (`str` или `list[str]`) : Набор возможных классов меток, в которые классифицируется каждая последовательность. Может быть одной меткой, строкой с метками, разделенными запятыми, или списком меток. hypothesis_template (`str`, *optional*, по умолчанию `"This example is {}."`) : Шаблон, используемый для преобразования каждой метки в гипотезу в стиле NLI. Этот шаблон должен содержать {} или аналогичный синтаксис для вставки кандидата метки в шаблон. Например, шаблон по умолчанию — `"This example is {}."` При кандидате метки `"sports"` в модель будет передано `" sequence to classify This example is sports . "`. Шаблон по умолчанию хорошо работает во многих случаях, но в зависимости от задачи может быть полезно экспериментировать с различными шаблонами. multi_label (`bool`, *необязательный*, по умолчанию `False`) : Указывает, может ли несколько меток быть истинными одновременно. Если `False`, оценки нормализуются так, чтобы сумма вероятностей меток для каждой последовательности равнялась 1. Если `True`, метки считаются независимыми, а вероятности нормализуются для каждой кандидатуры с помощью softmax от оценки entailment и оценки contradiction. **Возвращает:** `dict` или список `dict` Каждый результат представляет собой словарь со следующими ключами: - **sequence** (`str`) — последовательность, для которой это является выходом. - **labels** (`list[str]`) -- Метки, отсортированные по убыванию вероятности. - **scores** (`list[float]`) — вероятности для каждой из меток. Классифицирует последовательность(и), переданные в качестве входных данных. Подробнее см. в документации [ZeroShotClassificationPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.ZeroShotClassificationPipeline). ## Мультимодальность Среди доступных для мультимодальных задач пайплайнов есть следующие. ### DocumentQuestionAnsweringPipeline[[transformers.DocumentQuestionAnsweringPipeline]] #### transformers.DocumentQuestionAnsweringPipeline[[transformers.DocumentQuestionAnsweringPipeline]] ```python transformers.DocumentQuestionAnsweringPipeline(*args, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/document_question_answering.py#L206) **Параметры:** model ([PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel)): модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/ru/main_classes/tokenizer#transformers.PythonBackend)) : токенизатор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [PreTrainedTokenizer](/docs/transformers/main/ru/main_classes/tokenizer#transformers.PythonBackend). image_processor ([BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor)) : процессор изображений, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, по умолчанию `""`) : Идентификатор задачи для конвейера. num_workers (`int`, *необязательный*, по умолчанию 8) : Количество рабочих процессов, используемых, когда конвейер применяет *DataLoader* (при передаче набора данных, на GPU для модели PyTorch). batch_size (`int`, *optional*, defaults to 1) : When the pipeline will use *DataLoader* (when passing a dataset, on GPU for a Pytorch model), the size of the batch to use, for inference this is not always beneficial, please read [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/ru/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *optional*) : Ссылка на объект, отвечающий за разбор переданных параметров конвейера. device (`int` или `str` или `torch.device`, *optional*) : Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (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"`, что загружает модель в том типе данных (dtype), в котором она была сохранена (читается из `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 Пример: ```python >>> 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_tutorial) Этот конвейер для ответов на вопросы по документам в настоящее время можно загрузить из [pipeline()](/docs/transformers/main/ru/main_classes/pipelines#transformers.pipeline), используя следующий идентификатор задачи: `"document-question-answering"`. Модели, которые может использовать этот конвейер, — это модели, дообученные на задаче документного вопросно-ответного взаимодействия. Актуальный список доступных моделей можно найти на [huggingface.co/models](https://huggingface.co/models?filter=document-question-answering). #### __call__[[transformers.DocumentQuestionAnsweringPipeline.__call__]] ```python __call__(image: typing.Union[ForwardRef('Image.Image'), str, list[dict[str, typing.Any]]], question: str | None = None, word_boxes: tuple[str, list[float]] | None = None, **kwargs: Any) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/document_question_answering.py#L338) **Параметры:** 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`, *optional*, по умолчанию 1) : количество возвращаемых ответов (выбираются по убыванию вероятности). Обратите внимание, что мы возвращаем меньше, чем top_k ответов, если в контексте недостаточно вариантов. doc_stride (`int`, *optional*, по умолчанию 128) : Если слова в документе слишком длинные, чтобы вместе с вопросом поместиться в модель, документ будет разбит на несколько фрагментов с перекрытием. Этот аргумент управляет размером перекрытия. max_answer_len (`int`, *optional*, по умолчанию 15) : Максимальная длина предсказанных ответов (например, учитываются только ответы с меньшей длиной). max_seq_len (`int`, *optional*, по умолчанию 384) : Максимальная длина всего предложения (контекст + вопрос) в токенах для каждого фрагмента, передаваемого в модель. При необходимости контекст будет разбит на несколько фрагментов (с перекрытием `doc_stride`). max_question_len (`int`, *optional*, по умолчанию 64) : Максимальная длина вопроса после токенизации. При необходимости будет усечена. handle_impossible_answer (`bool`, *необязательный*, по умолчанию `False`) : Принимать ли «невозможно» в качестве ответа. lang (`str`, *необязательный*) : Язык, используемый при выполнении OCR. По умолчанию — английский. tesseract_config (`str`, *необязательный*) : Дополнительные флаги для передачи tesseract при выполнении OCR. timeout (`float`, *optional*, по умолчанию None) : Максимальное время ожидания в секундах при загрузке изображений из сети. Если значение равно None, таймаут не устанавливается, и вызов может блокироваться бесконечно. **Возвращает:** `dict` или список `dict` Каждый результат представляет собой словарь со следующими ключами: - **score** (`float`) — вероятность, связанная с ответом. - **start** (`int`) -- Индекс начального слова ответа (в распознанной версии входных данных или в предоставленных `word_boxes`). - **end** (`int`) — индекс последнего слова ответа (в распознанной версии входных данных или в предоставленных `word_boxes`). - **answer** (`str`) -- Ответ на вопрос. - **words** (`list[int]`) -- Индекс каждой пары слово/рамка, входящей в ответ Ответьте на вопрос(ы), переданный(ые) в качестве входных данных, используя документ(ы). Документ определяется как изображение и необязательный список кортежей (слово, рамка), представляющих текст в документе. Если `word_boxes` не предоставлены, будет использоваться движок Tesseract OCR (если он доступен) для автоматического извлечения слов и рамок для моделей типа LayoutLM, которым они необходимы в качестве входных данных. Для Donut распознавание текста не выполняется. Вы можете вызвать конвейер несколькими способами: - `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]] #### transformers.FeatureExtractionPipeline[[transformers.FeatureExtractionPipeline]] ```python transformers.FeatureExtractionPipeline(model: PreTrainedModel, tokenizer: PreTrainedTokenizer | None = None, feature_extractor: PreTrainedFeatureExtractor | None = None, image_processor: BaseImageProcessor | None = None, video_processor: BaseVideoProcessor | None = None, processor: ProcessorMixin | None = None, task: str = '', device: int | torch.device | None = None, binary_output: bool = False, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/feature_extraction.py#L15) **Параметры:** model ([PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel)): модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/ru/main_classes/tokenizer#transformers.PythonBackend)) : токенизатор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [PreTrainedTokenizer](/docs/transformers/main/ru/main_classes/tokenizer#transformers.PythonBackend). task (`str`, по умолчанию `""`) : Идентификатор задачи для конвейера. num_workers (`int`, *необязательный*, по умолчанию 8) : Количество рабочих процессов, используемых, когда конвейер применяет *DataLoader* (при передаче набора данных, на GPU для модели PyTorch). batch_size (`int`, *optional*, defaults to 1) : When the pipeline will use *DataLoader* (when passing a dataset, on GPU for a Pytorch model), the size of the batch to use, for inference this is not always beneficial, please read [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/ru/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *optional*) : Ссылка на объект, отвечающий за разбор переданных параметров конвейера. device (`int` или `str` или `torch.device`, *optional*) : Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (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"`, что загружает модель в том типе данных (dtype), в котором она была сохранена (читается из `config.dtype` контрольной точки, иначе выводится из весов). Передайте явное значение `torch.float16`, `torch.bfloat16`, `torch.float32`, ... для переопределения. tokenize_kwargs (`dict`, *необязательный*) : Дополнительный словарь аргументов с ключами, передаваемых в токенизатор. return_tensors (`bool`, *необязательный*) : Если `True`, возвращает тензор в соответствии с указанной фреймворком, иначе возвращает список. Пайплайн Feature extraction не использует модельную голову. Этот пайплайн извлекает скрытые состояния из базового трансформера, которые можно использовать в качестве признаков для задач, следующих за ним. Пример: ```python >>> 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_tutorial) Этот конвейер извлечения признаков в настоящее время можно загрузить из [pipeline()](/docs/transformers/main/ru/main_classes/pipelines#transformers.pipeline), используя идентификатор задачи: `"feature-extraction"`. Все модели могут использоваться для этого конвейера. Список всех моделей, включая модели, предоставленные сообществом, доступен на [huggingface.co/models](https://huggingface.co/models). #### __call__[[transformers.FeatureExtractionPipeline.__call__]] ```python __call__(*args: str | list[str], **kwargs: Any) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/feature_extraction.py#L78) **Параметры:** args (`str` или `list[str]`) : Один или несколько текстов (или один список текстов), для которых нужно получить признаки. **Возвращает:** вложенный список `float` Особенности, вычисленные моделью. Извлекайте признаки входного текста. ### ImageFeatureExtractionPipeline[[transformers.ImageFeatureExtractionPipeline]] #### transformers.ImageFeatureExtractionPipeline[[transformers.ImageFeatureExtractionPipeline]] ```python transformers.ImageFeatureExtractionPipeline(model: PreTrainedModel, tokenizer: PreTrainedTokenizer | None = None, feature_extractor: PreTrainedFeatureExtractor | None = None, image_processor: BaseImageProcessor | None = None, video_processor: BaseVideoProcessor | None = None, processor: ProcessorMixin | None = None, task: str = '', device: int | torch.device | None = None, binary_output: bool = False, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/image_feature_extraction.py#L23) **Параметры:** model ([PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel)): модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor)) : процессор изображений, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, по умолчанию `""`) : Идентификатор задачи для конвейера. num_workers (`int`, *необязательный*, по умолчанию 8) : Количество рабочих процессов, используемых, когда конвейер применяет *DataLoader* (при передаче набора данных, на GPU для модели PyTorch). batch_size (`int`, *optional*, defaults to 1) : When the pipeline will use *DataLoader* (when passing a dataset, on GPU for a Pytorch model), the size of the batch to use, for inference this is not always beneficial, please read [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/ru/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *optional*) : Ссылка на объект, отвечающий за разбор переданных параметров конвейера. device (`int` или `str` или `torch.device`, *optional*) : Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (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"`, что загружает модель в том типе данных (dtype), в котором она была сохранена (читается из `config.dtype` контрольной точки, иначе выводится из весов). Передайте явное значение `torch.float16`, `torch.bfloat16`, `torch.float32`, ... для переопределения. binary_output (`bool`, *необязательный*, по умолчанию `False`) : Флаг, указывающий, должен ли вывод пайплайна быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст. image_processor_kwargs (`dict`, *необязательный*) : Дополнительный словарь аргументов с ключевыми словами, передаваемых в процессор изображений, например, {"size": {"height": 100, "width": 100}} pool (`bool`, *необязательный*, по умолчанию `False`) : Возвращать ли объединённый вывод. Если `False`, модель вернёт необработанные скрытые состояния. Конвейер извлечения признаков изображений не использует головную часть модели. Этот конвейер извлекает скрытые состояния из базового трансформера, которые можно использовать в качестве признаков для задач, следующих за ним. Пример: ```python >>> 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_tutorial) Этот конвейер извлечения признаков изображений в настоящее время можно загрузить из [pipeline()](/docs/transformers/main/ru/main_classes/pipelines#transformers.pipeline), используя идентификатор задачи: `"image-feature-extraction"`. Все модели компьютерного зрения могут использоваться в этом конвейере. Список всех моделей, включая модели, предоставленные сообществом, доступен на [huggingface.co/models](https://huggingface.co/models). #### __call__[[transformers.ImageFeatureExtractionPipeline.__call__]] ```python __call__(*args: typing.Union[str, ForwardRef('Image.Image'), list['Image.Image'], list[str]], **kwargs: Any) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/image_feature_extraction.py#L94) **Параметры:** images (`str`, `list[str]`, `PIL.Image` or `list[PIL.Image]`) : Пайплайн обрабатывает три типа изображений: - строка, содержащая http-ссылку на изображение - строка, содержащая локальный путь к изображению - изображение, загруженное непосредственно в PIL Пайплайн принимает как одно изображение, так и пакет изображений, который в этом случае должен передаваться в виде строки. Все изображения в пакете должны быть в одном формате: либо все в виде http-ссылок, либо все в виде локальных путей, либо все в виде изображений PIL. timeout (`float`, *optional*, по умолчанию None) : Максимальное время ожидания в секундах при получении изображений из сети. Если значение равно None, таймаут не используется, и вызов может блокироваться бесконечно. **Возвращает:** вложенный список `float` Особенности, вычисленные моделью. Извлекайте признаки входных данных. ### ImageTextToTextPipeline[[transformers.ImageTextToTextPipeline]] #### transformers.ImageTextToTextPipeline[[transformers.ImageTextToTextPipeline]] ```python transformers.ImageTextToTextPipeline(*args, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/image_text_to_text.py#L53) **Параметры:** model ([PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel)): модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). processor ([ProcessorMixin](/docs/transformers/main/ru/main_classes/processors#transformers.ProcessorMixin)) : процессор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [ProcessorMixin](/docs/transformers/main/ru/main_classes/processors#transformers.ProcessorMixin). Процессор — это составный объект, который может содержать `tokenizer`, `feature_extractor` и `image_processor`. task (`str`, по умолчанию `""`) : Идентификатор задачи для конвейера. num_workers (`int`, *необязательный*, по умолчанию 8) : Количество рабочих процессов, используемых, когда конвейер применяет *DataLoader* (при передаче набора данных, на GPU для модели PyTorch). batch_size (`int`, *optional*, defaults to 1) : When the pipeline will use *DataLoader* (when passing a dataset, on GPU for a Pytorch model), the size of the batch to use, for inference this is not always beneficial, please read [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/ru/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *optional*) : Ссылка на объект, отвечающий за разбор переданных параметров конвейера. device (`int` или `str` или `torch.device`, *optional*) : Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (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"`, что загружает модель в том типе данных (dtype), в котором она была сохранена (читается из `config.dtype` контрольной точки, иначе выводится из весов). Передайте явное значение `torch.float16`, `torch.bfloat16`, `torch.float32`, ... для переопределения. binary_output (`bool`, *необязательный*, по умолчанию `False`) : Флаг, указывающий, должен ли вывод пайплайна быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст. Конвейер «изображение и текст в текст» на основе `AutoModelForImageTextToText`. Этот конвейер генерирует текст по заданному изображению и тексту. Если базовая модель является диалоговой, конвейер также принимает один или несколько чатов; в этом случае он работает в режиме чата и продолжает диалог(и), добавляя свой ответ(ы). Каждый чат представляет собой список словарей, где каждый словарь содержит ключи "role" и "content". Если модель, которую вы используете, явно не задаёт эти параметры генерации в своих файлах конфигурации (`generation_config.json`), будут использованы следующие значения по умолчанию: - max_new_tokens: 256 Пример: ```python >>> 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'}] ``` ```python >>> 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_tutorial) Этот пайплайн «изображение-текст в текст» в настоящее время можно загрузить из pipeline(), используя следующий идентификатор задачи: "image-text-to-text". Список доступных моделей можно найти на [huggingface.co/models](https://huggingface.co/models?pipeline_tag=image-text-to-text). #### __call__[[transformers.ImageTextToTextPipeline.__call__]] ```python __call__(images: typing.Union[str, list[str], list[list[str]], ForwardRef('Image.Image'), list['Image.Image'], list[list['Image.Image']], list[dict], NoneType] = None, text: str | list[str] | list[dict] | None = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/image_text_to_text.py#L215) **Параметры:** images (`str`, `list[str]`, `PIL.Image, `list[PIL.Image]`, `list[dict[str, Union[str, PIL.Image]]]`) : The pipeline handles three types of images: - A string containing a HTTP(s) link pointing to an image - A string containing a local path to an image - An image loaded in PIL directly The pipeline accepts either a single image or a batch of images. Finally, this pipeline also supports the chat format (see `text`) containing images and text in this argument. 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]] #### transformers.AnyToAnyPipeline[[transformers.AnyToAnyPipeline]] ```python transformers.AnyToAnyPipeline(*args, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/any_to_any.py#L67) **Параметры:** model ([PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel)): модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). processor ([ProcessorMixin](/docs/transformers/main/ru/main_classes/processors#transformers.ProcessorMixin)) : процессор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [ProcessorMixin](/docs/transformers/main/ru/main_classes/processors#transformers.ProcessorMixin). Процессор — это составный объект, который может содержать `tokenizer`, `feature_extractor` и `image_processor`. task (`str`, по умолчанию `""`) : Идентификатор задачи для конвейера. num_workers (`int`, *необязательный*, по умолчанию 8) : Количество рабочих процессов, используемых, когда конвейер применяет *DataLoader* (при передаче набора данных, на GPU для модели PyTorch). batch_size (`int`, *optional*, defaults to 1) : When the pipeline will use *DataLoader* (when passing a dataset, on GPU for a Pytorch model), the size of the batch to use, for inference this is not always beneficial, please read [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/ru/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *optional*) : Ссылка на объект, отвечающий за разбор переданных параметров конвейера. device (`int` или `str` или `torch.device`, *optional*) : Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (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"`, что загружает модель в том типе данных (dtype), в котором она была сохранена (читается из `config.dtype` контрольной точки, иначе выводится из весов). Передайте явное значение `torch.float16`, `torch.bfloat16`, `torch.float32`, ... для переопределения. binary_output (`bool`, *необязательный*, по умолчанию `False`) : Флаг, указывающий, должен ли вывод пайплайна быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст. Пайплайн мультимодальной генерации, использующий `AutoModelForMultimodalLM`. Этот пайплайн генерирует текст на основе любого сочетания мультимодальных данных и текста. Если базовая модель является диалоговой, пайплайн также может принимать один или несколько чатов; в этом случае он работает в режиме чата и продолжает диалог(и), добавляя свой ответ(ы). Каждый чат представляет собой список словарей, где каждый словарь содержит ключи "role" и "content". Если модель, которую вы используете, явно не задаёт эти параметры генерации в своих файлах конфигурации (`generation_config.json`), будут использованы следующие значения по умолчанию: - max_new_tokens: 256 Пример: ```python >>> 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'}] ``` ```python >>> 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_tutorial) Этот мультимодальный пайплайн в настоящее время можно загрузить с помощью pipeline(), используя следующий идентификатор задачи: "any-to-any". Список доступных моделей можно найти на [huggingface.co/models](https://huggingface.co/models?pipeline_tag=any-to-any). #### __call__[[transformers.AnyToAnyPipeline.__call__]] ```python __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] = None, videos: 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] = None, audio: typing.Union[str, list[str], numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/any_to_any.py#L258) **Параметры:** 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 Пайплайн принимает как одно аудио, так и пакет аудио. Кроме того, этот пайплайн поддерживает чат-формат (см. `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]] #### transformers.MaskGenerationPipeline[[transformers.MaskGenerationPipeline]] ```python transformers.MaskGenerationPipeline(**kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/mask_generation.py#L36) **Параметры:** model ([PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel)): модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor)) : процессор изображений, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, по умолчанию `""`) : Идентификатор задачи для конвейера. num_workers (`int`, *необязательный*, по умолчанию 8) : Количество рабочих процессов, используемых, когда конвейер применяет *DataLoader* (при передаче набора данных, на GPU для модели PyTorch). batch_size (`int`, *optional*, defaults to 1) : When the pipeline will use *DataLoader* (when passing a dataset, on GPU for a Pytorch model), the size of the batch to use, for inference this is not always beneficial, please read [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/ru/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *optional*) : Ссылка на объект, отвечающий за разбор переданных параметров конвейера. device (`int` или `str` или `torch.device`, *optional*) : Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (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"`, что загружает модель в том типе данных (dtype), в котором она была сохранена (читается из `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 к маске, чтобы оставить только релевантные. Пример: ```python >>> 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_tutorial) Этот конвейер сегментации в настоящее время можно загрузить из [pipeline()](/docs/transformers/main/ru/main_classes/pipelines#transformers.pipeline), используя следующий идентификатор задачи: `"mask-generation"`. Список доступных моделей можно найти на [huggingface.co/models](https://huggingface.co/models?filter=mask-generation). #### __call__[[transformers.MaskGenerationPipeline.__call__]] ```python __call__(image: typing.Union[str, ForwardRef('Image.Image'), list[str], list['Image.Image']], *args: Any, **kwargs: Any) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/mask_generation.py#L143) **Параметры:** image (`str`, `List[str]`, `PIL.Image` или `List[PIL.Image]`) : изображение или список изображений. mask_threshold (`float`, *optional*, по умолчанию 0.0) : Порог, используемый при преобразовании предсказанных масок в бинарные значения. pred_iou_thresh (`float`, *optional*, по умолчанию 0.88) : Порог фильтрации в диапазоне `[0,1]`, применяемый к качеству маски, предсказанной моделью. stability_score_thresh (`float`, *optional*, по умолчанию 0.95) : Порог фильтрации в диапазоне `[0,1]`, основанный на стабильности маски при изменении порога, используемого для бинаризации предсказаний маски модели. stability_score_offset (`int`, *optional*, по умолчанию 1) : Величина сдвига порога при вычислении оценки стабильности. crops_nms_thresh (`float`, *optional*, по умолчанию 0.7) : Порог IoU для ячеек, используемый в подавлении не-максимумов для фильтрации дублирующихся масок. crops_n_layers (`int`, *optional*, по умолчанию 0) : Если `crops_n_layers>0`, предсказание маски будет выполнено повторно на фрагментах изображения. Устанавливает количество слоев для выполнения, где каждый слой содержит 2**i_layer фрагментов изображения. crop_overlap_ratio (`float`, *optional*, по умолчанию `512 / 1500`) : Задаёт степень перекрытия кропов. На первом слое кропов перекрытие составляет указанную долю длины изображения. На последующих слоях с большим количеством кропов это перекрытие уменьшается. crop_n_points_downscale_factor (`int`, *optional*, по умолчанию `1`) : Количество точек на сторону, отобранных в слое n, масштабируется с коэффициентом crop_n_points_downscale_factor**n. timeout (`float`, *optional*, по умолчанию None) : Максимальное время ожидания в секундах при загрузке изображений из сети. Если значение равно None, таймаут не устанавливается, и вызов может блокироваться бесконечно. **Возвращает:** `Dict` Словарь со следующими ключами: - **mask** (`PIL.Image`) -- Двоичная маска обнаруженного объекта в виде изображения PIL с размерами `(width, height)` исходного изображения. Если объект не обнаружен, возвращается маска, заполненная нулями. - **score** (*необязательный* `float`) -- Необязательно, если модель способна оценивать уверенность в «объекте», описанном меткой и маской. Генерирует бинарные маски сегментации ## Родительский класс: `Pipeline`[[transformers.Pipeline]] #### transformers.Pipeline[[transformers.Pipeline]] ```python transformers.Pipeline(model: PreTrainedModel, tokenizer: PreTrainedTokenizer | None = None, feature_extractor: PreTrainedFeatureExtractor | None = None, image_processor: BaseImageProcessor | None = None, video_processor: BaseVideoProcessor | None = None, processor: ProcessorMixin | None = None, task: str = '', device: int | torch.device | None = None, binary_output: bool = False, **kwargs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L763) **Параметры:** model ([PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel)): модель, которая будет использоваться конвейером для выполнения предсказаний. Она должна наследоваться от [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/ru/main_classes/tokenizer#transformers.PythonBackend)) : токенизатор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [PreTrainedTokenizer](/docs/transformers/main/ru/main_classes/tokenizer#transformers.PythonBackend). feature_extractor ([SequenceFeatureExtractor](/docs/transformers/main/ru/main_classes/feature_extractor#transformers.SequenceFeatureExtractor)) : экстрактор признаков, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [SequenceFeatureExtractor](/docs/transformers/main/ru/main_classes/feature_extractor#transformers.SequenceFeatureExtractor). image_processor ([BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor)) : процессор изображений, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [BaseImageProcessor](/docs/transformers/main/ru/main_classes/image_processor#transformers.BaseImageProcessor). processor ([ProcessorMixin](/docs/transformers/main/ru/main_classes/processors#transformers.ProcessorMixin)) : процессор, который будет использоваться конвейером для кодирования данных для модели. Этот объект наследуется от [ProcessorMixin](/docs/transformers/main/ru/main_classes/processors#transformers.ProcessorMixin). Процессор — это составный объект, который может содержать `tokenizer`, `feature_extractor` и `image_processor`. task (`str`, по умолчанию `""`) : Идентификатор задачи для конвейера. num_workers (`int`, *необязательный*, по умолчанию 8) : Количество рабочих процессов, используемых, когда конвейер применяет *DataLoader* (при передаче набора данных, на GPU для модели PyTorch). batch_size (`int`, *optional*, defaults to 1) : When the pipeline will use *DataLoader* (when passing a dataset, on GPU for a Pytorch model), the size of the batch to use, for inference this is not always beneficial, please read [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/ru/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *optional*) : Ссылка на объект, отвечающий за разбор переданных параметров конвейера. device (`int` или `str` или `torch.device`, *optional*) : Устройство, на котором размещается конвейер. Если значение не задано, конвейер размещается на первом доступном ускорителе (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"`, что загружает модель в том типе данных (dtype), в котором она была сохранена (читается из `config.dtype` контрольной точки, иначе выводится из весов). Передайте явное значение `torch.float16`, `torch.bfloat16`, `torch.float32`, ... для переопределения. binary_output (`bool`, *необязательный*, по умолчанию `False`) : Флаг, указывающий, должен ли вывод пайплайна быть в сериализованном формате (например, pickle) или представлять собой исходные данные вывода, например текст. Класс Pipeline является базовым для всех конвейеров. Обращайтесь к этому классу, чтобы ознакомиться с методами, общими для различных конвейеров. Базовый класс, реализующий конвейерные операции. Рабочий процесс конвейера определяется как последовательность следующих операций: Вход -> Токенизация -> Инференс модели -> Постобработка (зависит от задачи) -> Выход Pipeline поддерживает запуск на CPU или GPU с помощью аргумента device (см. ниже). Некоторые пайплайны, например [FeatureExtractionPipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.FeatureExtractionPipeline) (`'feature-extraction'`), возвращают большие тензорные объекты в виде вложенных списков. Чтобы избежать сохранения таких крупных структур в текстовом виде, мы предоставляем аргумент конструктора `binary_output`. Если установить его в `True`, результат будет сохранён в формате pickle. #### check_model_type[[transformers.Pipeline.check_model_type]] ```python check_model_type(supported_models: list[str] | dict) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L1126) **Параметры:** supported_models (`list[str]` или `dict`) : Список моделей, поддерживаемых конвейером, или словарь со значениями классов моделей. Проверьте, поддерживается ли класс модели в конвейере. #### device_placement[[transformers.Pipeline.device_placement]] ```python device_placement() ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L1012) **Возвращаемое значение:** Менеджер контекста Контекстный менеджер, позволяющий выделять тензоры на устройстве, указанном пользователем. Примеры: ```python # 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[[transformers.Pipeline.ensure_tensor_on_device]] ```python ensure_tensor_on_device(**inputs) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L1094) **Параметры:** inputs (аргументы по имени, которые должны быть `torch.Tensor`, остальные игнорируются) : тензоры, которые нужно разместить на `self.device`. Рекурсивно для списков **только**. -- **Возвращает:** `dict[str, torch.Tensor]` То же самое, что и `inputs`, но на соответствующем устройстве. Убедитесь, что тензоры PyTorch находятся на указанном устройстве. #### postprocess[[transformers.Pipeline.postprocess]] ```python postprocess(model_outputs: ModelOutput, **postprocess_parameters: dict) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L1193) Метод Postprocess получает необработанные выходные данные метода `_forward`, как правило, тензоры, и преобразует их в более удобный формат. Обычно он возвращает список или словарь результатов (содержащий только строки и числа). #### predict[[transformers.Pipeline.predict]] ```python predict(X) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L991) Интерфейс Scikit / Keras для конвейеров transformers. Этот метод передаёт вызов в __call__(). #### preprocess[[transformers.Pipeline.preprocess]] ```python preprocess(input_: Any, **preprocess_parameters: dict) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L1172) Метод Preprocess принимает `input_` конкретного конвейера и возвращает словарь со всем необходимым для корректной работы `_forward`. Он должен содержать как минимум один тензор, но может включать и другие произвольные элементы. #### push_to_hub[[transformers.Pipeline.push_to_hub]] ```python push_to_hub(repo_id: str, commit_message: str | None = None, commit_description: str | None = None, private: bool | None = None, token: bool | str | None = None, revision: str | None = None, create_pr: bool = False, max_shard_size: int | str | None = '50GB', tags: list[str] | None = None) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/hub.py#L822) **Параметры:** repo_id (`str`) : Имя репозитория, в который вы хотите отправить свой pipe. При отправке в конкретную организацию имя должно содержать название вашей организации. commit_message (`str`, *необязательный*) : Сообщение для коммита при выполнении push. По умолчанию используется `"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. Примеры: ```python 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[[transformers.Pipeline.save_pretrained]] ```python save_pretrained(save_directory: str | os.PathLike, **kwargs: Any) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L939) **Параметры:** save_directory (`str` или `os.PathLike`) : Путь к каталогу для сохранения. Если каталог не существует, он будет создан. kwargs (`dict[str, Any]`, *необязательный*) : Дополнительные именованные аргументы, передаваемые в метод [push_to_hub()](/docs/transformers/main/ru/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub). Сохраните модель и токенизатор конвейера. #### transform[[transformers.Pipeline.transform]] ```python transform(X) ``` [Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L985) Интерфейс Scikit / Keras для конвейеров transformers. Этот метод передаёт вызов в __call__().