Hugging Face's logo

Transformers documentation

パイプライン

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

パイプライン

パイプラインは、モデルを推論に利用するための優れたかつ簡単な方法です。これらのパイプラインはオブジェクトであり、ライブラリの複雑なコードの大部分を抽象化し、タスク一覧に示されているような、Named Entity Recognition、Masked Language Modeling、Sentiment Analysis、Feature Extraction、Question Answering といった複数のタスクに特化したシンプルな API を提供します。

パイプラインの抽象化には、以下の2つのカテゴリがあります。

パイプライン抽象

pipeline 抽象は、利用可能な他のすべてのパイプラインをラップするものです。他のパイプラインと同様にインスタンス化されますが、追加の利便性をもたらすことができます。

単一アイテムに対するシンプルな呼び出し:

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

hub の特定のモデルを使用する場合、hub 上のモデルがすでにタスクを定義している場合は、タスクを無視できます。

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

多数のアイテムに対してパイプラインを呼び出すには、listを引数として渡すことができます。

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

全体を反復処理するには、datasetを直接使用することをお勧めします。これにより、一度にデータセット全体を割り当てる必要がなく、バッチ処理も自分で実装する必要がありません。GPU上では、カスタムループと同等の速度で動作するはずです。そうでない場合は、ためらわずにissueを作成してください。

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

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

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

使いやすさを考慮し、ジェネレーターも利用可能です。

from transformers import pipeline

pipe = pipeline("text-classification")


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


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

transformers.pipeline

< >

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

パラメータ

戻り値

パイプライン

タスクに適したパイプライン。

Pipelineを構築するためのユーティリティファクトリメソッドです。

パイプラインは、以下の要素で構成されています:

  • モデルの入力を前処理するための1つ以上のコンポーネント。例えば、tokenizer、image_processor、feature_extractor、またはprocessorなどです。
  • 入力から予測を生成するモデル。
  • モデルの出力を洗練するための任意の後処理ステップ。プロセッサによって処理することもできます。
While there are such optional arguments as `tokenizer`, `feature_extractor`, `image_processor`, and `processor`, they shouldn't be specified all at once. If these components are not provided, `pipeline` will try to load required ones automatically. In case you want to provide these components explicitly, please refer to a specific pipeline in order to get more details regarding what components are required.

例:

>>> from transformers import pipeline, AutoModelForTokenClassification, AutoTokenizer

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

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

Pipelineのバッチ処理

すべてのパイプラインでバッチ処理を使用できます。パイプラインがストリーミング機能を使用する場合（リストやDataset、generatorを渡す場合）には、常に動作します。

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

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

ただし、これが自動的にパフォーマンスの向上を意味するわけではありません。使用されるハードウェア、データ、および実際のモデルによって、10倍の高速化にもなり得れば、5倍の低速化にもなり得ます。

主に速度向上が見られる例:

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

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


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

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


dataset = MyDataset()

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

主にスローダウンが発生する例:

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

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

これは他の文と比較して、稀に非常に長い文です。その場合、全体のバッチは400トークンの長さになる必要があるため、バッチ全体が[64, 4]ではなく[64, 400]となり、大幅なスローダウンを引き起こします。さらに悪いことに、より大きなバッチでは、プログラムが単にクラッシュしてしまいます。

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

この問題に対する優れた（一般的な）解決策は存在せず、使用状況によって結果は異なります。目安として:

ユーザー向けの目安は以下の通りです。

  • ご自身のワークロードとハードウェアでパフォーマンスを測定してください。測定し、測定し、測定し続けましょう。実際の数値こそが唯一の道です。

  • レイテンシが制約される場合(推論を実行しているライブプロダクトなど)は、バッチ処理を行わないでください。

  • CPU を使用している場合は、バッチ処理を行わないでください。

  • スループット（大量の静的データでモデルを実行したい場合）を重視し、GPU を使用している場合は、次のようにします。

    • （「自然な」データ）のサイズが全くわからない場合は、デフォルトではバッチ処理を行わず、測定して試しに追加してみてください。また、失敗した際に復旧するための OOM チェックを追加してください（を制御しない場合、いつかは失敗します）。
    • sequence_length が非常に規則的である場合、バッチ処理が非常に有効になる可能性が高いため、OOM（メモリ不足）が発生するまで測定し、バッチサイズを押し上げてください。
    • GPUが大きいほど、バッチ処理がより重要になります

  • バッチ処理を有効にした直後には、OOM（メモリ不足）を適切に処理できることを確認してください。

Pipelineのチャンクバッチ処理

zero-shot-classification と question-answering は、単一の入力に対してモデルのフォワードパスが複数回実行される可能性がある点で、やや特殊です。通常であれば、この状況は batch_size 引数に問題を引き起こします。

この問題を回避するために、これらの2つのパイプラインはいずれもChunkPipelineであり、通常のPipelineではありません。簡単に言うと：

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

次に次のようになります:

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

パイプラインは同じ方法で使用されるため、この点はコードに対して非常に透明であるはずです。

パイプラインがバッチ処理を自動的に処理してくれるため、これは簡略化された表示です。つまり、入力によって実際に何回のフォワードパスがトリガーされるかを気にする必要はなく、batch_sizeを入力とは独立して最適化できます。前節で述べた注意点も引き続き適用されます。

Pipeline FP16 推論

モデルはFP16で実行でき、GPU上ではメモリを節約しながら大幅に高速化できる場合があります。ほとんどのモデルでは、これによる性能の低下は顕著ではありません。モデルが大きいほど、性能低下が発生する可能性は低くなります。

FP16推論を有効にするには、パイプラインのコンストラクタに dtype=torch.float16 または dtype='float16' を渡すだけです。なお、これはPyTorchバックエンドを持つモデルでのみ動作します。入力データは内部でFP16に変換されます。

Pipelineのカスタムコード

特定のpipelineをオーバーライドしたい場合は、

手元のタスクについて、ためらわずに issue を作成してください。pipeline の目標は使いやすさとほとんどのケースへのサポートであり、transformers があなたのユースケースをサポートできる可能性があります。

簡単に試したい場合は、次のようにできます：

  • 選択したパイプラインをサブクラス化
class MyPipeline(TextClassificationPipeline):
    def postprocess():
        # Your code goes here
        scores = scores * 100
        # And here


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

これにより、ご要望のすべてのカスタムコードを実行できるようになります。

パイプラインの実装

新しいパイプラインの実装

オーディオ

音声タスクで利用可能なPipelinesには、次のものがあります。

AudioClassificationPipeline

class transformers.AudioClassificationPipeline

< >

( *args**kwargs )

パラメータ

  • model (PreTrainedModel) — パイプラインが予測を行う際に使用するモデルです。PreTrainedModel を継承するモデルである必要があります。
  • feature_extractor (SequenceFeatureExtractor) — パイプラインがモデル用のデータエンコードに使用するフィーチャーエクストラクター。このオブジェクトは SequenceFeatureExtractor を継承します。
  • task (str、デフォルトは "") — パイプラインのタスク識別子です。
  • num_workers (int, 任意、デフォルトは 8) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するワーカーの数。
  • batch_size (int、任意、デフォルトは 1) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するバッチサイズです。推論では常に有益とは限らないため、パイプラインでのバッチ処理 をお読みください。
  • args_parser (ArgumentHandler、任意) — 提供されたパイプラインのパラメータを解析する責任を持つオブジェクトへの参照です。
  • device (int または str または torch.device、省略可) — パイプラインが割り当てられるデバイスです。設定しない場合、パイプラインは最初に利用可能なアクセラレータ（CUDA、MPS、XPU など）に配置され、利用可能なアクセラレータがない場合のみ CPU にフォールバックします。モデルは自動的にそこに移動されます。CPU を強制するには device="cpu"（または -1）を、特定のアクセラレータを選択するには正の ordinal または "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 のインストールが必要です。

例:

>>> 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 チュートリアルで、pipeline の基本的な使用方法について詳しく学んでください。

このパイプラインは、現在、pipeline()から、以下のタスク識別子 "audio-classification" を使用して読み込むことができます。

利用可能なモデルの一覧は、huggingface.co/models をご覧ください。

__call__

< >

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

パラメータ

  • inputs (np.ndarray または bytes または str または dict) — inputs は以下のいずれかです：
    • 音声ファイルのファイル名であるstr。ファイルは適切なサンプリングレートで読み込まれ、ffmpegを使用して波形を取得します。これには、システムにffmpegがインストールされている必要があります。
    • bytes は音声ファイルの内容であるべきであり、ffmpeg によって同じ方法で解釈されます。
    • (np.ndarray、shape (n, )、型は np.float32 または np.float64) 正しいサンプリングレートでの生オーディオ（これ以上のチェックは行われません）
    • dict形式は、任意のsampling_rateでサンプリングされた生オーディオを渡すために使用でき、リサンプリングはこのパイプラインが処理します。dictは{"sampling_rate": int, "raw": np.array}または{"sampling_rate": int, "array": np.array}の形式でなければならず、キー"raw"または"array"は生オーディオ波形を示すために使用されます。
  • top_k (int、任意、デフォルトは None)— パイプラインが返す上位ラベルの数です。指定された値が None の場合、またはモデル設定で利用可能なラベル数を超える場合は、ラベル数がデフォルト値として使用されます。
  • function_to_apply (str, 省略可能) — モデルの出力に適用する関数です。デフォルトでは、回帰問題の場合は “none”、マルチラベル分類の場合は “sigmoid”、それ以外の場合は “softmax” が使用されます。有効なオプション: [“softmax”, “sigmoid”, “none”]。初期化時または呼び出し時に明示的に指定された値は、これらのデフォルト値を上書きします。後処理を無効にするには、文字列 “none” を渡してください。

戻り値

以下のキーを持つdictのリスト

  • label (str) — 予測されたラベル。
  • score (float) — 対応する確率。

入力として与えられたシーケンスを分類します。詳細については、AutomaticSpeechRecognitionPipelineのドキュメントを参照してください。

AutomaticSpeechRecognitionPipeline

class transformers.AutomaticSpeechRecognitionPipeline

< >

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

パラメータ

  • model (PreTrainedModel) — パイプラインが予測を行う際に使用するモデルです。PreTrainedModel を継承するモデルである必要があります。
  • feature_extractor (SequenceFeatureExtractor、任意) — パイプラインがモデル用に波形をエンコードするために使用するフィーチャーエクストラクター。
  • tokenizer (PreTrainedTokenizer、任意) — パイプラインがモデル用のデータをエンコードするために使用するトークナイザーです。このオブジェクトはPreTrainedTokenizerを継承しています。
  • decoder (pyctcdecode.BeamSearchDecoderCTC、任意) — PyCTCDecode の BeamSearchDecoderCTC を渡すことで、言語モデルを活用したデコーディングを行うことができます。詳細は Wav2Vec2ProcessorWithLM を参照してください。 非推奨です。Transformers v6 で削除されます。
  • device (Union[int, torch.device], 省略可) — CPU/GPU サポート用のデバイス番号です。これを None に設定すると CPU が使用され、正の値を設定すると、対応する CUDA デバイス ID の上でモデルが実行されます。

音声に含まれる発話テキストを抽出することを目的としたPipelineです。

入力には、生の波形またはオーディオファイルのいずれかを指定できます。オーディオファイルを使用する場合は、複数のオーディオ形式をサポートするためにffmpegがインストールされている必要があります。

使用しているモデルが設定ファイル(generation_config.json)内でこれらの生成パラメータを明示的に設定していない場合、以下のデフォルト値が使用されます:

  • max_new_tokens: 256
  • num_beams: 5

例:

>>> from transformers import pipeline

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

pipeline チュートリアルで、pipeline の基本的な使用方法について詳しく学んでください。

__call__

< >

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

パラメータ

  • inputs (np.ndarray または bytes または str または dict) — inputs は次のいずれかです：
    • ローカルオーディオファイルのファイル名、またはオーディオファイルをダウンロードするためのパブリックURLアドレスであるstr。ファイルは、ffmpegを使用して適切なサンプリングレートで読み込まれ、波形を取得します。これには、システムにffmpegがインストールされている必要があります。
    • bytes は音声ファイルの内容であるべきであり、ffmpeg によって同じ方法で解釈されます。
    • (np.ndarray、shape (n, )、型は np.float32 または np.float64) 正しいサンプリングレートでの生オーディオ（これ以上のチェックは行われません）
    • dict形式を使用すると、任意のsampling_rateでサンプリングされた生オーディオを渡すことができ、リサンプリングはこのパイプラインに委ねられます。dictは{"sampling_rate": int, "raw": np.array}の形式でなければならず、オプションとして"stride": (left: int, right: int)を含めることができます。これにより、パイプラインにデコード時に最初のleftサンプルと最後のrightサンプルを無視するよう指示できます（ただし、推論時にはモデルにより多くのコンテキストを提供するために使用されます）。strideはCTCモデルでのみ使用してください。
  • return_timestamps (省略可能, str または bool) — 純粋な CTC モデル (Wav2Vec2、HuBERT など) および Whisper モデルでのみ利用可能です。その他のシーケンスツーシーケンスモデルでは利用できません。

    CTCモデルでは、タイムスタンプは2つの形式のいずれかを取ります。

    • "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モデルでは、タイムスタンプは2つの形式のいずれかを取得できます。

    • "word": 単語レベルのCTCタイムスタンプについては上記と同様です。単語レベルのタイムスタンプは、動的タイムワープ (DTW) アルゴリズムを用いて予測されます。これは、クロスアテンションの重みを検査することによる単語レベルのタイムスタンプの近似です。
    • True: パイプラインは、テキスト内の単語のセグメントについて、テキストとともにタイムスタンプを返します。 例えば、[{"text": " Hi there!", "timestamp": (0.5, 1.5)}]が返された場合、これはモデルがセグメント「Hi there!」が0.5秒以降で1.5秒以前に発話されたと予測していることを意味します。 テキストのセグメントとは、単語レベルのタイムスタンプにおける個々の単語ではなく、1語以上の単語のシーケンスを指します。
  • generate_kwargs (dict、省略可) — 生成呼び出しで使用するgenerate_configのアドホックなパラメータ設定の辞書です。generateの完全な概要については、次のガイドを参照してください。

戻り値

Dict

以下のキーを持つ辞書:

  • text (str): 認識されたテキスト。
  • chunks (optional(, list[Dict]) When using return_timestamps, the chunks will become a list containing all the various text chunks identified by the model, e.g.* [{"text": "hi ", "timestamp": (0.5, 0.9)}, {"text": "there", "timestamp": (1.0, 1.5)}]. The original full text can roughly be recovered by doing "".join(chunk["text"] for chunk in output["chunks"]).

入力として与えられた音声シーケンスをテキストに書き起こします。詳細については、AutomaticSpeechRecognitionPipelineのドキュメントを参照してください。

TextToAudioPipeline

class transformers.TextToAudioPipeline

< >

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

AutoModelForTextToWaveform または AutoModelForTextToSpectrogram を使用したテキストからオーディオを生成するパイプラインです。このパイプラインは、入力テキストおよび任意の他の条件付き入力からオーディオファイルを生成します。

使用しているモデルがgeneration_config.json内で生成パラメータを明示的に設定していない場合、generation.configuration_utils.py._get_default_generation_params()のデフォルト値が使用されます。

  • max_new_tokens: 256

例:

>>> from transformers import pipeline

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

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

pipeline チュートリアルで、pipeline の基本的な使用方法について詳しく学んでください。

TextToAudioPipeline.__call__.forward_params または TextToAudioPipeline.__call__.generate_kwargs を使用して、モデルに渡すパラメータを指定できます。

例:

>>> from transformers import pipeline

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

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

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

このパイプラインは、現在、pipeline()から、以下のタスク識別子 "text-to-speech" または "text-to-audio" を使用して読み込むことができます。

利用可能なモデルの一覧は、huggingface.co/models をご覧ください。

__call__

< >

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

パラメータ

  • text_inputs (str、list[str]、ChatType、または list[ChatType]) — 生成対象のテキストを1つ以上指定します。文字列または文字列のリストが渡された場合、このパイプラインは対応するテキストを生成します。代わりに、“role”キーと“content”キーを持つ辞書のリストという形式の“チャット”、またはそのようなチャットのリストを渡すこともできます。チャットが渡された場合、モデルに渡す前に、モデルのチャットテンプレートを使用してそれらを整形します。
  • forward_params (dict, 任意) — モデルの生成/forward メソッドに渡されるパラメータです。forward_params は常に、基盤となるモデルに渡されます。
  • generate_kwargs (dict, 任意) — 生成呼び出しで使用する generate_config のアドホックなパラメータ化の辞書です。generate の完全な概要については、以下のガイドを参照してください。 generate_kwargs は、基盤となるモデルが生成モデルである場合のみそのモデルに渡され、 forward_params より優先されます。

戻り値

AudioOutput または AudioOutput のリスト。これは2つのキーを持つ TypedDict です

  • audio (np.ndarray、形状 (nb_channels, audio_length)) — 生成されたオーディオ波形。
  • sampling_rate (int) — 生成されたオーディオ波形のサンプリングレート。

入力から音声/オーディオを生成します。詳細については、TextToAudioPipelineのドキュメントを参照してください。

ZeroShotAudioClassificationPipeline

class transformers.ZeroShotAudioClassificationPipeline

< >

( **kwargs )

パラメータ

  • model (PreTrainedModel) — パイプラインが予測を行う際に使用するモデルです。PreTrainedModel を継承するモデルである必要があります。
  • tokenizer (PreTrainedTokenizer) — パイプラインがモデル用のデータエンコードに使用するトークナイザーです。このオブジェクトはPreTrainedTokenizerを継承しています。
  • feature_extractor (SequenceFeatureExtractor) — パイプラインがモデル用のデータエンコードに使用するフィーチャーエクストラクター。このオブジェクトは SequenceFeatureExtractor を継承します。
  • task (str、デフォルトは "") — パイプラインのタスク識別子です。
  • num_workers (int, 任意、デフォルトは 8) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するワーカーの数。
  • batch_size (int、任意、デフォルトは 1) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するバッチサイズです。推論では常に有益とは限らないため、パイプラインでのバッチ処理 をお読みください。
  • args_parser (ArgumentHandler、任意) — 提供されたパイプラインのパラメータを解析する責任を持つオブジェクトへの参照です。
  • device (int または str または torch.device、省略可) — パイプラインが割り当てられるデバイスです。設定しない場合、パイプラインは最初に利用可能なアクセラレータ（CUDA、MPS、XPU など）に配置され、利用可能なアクセラレータがない場合のみ CPU にフォールバックします。モデルは自動的にそこに移動されます。CPU を強制するには device="cpu"（または -1）を、特定のアクセラレータを選択するには正の ordinal または "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 など）で行われるか、テキストなどの生データとして行われるかを指定するフラグ。

ClapModel を使用したゼロショット音声分類パイプライン。このパイプラインでは、音声とcandidate_labels のセットを指定すると、音声のクラスを予測します。

デフォルトのhypothesis_templateは"This is a sound of {}."です。ご自身の用途に合わせて更新してください。

例:

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

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

パイプラインの基本的な使い方については、パイプラインのチュートリアルを参照してください。この音声分類パイプラインは、現在、pipeline()から以下のタスク識別子 "zero-shot-audio-classification" を使用して読み込むことができます。利用可能なモデルの一覧は huggingface.co/models をご覧ください。

__call__

< >

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

パラメータ

  • audios (str, list[str], np.array または list[np.array]) — パイプラインは3種類の入力を処理します:
    • 音声へのリンクを含む文字列
    • オーディオのローカルパスを含む文字列
    • numpy に読み込まれたオーディオ
  • candidate_labels (list[str]) — この音声の候補ラベルです。hypothesis_template を使用してフォーマットされます。
  • hypothesis_template (str、任意、デフォルトは "This is a sound of {}") — 音声分類を試みる際に candidate_labels と組み合わせて使用されるフォーマットです。プレースホルダーを candidate_labels に置き換えます。

入力として渡された音声にラベルを割り当てます。

コンピュータビジョン

コンピュータビジョンタスクで利用可能なPipelinesには、以下が含まれます。

DepthEstimationPipeline

class transformers.DepthEstimationPipeline

< >

( *args**kwargs )

パラメータ

  • model (PreTrainedModel) — パイプラインが予測を行う際に使用するモデルです。PreTrainedModel を継承するモデルである必要があります。
  • image_processor (BaseImageProcessor) — パイプラインがモデル用のデータエンコードに使用する画像プロセッサです。このオブジェクトは BaseImageProcessor を継承します。
  • task (str、デフォルトは "") — パイプラインのタスク識別子です。
  • num_workers (int, 任意、デフォルトは 8) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するワーカーの数。
  • batch_size (int、任意、デフォルトは 1) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するバッチサイズです。推論では常に有益とは限らないため、パイプラインでのバッチ処理 をお読みください。
  • args_parser (ArgumentHandler、任意) — 提供されたパイプラインのパラメータを解析する責任を持つオブジェクトへの参照です。
  • device (int または str または torch.device、省略可) — パイプラインが割り当てられるデバイスです。設定しない場合、パイプラインは最初に利用可能なアクセラレータ（CUDA、MPS、XPU など）に配置され、利用可能なアクセラレータがない場合のみ CPU にフォールバックします。モデルは自動的にそこに移動されます。CPU を強制するには device="cpu"（または -1）を、特定のアクセラレータを選択するには正の ordinal または "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 を使用した深度推定パイプライン。このパイプラインは画像の深度を予測します。

例:

>>> 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 チュートリアルで、pipeline の基本的な使用方法について詳しく学んでください。

この深度推定パイプラインは、現在、pipeline()から、以下のタスク識別子 "depth-estimation" を使用して読み込むことができます。

利用可能なモデルの一覧は、huggingface.co/models をご覧ください。

__call__

< >

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

パラメータ

  • inputs (str, list[str], PIL.Image または list[PIL.Image]) — パイプラインは、以下の3種類の画像を処理します:
    • 画像を指す http リンクを含む文字列
    • 画像のローカルパスを含む文字列
    • PILで直接読み込まれた画像

    パイプラインは、単一の画像または画像のバッチを受け取ります。この場合、文字列として渡す必要があります。 バッチ内の画像はすべて同じ形式である必要があります。すべてhttpリンク、すべてローカルパス、またはすべてPIL画像である必要があります。

  • parameters (Dict, 任意) — パイプラインの動作を制御するために、引数名からパラメータ値への対応を表す辞書です。 現在利用可能なパラメータは timeout のみで、これは画像のダウンロードを試みて諦めるまでの待機時間（秒）です。
  • timeout (float、任意、デフォルトは None)— Web から画像を取得する際に待機する最大時間（秒）です。None の場合はタイムアウトが設定されず、呼び出しが永久にブロックされる可能性があります。

入力として渡された画像の深度を予測します。

ImageClassificationPipeline

class transformers.ImageClassificationPipeline

< >

( *args**kwargs )

パラメータ

  • model (PreTrainedModel) — パイプラインが予測を行う際に使用するモデルです。PreTrainedModel を継承するモデルである必要があります。
  • image_processor (BaseImageProcessor) — パイプラインがモデル用のデータエンコードに使用する画像プロセッサです。このオブジェクトは BaseImageProcessor を継承します。
  • task (str、デフォルトは "") — パイプラインのタスク識別子です。
  • num_workers (int, 任意、デフォルトは 8) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するワーカーの数。
  • batch_size (int、任意、デフォルトは 1) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するバッチサイズです。推論では常に有益とは限らないため、パイプラインでのバッチ処理 をお読みください。
  • args_parser (ArgumentHandler、任意) — 提供されたパイプラインのパラメータを解析する責任を持つオブジェクトへの参照です。
  • device (int または str または torch.device、省略可) — パイプラインが割り当てられるデバイスです。設定しない場合、パイプラインは最初に利用可能なアクセラレータ（CUDA、MPS、XPU など）に配置され、利用可能なアクセラレータがない場合のみ CPU にフォールバックします。モデルは自動的にそこに移動されます。CPU を強制するには device="cpu"（または -1）を、特定のアクセラレータを選択するには正の ordinal または "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") — モデルの出力に適用してスコアを取得するための関数。以下の4つの値を受け取ります：
    • "default": モデルが単一のラベルを持つ場合、出力にシグモイド関数を適用します。複数のラベルを持つ場合、出力にsoftmax関数を適用します。回帰タスクの場合、出力には関数を適用しません。
    • "sigmoid": 出力にシグモイド関数を適用します。
    • "softmax": 出力に softmax 関数を適用します。
    • "none": 出力にどの関数も適用しません。

AutoModelForImageClassification を使用した画像分類パイプライン。このパイプラインは画像のクラスを予測します。

例:

>>> from transformers import pipeline

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

pipeline チュートリアルで、pipeline の基本的な使用方法について詳しく学んでください。

この画像分類パイプラインは、現在、pipeline()から、以下のタスク識別子 "image-classification" を使用して読み込むことができます。

利用可能なモデルの一覧は、huggingface.co/models をご覧ください。

__call__

< >

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

パラメータ

  • inputs (str, list[str], PIL.Image または list[PIL.Image]) — パイプラインは、以下の3種類の画像を処理します:
    • 画像を指す http リンクを含む文字列
    • 画像のローカルパスを含む文字列
    • PILで直接読み込まれた画像

    パイプラインは、単一の画像または画像のバッチを受け取ります。この場合、文字列として渡す必要があります。 バッチ内の画像はすべて同じ形式である必要があります。すべてhttpリンク、すべてローカルパス、またはすべてPIL画像である必要があります。

  • function_to_apply (str, 省略可, デフォルトは "default") — スコアを取得するためにモデルの出力に適用する関数。以下の4つの値を受け取ります:

    この引数が指定されない場合、ラベルの数に応じて以下の関数が適用されます。

    • problem type が regression の場合、出力には関数を適用しません。
    • モデルが単一のラベルを持つ場合、出力にシグモイド関数を適用します。
    • モデルに複数のラベルがある場合、出力にsoftmax関数を適用します。

    可能な値は以下の通りです:

    • "sigmoid": 出力にシグモイド関数を適用します。
    • "softmax": 出力に softmax 関数を適用します。
    • "none": 出力にどの関数も適用しません。
  • top_k (int、任意、デフォルトは 5) — パイプラインが返す上位ラベルの数です。指定された数がモデル設定で利用可能なラベル数より大きい場合、ラベル数にデフォルトで設定されます。
  • timeout (float、任意、デフォルトは None)— Web から画像を取得する際に待機する最大時間（秒）です。None の場合はタイムアウトが設定されず、呼び出しが永久にブロックされる可能性があります。

入力として渡された画像にラベルを割り当てます。

ImageSegmentationPipeline

class transformers.ImageSegmentationPipeline

< >

( *args**kwargs )

パラメータ

  • model (PreTrainedModel) — パイプラインが予測を行う際に使用するモデルです。PreTrainedModel を継承するモデルである必要があります。
  • image_processor (BaseImageProcessor) — パイプラインがモデル用のデータエンコードに使用する画像プロセッサです。このオブジェクトは BaseImageProcessor を継承します。
  • task (str、デフォルトは "") — パイプラインのタスク識別子です。
  • num_workers (int, 任意、デフォルトは 8) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するワーカーの数。
  • batch_size (int、任意、デフォルトは 1) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するバッチサイズです。推論では常に有益とは限らないため、パイプラインでのバッチ処理 をお読みください。
  • args_parser (ArgumentHandler、任意) — 提供されたパイプラインのパラメータを解析する責任を持つオブジェクトへの参照です。
  • device (int または str または torch.device、省略可) — パイプラインが割り当てられるデバイスです。設定しない場合、パイプラインは最初に利用可能なアクセラレータ（CUDA、MPS、XPU など）に配置され、利用可能なアクセラレータがない場合のみ CPU にフォールバックします。モデルは自動的にそこに移動されます。CPU を強制するには device="cpu"（または -1）を、特定のアクセラレータを選択するには正の ordinal または "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 を使用した画像セグメンテーションのパイプラインです。このパイプラインは、オブジェクトのマスクとそのクラスを予測します。

例:

>>> from transformers import pipeline

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

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

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

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

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

この画像セグメンテーションのパイプラインは、現在、pipeline()から、以下のタスク識別子 "image-segmentation" を使用して読み込むことができます。

利用可能なモデルの一覧は、huggingface.co/models をご覧ください。

__call__

< >

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

パラメータ

  • inputs (str, list[str], PIL.Image または list[PIL.Image]) — パイプラインは、3 種類の画像を処理します:
    • 画像を指す HTTP(S) リンクを含む文字列
    • 画像のローカルパスを含む文字列
    • PILで直接読み込まれた画像

    パイプラインは、単一の画像または画像のバッチを受け入れます。バッチ内の画像はすべて同じ形式である必要があります。すべてHTTP(S)リンク、すべてローカルパス、またはすべてPIL画像である必要があります。

  • subtask (str, 省略可) — モデルの機能に応じて、セグメンテーションタスクを選択します。選択可能な値は [semantic, instance, panoptic] です。未設定の場合、パイプラインは以下の順序で解決を試みます: panoptic、instance、semantic。
  • threshold (float、任意、デフォルト値は 0.9)— 予測されたマスクをフィルタリングするための確率のしきい値。
  • mask_threshold (float、任意、デフォルトは 0.5) — 予測されたマスクをバイナリ値に変換する際に使用する閾値。
  • overlap_mask_area_threshold (float、任意、デフォルト値は 0.5) — 小さな断片化されたセグメントを除去するためのマスク重複の閾値です。
  • timeout (float、任意、デフォルトは None)— Web から画像を取得する際に待機する最大時間（秒）です。None の場合はタイムアウトが設定されず、呼び出しが永久にブロックされる可能性があります。

入力として渡された画像に対してセグメンテーション（マスクとクラスの検出）を実行します。

KeypointMatchingPipeline

class transformers.KeypointMatchingPipeline

< >

( *args**kwargs )

AutoModelForKeypointMatching を使用したキーポイントマッチングのパイプラインです。このパイプラインは、2つの画像間のキーポイントをマッチングします。

__call__

< >

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

パラメータ

  • inputs (str, list[str], PIL.Image または list[PIL.Image]) — パイプラインは3種類の画像を処理します:
    • 画像を指す http リンクを含む文字列
    • 画像のローカルパスを含む文字列
    • PILで直接読み込まれた画像

    pipelineは、単一の画像ペアまたは画像ペアのバッチを受け取ります。バッチを渡す場合は、文字列として渡す必要があります。 バッチ内の画像はすべて同じ形式である必要があります。すべてhttpリンク、すべてローカルパス、またはすべてPIL画像である必要があります。

  • threshold (float, 任意、デフォルトは 0.0) — キーポイントのマッチングに使用する閾値です。マッチングスコアがこの閾値を下回るキーポイントは除外されます。 0 を指定すると、マッチングされたすべてのキーポイントが返されます。
  • kwargs — timeout (float, *optional*, defaults to None) Web から画像を取得する際に待機する最大時間（秒）。None の場合はタイムアウトが設定されず、呼び出しが永久にブロックされる可能性があります。

戻り値

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

1つの画像ペアが提供された場合はマッチのリスト、画像ペアのバッチが提供された場合はマッチのリストのリストを返します。各マッチは、以下のキーを含む辞書です:

  • keypoint_image_0 (Keypoint): 最初の画像におけるキーポイント（x、y 座標）。
  • keypoint_image_1 (Keypoint): 2番目の画像におけるキーポイント（x、y座標）。
  • score (float): 2つのキーポイント間のマッチングスコア。

2つの画像間のキーポイントの一致を検出します。

ObjectDetectionPipeline

class transformers.ObjectDetectionPipeline

< >

( *args**kwargs )

パラメータ

  • model (PreTrainedModel) — パイプラインが予測を行う際に使用するモデルです。PreTrainedModel を継承するモデルである必要があります。
  • image_processor (BaseImageProcessor) — パイプラインがモデル用のデータエンコードに使用する画像プロセッサです。このオブジェクトは BaseImageProcessor を継承します。
  • task (str、デフォルトは "") — パイプラインのタスク識別子です。
  • num_workers (int, 任意、デフォルトは 8) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するワーカーの数。
  • batch_size (int、任意、デフォルトは 1) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するバッチサイズです。推論では常に有益とは限らないため、パイプラインでのバッチ処理 をお読みください。
  • args_parser (ArgumentHandler、任意) — 提供されたパイプラインのパラメータを解析する責任を持つオブジェクトへの参照です。
  • device (int または str または torch.device、省略可) — パイプラインが割り当てられるデバイスです。設定しない場合、パイプラインは最初に利用可能なアクセラレータ（CUDA、MPS、XPU など）に配置され、利用可能なアクセラレータがない場合のみ CPU にフォールバックします。モデルは自動的にそこに移動されます。CPU を強制するには device="cpu"（または -1）を、特定のアクセラレータを選択するには正の ordinal または "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 を使用したオブジェクト検出パイプラインです。このパイプラインは、オブジェクトのバウンディングボックスとそのクラスを予測します。

例:

>>> 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 チュートリアルで、pipeline の基本的な使用方法について詳しく学んでください。

このオブジェクト検出パイプラインは、現在、pipeline()から、次のタスク識別子 "object-detection" を使用して読み込むことができます。

利用可能なモデルの一覧は、huggingface.co/models をご覧ください。

__call__

< >

( *args**kwargs )

パラメータ

  • inputs (str, list[str], PIL.Image または list[PIL.Image]) — パイプラインは、3 種類の画像を処理します:
    • 画像を指す HTTP(S) リンクを含む文字列
    • 画像のローカルパスを含む文字列
    • PILで直接読み込まれた画像

    パイプラインは、単一の画像または画像のバッチを受け入れます。バッチ内の画像はすべて同じ形式である必要があります。すべてHTTP(S)リンク、すべてローカルパス、またはすべてPIL画像である必要があります。

  • threshold (float、任意、デフォルト値は 0.5) — 予測を行うために必要な確率。
  • timeout (float、任意、デフォルトは None)— Web から画像を取得する際に待機する最大時間（秒）です。None の場合はタイムアウトが設定されず、呼び出しが永久にブロックされる可能性があります。

入力として渡された画像内のオブジェクト（バウンディングボックスとクラス）を検出します。

VideoClassificationPipeline

class transformers.VideoClassificationPipeline

< >

( *args**kwargs )

パラメータ

  • model (PreTrainedModel) — パイプラインが予測を行う際に使用するモデルです。PreTrainedModel を継承するモデルである必要があります。
  • image_processor (BaseImageProcessor) — パイプラインがモデル用のデータエンコードに使用する画像プロセッサです。このオブジェクトは BaseImageProcessor を継承します。
  • video_processor (BaseVideoProcessor) — パイプラインがモデル用の動画データをエンコードするために使用する動画プロセッサです。このオブジェクトは BaseVideoProcessor を継承しています。
  • task (str、デフォルトは "") — パイプラインのタスク識別子です。
  • num_workers (int, 任意、デフォルトは 8) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するワーカーの数。
  • batch_size (int、任意、デフォルトは 1) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するバッチサイズです。推論では常に有益とは限らないため、パイプラインでのバッチ処理 をお読みください。
  • args_parser (ArgumentHandler、任意) — 提供されたパイプラインのパラメータを解析する責任を持つオブジェクトへの参照です。
  • device (int または str または torch.device、省略可) — パイプラインが割り当てられるデバイスです。設定しない場合、パイプラインは最初に利用可能なアクセラレータ（CUDA、MPS、XPU など）に配置され、利用可能なアクセラレータがない場合のみ CPU にフォールバックします。モデルは自動的にそこに移動されます。CPU を強制するには device="cpu"（または -1）を、特定のアクセラレータを選択するには正の ordinal または "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()から、以下のタスク識別子 "video-classification" を使用して読み込むことができます。

利用可能なモデルの一覧は、huggingface.co/models をご覧ください。

パイプラインは、image processor（VideoMAE、ViViT、TimeSformer などのレガシーな動画モデル）または video processor（VJEPA2 などの新しいモデル）を使用するモデルをサポートしています。両方が存在する場合は video processor が優先され、どちらも見つからない場合はパイプラインがエラーを送出します。

__call__

< >

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

パラメータ

  • inputs (str, list[str]) — このパイプラインは、3 種類の動画を処理します:
    • 動画へのリンクを含む文字列
    • ローカルの動画へのパスを含む文字列

    pipelineは、単一の動画または動画のバッチを受け取ります。この場合、文字列として渡す必要があります。 バッチ内の動画はすべて同じ形式である必要があります。すべてhttpリンクであるか、すべてローカルパスであるかのどちらかです。

  • top_k (int、任意、デフォルトは 5) — パイプラインが返す上位ラベルの数です。指定された数がモデル設定で利用可能なラベル数より大きい場合、ラベル数にデフォルトで設定されます。
  • num_frames (int、任意、デフォルトは self.model.config.num_frames) — 分類を実行するために動画からサンプリングするフレーム数です。指定しない場合、モデル設定で指定されたフレーム数がデフォルトとして使用されます。
  • frame_sampling_rate (int, 任意、デフォルトは 1) — 動画からフレームを選択するために使用するサンプリングレートです。指定しない場合、デフォルトで 1 となり、すべてのフレームが使用されます。
  • function_to_apply (str, 省略可能) — モデルの出力に適用する関数です。デフォルトでは、回帰問題の場合は “none”、マルチラベル分類の場合は “sigmoid”、それ以外の場合は “softmax” が使用されます。有効なオプション: [“softmax”, “sigmoid”, “none”]。初期化時または呼び出し時に明示的に指定された値は、これらのデフォルト値を上書きします。後処理を無効にするには、文字列 “none” を渡してください。

入力として渡された動画にラベルを割り当てます。

ZeroShotImageClassificationPipeline

class transformers.ZeroShotImageClassificationPipeline

< >

( **kwargs )

パラメータ

  • model (PreTrainedModel) — パイプラインが予測を行う際に使用するモデルです。PreTrainedModel を継承するモデルである必要があります。
  • image_processor (BaseImageProcessor) — パイプラインがモデル用のデータエンコードに使用する画像プロセッサです。このオブジェクトは BaseImageProcessor を継承します。
  • task (str、デフォルトは "") — パイプラインのタスク識別子です。
  • num_workers (int, 任意、デフォルトは 8) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するワーカーの数。
  • batch_size (int、任意、デフォルトは 1) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するバッチサイズです。推論では常に有益とは限らないため、パイプラインでのバッチ処理 をお読みください。
  • args_parser (ArgumentHandler、任意) — 提供されたパイプラインのパラメータを解析する責任を持つオブジェクトへの参照です。
  • device (int または str または torch.device、省略可) — パイプラインが割り当てられるデバイスです。設定しない場合、パイプラインは最初に利用可能なアクセラレータ（CUDA、MPS、XPU など）に配置され、利用可能なアクセラレータがない場合のみ CPU にフォールバックします。モデルは自動的にそこに移動されます。CPU を強制するには device="cpu"（または -1）を、特定のアクセラレータを選択するには正の ordinal または "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 など）で行われるか、テキストなどの生データとして行われるかを指定するフラグ。

CLIPModel を使用したゼロショット画像分類パイプライン。このパイプラインは、画像とcandidate_labelsのセットを指定すると、画像のクラスを予測します。

例:

>>> from transformers import pipeline

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

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

pipeline チュートリアルで、pipeline の基本的な使用方法について詳しく学んでください。

この画像分類パイプラインは、現在、pipeline()から、以下のタスク識別子 "zero-shot-image-classification" を使用して読み込むことができます。

利用可能なモデルの一覧は、huggingface.co/models をご覧ください。

__call__

< >

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

パラメータ

  • image (str, list[str], PIL.Image または list[PIL.Image]) — パイプラインは、以下の3種類の画像を処理します:
    • 画像を指す http リンクを含む文字列
    • 画像のローカルパスを含む文字列
    • PILで直接読み込まれた画像
  • candidate_labels (list[str]) — この画像の候補ラベルです。hypothesis_template を使用してフォーマットされます。
  • hypothesis_template (str、任意、デフォルトは "This is a photo of {}") — candidate_labels と組み合わせて画像分類を試みる際に使用される形式です。プレースホルダーを candidate_labels に置き換えます。candidate_labels がすでにフォーマット済みの場合は、”{}” を渡してください。
  • timeout (float、任意、デフォルトは None)— Web から画像を取得する際に待機する最大時間（秒）です。None の場合はタイムアウトが設定されず、呼び出しが永久にブロックされる可能性があります。

入力として渡された画像にラベルを割り当てます。

ZeroShotObjectDetectionPipeline

クラス transformers.ZeroShotObjectDetectionPipeline

< >

( **kwargs )

パラメータ

  • model (PreTrainedModel) — パイプラインが予測を行う際に使用するモデルです。PreTrainedModel を継承するモデルである必要があります。
  • image_processor (BaseImageProcessor) — パイプラインがモデル用のデータエンコードに使用する画像プロセッサです。このオブジェクトは BaseImageProcessor を継承します。
  • task (str、デフォルトは "") — パイプラインのタスク識別子です。
  • num_workers (int, 任意、デフォルトは 8) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するワーカーの数。
  • batch_size (int、任意、デフォルトは 1) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するバッチサイズです。推論では常に有益とは限らないため、パイプラインでのバッチ処理 をお読みください。
  • args_parser (ArgumentHandler、任意) — 提供されたパイプラインのパラメータを解析する責任を持つオブジェクトへの参照です。
  • device (int または str または torch.device、省略可) — パイプラインが割り当てられるデバイスです。設定しない場合、パイプラインは最初に利用可能なアクセラレータ（CUDA、MPS、XPU など）に配置され、利用可能なアクセラレータがない場合のみ CPU にフォールバックします。モデルは自動的にそこに移動されます。CPU を強制するには device="cpu"（または -1）を、特定のアクセラレータを選択するには正の ordinal または "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 など）で行われるか、テキストなどの生データとして行われるかを指定するフラグ。

OwlViTForObjectDetection を使用したゼロショット物体検出パイプラインです。画像とcandidate_labelsのセットを指定すると、このパイプラインは対象物のバウンディングボックスを予測します。

例:

>>> from transformers import pipeline

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

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

pipeline チュートリアルで、pipeline の基本的な使用方法について詳しく学んでください。

このオブジェクト検出パイプラインは、現在、pipeline()から、次のタスク識別子 "zero-shot-object-detection" を使用して読み込むことができます。

利用可能なモデルの一覧は、huggingface.co/models をご覧ください。

__call__

< >

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

パラメータ

  • image (str, PIL.Image または list[dict[str, Any]]) — パイプラインは3種類の画像を処理します:
    • 画像を指す http URL を含む文字列
    • 画像のローカルパスを含む文字列
    • PILで直接読み込まれた画像

    このパラメータを使用すると、画像のリスト、データセット、ジェネレーターを直接送信できます。

    >>> 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}&zwnj;}, {'score': 0.25, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}&zwnj;}, {'score': 0.121, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}&zwnj;}], [{'score': 0.287, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}&zwnj;}, {'score': 0.254, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}&zwnj;}, {'score': 0.121, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}&zwnj;}]]
  • candidate_labels (str または list[str] または list[list[str]]) — モデルが画像内で認識すべき対象です。
  • threshold (float, 任意、デフォルト値は 0.1) — 予測を行うために必要な確率。
  • top_k (int、任意、デフォルトは None) — パイプラインが返す上位予測の数です。指定された値がNoneであるか、利用可能な予測数より大きい場合、予測数にデフォルト設定されます。
  • timeout (float、任意、デフォルトは None)— Web から画像を取得する際に待機する最大時間（秒）です。None の場合はタイムアウトが設定されず、呼び出しが永久にブロックされる可能性があります。

入力として渡された画像内のオブジェクト（バウンディングボックスとクラス）を検出します。

自然言語処理

自然言語処理タスクで利用可能なPipelinesには、以下が含まれます。

DecisionPipeline

決定モデル、decision パイプライン、および DecisionConfig は実験的な機能です。これらの API は、非推奨化なしにいつでも変更される可能性があります。

各呼び出しは、その質問を尋ねます: リクエスト {"state": ..., "questions": ...}、または questions を持つ状態:

from transformers import pipeline

decide = pipeline("decision", model="autotrust/GEV-26B-Decide")
decide(
    {
        "state": "I was charged twice for my order and want a refund.",
        "questions": {"refund": {"type": "noul", "instructions": "Is a refund requested?"}},
    }
)

画像は System One API と同様にassetsとして提供されます。状態、指示、基準内の各プレースホルダーは、それぞれに対応する画像に置き換えられます。アセットは{"type": "image", "format": "png", "data_base64": ...}、PIL 画像、パス、または URL であり、モデルには画像を処理するプロセッサが必要です。

decide(
    {
        "state": "The customer sent photo-1 and asks if it is damaged.",
        "assets": {"photo-1": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/coco_sample.png"},
        "questions": {"damaged": {"type": "noul", "instructions": "Is the product in the photo damaged?"}},
    }
)

クラス transformers.DecisionPipeline

< >

( *argsdecision_config: transformers.decision.configuration_utils.DecisionConfig | str | None = None**kwargs )

パラメータ

  • model (PreTrainedModel) — パイプラインが予測を行う際に使用するモデルです。PreTrainedModel を継承するモデルである必要があります。
  • tokenizer (PreTrainedTokenizer) — パイプラインがモデル用のデータエンコードに使用するトークナイザーです。このオブジェクトはPreTrainedTokenizerを継承しています。
  • task (str、デフォルトは "") — パイプラインのタスク識別子です。
  • num_workers (int, 任意、デフォルトは 8) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するワーカーの数。
  • batch_size (int、任意、デフォルトは 1) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するバッチサイズです。推論では常に有益とは限らないため、パイプラインでのバッチ処理 をお読みください。
  • args_parser (ArgumentHandler、任意) — 提供されたパイプラインのパラメータを解析する責任を持つオブジェクトへの参照です。
  • device (int または str または torch.device、省略可) — パイプラインが割り当てられるデバイスです。設定しない場合、パイプラインは最初に利用可能なアクセラレータ（CUDA、MPS、XPU など）に配置され、利用可能なアクセラレータがない場合のみ CPU にフォールバックします。モデルは自動的にそこに移動されます。CPU を強制するには device="cpu"（または -1）を、特定のアクセラレータを選択するには正の ordinal または "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 など）で行われるか、テキストなどの生データとして行われるかを指定するフラグ。

決定パイプライン: state に関する、入力された形式の質問 (choice、score、noul) に、各選択肢に対する確率で応答します。これはプロンプトごとに1回のフォワードパスで実現されます (Jev 類似モデルの System One API)。決定設定 (詳細は DecisionConfig を参照) は、モデルの隣に配置するか、decision_config として指定されたリポジトリ内に配置します。決定モデル (XxxForDecision) は選択肢を自らスコアリングしますが、その他のモデルはラベルの次のトークンのロジットによってスコアリングするため、任意のチャットモデルが応答できます。

例:

>>> from transformers import pipeline

>>> decide = pipeline("decision", model="Qwen/Qwen2.5-0.5B-Instruct")
>>> answers = decide(
...     {
...         "state": "I was charged twice for my order and want a refund.",
...         "questions": {"refund": {"type": "noul", "instructions": "Is a refund requested?"}},
...     }
... )
>>> answers["refund"]["type"]
'noul'

呼び出し引数: inputs (dict、strまたはlist): {"state": ..., "questions": {name: {"type": ..., "instructions": ..., "criteria": ...}}}またはそのJSON。typeはchoice(criteriaが選択肢を説明にマッピングする)、score(criteriaがレベルを最低から順に列挙する)、またはnoul(任意のcriteriaがtrueとfalseを説明する)のいずれかです。System One APIと同様に、リクエストにassetsを含めることができます。 questions (dict、任意): リクエストのstateとして、入力に尋ねる質問です。 assets (dict、任意): プレースホルダーをキーとする画像です。state、instructions、criteriaの文字列内でプレースホルダーが出現する箇所では、モデルがその画像を確認します。画像はSystem Oneの資産({"type": "image", "format": "png", "data_base64": ...})、PIL画像、パス、またはURLです。画像を処理できるプロセッサを持つモデルが必要です。

dict（またはdictのリスト）を返します。System One の形式で、質問名をキーとする回答です。

__call__

< >

( inputs*argsnum_workers = Nonebatch_size = None**kwargs )

クラス transformers.DecisionConfig

< >

( labels: dict[str, list[str]] = <factory>temperature: dict[str, float | int] = <factory>chat_template: str | None = Nonenoul_options: list[str] = <factory>sanitize_control_tokens: bool = Trueadapter: str | None = None )

パラメータ

  • labels (dict[str, list[str]], 任意) — 各問題タイプごとの選択肢の単一トークンラベル。logits からそれを読み取るヘッド用です。デフォルトでは、noul の場合は Yes/No、それ以外の場合は A、B、C、… となります。
  • temperature (dict[str, float]、省略可) — 質問タイプごとの温度。softmax の前に選択肢のスコアに適用されます。デフォルト値は 1 です。
  • chat_template (str, 省略可) — question（1つの質問ごとに1つのプロンプト）または questions（すべての質問を1つのプロンプトにまとめる）で state をレンダリングする Jinja テンプレートです。デフォルトでは、トークナイザーのチャットテンプレートにある汎用的なプロンプトが使用されます。
  • noul_options (list[str]、任意、デフォルトは ["true", "false"]) — noul 質問の2つの選択肢がテンプレートに渡される順序。
  • sanitize_control_tokens (bool、省略可能、デフォルトはTrue) — リクエスト内の制御トークンをテキストとしてエンコードするかどうか。それ自体でエスケープ処理を行うテンプレートは、元のコードの input ids を保持するためにこれを無効にします。
  • adapter (str, 省略可能) — モデルにロードする LoRA のサブフォルダ。ルートに配置されていないリポジトリ用です。

decision.json として保存される決定モデルの設定（そのチャットテンプレートは decision_template.jinja として保存されます）。

get_logits_processor

< >

( question_type: str )

question_type 型の質問の選択肢スコアに適用される LogitsProcessorList。

prepare_inputs

< >

( requestprocessor )

request の各プロンプトのトークン化された(inputs, questions)。詳細はprepare_inputs()を参照してください。

validate

< >

( )

インスタンスに対してクラスバリデータを実行します。

FillMaskPipeline

class transformers.FillMaskPipeline

< >

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

パラメータ

  • model (PreTrainedModel) — パイプラインが予測を行う際に使用するモデルです。PreTrainedModel を継承するモデルである必要があります。
  • tokenizer (PreTrainedTokenizer) — パイプラインがモデル用のデータエンコードに使用するトークナイザーです。このオブジェクトはPreTrainedTokenizerを継承しています。
  • task (str、デフォルトは "") — パイプラインのタスク識別子です。
  • num_workers (int, 任意、デフォルトは 8) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するワーカーの数。
  • batch_size (int、任意、デフォルトは 1) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するバッチサイズです。推論では常に有益とは限らないため、パイプラインでのバッチ処理 をお読みください。
  • args_parser (ArgumentHandler、任意) — 提供されたパイプラインのパラメータを解析する責任を持つオブジェクトへの参照です。
  • device (int または str または torch.device、省略可) — パイプラインが割り当てられるデバイスです。設定しない場合、パイプラインは最初に利用可能なアクセラレータ（CUDA、MPS、XPU など）に配置され、利用可能なアクセラレータがない場合のみ CPU にフォールバックします。モデルは自動的にそこに移動されます。CPU を強制するには device="cpu"（または -1）を、特定のアクセラレータを選択するには正の ordinal または "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]、省略可) — 指定された場合、モデルは vocab 全体を参照するのではなく、渡された targets に限定してスコアを計算します。提供された targets がモデルの vocab に存在しない場合は、それらがトークン化され、結果として得られた最初のトークンが使用されます（警告が表示され、処理が遅くなる可能性があります）。
  • tokenizer_kwargs (dict、省略可) — tokenizer に渡す追加のキーワード引数の辞書。

__call__

< >

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

パラメータ

  • inputs (str または list[str]) — マスクされたトークンを含む1つ以上のテキスト(またはプロンプトのリスト1つ)。
  • targets (str または list[str]、省略可) — 指定された場合、モデルは vocab 全体を参照するのではなく、指定された targets にスコアを限定します。提供された targets がモデルの vocab に存在しない場合は、それらがトークン化され、得られた最初のトークンが使用されます（警告が表示され、処理が遅くなる可能性があります）。
  • top_k (int、省略可) — 指定された場合、返す予測の数を上書きします。

戻り値

dict のリスト、または dict のリストのリスト

各結果は、以下のキーを持つ辞書のリストとして返されます。

  • sequence (str) — マスクトークンの予測を含む対応する入力。
  • score (float) — 対応する確率。
  • token (int) — 予測されたトークン ID（マスクされたトークンを置き換えるもの）。
  • token_str (str) — 予測されたトークン（マスクされたトークンを置き換えるもの）。

入力として与えられたテキスト内のマスクされたトークンを埋めてください。

TableQuestionAnsweringPipeline

class transformers.TableQuestionAnsweringPipeline

< >

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

パラメータ

  • model (PreTrainedModel) — パイプラインが予測を行う際に使用するモデルです。PreTrainedModel を継承するモデルである必要があります。
  • tokenizer (PreTrainedTokenizer) — パイプラインがモデル用のデータエンコードに使用するトークナイザーです。このオブジェクトはPreTrainedTokenizerを継承しています。
  • task (str、デフォルトは "") — パイプラインのタスク識別子です。
  • num_workers (int, 任意、デフォルトは 8) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するワーカーの数。
  • batch_size (int、任意、デフォルトは 1) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するバッチサイズです。推論では常に有益とは限らないため、パイプラインでのバッチ処理 をお読みください。
  • args_parser (ArgumentHandler、任意) — 提供されたパイプラインのパラメータを解析する責任を持つオブジェクトへの参照です。
  • device (int または str または torch.device、省略可) — パイプラインが割り当てられるデバイスです。設定しない場合、パイプラインは最初に利用可能なアクセラレータ（CUDA、MPS、XPU など）に配置され、利用可能なアクセラレータがない場合のみ CPU にフォールバックします。モデルは自動的にそこに移動されます。CPU を強制するには device="cpu"（または -1）を、特定のアクセラレータを選択するには正の ordinal または "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 など）で行われるか、テキストなどの生データとして行われるかを指定するフラグ。

ModelForTableQuestionAnswering を使用した Table Question Answering パイプラインです。このパイプラインは PyTorch のみで利用可能です。

使用しているモデルが設定ファイル(generation_config.json)内でこれらの生成パラメータを明示的に設定していない場合、以下のデフォルト値が使用されます:

  • max_new_tokens: 256

例:

>>> from transformers import pipeline

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

pipeline チュートリアルで、pipeline の基本的な使用方法について詳しく学んでください。

この表形式の質問応答パイプラインは、現在、次のタスク識別子 "table-question-answering" を使用して pipeline() から読み込むことができます。

このパイプラインで使用できるモデルは、表形式の質問応答タスクでファインチューニングされたモデルです。 利用可能なモデルの最新リストは、huggingface.co/modelsでご覧いただけます。

__call__

< >

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

パラメータ

  • table (pd.DataFrame または Dict) — テーブルのすべての値を含む DataFrame に変換される Pandas DataFrame または辞書です。辞書の例については上記を参照してください。
  • query (str または list[str]) — テーブルとともにモデルに送信されるクエリ、またはクエリのリスト。
  • sequential (bool、省略可能、デフォルトはFalse) — 推論をシーケンシャルに行うか、バッチとして行うかを指定します。バッチ処理の方が高速ですが、SQAのようなモデルは、対話的な性質上、シーケンス内の関係を抽出するために推論をシーケンシャルで行う必要があります。
  • padding (bool, str または PaddingStrategy, 省略可, デフォルトは False) — パディングの有効化と制御を行います。以下の値を受け入れます:
    • Trueまたは'longest': バッチ内の最長のシーケンスの長さにパディングします（単一のシーケンスのみが提供された場合は、パディングを行いません）。
    • 'max_length': 引数 max_length で指定された最大長、またはその引数が指定されていない場合はモデルが受け入れ可能な最大入力長までパディングします。
    • False または 'do_not_pad'（デフォルト）：パディングを行いません（つまり、長さが異なるシーケンスのバッチを出力できます）。
  • truncation (bool, str または TapasTruncationStrategy, 省略可, デフォルトは False) — 切り詰めを有効にし、制御します。以下の値を受け入れます:
    • True または 'drop_rows_to_fit': 引数 max_length で指定された最大長、またはその引数が指定されていない場合はモデルが受け入れられる最大入力長まで切り詰めます。これにより、テーブルから行単位で切り詰め、行を削除します。
    • False または 'do_not_truncate'（デフォルト）: トランケーションを行いません（つまり、モデルが許容する最大入力サイズを超えるシーケンス長を持つバッチを出力する可能性があります）。

戻り値

結果を含む辞書または辞書のリスト

各結果は、以下のキーを持つ辞書です。

  • answer (str) — テーブルを前提としたクエリに対する回答です。アグリゲーターがある場合、回答の先頭にAGGREGATOR >が付与されます。
  • coordinates (list[tuple[int, int]]) — 回答のセルの座標。
  • cells (list[str]) — 回答セルの値で構成された文字列のリスト。
  • aggregator (str) — モデルにaggregatorがある場合、そのaggregatorを返します。

テーブルに基づいてクエリに回答します。このパイプラインは、以下に詳述する複数のタイプの入力を接受します。

  • 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 引数には、テーブル全体を含む dict またはそこから構築された DataFrame を指定します:

例:

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

この辞書はそのまま渡すことも、pandas の DataFrame に変換することもできます。

例:

import pandas as pd

table = pd.DataFrame.from_dict(data)

TextClassificationPipeline

class transformers.TextClassificationPipeline

< >

( **kwargs )

パラメータ

  • model (PreTrainedModel) — パイプラインが予測を行う際に使用するモデルです。PreTrainedModel を継承するモデルである必要があります。
  • tokenizer (PreTrainedTokenizer) — パイプラインがモデル用のデータエンコードに使用するトークナイザーです。このオブジェクトはPreTrainedTokenizerを継承しています。
  • task (str、デフォルトは "") — パイプラインのタスク識別子です。
  • num_workers (int, 任意、デフォルトは 8) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するワーカーの数。
  • batch_size (int、任意、デフォルトは 1) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するバッチサイズです。推論では常に有益とは限らないため、パイプラインでのバッチ処理 をお読みください。
  • args_parser (ArgumentHandler、任意) — 提供されたパイプラインのパラメータを解析する責任を持つオブジェクトへの参照です。
  • device (int または str または torch.device、省略可) — パイプラインが割り当てられるデバイスです。設定しない場合、パイプラインは最初に利用可能なアクセラレータ（CUDA、MPS、XPU など）に配置され、利用可能なアクセラレータがない場合のみ CPU にフォールバックします。モデルは自動的にそこに移動されます。CPU を強制するには device="cpu"（または -1）を、特定のアクセラレータを選択するには正の ordinal または "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") — モデルの出力に適用してスコアを取得するための関数。以下の4つの値を受け取ります：
    • "default": モデルが単一のラベルを持つ場合、出力にシグモイド関数を適用します。複数のラベルを持つ場合、出力にsoftmax関数を適用します。回帰タスクの場合、出力には関数を適用しません。
    • "sigmoid": 出力にシグモイド関数を適用します。
    • "softmax": 出力に softmax 関数を適用します。
    • "none": 出力にどの関数も適用しません。

ModelForSequenceClassification を使用したテキスト分類パイプラインです。詳細については、シーケンス分類の例を参照してください。

例:

>>> from transformers import pipeline

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

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

pipeline チュートリアルで、pipeline の基本的な使用方法について詳しく学んでください。

このテキスト分類パイプラインは、現在、pipeline()から、以下のタスク識別子 "sentiment-analysis" を使用して読み込むことができます（ポジティブまたはネガティブの感情に基づいてシーケンスを分類する場合）。

複数の分類ラベルが利用可能な場合（model.config.num_labels >= 2）、pipeline は結果に対して softmax を実行します。ラベルが1つのみの場合、pipeline は結果に対して sigmoid を実行します。回帰タスクの場合（model.config.problem_type == "regression"）、出力には関数を適用しません。

このパイプラインで使用できるモデルは、シーケンス分類タスクでファインチューニングされたモデルです。利用可能なモデルの最新リストは、huggingface.co/modelsを参照してください。

__call__

< >

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

パラメータ

  • inputs (str または list[str] または dict[str]、または list[dict[str]]) — 分類対象のテキストを1つ以上指定します。テキストのペアを分類に使用するには、{"text", "text_pair"} キーを含む辞書、またはそのリストを渡すことができます。
  • top_k (int、任意、デフォルトは1) — 返す結果の数を指定します。
  • function_to_apply (str, 省略可, デフォルトは "default") — スコアを取得するためにモデルの出力に適用する関数。以下の4つの値を受け取ります:

    この引数が指定されない場合、ラベルの数に応じて以下の関数が適用されます。

    • problem type が regression の場合、出力には関数を適用しません。
    • モデルが単一のラベルを持つ場合、出力にシグモイド関数を適用します。
    • モデルに複数のラベルがある場合、出力にsoftmax関数を適用します。

    可能な値は以下の通りです:

    • "sigmoid": 出力にシグモイド関数を適用します。
    • "softmax": 出力に softmax 関数を適用します。
    • "none": 出力にどの関数も適用しません。

戻り値

dictのリスト

各結果は、以下のキーを持つ辞書のリストとして返されます。

  • label (str) — 予測されたラベル。
  • score (float) — 対応する確率。

top_kが使用されている場合、ラベルごとに1つの辞書が返されます。

入力として与えられたテキストを分類します。

TextGenerationPipeline

class transformers.TextGenerationPipeline

< >

( *args**kwargs )

パラメータ

  • model (PreTrainedModel) — パイプラインが予測を行う際に使用するモデルです。PreTrainedModel を継承するモデルである必要があります。
  • tokenizer (PreTrainedTokenizer) — パイプラインがモデル用のデータエンコードに使用するトークナイザーです。このオブジェクトはPreTrainedTokenizerを継承しています。
  • task (str、デフォルトは "") — パイプラインのタスク識別子です。
  • num_workers (int, 任意、デフォルトは 8) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するワーカーの数。
  • batch_size (int、任意、デフォルトは 1) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するバッチサイズです。推論では常に有益とは限らないため、パイプラインでのバッチ処理 をお読みください。
  • args_parser (ArgumentHandler、任意) — 提供されたパイプラインのパラメータを解析する責任を持つオブジェクトへの参照です。
  • device (int または str または torch.device、省略可) — パイプラインが割り当てられるデバイスです。設定しない場合、パイプラインは最初に利用可能なアクセラレータ（CUDA、MPS、XPU など）に配置され、利用可能なアクセラレータがない場合のみ CPU にフォールバックします。モデルは自動的にそこに移動されます。CPU を強制するには device="cpu"（または -1）を、特定のアクセラレータを選択するには正の ordinal または "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 を使用した言語生成パイプラインです。このパイプラインは、指定されたテキストプロンプトに続く単語を予測します。基盤となるモデルが会話モデルの場合、1 つ以上のチャットを受け入れることもでき、その場合、パイプラインはチャットモードで動作し、応答を追加してチャットを続行します。各チャットは辞書のリストの形式を持ち、各辞書には “role” と “content” というキーが含まれます。

使用しているモデルが設定ファイル(generation_config.json)内でこれらの生成パラメータを明示的に設定していない場合、以下のデフォルト値が使用されます:

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

例:

>>> from transformers import pipeline

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

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

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

pipeline チュートリアルで、pipeline の基本的な使用方法について詳しく学んでください。この pipeline にはテキスト生成パラメータを渡すことができ、停止条件やデコーディング戦略などを制御できます。テキスト生成パラメータについては、Text generation strategiesおよびText generationを参照してください。

この言語生成パイプラインは、現在、pipeline()から、以下のタスク識別子 "text-generation" を使用して読み込むことができます。

このパイプラインで使用できるモデルは、自己回帰型言語モデリングの目的で学習されたモデルです。利用可能なテキスト補完モデルのリストと、会話モデルのリストは、[huggingface.co/models] で確認できます。

__call__

< >

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

パラメータ

  • text_inputs (str、list[str]、ChatType、または list[ChatType]) — 補完する 1 つ以上のプロンプト（またはプロンプトのリスト 1 つ）です。文字列または文字列のリストが渡された場合、このパイプラインは各プロンプトを補完します。代わりに、「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) — 入力チャットの最後のメッセージを新しいメッセージとして開始するのではなく、その続きを生成することをモデルに指示します。これにより、応答を「プリフィル」できます。デフォルトでは、入力チャットの最後のメッセージがassistantロールの場合にTrue、それ以外の場合にFalseとなりますが、このフラグを設定することでこの動作を手動で上書きできます。
  • prefix (str、省略可) — プロンプトに追加されるプレフィックス。
  • stop_sequence (str または list[str]、省略可) — 生成が停止される1つ以上の文字列です。停止文字列は出力に含まれます。
  • handle_long_generation (str, 省略可能) — デフォルトでは、このパイプラインは長い生成（モデルの最大長を超えるもの）を処理しません。これに対処する完璧な方法はありません（詳細はhttps://github.com/huggingface/transformers/issues/14033#issuecomment-948385227). ）。使用ケースに応じて、この問題を回避するための一般的な戦略を提供します。
    • None : 特に何も行われないデフォルトの戦略
    • "hole": 入力の左側を切り詰め、生成が行えるほど広い隙間を残します（プロンプトの大部分が切り詰められる可能性があるため、生成がモデルの容量を超える場合には適していません）
  • tokenizer_encode_kwargs (dict, 省略可) — トークナイザーのエンコード処理に渡す追加のキーワード引数です。テキスト入力がチャットの場合、apply_chat_template に渡されます。それ以外の場合、__call__ に渡されます。
  • generate_kwargs (dict, 任意) — モデルの generate メソッドに渡す追加のキーワード引数（generate メソッドの詳細はこちらを参照）。

戻り値

dict のリスト、または dict のリストのリスト

次のいずれかの辞書を返します（generated_textとgenerated_token_idsの両方を同時に返すことはできません）：

  • generated_text (str、return_text=True の場合のみ存在) — 生成されたテキスト。
  • generated_token_ids (torch.Tensor、return_tensors=True の場合に存在) — 生成されたテキストのトークン ID です。

入力として与えられたプロンプトを補完します。

TokenClassificationPipeline

class transformers.TokenClassificationPipeline

< >

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

パラメータ

  • model (PreTrainedModel) — パイプラインが予測を行う際に使用するモデルです。PreTrainedModel を継承するモデルである必要があります。
  • tokenizer (PreTrainedTokenizer) — パイプラインがモデル用のデータエンコードに使用するトークナイザーです。このオブジェクトはPreTrainedTokenizerを継承しています。
  • task (str、デフォルトは "") — パイプラインのタスク識別子です。
  • num_workers (int, 任意、デフォルトは 8) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するワーカーの数。
  • batch_size (int、任意、デフォルトは 1) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するバッチサイズです。推論では常に有益とは限らないため、パイプラインでのバッチ処理 をお読みください。
  • args_parser (ArgumentHandler、任意) — 提供されたパイプラインのパラメータを解析する責任を持つオブジェクトへの参照です。
  • device (int または str または torch.device、省略可) — パイプラインが割り当てられるデバイスです。設定しない場合、パイプラインは最初に利用可能なアクセラレータ（CUDA、MPS、XPU など）に配置され、利用可能なアクセラレータがない場合のみ CPU にフォールバックします。モデルは自動的にそこに移動されます。CPU を強制するには device="cpu"（または -1）を、特定のアクセラレータを選択するには正の ordinal または "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, 省略可) — stride が指定されている場合、パイプラインはテキスト全体に適用されます。テキストは model_max_length のサイズでチャンクに分割されます。fast tokenizer と、NONE 以外の aggregation_strategy の組み合わせでのみ動作します。この引数の値は、チャンク間の重複トークン数を定義します。言い換えれば、モデルは各ステップで 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”}] になります。連続する 2 つの B タグは異なるエンティティとして扱われることに注意してください。単語ベースの言語では、望ましくない形で単語が分割される可能性があります。例えば、Microsoft が [{“word”: “Micro”, “entity”: “ENTERPRISE”}, {“word”: “soft”, “entity”: “NAME”}] とタグ付けされるようなケースです。FIRST、MAX、AVERAGE を使用して、その問題を緩和し、単語の曖昧さを解消できます（スペースで区切られたトークンという意味を持つ言語、つまり基本的にスペースで単語が区切られている言語でのみ有効です）。これらの緩和策は実際の単語に対してのみ機能し、“New york” のように 2 つの異なるエンティティでタグ付けされる場合があります。
    • “first” : (単語ベースのモデルでのみ動作) SIMPLE戦略を使用しますが、単語が異なるタグで終わることはありません。曖昧な場合は、単語は単にその単語の最初のトークンのタグを使用します。
    • “average” : (word based models のみ動作) SIMPLE戦略を使用しますが、単語が異なるタグを持つことはありません。スコアはまずトークン間で平均化され、その後、最大ラベルが適用されます。
    • “max” : (単語ベースのモデルでのみ動作) SIMPLE戦略を使用しますが、単語が異なるタグで終わることはありません。単語エンティティは、スコアが最大であるトークンになります。

ModelForTokenClassification を使用した Named Entity Recognition パイプラインです。詳細については、named entity recognition の例を参照してください。

例:

>>> 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 チュートリアルで、pipeline の基本的な使用方法について詳しく学んでください。

このトークン認識パイプラインは、現在、pipeline()から、以下のタスク識別子 "ner" を使用して読み込むことができます（シーケンス内のトークンのクラスを予測します：人物、組織、場所、その他）。

このパイプラインで使用できるモデルは、トークン分類タスクでファインチューニングされたモデルです。利用可能なモデルの最新リストは、huggingface.co/modelsを参照してください。

__call__

< >

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

パラメータ

  • inputs (str または List[str]) — トークン分類用のテキストを1つ以上（またはテキストのリストを1つ）指定します。is_split_into_words=True の場合、事前トークン化済みのテキストを指定できます。

戻り値

dict のリスト、または dict のリストのリスト

各結果は辞書のリストとして返されます（対応する入力内の各トークンごと、またはこのパイプラインがaggregation_strategyでインスタンス化された場合は各エンティティごと）。 各辞書には、以下のキーが含まれます。

  • word (str) — 分類されたトークン/単語です。これは選択されたトークンをデコードすることで得られます。元の文における正確な文字列を取得したい場合は、start と end を使用してください。
  • score (float) — entity に対応する確率。
  • entity (str) — そのトークン/単語に対して予測されたエンティティ（aggregation_strategyが"none"でない場合は、entity_groupと呼ばれます）。
  • index (int、aggregation_strategy="none" の場合のみ存在) — 文内の対応するトークンのインデックス。
  • start (int, optional) — 文内の対応するエンティティの開始位置のインデックスです。トークナイザー内でオフセットが利用可能な場合のみ存在します。
  • end (int, 任意) — 文内の対応するエンティティの終了位置のインデックスです。トークナイザー内でオフセットが利用可能な場合のみ存在します。

入力として与えられたテキストの各トークンを分類します。

aggregate_words

< >

( entities: list[dict]aggregation_strategy: AggregationStrategy )

単語境界での一致を強制するために、一致しない指定された単語のトークンを上書きします。

例: micro|soft| com|pany| B-ENT I-NAME I-ENT I-ENT は、最初の戦略によって micro|soft| com|pany| B-ENT I-ENT に書き換えられます。

gather_pre_entities

< >

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

numpy配列を融合し、集計に必要なすべての情報を含む辞書に変換します

group_entities

< >

( entities: list[dict] )

パラメータ

  • entities (dict) — パイプラインによって予測されたエンティティ。

予測されたエンティティが同じである隣接するトークンを特定し、グループ化します。

group_sub_entities

< >

( entities: list[dict] )

パラメータ

  • entities (dict) — パイプラインによって予測されたエンティティ。

予測されたエンティティが同じである隣接するトークンをグループ化します。

ZeroShotClassificationPipeline

class transformers.ZeroShotClassificationPipeline

< >

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

パラメータ

  • model (PreTrainedModel) — パイプラインが予測を行う際に使用するモデルです。PreTrainedModel を継承するモデルである必要があります。
  • tokenizer (PreTrainedTokenizer) — パイプラインがモデル用のデータエンコードに使用するトークナイザーです。このオブジェクトはPreTrainedTokenizerを継承しています。
  • task (str、デフォルトは "") — パイプラインのタスク識別子です。
  • num_workers (int, 任意、デフォルトは 8) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するワーカーの数。
  • batch_size (int、任意、デフォルトは 1) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するバッチサイズです。推論では常に有益とは限らないため、パイプラインでのバッチ処理 をお読みください。
  • args_parser (ArgumentHandler、任意) — 提供されたパイプラインのパラメータを解析する責任を持つオブジェクトへの参照です。
  • device (int または str または torch.device、省略可) — パイプラインが割り当てられるデバイスです。設定しない場合、パイプラインは最初に利用可能なアクセラレータ（CUDA、MPS、XPU など）に配置され、利用可能なアクセラレータがない場合のみ CPU にフォールバックします。モデルは自動的にそこに移動されます。CPU を強制するには device="cpu"（または -1）を、特定のアクセラレータを選択するには正の ordinal または "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のlogitが、候補ラベルが有効であることのlogitとして採用されます。NLIモデルは任意のものを使用できますが、モデルのconfigに:attr:~transformers.PreTrainedConfig.label2idにentailmentラベルのidが含まれている必要があります。

例:

>>> 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 チュートリアルで、pipeline の基本的な使用方法について詳しく学んでください。

この NLI パイプラインは、現在、pipeline() から、次のタスク識別子 "zero-shot-classification" を使用して読み込むことができます。

このパイプラインで使用できるモデルは、NLIタスクでファインチューニングされたモデルです。利用可能なモデルの最新リストは、huggingface.co/modelsでご覧いただけます。

__call__

< >

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

パラメータ

  • sequences (str または list[str]) — 分類対象のシーケンスです。モデルの入力が大きすぎる場合は切り詰められます。
  • candidate_labels (str または list[str]) — 各シーケンスを分類するための候補となるクラスラベルの集合です。単一のラベル、カンマ区切りのラベル文字列、またはラベルのリストを指定できます。
  • hypothesis_template (str、任意、デフォルトは "This example is {}.") — 各ラベルを NLI スタイルの仮説に変換するために使用されるテンプレートです。このテンプレートには、候補ラベルを挿入するための {} または同様の構文を含める必要があります。例えば、デフォルトのテンプレートは "This example is {}." です。候補ラベルが "sports" の場合、モデルには "<cls> sequence to classify <sep> This example is sports . <sep>" のように入力されます。デフォルトのテンプレートは多くのケースで機能しますが、タスクの状況に応じて異なるテンプレートを試す価値がある場合があります。
  • multi_label (bool、任意、デフォルトは False) — 複数の候補ラベルが同時に真になり得るかどうかを指定します。False の場合、各シーケンスにおけるラベルの尤度の合計が 1 になるようにスコアが正規化されます。True の場合、ラベルは独立であるとみなされ、エンタイルメントスコアとコントラディクションスコアに対して softmax を適用することで、各候補ごとに確率が正規化されます。

戻り値

dictまたはdictのリスト

各結果は、以下のキーを持つ辞書として返されます。

  • sequence (str) — この出力が対応するシーケンス。
  • labels (list[str]) — 可能性の高い順にソートされたラベル。
  • scores (list[float]) — 各ラベルの確率。

入力として与えられたシーケンスを分類します。詳細については、ZeroShotClassificationPipelineのドキュメントを参照してください。

マルチモーダル

マルチモーダルタスクで利用可能なパイプラインには、次のものがあります。

DocumentQuestionAnsweringPipeline

class transformers.DocumentQuestionAnsweringPipeline

< >

( *args**kwargs )

パラメータ

  • model (PreTrainedModel) — パイプラインが予測を行う際に使用するモデルです。PreTrainedModel を継承するモデルである必要があります。
  • tokenizer (PreTrainedTokenizer) — パイプラインがモデル用のデータエンコードに使用するトークナイザーです。このオブジェクトはPreTrainedTokenizerを継承しています。
  • image_processor (BaseImageProcessor) — パイプラインがモデル用のデータエンコードに使用する画像プロセッサです。このオブジェクトは BaseImageProcessor を継承します。
  • task (str、デフォルトは "") — パイプラインのタスク識別子です。
  • num_workers (int, 任意、デフォルトは 8) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するワーカーの数。
  • batch_size (int、任意、デフォルトは 1) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するバッチサイズです。推論では常に有益とは限らないため、パイプラインでのバッチ処理 をお読みください。
  • args_parser (ArgumentHandler、任意) — 提供されたパイプラインのパラメータを解析する責任を持つオブジェクトへの参照です。
  • device (int または str または torch.device、省略可) — パイプラインが割り当てられるデバイスです。設定しない場合、パイプラインは最初に利用可能なアクセラレータ（CUDA、MPS、XPU など）に配置され、利用可能なアクセラレータがない場合のみ CPU にフォールバックします。モデルは自動的にそこに移動されます。CPU を強制するには device="cpu"（または -1）を、特定のアクセラレータを選択するには正の ordinal または "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 など）で行われるか、テキストなどの生データとして行われるかを指定するフラグ。

AutoModelForDocumentQuestionAnswering を使用した Document Question Answering パイプラインです。入力/出力は（抽出型）質問応答パイプラインと似ていますが、テキストコンテキストの代わりに画像（および任意の OCR 済み単語/ボックス）を入力として受け取ります。

使用しているモデルが設定ファイル(generation_config.json)内でこれらの生成パラメータを明示的に設定していない場合、以下のデフォルト値が使用されます:

  • max_new_tokens: 256

例:

>>> from transformers import pipeline

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

pipeline チュートリアルで、pipeline の基本的な使用方法について詳しく学んでください。

このドキュメント質問応答パイプラインは、現在、pipeline()から、以下のタスク識別子 "document-question-answering" を使用して読み込むことができます。

このパイプラインで使用できるモデルは、文書質問応答タスクでファインチューニングされたモデルです。利用可能なモデルの最新リストは、huggingface.co/modelsでご覧いただけます。

__call__

< >

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

パラメータ

  • image (str または PIL.Image) — パイプラインは、以下の3種類の画像を処理します:
    • 画像を指す http リンクを含む文字列
    • 画像のローカルパスを含む文字列
    • PILで直接読み込まれた画像

    パイプラインは、単一の画像または画像のバッチを受け取ります。単一の画像が与えられた場合、複数の質問にブロードキャストできます。

  • question (str) — ドキュメントに対して質問する内容です。
  • word_boxes (list[str, tuple[float, float, float, float]], 任意) — 単語とバウンディングボックス（正規化済み 0->1000）のリストです。この任意の入力を指定すると、パイプラインは画像に対して OCR を実行してそれらを導出する代わりに、これらの単語とボックスを使用します（それらを必要とするモデル、例えば LayoutLM など）。これにより、パイプラインを毎回再実行することなく、OCR の結果をパイプラインの多数の呼び出しに再利用できます。
  • top_k (int、任意、デフォルトは 1) — 返す回答の数（確率の高い順に選択されます）。コンテキスト内に十分な選択肢がない場合は、top_k より少ない数の回答が返されます。
  • doc_stride (int、任意、デフォルトは 128) — ドキュメント内の単語が長すぎて、モデルの質問と合わせて収まらない場合は、ある程度の重複を伴って複数のチャンクに分割されます。この引数は、その重複のサイズを制御します。
  • max_answer_len (int、任意、デフォルト値は 15) — 予測された回答の最大長（例：この長さより短い回答のみが対象とされる）。
  • max_seq_len (int、任意、デフォルトは 384) — モデルに渡される各チャンクにおける、文全体（コンテキスト + 質問）の最大トークン数です。必要に応じて、コンテキストは複数のチャンクに分割されます（重複部分として doc_stride を使用）。
  • max_question_len (int、省略可、デフォルト値は 64)— トークン化後の質問の最大長です。必要に応じて切り詰められます。
  • handle_impossible_answer (bool、省略可、デフォルトはFalse) — 「impossible」を回答として受け入れるかどうかを指定します。
  • lang (str, 任意) — OCR 実行時に使用する言語。デフォルトは english です。
  • tesseract_config (str, 任意) — OCR実行時にtesseractに渡す追加フラグ。
  • timeout (float、任意、デフォルトは None)— Web から画像を取得する際に待機する最大時間（秒）です。None の場合はタイムアウトが設定されず、呼び出しが永久にブロックされる可能性があります。

戻り値

dictまたはdictのリスト

各結果は、以下のキーを持つ辞書として返されます。

  • score (float) — 回答に関連付けられた確率。
  • start (int) — 回答の開始単語インデックス（入力または提供されたword_boxesのOCR済みバージョンにおけるもの）。
  • end (int) — 回答の終了単語インデックス（入力または提供されたword_boxesのOCR済みバージョンにおけるもの）。
  • answer (str) — 質問に対する回答。
  • words (list[int]) — 回答に含まれる各単語/ボックスのペアのインデックス

入力として与えられた質問に、ドキュメントを用いて答えます。ドキュメントは、画像と、ドキュメント内のテキストを表す任意の (word, box) タプルのリストで定義されます。word_boxes が提供されない場合、それらを必要とする LayoutLM 系のモデルに対して、利用可能な場合は Tesseract OCR エンジンを使用して単語とボックスを自動的に抽出します。Donut では、OCR は実行されません。

パイプラインは、いくつかの方法で呼び出すことができます。

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

FeatureExtractionPipeline

class transformers.FeatureExtractionPipeline

< >

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

パラメータ

  • model (PreTrainedModel) — パイプラインが予測を行う際に使用するモデルです。PreTrainedModel を継承するモデルである必要があります。
  • tokenizer (PreTrainedTokenizer) — パイプラインがモデル用のデータエンコードに使用するトークナイザーです。このオブジェクトはPreTrainedTokenizerを継承しています。
  • task (str、デフォルトは "") — パイプラインのタスク識別子です。
  • num_workers (int, 任意、デフォルトは 8) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するワーカーの数。
  • batch_size (int、任意、デフォルトは 1) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するバッチサイズです。推論では常に有益とは限らないため、パイプラインでのバッチ処理 をお読みください。
  • args_parser (ArgumentHandler、任意) — 提供されたパイプラインのパラメータを解析する責任を持つオブジェクトへの参照です。
  • device (int または str または torch.device、省略可) — パイプラインが割り当てられるデバイスです。設定しない場合、パイプラインは最初に利用可能なアクセラレータ（CUDA、MPS、XPU など）に配置され、利用可能なアクセラレータがない場合のみ CPU にフォールバックします。モデルは自動的にそこに移動されます。CPU を強制するには device="cpu"（または -1）を、特定のアクセラレータを選択するには正の ordinal または "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 パイプラインはモデルヘッドを使用しません。このパイプラインはベースのtransformerから隠れ状態を抽出し、下流タスクでの特徴量として利用できます。

例:

>>> 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 チュートリアルで、pipeline の基本的な使用方法について詳しく学んでください。

この特徴抽出パイプラインは、現在、タスク識別子 "feature-extraction" を使用して pipeline() から読み込むことができます。

このパイプラインにはすべてのモデルを使用できます。コミュニティが貢献したモデルを含むすべてのモデルの一覧は、huggingface.co/modelsを参照してください。

__call__

< >

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

パラメータ

  • args (str または list[str]) — 特徴量を取得するテキストを1つ以上（またはテキストのリスト1つ）指定します。

戻り値

float のネストされたリスト

モデルによって計算される特徴量。

入力テキストの特徴量を抽出します。

ImageFeatureExtractionPipeline

class transformers.ImageFeatureExtractionPipeline

< >

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

パラメータ

  • model (PreTrainedModel) — パイプラインが予測を行う際に使用するモデルです。PreTrainedModel を継承するモデルである必要があります。
  • image_processor (BaseImageProcessor) — パイプラインがモデル用のデータエンコードに使用する画像プロセッサです。このオブジェクトは BaseImageProcessor を継承します。
  • task (str、デフォルトは "") — パイプラインのタスク識別子です。
  • num_workers (int, 任意、デフォルトは 8) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するワーカーの数。
  • batch_size (int、任意、デフォルトは 1) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するバッチサイズです。推論では常に有益とは限らないため、パイプラインでのバッチ処理 をお読みください。
  • args_parser (ArgumentHandler、任意) — 提供されたパイプラインのパラメータを解析する責任を持つオブジェクトへの参照です。
  • device (int または str または torch.device、省略可) — パイプラインが割り当てられるデバイスです。設定しない場合、パイプラインは最初に利用可能なアクセラレータ（CUDA、MPS、XPU など）に配置され、利用可能なアクセラレータがない場合のみ CPU にフォールバックします。モデルは自動的にそこに移動されます。CPU を強制するには device="cpu"（または -1）を、特定のアクセラレータを選択するには正の ordinal または "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 の場合、モデルは生の隠れ状態を返します。

Image feature extraction pipeline はモデルヘッドを使用しません。このパイプラインはベースのtransformerから隠れ状態を抽出し、下流タスクの機能として利用できます。

例:

>>> 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 チュートリアルで、pipeline の基本的な使用方法について詳しく学んでください。

この画像特徴抽出パイプラインは、現在、タスク識別子 "image-feature-extraction" を使用して pipeline() から読み込むことができます。

このパイプラインには、すべてのビジョンモデルを使用できます。コミュニティが貢献したモデルを含むすべてのモデルのリストは、huggingface.co/modelsを参照してください。

__call__

< >

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

パラメータ

  • images (str, list[str], PIL.Image または list[PIL.Image]) — パイプラインは、以下の3種類の画像を処理します:
    • 画像を指す http リンクを含む文字列
    • 画像のローカルパスを含む文字列
    • PILで直接読み込まれた画像

    パイプラインは、単一の画像または画像のバッチを受け取ります。この場合、文字列として渡す必要があります。 バッチ内の画像はすべて同じ形式である必要があります。すべてhttpリンク、すべてローカルパス、またはすべてPIL画像である必要があります。

  • timeout (float、任意、デフォルトは None)— Web から画像を取得する際に待機する最大時間（秒）です。None の場合はタイムアウトが設定されず、呼び出しが永久にブロックされる可能性があります。

戻り値

float のネストされたリスト

モデルによって計算される特徴量。

入力の特徴量を抽出します。

ImageTextToTextPipeline

class transformers.ImageTextToTextPipeline

< >

( *args**kwargs )

パラメータ

  • model (PreTrainedModel) — パイプラインが予測を行う際に使用するモデルです。PreTrainedModel を継承するモデルである必要があります。
  • processor (ProcessorMixin) — パイプラインがモデル用のデータエンコードに使用するプロセッサです。このオブジェクトは ProcessorMixin を継承しています。プロセッサは複合オブジェクトであり、tokenizer、feature_extractor、image_processor を含める場合があります。
  • task (str、デフォルトは "") — パイプラインのタスク識別子です。
  • num_workers (int, 任意、デフォルトは 8) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するワーカーの数。
  • batch_size (int、任意、デフォルトは 1) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するバッチサイズです。推論では常に有益とは限らないため、パイプラインでのバッチ処理 をお読みください。
  • args_parser (ArgumentHandler、任意) — 提供されたパイプラインのパラメータを解析する責任を持つオブジェクトへの参照です。
  • device (int または str または torch.device、省略可) — パイプラインが割り当てられるデバイスです。設定しない場合、パイプラインは最初に利用可能なアクセラレータ（CUDA、MPS、XPU など）に配置され、利用可能なアクセラレータがない場合のみ CPU にフォールバックします。モデルは自動的にそこに移動されます。CPU を強制するには device="cpu"（または -1）を、特定のアクセラレータを選択するには正の ordinal または "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 を使用した画像・テキストからテキストへのパイプラインです。このパイプラインは、画像とテキストを指定するとテキストを生成します。 基盤となるモデルが会話モデルの場合、1 つ以上のチャットも受け入れることができます。この場合、パイプラインはチャットモードで動作し、応答を追加してチャットを続行します。 各チャットは辞書のリストの形式で、各辞書には “role” と “content” というキーが含まれます。

使用しているモデルが設定ファイル(generation_config.json)内でこれらの生成パラメータを明示的に設定していない場合、以下のデフォルト値が使用されます:

  • max_new_tokens: 256

例:

>>> from transformers import pipeline

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

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

pipeline チュートリアルで、pipeline の基本的な使用方法について詳しく学んでください。

この画像・テキストからテキストへのパイプラインは、現在、pipeline() を使用して、以下のタスク識別子で読み込むことができます: “image-text-to-text”。

利用可能なモデルの一覧は、huggingface.co/models をご覧ください。

__call__

< >

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

パラメータ

  • images (str, list[str], PIL.Image, list[PIL.Image], list[dict[str, Union[str, PIL.Image]]]`) — このパイプラインは、3 種類の画像を処理します:
    • 画像を指す HTTP(s) リンクを含む文字列
    • 画像のローカルパスを含む文字列
    • PILで直接読み込まれた画像

    pipeline は、単一の画像または画像のバッチを受け取ります。最後に、この pipeline は、この引数に画像とテキストを含むチャット形式（textを参照）にも対応しています。

  • text (str, list[str], list[dict[str, Union[str, PIL.Image]]]) — 生成に使用するテキストです。文字列のリストを渡す場合、リストの長さは画像の数と同じである必要があります。テキストはチャット形式に従うこともできます。これは、会話内の各メッセージを表す辞書のリストです。各辞書には2つのキーが必要です: ‘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) — 入力チャットの最後のメッセージを新しいメッセージとして開始するのではなく、その続きを生成することをモデルに指示します。これにより、応答を「プリフィル」できます。デフォルトでは、入力チャットの最後のメッセージがassistantロールの場合にTrue、それ以外の場合にFalseとなりますが、このフラグを設定することでこの動作を手動で上書きできます。

戻り値

dict のリスト、または dict のリストのリスト

各結果は、以下のキーを持つ辞書として返されます（generated_textとgenerated_token_idsの両方を同時に返すことはできません）：

  • generated_text (str、return_text=True の場合のみ存在) — 生成されたテキスト。
  • generated_token_ids (torch.Tensor、return_tensors=True の場合に存在) — 生成されたテキストのトークン ID です。
  • input_text (str) — 入力テキスト。

入力としてテキストと画像が渡された場合、テキストを生成します。

AnyToAnyPipeline

class transformers.AnyToAnyPipeline

< >

( *args**kwargs )

パラメータ

  • model (PreTrainedModel) — パイプラインが予測を行う際に使用するモデルです。PreTrainedModel を継承するモデルである必要があります。
  • processor (ProcessorMixin) — パイプラインがモデル用のデータエンコードに使用するプロセッサです。このオブジェクトは ProcessorMixin を継承しています。プロセッサは複合オブジェクトであり、tokenizer、feature_extractor、image_processor を含める場合があります。
  • task (str、デフォルトは "") — パイプラインのタスク識別子です。
  • num_workers (int, 任意、デフォルトは 8) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するワーカーの数。
  • batch_size (int、任意、デフォルトは 1) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するバッチサイズです。推論では常に有益とは限らないため、パイプラインでのバッチ処理 をお読みください。
  • args_parser (ArgumentHandler、任意) — 提供されたパイプラインのパラメータを解析する責任を持つオブジェクトへの参照です。
  • device (int または str または torch.device、省略可) — パイプラインが割り当てられるデバイスです。設定しない場合、パイプラインは最初に利用可能なアクセラレータ（CUDA、MPS、XPU など）に配置され、利用可能なアクセラレータがない場合のみ CPU にフォールバックします。モデルは自動的にそこに移動されます。CPU を強制するには device="cpu"（または -1）を、特定のアクセラレータを選択するには正の ordinal または "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 を使用したマルチモーダル生成パイプラインです。このパイプラインは、マルチモーダルデータとテキストの任意の組み合わせを指定すると、テキストを生成します。基盤となるモデルが会話モデルの場合、1 つ以上のチャットを受け入れることもでき、その場合、パイプラインはチャットモードで動作し、応答を追加してチャットを続行します。各チャットは辞書のリストの形式を持ち、各辞書には “role” と “content” というキーが含まれます。

使用しているモデルが設定ファイル(generation_config.json)内でこれらの生成パラメータを明示的に設定していない場合、以下のデフォルト値が使用されます:

  • max_new_tokens: 256

例:

>>> from transformers import pipeline

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

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

pipeline チュートリアルで、pipeline の基本的な使用方法について詳しく学んでください。

このマルチモーダルパイプラインは、現在、pipeline()から、以下のタスク識別子を使用して読み込むことができます。 “any-to-any”

利用可能なモデルの一覧は、huggingface.co/models をご覧ください。

__call__

< >

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

パラメータ

  • text (str、list[str]、list[dict]) — 生成に使用するテキストです。文字列のリストを渡す場合、リストの長さは画像の数と一致する必要があります。テキストはチャット形式に従うこともできます。これは、各辞書が会話内のメッセージを表す辞書のリストです。各辞書には2つのキーが必要です: ‘role’ と ‘content’ です。‘role’ は ‘user’、‘system’、‘assistant’ のいずれかである必要があります。‘content’ は、メッセージのテキストとメッセージの種類を含む辞書のリストである必要があります。
  • images (str, list[str], ImageInput) — このパイプラインは、3 種類の画像を処理します:
    • 画像を指す HTTP(s) リンクを含む文字列
    • 画像のローカルパスを含む文字列
    • PILで直接読み込まれた画像

    pipeline は、単一の画像または画像のバッチを受け取ります。最後に、この pipeline は、この引数に画像とテキストを含むチャット形式（textを参照）にも対応しています。

  • videos (str, list[str], VideoInput) — このパイプラインは、以下の3種類の動画を処理します:
    • 動画へのHTTP(s)リンクを含む文字列
    • ローカルの動画へのパスを含む文字列
    • 配列形式に読み込み・デコードされた動画

    pipeline は、単一の動画または動画のバッチを受け取ります。最後に、この pipeline は、この引数に動画とテキストを含むチャット形式（text を参照）にも対応しています。

  • audio (str, list[str], AudioInput) — このパイプラインは、以下の3種類のオーディオを処理します:
    • オーディオを指す HTTP(s) リンクを含む文字列
    • オーディオのローカルパスを含む文字列
    • PILに直接読み込まれたオーディオ

    pipeline は、単一の audios または audios のバッチを受け取ります。最後に、この pipeline は、audios と text を含むチャット形式（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) — 入力チャットの最後のメッセージを新しいメッセージとして開始するのではなく、その続きを生成することをモデルに指示します。これにより、応答を「プリフィル」できます。デフォルトでは、入力チャットの最後のメッセージがassistantロールの場合にTrue、それ以外の場合にFalseとなりますが、このフラグを設定することでこの動作を手動で上書きできます。

戻り値

dict のリスト、または 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" の場合に存在) — 生成されたテキストのトークン ID です。
  • input_text (str) — 入力テキスト。

テキストおよび任意のマルチモーダルデータをインプットとして渡して、テキストを生成します。

MaskGenerationPipeline

class transformers.MaskGenerationPipeline

< >

( **kwargs )

パラメータ

  • model (PreTrainedModel) — パイプラインが予測を行う際に使用するモデルです。PreTrainedModel を継承するモデルである必要があります。
  • image_processor (BaseImageProcessor) — パイプラインがモデル用のデータエンコードに使用する画像プロセッサです。このオブジェクトは BaseImageProcessor を継承します。
  • task (str、デフォルトは "") — パイプラインのタスク識別子です。
  • num_workers (int, 任意、デフォルトは 8) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するワーカーの数。
  • batch_size (int、任意、デフォルトは 1) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するバッチサイズです。推論では常に有益とは限らないため、パイプラインでのバッチ処理 をお読みください。
  • args_parser (ArgumentHandler、任意) — 提供されたパイプラインのパラメータを解析する責任を持つオブジェクトへの参照です。
  • device (int または str または torch.device、省略可) — パイプラインが割り当てられるデバイスです。設定しない場合、パイプラインは最初に利用可能なアクセラレータ（CUDA、MPS、XPU など）に配置され、利用可能なアクセラレータがない場合のみ CPU にフォールバックします。モデルは自動的にそこに移動されます。CPU を強制するには device="cpu"（または -1）を、特定のアクセラレータを選択するには正の ordinal または "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を使用して前処理されます。この関数はpoints_per_batchのミニバッチをyieldsします。

  2. forward: preprocessの出力をモデルに与えます。画像埋め込みは一度だけ計算されます。 self.model.get_image_embeddingsを呼び出し、勾配が計算されないことを確認するとともに、テンソルとモデルが同じデバイス上にあることを確認します。

  3. postprocess: 自動マスク生成で最も重要な処理がここで行われます。3つのステップが実行されます。

    • image_processor.postprocess_masks（各ミニバッチループで実行）: 生の出力マスクを受け取り、画像サイズに応じてリサイズし、バイナリマスクに変換します。
    • image_processor.filter_masks (各ミニバッチループごと): pred_iou_thresh と stability_scores の両方を使用します。また、非最大値抑制に基づくさまざまなフィルタを適用して、不適切なマスクを除去します。
    • image_processor.postprocess_masks_for_amg は、マスクに対して NSM を適用して、関連するマスクのみを保持します。

例:

>>> from transformers import pipeline

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

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

pipeline チュートリアルで、pipeline の基本的な使用方法について詳しく学んでください。

このセグメンテーションパイプラインは、現在、pipeline()から、次のタスク識別子 "mask-generation" を使用して読み込むことができます。

利用可能なモデルの一覧は、huggingface.co/models をご覧ください。

__call__

< >

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

パラメータ

  • image (str、List[str]、PIL.Image または List[PIL.Image]) — 画像または画像のリスト。
  • mask_threshold (float、任意、デフォルト値は 0.0)— 予測されたマスクをバイナリ値に変換する際に使用する閾値。
  • pred_iou_thresh (float、任意、デフォルト値は 0.88) — モデルが予測したマスクの品質に対して適用される、[0,1] 範囲のフィルタリング閾値です。
  • stability_score_thresh (float、任意、デフォルト値は 0.95) — [0,1] の範囲で、モデルのマスク予測を二値化するために使用されるカットオフ値の変化に対するマスクの安定性を用いたフィルタリングの閾値です。
  • stability_score_offset (int、任意、デフォルト値は 1) — 安定性スコアを計算する際に、カットオフをシフトする量です。
  • crops_nms_thresh (float、任意、デフォルト値は 0.7)— 重複したマスクをフィルタリングするために、non-maximal suppression が使用するボックス IoU のカットオフ値です。
  • crops_n_layers (int、任意、デフォルトは 0) — crops_n_layers>0 の場合、マスク予測が画像のクロップに対して再度実行されます。実行するレイヤー数を設定します。各レイヤーには 2**i_layer 個の画像クロップが含まれます。
  • crop_overlap_ratio (float、任意、デフォルトは 512 / 1500) — クロップの重複度を設定します。最初のクロップ層では、画像の長さに対するこの割合だけクロップが重複します。クロップ数が多い後続の層では、この重複度を縮小します。
  • crop_n_points_downscale_factor (int、任意、デフォルトは1) — レイヤー n でサンプリングされる辺あたりの点数は、crop_n_points_downscale_factor**n 倍に縮小されます。
  • timeout (float、任意、デフォルトは None)— Web から画像を取得する際に待機する最大時間（秒）です。None の場合はタイムアウトが設定されず、呼び出しが永久にブロックされる可能性があります。

戻り値

Dict

以下のキーを持つ辞書:

  • mask (PIL.Image) — 検出されたオブジェクトのバイナリマスク。元の画像の形状 (width, height) を持つ PIL Image です。オブジェクトが検出されない場合は、ゼロで埋められたマスクを返します。
  • score (任意 float) — ラベルとマスクで記述される「オブジェクト」の信頼度をモデルが推定できる場合、任意で指定できます。

バイナリセグメンテーションマスクを生成します

親クラス: Pipeline

class transformers.Pipeline

< >

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

パラメータ

  • model (PreTrainedModel) — パイプラインが予測を行う際に使用するモデルです。PreTrainedModel を継承するモデルである必要があります。
  • tokenizer (PreTrainedTokenizer) — パイプラインがモデル用のデータエンコードに使用するトークナイザーです。このオブジェクトはPreTrainedTokenizerを継承しています。
  • feature_extractor (SequenceFeatureExtractor) — パイプラインがモデル用のデータエンコードに使用するフィーチャーエクストラクター。このオブジェクトは SequenceFeatureExtractor を継承します。
  • image_processor (BaseImageProcessor) — パイプラインがモデル用のデータエンコードに使用する画像プロセッサです。このオブジェクトは BaseImageProcessor を継承します。
  • processor (ProcessorMixin) — パイプラインがモデル用のデータエンコードに使用するプロセッサです。このオブジェクトは ProcessorMixin を継承しています。プロセッサは複合オブジェクトであり、tokenizer、feature_extractor、image_processor を含める場合があります。
  • task (str、デフォルトは "") — パイプラインのタスク識別子です。
  • num_workers (int, 任意、デフォルトは 8) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するワーカーの数。
  • batch_size (int、任意、デフォルトは 1) — パイプラインが DataLoader を使用する場合（データセットを渡す場合、または PyTorch モデルで GPU を使用する場合）、使用するバッチサイズです。推論では常に有益とは限らないため、パイプラインでのバッチ処理 をお読みください。
  • args_parser (ArgumentHandler、任意) — 提供されたパイプラインのパラメータを解析する責任を持つオブジェクトへの参照です。
  • device (int または str または torch.device、省略可) — パイプラインが割り当てられるデバイスです。設定しない場合、パイプラインは最初に利用可能なアクセラレータ（CUDA、MPS、XPU など）に配置され、利用可能なアクセラレータがない場合のみ CPU にフォールバックします。モデルは自動的にそこに移動されます。CPU を強制するには device="cpu"（または -1）を、特定のアクセラレータを選択するには正の ordinal または "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 は、device 引数（下記を参照）を介して、CPU または GPU での実行をサポートしています。

FeatureExtractionPipeline（'feature-extraction'）などの一部の pipeline は、ネストされたリストとして大きなテンソルオブジェクトを出力します。このような大きな構造をテキストデータとしてダンプすることを避けるために、binary_output というコンストラクタ引数を提供しています。True に設定すると、出力は pickle 形式で保存されます。

check_model_type

< >

( supported_models: list[str] | dict )

パラメータ

  • supported_models (list[str] または dict) — パイプラインがサポートするモデルのリスト、またはモデルクラスを値とする辞書。

モデルクラスがpipelineでサポートされているかどうかを確認します。

device_placement

< >

( )

ユーザーが指定したデバイス上でテンソルの割り込みを許可するコンテキストマネージャー。

例:

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

ensure_tensor_on_device

< >

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

パラメータ

  • inputs（torch.Tensor であるべきキーワード引数。それ以外は無視されます）— self.device に配置するテンソル。
  • Recursive はリストでのみ使用可能。 —

戻り値

dict[str, torch.Tensor]

inputsと同じですが、適切なデバイス上に配置されたものです。

PyTorch テンソルが指定されたデバイス上にあることを確認します。

postprocess

< >

( model_outputs: ModelOutput**postprocess_parameters: dict )

Postprocess は _forward メソッドの生出力（一般的にはテンソル）を受け取り、より扱いやすい形式に整形します。一般的には、結果（文字列と数値のみを含む）のリストまたは dict を出力します。

predict

< >

( X )

Transformers のパイプラインへの Scikit / Keras インターフェース。このメソッドは call() にフォワードします。

preprocess

< >

( input_: Any**preprocess_parameters: dict )

Preprocess は、特定の pipeline の input_ を受け取り、_forward が正しく実行されるために必要なすべての要素を含む辞書を返します。少なくとも 1 つのテンソルを含む必要がありますが、その他の任意の項目も含む場合があります。

push_to_hub

< >

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

パラメータ

  • repo_id (str) — pipe をプッシュするリポジトリの名前です。特定の組織にプッシュする場合は、組織名を含む必要があります。
  • commit_message (str, 任意) — プッシュ時にコミットするメッセージ。デフォルトは "Upload pipe" です。
  • commit_description (str, 省略可) — 作成されるコミットの説明
  • private (bool、省略可) — リポジトリを非公開にするかどうか。None（デフォルト）の場合、組織のデフォルトが非公開でない限り、リポジトリは公開になります。リポジトリが既に存在する場合、この値は無視されます。
  • token (bool または str、省略可) — リモートファイルの HTTP ベアラ認証に使用するトークン。True（デフォルト）の場合、hf auth login を実行した際に生成されたトークン（~/.huggingface に保存）が使用されます。
  • revision (str、省略可) — アップロードしたファイルをプッシュするブランチ。
  • create_pr (bool、省略可、デフォルトはFalse) — アップロードしたファイルを含む PR を作成するか、直接コミットするかどうかを指定します。
  • max_shard_size (int または str、省略可能、デフォルトは "50GB") — モデルにのみ適用されます。シャード化される前のチェックポイントの最大サイズです。シャード化されたチェックポイントは、それぞれがこのサイズ未満になります。文字列で指定する場合は、数字の後に単位（"5MB" など）を続ける必要があります。
  • tags (list[str]、省略可) — Hub にプッシュするタグのリストです。

パイプラインファイルを🤗 Model Hubにアップロードします。

例:

from transformers import pipeline

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

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

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

save_pretrained

< >

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

パラメータ

  • save_directory (str または os.PathLike) — 保存先ディレクトリのパスです。存在しない場合は作成されます。
  • kwargs (dict[str, Any]、省略可) — push_to_hub() メソッドに渡される追加のキーワード引数。

パイプラインのモデルとトークナイザーを保存します。

transform

< >

( X )

Transformers のパイプラインへの Scikit / Keras インターフェース。このメソッドは call() にフォワードします。

Update on GitHub

←PEFT プロセッサ→