# パイプライン パイプラインは、モデルを推論に利用するための優れたかつ簡単な方法です。これらのパイプラインはオブジェクトであり、ライブラリの複雑なコードの大部分を抽象化し、[タスク一覧](https://huggingface.co/tasks)に示されているような、Named Entity Recognition、Masked Language Modeling、Sentiment Analysis、Feature Extraction、Question Answering などの複数のタスクに特化したシンプルな API を提供します。 パイプラインの抽象化には、以下の2つのカテゴリがあります。 - 他のすべてのパイプラインをカプセル化している最も強力なオブジェクトである [pipeline()](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.pipeline)。 - [オーディオ](#audio)、[コンピュータビジョン](#computer-vision)、[自然言語処理](#natural-language-processing)、[マルチモーダル](#multimodal)のタスク向けに、タスク固有のパイプラインが利用可能です。 ## パイプライン抽象[[transformers.pipeline]] *pipeline*抽象は、利用可能な他のすべてのパイプラインをラップするものです。他のパイプラインと同様にインスタンス化されますが、追加の利便性をもたらすことができます。 単一アイテムに対するシンプルな呼び出し: ```python >>> pipe = pipeline("text-classification") >>> pipe("This restaurant is awesome") [{'label': 'POSITIVE', 'score': 0.9998743534088135}] ``` [hub](https://huggingface.co) の特定のモデルを使用する場合、hub 上のモデルがすでにタスクを定義している場合は、タスクを無視できます。 ```python >>> pipe = pipeline(model="FacebookAI/roberta-large-mnli") >>> pipe("This restaurant is awesome") [{'label': 'NEUTRAL', 'score': 0.7313136458396912}] ``` 多数のアイテムに対してパイプラインを呼び出すには、*list*を引数として渡すことができます。 ```python >>> pipe = pipeline("text-classification") >>> pipe(["This restaurant is awesome", "This restaurant is awful"]) [{'label': 'POSITIVE', 'score': 0.9998743534088135}, {'label': 'NEGATIVE', 'score': 0.9996669292449951}] ``` 全体を反復処理するには、`dataset`を直接使用することをお勧めします。これにより、一度にデータセット全体を割り当てる必要がなく、バッチ処理も自分で実装する必要がありません。GPU上では、カスタムループと同等の速度で動作するはずです。そうでない場合は、ためらわずにissueを作成してください。 ```python import datasets from transformers import pipeline from transformers.pipelines.pt_utils import KeyDataset from tqdm.auto import tqdm pipe = pipeline("automatic-speech-recognition", model="facebook/wav2vec2-base-960h", device=0) dataset = datasets.load_dataset("s3prl/superb", name="asr", split="test") # KeyDataset (only *pt*) will simply return the item in the dict returned by the dataset item # as we're not interested in the *target* part of the dataset. For sentence pair use KeyPairDataset for out in tqdm(pipe(KeyDataset(dataset, "file"))): print(out) # {"text": "NUMBER TEN FRESH NELLY IS WAITING ON YOU GOOD NIGHT HUSBAND"} # {"text": ....} # .... ``` 使いやすさを考慮し、ジェネレーターも利用可能です。 ```python from transformers import pipeline pipe = pipeline("text-classification") def data(): while True: # This could come from a dataset, a database, a queue or HTTP request # in a server # Caveat: because this is iterative, you cannot use `num_workers > 1` variable # to use multiple threads to preprocess data. You can still have 1 thread that # does the preprocessing while the main runs the big inference yield "This is a test" for out in pipe(data()): print(out) # {"text": "NUMBER TEN FRESH NELLY IS WAITING ON YOU GOOD NIGHT HUSBAND"} # {"text": ....} # .... ``` #### transformers.pipeline[[transformers.pipeline]] ```python transformers.pipeline(task: str | None = None, model: str | PreTrainedModel | None = None, config: str | PreTrainedConfig | None = None, tokenizer: str | PreTrainedTokenizer | PreTrainedTokenizerFast | None = None, feature_extractor: str | FeatureExtractionMixin | None = None, image_processor: str | BaseImageProcessor | None = None, video_processor: str | BaseVideoProcessor | None = None, processor: str | ProcessorMixin | None = None, revision: str | None = None, use_fast: bool = True, token: str | bool | None = None, device: int | str | torch.device | None = None, device_map: str | dict[str, int | str] | None = None, dtype: str | torch.dtype | None = 'auto', trust_remote_code: bool | None = None, model_kwargs: dict[str, Any] | None = None, pipeline_class: Any | None = None, **kwargs: Any) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/__init__.py#L759) **パラメータ:** task (`str`) : 返されるパイプラインを定義するタスク。現在サポートされているタスクは以下の通りです: - `"audio-classification"`: [AudioClassificationPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.AudioClassificationPipeline) を返します。 - `"automatic-speech-recognition"`: [AutomaticSpeechRecognitionPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.AutomaticSpeechRecognitionPipeline) を返します。 - `"decision"`: [DecisionPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.DecisionPipeline) を返します。 - `"depth-estimation"`: [DepthEstimationPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.DepthEstimationPipeline) を返します。 - `"document-question-answering"`: [DocumentQuestionAnsweringPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.DocumentQuestionAnsweringPipeline) を返します。 - `"feature-extraction"`: [FeatureExtractionPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.FeatureExtractionPipeline) を返します。 - `"fill-mask"`: [FillMaskPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.FillMaskPipeline) を返します。 - `"image-classification"`: [ImageClassificationPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.ImageClassificationPipeline) を返します。 - `"image-feature-extraction"`: [ImageFeatureExtractionPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.ImageFeatureExtractionPipeline) を返します。 - `"image-segmentation"`: [ImageSegmentationPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.ImageSegmentationPipeline) を返します。 - `"image-text-to-text"`: [ImageTextToTextPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.ImageTextToTextPipeline) を返します。 - `"keypoint-matching"`: [KeypointMatchingPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.KeypointMatchingPipeline) を返します。 - `"mask-generation"`: [MaskGenerationPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.MaskGenerationPipeline) を返します。 - `"object-detection"`: [ObjectDetectionPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.ObjectDetectionPipeline) を返します。 - `"table-question-answering"`: [TableQuestionAnsweringPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.TableQuestionAnsweringPipeline) を返します。 - `"text-classification"` (別名 `"sentiment-analysis"` が利用可能): [TextClassificationPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.TextClassificationPipeline) を返します。 - `"text-generation"`: [TextGenerationPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.TextGenerationPipeline) を返します。 - `"text-to-audio"` (別名 `"text-to-speech"` が利用可能): [TextToAudioPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.TextToAudioPipeline) を返します。 - `"token-classification"` (別名 `"ner"` が利用可能): [TokenClassificationPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.TokenClassificationPipeline) を返します。 - `"video-classification"`: [VideoClassificationPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.VideoClassificationPipeline) を返します。 - `"zero-shot-classification"`: [ZeroShotClassificationPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.ZeroShotClassificationPipeline) を返します。 - `"zero-shot-image-classification"`: [ZeroShotImageClassificationPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.ZeroShotImageClassificationPipeline) を返します。 - `"zero-shot-audio-classification"`: [ZeroShotAudioClassificationPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.ZeroShotAudioClassificationPipeline) を返します。 - `"zero-shot-object-detection"`: [ZeroShotObjectDetectionPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.ZeroShotObjectDetectionPipeline) を返します。 model (`str` または [PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)、*optional*) : パイプラインが予測を行う際に使用するモデルです。これは、モデル識別子、または [PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承した事前学習済みモデルの実際のインスタンスのいずれかです。指定されない場合、`task` のデフォルトが読み込まれます。 config (`str` または [PreTrainedConfig](/docs/transformers/v5.23.0/ja/main_classes/configuration#transformers.PreTrainedConfig)、*optional*) : パイプラインがモデルをインスタンス化するために使用する設定です。これはモデル識別子、または [PreTrainedConfig](/docs/transformers/v5.23.0/ja/main_classes/configuration#transformers.PreTrainedConfig) を継承する実際の事前学習済みモデルの設定オブジェクトを指定できます。 指定されない場合、要求されたモデルのデフォルトの設定ファイルが使用されます。つまり、`model` が指定されている場合は、そのデフォルトの設定が使用されます。一方、`model` が指定されていない場合は、代わりにこの `task` のデフォルトモデルの設定が使用されます。 tokenizer (`str` または [PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend)、*optional*) : パイプラインがモデル用のデータをエンコードするために使用するトークナイザーです。モデル識別子、または [PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend) を継承する実際の事前学習済みトークナイザーを指定できます。 指定されない場合、指定された `model` のデフォルトのトークナイザーが読み込まれます（文字列の場合）。`model` が指定されていないか文字列でない場合、`config` のデフォルトのトークナイザーが読み込まれます（文字列の場合）。ただし、`config` も指定されていないか文字列でない場合、指定された `task` のデフォルトのトークナイザーが読み込まれます。 feature_extractor (`str` または [FeatureExtractionMixin](/docs/transformers/v5.23.0/ja/main_classes/feature_extractor#transformers.FeatureExtractionMixin)、*任意*) : パイプラインがモデル用のデータエンコードに使用するフィーチャーエクストラクターです。モデル識別子、または [FeatureExtractionMixin](/docs/transformers/v5.23.0/ja/main_classes/feature_extractor#transformers.FeatureExtractionMixin) を継承する事前学習済みフィーチャーエクストラクターを指定できます。フィーチャーエクストラクターは、Speech や Vision などの非 NLP モデル、およびマルチモーダルモデルで使用されます。マルチモーダルモデルでは、トークナイザーの指定も必要になります。 指定されない場合、指定された `model` のデフォルトのフィーチャーエクストラクターが読み込まれます（文字列の場合）。`model` が指定されていないか文字列でない場合、`config` のデフォルトのフィーチャーエクストラクターが読み込まれます（文字列の場合）。ただし、`config` も指定されていないか文字列でない場合、指定された `task` のデフォルトのフィーチャーエクストラクターが読み込まれます。 image_processor (`str` または [BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor)、*任意*) : パイプラインがモデル用の画像の前処理に使用する画像プロセッサです。モデル識別子、または [BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor) を継承する実際の画像プロセッサを指定できます。画像プロセッサは、画像入力を必要とする Vision モデルやマルチモーダルモデルで使用されます。マルチモーダルモデルでは、トークナイザの指定も必要になります。 指定しない場合、指定された `model` のデフォルトの画像プロセッサが読み込まれます（文字列の場合）。`model` が指定されていないか文字列でない場合、`config` のデフォルトの画像プロセッサが読み込まれます（文字列の場合）。 processor (`str` または [ProcessorMixin](/docs/transformers/v5.23.0/ja/main_classes/processors#transformers.ProcessorMixin)、*任意*) : パイプラインがモデル用のデータを前処理するために使用するプロセッサです。モデル識別子、または [ProcessorMixin](/docs/transformers/v5.23.0/ja/main_classes/processors#transformers.ProcessorMixin) を継承する実際のプロセッサを指定できます。 プロセッサは、テキストと画像の両方の入力など、マルチモーダル入力が必要なマルチモーダルモデルで 사용됩니다。 指定されない場合、指定された `model` のデフォルトのプロセッサが読み込まれます（文字列の場合）。 `model` が指定されていないか文字列でない場合、`config` のデフォルトのプロセッサが読み込まれます（文字列の場合）。 revision (`str`、*任意*、デフォルトは `"main"`) : タスク名または文字列のモデル識別子を渡す場合: 使用する特定のモデルバージョンです。huggingface.co ではモデルやその他の成果物を保存するために git ベースのシステムを使用しているため、ブランチ名、タグ名、コミット ID のいずれかを指定できます。つまり、`revision` には git で許可される任意の識別子を指定できます。 use_fast (`bool`、*任意*、デフォルトは`True`) : 可能な場合は Fast トークナイザー（[PreTrainedTokenizerFast](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.TokenizersBackend)）を使用するかどうか。 token (`str` または *bool*、*省略可能*) : リモートファイルの HTTP ベアラ認証に使用するトークンです。`True` の場合、`hf auth login` を実行した際に生成されたトークンを使用します。 device (`int` または `str` または `torch.device`、*省略可*) : このパイプラインが割り当てられるデバイス（*例*、`"cpu"`、`"cuda:1"`、`"mps"`、または `1` のような GPU の ordinal rank）を定義します。設定されない場合、パイプラインは自動的に最初の利用可能なアクセラレーター（CUDA、MPS、XPU など）に配置され、利用可能なアクセラレーターがない場合のみ CPU にフォールバックします。モデルは自動的にそこへ移動されます。CPU を強制するには `device="cpu"`（または `-1`）を指定してください。`device_map` と併用することはできません。 device_map (`str` または `dict[str, Union[int, str, torch.device]`、*省略可*) : `model_kwargs` として直接渡されます（よりシンプルなショートカットです）。`accelerate` ライブラリが存在する場合、`device_map="auto"` を設定すると、最も最適化された `device_map` が自動的に計算されます（詳細は [こちら](https://huggingface.co/docs/accelerate/main/en/package_reference/big_modeling#accelerate.cpu_offload) を参照）。`device_map` と `device` を同時に使用しないでください。競合が発生するためです。 dtype (`str` または `torch.dtype`、*省略可能*、デフォルトは `"auto"`) : モデルがロードされる精度を指定します。`from_pretrained` に転送されます。デフォルトは `"auto"` で、モデルが保存された dtype でロードされます。明示的に `torch.float16`、`torch.bfloat16`、`torch.float32` などを渡すことで上書きできます。 trust_remote_code (`bool`, *任意*, デフォルトは `False`) : Hub 上で定義されたカスタムコードを、独自のモデリング、設定、トークナイゼーション、さらにはパイプラインファイル内で許可するかどうか。このオプションは、信頼できるリポジトリで、かつコードを確認済みの場合にのみ `True` に設定すべきです。そうしないと、Hub に存在するコードがローカルマシン上で実行されてしまうためです。 model_kwargs (`dict[str, Any]`、*任意*) : モデルの `from_pretrained(..., **model_kwargs)` 関数に渡される追加のキーワード引数の辞書。 kwargs (`dict[str, Any]`、*省略可*) : 特定の pipeline の初期化に渡される追加のキーワード引数です（可能な値については、対応する pipeline クラスのドキュメントを参照してください）。 **戻り値:** [Pipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.Pipeline) タスクに適したパイプライン。 [Pipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.Pipeline)を構築するためのユーティリティファクトリメソッドです。 パイプラインは、以下の要素で構成されています: - モデルの入力を前処理するための1つ以上のコンポーネント(例:[tokenizer](tokenizer)) [image_processor](image_processor)、[feature_extractor](feature_extractor)、または [processor](processors) - 入力から予測を生成する[モデル](model)。 - モデルの出力を洗練するための任意の後処理ステップ。プロセッサによって処理することもできます。 `tokenizer`、`feature_extractor`、`image_processor`、`processor` といった任意の引数は存在しますが、これらをすべて同時に指定すべきではありません。これらのコンポーネントが提供されない場合、`pipeline` は必要なものを自動的に読み込もうとします。これらのコンポーネントを明示的に提供したい場合は、必要なコンポーネントの詳細を確認するために、特定の pipeline を参照してください。 例: ```python >>> from transformers import pipeline, AutoModelForTokenClassification, AutoTokenizer >>> # Sentiment analysis pipeline >>> analyzer = pipeline("sentiment-analysis") >>> # Named entity recognition pipeline, passing in a specific model and tokenizer >>> model = AutoModelForTokenClassification.from_pretrained("dbmdz/bert-large-cased-finetuned-conll03-english") >>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-cased") >>> recognizer = pipeline("ner", model=model, tokenizer=tokenizer) ``` ## Pipelineのバッチ処理 すべてのパイプラインでバッチ処理を使用できます。パイプラインがストリーミング機能を使用する場合（リストや`Dataset`、`generator`を渡す場合）には、この機能が有効になります。 ```python from transformers import pipeline from transformers.pipelines.pt_utils import KeyDataset import datasets dataset = datasets.load_dataset("stanfordnlp/imdb", name="plain_text", split="unsupervised") pipe = pipeline("text-classification", device=0) for out in pipe(KeyDataset(dataset, "text"), batch_size=8, truncation="only_first"): print(out) # [{'label': 'POSITIVE', 'score': 0.9998743534088135}] # Exactly the same output as before, but the content are passed # as batches to the model ``` ただし、これが自動的にパフォーマンスの向上を意味するわけではありません。使用されるハードウェア、データ、および実際のモデルによって、10倍の高速化にもなり得れば、5倍の低速化にもなり得ます。 主に高速化が見られる例: ```python from transformers import pipeline from torch.utils.data import Dataset from tqdm.auto import tqdm pipe = pipeline("text-classification", device=0) class MyDataset(Dataset): def __len__(self): return 5000 def __getitem__(self, i): return "This is a test" dataset = MyDataset() for batch_size in [1, 8, 64, 256]: print("-" * 30) print(f"Streaming batch_size={batch_size}") for out in tqdm(pipe(dataset, batch_size=batch_size), total=len(dataset)): pass ``` ```text # On GTX 970 ------------------------------ Streaming no batching 100%|██████████████████████████████████████████████████████████████████████| 5000/5000 [00:26<00:00, 187.52it/s] ------------------------------ Streaming batch_size=8 100%|█████████████████████████████████████████████████████████████████████| 5000/5000 [00:04<00:00, 1205.95it/s] ------------------------------ Streaming batch_size=64 100%|█████████████████████████████████████████████████████████████████████| 5000/5000 [00:02<00:00, 2478.24it/s] ------------------------------ Streaming batch_size=256 100%|█████████████████████████████████████████████████████████████████████| 5000/5000 [00:01<00:00, 2554.43it/s] (diminishing returns, saturated the GPU) ``` 主にスローダウンが発生する例: ```python class MyDataset(Dataset): def __len__(self): return 5000 def __getitem__(self, i): if i % 64 == 0: n = 100 else: n = 1 return "This is a test" * n ``` これは他の文と比較して、稀に非常に長い文です。その場合、**全体**のバッチが400トークンの長さになる必要があるため、バッチ全体が[64, 4]ではなく[64, 400]となり、大幅なスローダウンを引き起こします。さらに悪いことに、より大きなバッチでは、プログラムが単にクラッシュしてしまいます。 ```text ------------------------------ Streaming no batching 100%|█████████████████████████████████████████████████████████████████████| 1000/1000 [00:05<00:00, 183.69it/s] ------------------------------ Streaming batch_size=8 100%|█████████████████████████████████████████████████████████████████████| 1000/1000 [00:03<00:00, 265.74it/s] ------------------------------ Streaming batch_size=64 100%|██████████████████████████████████████████████████████████████████████| 1000/1000 [00:26<00:00, 37.80it/s] ------------------------------ Streaming batch_size=256 0%| | 0/1000 [00:00 for out in tqdm(pipe(dataset, batch_size=256), total=len(dataset)): .... q = q / math.sqrt(dim_per_head) # (bs, n_heads, q_length, dim_per_head) RuntimeError: CUDA out of memory. Tried to allocate 376.00 MiB (GPU 0; 3.95 GiB total capacity; 1.72 GiB already allocated; 354.88 MiB free; 2.46 GiB reserved in total by PyTorch) ``` この問題に対する優れた（一般的な）解決策は存在せず、使用状況によって結果は異なります。目安として: ユーザー向けの目安は以下の通りです。 - **ご自身のワークロードとハードウェアでパフォーマンスを測定してください。測定し、測定し、測定し続けましょう。実測値こそが唯一の道です。** - レイテンシが制約となる場合（推論を実行しているライブプロダクトなど）は、バッチ処理を行わないでください。 - CPU を使用している場合は、バッチ処理を行わないでください。 - スループット（大量の静的データでモデルを実行したい場合）を重視し、GPU を使用している場合は、次のようにします。 - sequence_length（「自然な」データ）のサイズが全く分からない場合は、デフォルトではバッチ処理を行わず、計測を行い、暫定的にバッチ処理を追加してみてください。また、sequence_lengthを制御しない限り、いずれ失敗するようになるため、失敗時に復旧するための OOM チェックを追加してください。 - sequence_length が非常に規則的である場合、バッチ処理が非常に有効になる可能性が高いため、OOM（メモリ不足）が発生するまで測定し、バッチサイズを押し上げてください。 - GPUが大きいほど、バッチ処理がより重要になります - バッチ処理を有効にした直後には、OOM（メモリ不足）を適切に処理できることを確認してください。 ## Pipelineのチャンクバッチ処理 `zero-shot-classification` と `question-answering` は、単一の入力に対してモデルのフォワードパスが複数回実行される可能性がある点で、やや特殊です。通常であれば、この状況は `batch_size` 引数に関する問題を引き起こします。 この問題を回避するために、これらの2つのパイプラインはいずれも通常の`Pipeline`ではなく、`ChunkPipeline`というやや特殊な実装になっています。簡単にまとめると、以下のようになります。 ```python preprocessed = pipe.preprocess(inputs) model_outputs = pipe.forward(preprocessed) outputs = pipe.postprocess(model_outputs) ``` 次に次のようになります: ```python all_model_outputs = [] for preprocessed in pipe.preprocess(inputs): model_outputs = pipe.forward(preprocessed) all_model_outputs.append(model_outputs) outputs = pipe.postprocess(all_model_outputs) ``` パイプラインは同じ方法で使用されるため、この点はコードに対して非常に透明であるはずです。 パイプラインがバッチを自動的に処理してくれるため、これは簡略化された表示です。つまり、入力によって実際に何回のフォワードパスがトリガーされるかを気にする必要はなく、`batch_size`を入力とは独立して最適化できます。前節で述べた注意点も引き続き適用されます。 ## Pipeline FP16 推論 モデルはFP16で実行でき、GPU上ではメモリを節約しながら大幅に高速化できる場合があります。ほとんどのモデルでは、これによる性能の低下は顕著ではありません。モデルが大きいほど、性能低下が発生する可能性は低くなります。 FP16推論を有効にするには、パイプラインのコンストラクタに `dtype=torch.float16` または `dtype='float16'` を渡すだけです。なお、これはPyTorchバックエンドを持つモデルでのみ動作します。入力データは内部でFP16に変換されます。 ## Pipelineのカスタムコード 特定のpipelineをオーバーライドしたい場合は、 手元のタスクについて、ためらわずに issue を作成してください。pipeline の目標は使いやすさとほとんどのケースへのサポートであり、`transformers` があなたのユースケースをサポートできる可能性があります。 簡単に試したい場合は、次のようにできます： - 選択したパイプラインをサブクラス化 ```python class MyPipeline(TextClassificationPipeline): def postprocess(): # Your code goes here scores = scores * 100 # And here my_pipeline = MyPipeline(model=model, tokenizer=tokenizer, ...) # or if you use *pipeline* function, then: my_pipeline = pipeline(model="xxxx", pipeline_class=MyPipeline) ``` これにより、ご要望のすべてのカスタムコードを実行できるようになります。 ## パイプラインの実装 [新しいパイプラインの実装](../add_new_pipeline) ## オーディオ 音声タスクで利用可能なPipelinesには、次のものがあります。 ### AudioClassificationPipeline[[transformers.AudioClassificationPipeline]] #### transformers.AudioClassificationPipeline[[transformers.AudioClassificationPipeline]] ```python transformers.AudioClassificationPipeline(*args, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/audio_classification.py#L68) **パラメータ:** model ([PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)) : パイプラインが予測を行う際に使用するモデルです。[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承するモデルである必要があります。 feature_extractor ([SequenceFeatureExtractor](/docs/transformers/v5.23.0/ja/main_classes/feature_extractor#transformers.SequenceFeatureExtractor)) : パイプラインがモデル用のデータエンコードに使用するフィーチャーエクストラクター。このオブジェクトは [SequenceFeatureExtractor](/docs/transformers/v5.23.0/ja/main_classes/feature_extractor#transformers.SequenceFeatureExtractor) を継承します。 task (`str`、デフォルトは `""`) : パイプラインのタスク識別子です。 num_workers (`int`、*任意*、デフォルトは 8) : パイプラインが *DataLoader* を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）、使用するワーカーの数。 batch_size (`int`、*optional*、デフォルトは 1) : パイプラインが*DataLoader*を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）に、使用するバッチサイズです。推論では常に有益とは限らないため、[Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching)をお読みください。 args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/ja/internal/pipelines_utils#transformers.pipelines.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 のインストールが必要です。 例: ```python >>> from transformers import pipeline >>> classifier = pipeline(model="superb/wav2vec2-base-superb-ks") >>> classifier("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/1.flac") [{'score': 0.997, 'label': '_unknown_'}, {'score': 0.002, 'label': 'left'}, {'score': 0.0, 'label': 'yes'}, {'score': 0.0, 'label': 'down'}, {'score': 0.0, 'label': 'stop'}] ``` [pipeline チュートリアル](../pipeline_tutorial)で、pipeline の基本的な使用方法について詳しく学んでください。 このパイプラインは、現在、[pipeline()](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.pipeline)から、以下のタスク識別子 `"audio-classification"` を使用して読み込むことができます。 利用可能なモデルの一覧は、[huggingface.co/models](https://huggingface.co/models?filter=audio-classification) をご覧ください。 #### __call__[[transformers.AudioClassificationPipeline.__call__]] ```python __call__(inputs: numpy.ndarray | bytes | str | dict, **kwargs: Any) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/audio_classification.py#L110) **パラメータ:** inputs (`np.ndarray` または `bytes` または `str` または `dict`) : 入力値は以下のいずれかです。 - `str` 音声ファイルのファイル名です。*ffmpeg* を使用して、適切なサンプリングレートでファイルを読み取り、波形を取得します。これには、システムに *ffmpeg* がインストールされている必要があります。 - `bytes` 音声ファイルの内容であるべきで、*ffmpeg* によって同様に解釈されます。 - (`np.ndarray` 形状 (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](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.AutomaticSpeechRecognitionPipeline)のドキュメントを参照してください。 ### AutomaticSpeechRecognitionPipeline[[transformers.AutomaticSpeechRecognitionPipeline]] #### transformers.AutomaticSpeechRecognitionPipeline[[transformers.AutomaticSpeechRecognitionPipeline]] ```python transformers.AutomaticSpeechRecognitionPipeline(model: PreTrainedModel, feature_extractor: typing.Union[ForwardRef('SequenceFeatureExtractor'), str, NoneType] = None, tokenizer: transformers.tokenization_python.PythonBackend | None = None, decoder: typing.Union[ForwardRef('BeamSearchDecoderCTC'), str, NoneType] = None, device: typing.Union[int, ForwardRef('torch.device'), NoneType] = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/automatic_speech_recognition.py#L147) **パラメータ:** model ([PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)) : パイプラインが予測を行う際に使用するモデルです。[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承するモデルである必要があります。 feature_extractor ([SequenceFeatureExtractor](/docs/transformers/v5.23.0/ja/main_classes/feature_extractor#transformers.SequenceFeatureExtractor)、*任意*) : パイプラインがモデル用に波形をエンコードするために使用するフィーチャーエクストラクター。 tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend)、*任意*) : パイプラインがモデル用のデータエンコードに使用するトークナイザーです。このオブジェクトは [PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend) を継承しています。 decoder (`pyctcdecode.BeamSearchDecoderCTC`、*任意*) : [PyCTCDecode の BeamSearchDecoderCTC](https://github.com/kensho-technologies/pyctcdecode/blob/2fd33dc37c4111417e08d89ccd23d28e9b308d19/pyctcdecode/decoder.py#L180) を渡すことで、言語モデルを活用したデコーディングを行うことができます。詳細は [Wav2Vec2ProcessorWithLM](/docs/transformers/v5.23.0/ja/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM) を参照してください。非推奨であり、Transformers v6 で削除されます。 device (Union[`int`, `torch.device`], *optional*) : CPU/GPU サポートのデバイス番号です。これを `None` に設定すると CPU が使用され、正の値を設定すると、対応する CUDA デバイス ID でモデルが実行されます。 音声に含まれる発話テキストを抽出することを目的としたPipelineです。 入力には、生の波形またはオーディオファイルのいずれかを指定できます。オーディオファイルを使用する場合は、複数のオーディオ形式をサポートするためにffmpegがインストールされている必要があります。 使用しているモデルが設定ファイル（`generation_config.json`）でこれらの生成パラメータを明示的に設定していない場合、以下のデフォルト値が使用されます。 - max_new_tokens: 256 - num_beams: 5 例: ```python >>> from transformers import pipeline >>> transcriber = pipeline(model="openai/whisper-base") >>> transcriber("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/1.flac") {'text': ' He hoped there would be stew for dinner, turnips and carrots and bruised potatoes and fat mutton pieces to be ladled out in thick, peppered flour-fatten sauce.'} ``` [pipeline チュートリアル](../pipeline_tutorial)で、pipeline の基本的な使用方法について詳しく学んでください。 #### __call__[[transformers.AutomaticSpeechRecognitionPipeline.__call__]] ```python __call__(inputs: numpy.ndarray | bytes | str | dict, **kwargs: Any) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/automatic_speech_recognition.py#L238) **パラメータ:** inputs (`np.ndarray` または `bytes` または `str` または `dict`) : 入力値は以下のいずれかです。 - `str` : ローカルオーディオファイルのファイル名、またはオーディオファイルをダウンロードするためのパブリックURL。ファイルは *ffmpeg* を使用して適切なサンプリングレートで読み込まれ、波形が取得されます。これにはシステムに *ffmpeg* がインストールされている必要があります。 - `bytes` : オーディオファイルの内容であるべきで、*ffmpeg* によって同様に解釈されます。 - (型が `np.float32` または `np.float64` で、shape が (n, ) の `np.ndarray`) : 適切なサンプリングレートでの生オーディオ（さらなるチェックは行われません） - `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 の全体像については、[こちらのガイド](https://huggingface.co/docs/transformers/en/main_classes/text_generation)を参照してください。 **戻り値:** `Dict` 以下のキーを持つ辞書: - **text** (`str`): 認識されたテキスト。 - **chunks** (*任意、`list[Dict]`) `return_timestamps` を使用する場合、`chunks` はモデルによって識別されたさまざまなテキストチャンクをすべて含むリストになります。*例* `[{"text": "hi ", "timestamp": (0.5, 0.9)}, {"text": "there", "timestamp": (1.0, 1.5)}]`。元の完全なテキストは、`"".join(chunk["text"] for chunk in output["chunks"])` を実行することで、おおよそ復元できます。 入力として与えられた音声シーケンスをテキストに書き起こします。詳細については、[AutomaticSpeechRecognitionPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.AutomaticSpeechRecognitionPipeline)のドキュメントを参照してください。 ### TextToAudioPipeline[[transformers.TextToAudioPipeline]] #### transformers.TextToAudioPipeline[[transformers.TextToAudioPipeline]] ```python transformers.TextToAudioPipeline(*args, vocoder = None, sampling_rate = None, noise_scheduler = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/text_to_audio.py#L46) `AutoModelForTextToWaveform` または `AutoModelForTextToSpectrogram` を使用したテキストからオーディオを生成するパイプラインです。このパイプラインは、入力テキストおよび任意の他の条件付き入力からオーディオファイルを生成します。 使用しているモデルが`generation_config.json`内で生成パラメータを明示的に設定していない場合、`generation.configuration_utils.py._get_default_generation_params()`のデフォルト値が使用されます。 - max_new_tokens: 256 例: ```python >>> from transformers import pipeline >>> pipe = pipeline(model="suno/bark-small") >>> output = pipe("Hey it's HuggingFace on the phone!") >>> audio = output["audio"] >>> sampling_rate = output["sampling_rate"] ``` [pipeline チュートリアル](../pipeline_tutorial)で、pipeline の基本的な使用方法について詳しく学んでください。 `TextToAudioPipeline.__call__.forward_params` または `TextToAudioPipeline.__call__.generate_kwargs` を使用して、モデルに渡すパラメータを指定できます。 例: ```python >>> from transformers import pipeline >>> music_generator = pipeline(task="text-to-audio", model="facebook/musicgen-small") >>> # diversify the music generation by adding randomness with a high temperature and set a maximum music length >>> generate_kwargs = { ... "do_sample": True, ... "temperature": 0.7, ... "max_new_tokens": 35, ... } >>> outputs = music_generator("Techno music with high melodic riffs", generate_kwargs=generate_kwargs) ``` このパイプラインは、現在、[pipeline()](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.pipeline)から、以下のタスク識別子 `"text-to-speech"` または `"text-to-audio"` を使用して読み込むことができます。 利用可能なモデルの一覧は、[huggingface.co/models](https://huggingface.co/models?filter=text-to-speech) をご覧ください。 #### __call__[[transformers.TextToAudioPipeline.__call__]] ```python __call__(text_inputs, **forward_params) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/text_to_audio.py#L260) **パラメータ:** text_inputs (`str`、`list[str]`、`ChatType`、または `list[ChatType]`) : 生成対象のテキストを1つ以上指定します。文字列または文字列のリストが渡された場合、このパイプラインは対応するテキストを生成します。代わりに、"role" と "content" キーを持つ辞書のリストという形式の "chat"、またはそのようなチャットのリストを渡すこともできます。チャットが渡された場合、モデルのチャットテンプレートを使用して整形してから、モデルに渡されます。 forward_params (`dict`、*任意*) : モデルの生成/forward メソッドに渡すパラメータです。`forward_params` は常に基盤となるモデルに渡されます。 generate_kwargs (`dict`, *任意*) : `generate_config` のアドホックなパラメータ化の辞書で、生成呼び出しに使用されます。generate の全体像については、[こちらのガイド](https://huggingface.co/docs/transformers/en/main_classes/text_generation)を参照してください。`generate_kwargs` は、基盤となるモデルが生成モデルである場合のみそのモデルに渡され、`forward_params` より優先されます。 **戻り値:** `AudioOutput` または `AudioOutput` のリスト。これは2つのキーを持つ `TypedDict` です - **audio** (`np.ndarray`、形状 `(nb_channels, audio_length)`) -- 生成されたオーディオ波形。 - **sampling_rate** (`int`) -- 生成されるオーディオ波形のサンプリングレート。 入力から音声/オーディオを生成します。詳細については、[TextToAudioPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.TextToAudioPipeline)のドキュメントを参照してください。 ### ZeroShotAudioClassificationPipeline[[transformers.ZeroShotAudioClassificationPipeline]] #### transformers.ZeroShotAudioClassificationPipeline[[transformers.ZeroShotAudioClassificationPipeline]] ```python transformers.ZeroShotAudioClassificationPipeline(**kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/zero_shot_audio_classification.py#L32) **パラメータ:** model ([PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)) : パイプラインが予測を行う際に使用するモデルです。[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承するモデルである必要があります。 tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend)) : パイプラインがモデル用のデータエンコードに使用するトークナイザーです。このオブジェクトは [PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend) を継承しています。 feature_extractor ([SequenceFeatureExtractor](/docs/transformers/v5.23.0/ja/main_classes/feature_extractor#transformers.SequenceFeatureExtractor)) : パイプラインがモデル用のデータエンコードに使用するフィーチャーエクストラクター。このオブジェクトは [SequenceFeatureExtractor](/docs/transformers/v5.23.0/ja/main_classes/feature_extractor#transformers.SequenceFeatureExtractor) を継承します。 task (`str`、デフォルトは `""`) : パイプラインのタスク識別子です。 num_workers (`int`、*任意*、デフォルトは 8) : パイプラインが *DataLoader* を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）、使用するワーカーの数。 batch_size (`int`、*optional*、デフォルトは 1) : パイプラインが*DataLoader*を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）に、使用するバッチサイズです。推論では常に有益とは限らないため、[Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching)をお読みください。 args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/ja/internal/pipelines_utils#transformers.pipelines.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 {}."`です。ご自身の用途に合わせて更新してください。 例: ```python >>> from transformers import pipeline >>> from datasets import load_dataset >>> dataset = load_dataset("ashraq/esc50") >>> audio = next(iter(dataset["train"]["audio"]))["array"] >>> classifier = pipeline(task="zero-shot-audio-classification", model="laion/clap-htsat-unfused") >>> classifier(audio, candidate_labels=["Sound of a dog", "Sound of vacuum cleaner"]) [{'score': 0.9996, 'label': 'Sound of a dog'}, {'score': 0.0004, 'label': 'Sound of vacuum cleaner'}] ``` パイプラインの基本的な使い方については、[パイプラインのチュートリアル](../pipeline_tutorial)を参照してください。この音声分類パイプラインは、現在、[pipeline()](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.pipeline)から以下のタスク識別子 `"zero-shot-audio-classification"` を使用して読み込むことができます。利用可能なモデルの一覧は [huggingface.co/models](https://huggingface.co/models?filter=zero-shot-audio-classification) をご覧ください。 #### __call__[[transformers.ZeroShotAudioClassificationPipeline.__call__]] ```python __call__(audios: numpy.ndarray | bytes | str | dict, **kwargs: Any) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/zero_shot_audio_classification.py#L70) **パラメータ:** audios (`str`、`list[str]`、`np.array` または `list[np.array]`) : パイプラインは3種類の入力を処理します。 - オーディオを指す http リンクを含む文字列 - ローカルのオーディオへのパスを含む文字列 - numpy に読み込まれたオーディオ candidate_labels (`list[str]`) : この音声の候補ラベルです。*hypothesis_template* を使用してフォーマットされます。 hypothesis_template (`str`、*任意*、デフォルトは`"This is a sound of {}"`) : *candidate_labels*と組み合わせて音声分類を試みる際に使用される形式です。プレースホルダーを candidate_labels に置き換えます。*candidate_labels*がすでにフォーマット済みの場合は、"{}" を渡してください。 **戻り値:** 提案ラベルごとに1つのエントリを含む辞書のリストです。各辞書には、以下のキーが含まれます。 - **label** (`str`) -- *candidate_labels* のいずれか。 - **score** (`float`) -- モデルがそのラベルに付与したスコアです。`logits_per_audio` の `softmax` として計算される 0 から 1 までの値です。 入力として渡された音声にラベルを割り当てます。 ## コンピュータビジョン コンピュータビジョンタスクで利用可能なPipelinesには、以下が含まれます。 ### DepthEstimationPipeline[[transformers.DepthEstimationPipeline]] #### transformers.DepthEstimationPipeline[[transformers.DepthEstimationPipeline]] ```python transformers.DepthEstimationPipeline(*args, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/depth_estimation.py#L25) **パラメータ:** model ([PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)) : パイプラインが予測を行う際に使用するモデルです。[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承するモデルである必要があります。 image_processor ([BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor)) : パイプラインがモデル用のデータエンコードに使用する画像プロセッサです。このオブジェクトは [BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor) を継承しています。 task (`str`、デフォルトは `""`) : パイプラインのタスク識別子です。 num_workers (`int`、*任意*、デフォルトは 8) : パイプラインが *DataLoader* を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）、使用するワーカーの数。 batch_size (`int`、*optional*、デフォルトは 1) : パイプラインが*DataLoader*を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）に、使用するバッチサイズです。推論では常に有益とは限らないため、[Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching)をお読みください。 args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/ja/internal/pipelines_utils#transformers.pipelines.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` を使用した深度推定パイプライン。このパイプラインは画像の深度を予測します。 例: ```python >>> from transformers import pipeline >>> depth_estimator = pipeline(task="depth-estimation", model="LiheYoung/depth-anything-base-hf") >>> output = depth_estimator("http://images.cocodataset.org/val2017/000000039769.jpg") >>> # This is a tensor with the values being the depth expressed in meters for each pixel >>> output["predicted_depth"].shape torch.Size([1, 384, 384]) ``` [pipeline チュートリアル](../pipeline_tutorial)で、pipeline の基本的な使用方法について詳しく学んでください。 この深度推定パイプラインは、現在、[pipeline()](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.pipeline)から、以下のタスク識別子 `"depth-estimation"` を使用して読み込むことができます。 利用可能なモデルの一覧は、[huggingface.co/models](https://huggingface.co/models?filter=depth-estimation) をご覧ください。 #### __call__[[transformers.DepthEstimationPipeline.__call__]] ```python __call__(inputs: typing.Union[str, list[str], ForwardRef('Image.Image'), list['Image.Image']], **kwargs: Any) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/depth_estimation.py#L66) **パラメータ:** inputs (`str`、`list[str]`、`PIL.Image` または `list[PIL.Image]`) : パイプラインは、以下の 3 種類の画像を処理します。 - 画像を指す http リンクを含む文字列 - 画像のローカルパスを含む文字列 - PIL で直接読み込まれた画像 パイプラインは、単一の画像または画像のバッチを受け取ります。バッチとして渡す場合は、文字列として渡す必要があります。バッチ内の画像はすべて同じ形式である必要があります。すなわち、すべて http リンク、すべてローカルパス、またはすべて PIL 画像である必要があります。 parameters (`Dict`、*任意*) : パイプラインの動作を制御するために、引数名からパラメータ値への対応を表す辞書です。現在利用可能なパラメータは `timeout` のみで、これは画像のダウンロードを試みて諦めるまでの待機時間（秒）です。 timeout (`float`、*任意*、デフォルトは None) : ウェブから画像を取得する際に待機する最大時間（秒）。None の場合はタイムアウトが設定されず、呼び出しが永久にブロックされる可能性があります。 **戻り値:** 結果を含む辞書、または辞書のリスト。入力が単一の画像の場合は辞書を返し、入力が複数の画像のリストの場合は、画像に対応する辞書のリストを返します。 辞書には、以下のキーが含まれています。 - **predicted_depth** (`torch.Tensor`) -- モデルが予測した深度を`torch.Tensor`として表したものです。 - **depth** (`PIL.Image`) -- モデルが予測した深度を`PIL.Image`として表したものです。 入力として渡された画像の深度を予測します。 ### ImageClassificationPipeline[[transformers.ImageClassificationPipeline]] #### transformers.ImageClassificationPipeline[[transformers.ImageClassificationPipeline]] ```python transformers.ImageClassificationPipeline(*args, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/image_classification.py#L74) **パラメータ:** model ([PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)) : パイプラインが予測を行う際に使用するモデルです。[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承するモデルである必要があります。 image_processor ([BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor)) : パイプラインがモデル用のデータエンコードに使用する画像プロセッサです。このオブジェクトは [BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor) を継承しています。 task (`str`、デフォルトは `""`) : パイプラインのタスク識別子です。 num_workers (`int`、*任意*、デフォルトは 8) : パイプラインが *DataLoader* を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）、使用するワーカーの数。 batch_size (`int`、*optional*、デフォルトは 1) : パイプラインが*DataLoader*を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）に、使用するバッチサイズです。推論では常に有益とは限らないため、[Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching)をお読みください。 args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/ja/internal/pipelines_utils#transformers.pipelines.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"`: モデルが単一のラベルを持つ場合、出力にシグモイド関数を適用します。複数のラベルを持つ場合、出力にソフトマックス関数を適用します。回帰タスクの場合、出力には関数を適用しません。 - `"sigmoid"`: 出力にシグモイド関数を適用します。 - `"softmax"`: 出力にソフトマックス関数を適用します。 - `"none"`: 出力には関数を適用しません。 `AutoModelForImageClassification` を使用した画像分類パイプライン。このパイプラインは、画像のクラスを予測します。 例: ```python >>> from transformers import pipeline >>> classifier = pipeline(model="microsoft/beit-base-patch16-224-pt22k-ft22k") >>> classifier("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png") [{'score': 0.442, 'label': 'macaw'}, {'score': 0.088, 'label': 'popinjay'}, {'score': 0.075, 'label': 'parrot'}, {'score': 0.073, 'label': 'parodist, lampooner'}, {'score': 0.046, 'label': 'poll, poll_parrot'}] ``` [pipeline チュートリアル](../pipeline_tutorial)で、pipeline の基本的な使用方法について詳しく学んでください。 この画像分類パイプラインは、現在、[pipeline()](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.pipeline)から、以下のタスク識別子 `"image-classification"` を使用して読み込むことができます。 利用可能なモデルの一覧は、[huggingface.co/models](https://huggingface.co/models?filter=image-classification) をご覧ください。 #### __call__[[transformers.ImageClassificationPipeline.__call__]] ```python __call__(inputs: typing.Union[str, list[str], ForwardRef('Image.Image'), list['Image.Image']], **kwargs: Any) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/image_classification.py#L128) **パラメータ:** inputs (`str`、`list[str]`、`PIL.Image` または `list[PIL.Image]`) : パイプラインは、以下の 3 種類の画像を処理します。 - 画像を指す http リンクを含む文字列 - 画像のローカルパスを含む文字列 - PIL で直接読み込まれた画像 パイプラインは、単一の画像または画像のバッチを受け取ります。バッチとして渡す場合は、文字列として渡す必要があります。バッチ内の画像はすべて同じ形式である必要があります。すなわち、すべて http リンク、すべてローカルパス、またはすべて PIL 画像である必要があります。 function_to_apply (`str`、*任意*、デフォルトは`"default"`) : モデルの出力に適用してスコアを取得するための関数です。4つの異なる値を受け取ります: この引数が指定されない場合、ラベルの数に応じて以下の関数が適用されます: - 問題の種類が回帰の場合、出力には関数を適用しません。 - モデルが単一のラベルを持つ場合、出力にシグモイド関数を適用します。 - モデルが複数のラベルを持つ場合、出力にソフトマックス関数を適用します。 指定可能な値は以下の通りです: - `"sigmoid"`: 出力にシグモイド関数を適用します。 - `"softmax"`: 出力にソフトマックス関数を適用します。 - `"none"`: 出力には関数を適用しません。 top_k (`int`、*optional*、デフォルト値は 5) : パイプラインが返す上位ラベルの数です。指定した数がモデル設定で利用可能なラベル数より大きい場合、ラベル数にデフォルトされます。 timeout (`float`、*任意*、デフォルトは None) : ウェブから画像を取得する際に待機する最大時間（秒）。None の場合はタイムアウトが設定されず、呼び出しが永久にブロックされる可能性があります。 **戻り値:** 結果を含む辞書、または辞書のリスト。入力が単一の画像の場合は辞書を返し、入力が複数の画像のリストの場合は、画像に対応する辞書のリストを返します。 辞書には、以下のキーが含まれています。 - **label** (`str`) -- モデルによって識別されたラベル。 - **score** (`int`) -- モデルがそのラベルに付与したスコア。 入力として渡された画像にラベルを割り当てます。 ### ImageSegmentationPipeline[[transformers.ImageSegmentationPipeline]] #### transformers.ImageSegmentationPipeline[[transformers.ImageSegmentationPipeline]] ```python transformers.ImageSegmentationPipeline(*args, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/image_segmentation.py#L27) **パラメータ:** model ([PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)) : パイプラインが予測を行う際に使用するモデルです。[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承するモデルである必要があります。 image_processor ([BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor)) : パイプラインがモデル用のデータエンコードに使用する画像プロセッサです。このオブジェクトは [BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor) を継承しています。 task (`str`、デフォルトは `""`) : パイプラインのタスク識別子です。 num_workers (`int`、*任意*、デフォルトは 8) : パイプラインが *DataLoader* を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）、使用するワーカーの数。 batch_size (`int`、*optional*、デフォルトは 1) : パイプラインが*DataLoader*を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）に、使用するバッチサイズです。推論では常に有益とは限らないため、[Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching)をお読みください。 args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/ja/internal/pipelines_utils#transformers.pipelines.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` を使用した画像セグメンテーションのパイプラインです。このパイプラインは、オブジェクトのマスクとそのクラスを予測します。 例: ```python >>> from transformers import pipeline >>> segmenter = pipeline(model="facebook/detr-resnet-50-panoptic") >>> segments = segmenter("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png") >>> len(segments) 2 >>> segments[0]["label"] 'bird' >>> segments[1]["label"] 'bird' >>> type(segments[0]["mask"]) # This is a black and white mask showing where is the bird on the original image. >>> segments[0]["mask"].size (768, 512) ``` この画像セグメンテーションのパイプラインは、現在、[pipeline()](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.pipeline)から、以下のタスク識別子 `"image-segmentation"` を使用して読み込むことができます。 利用可能なモデルの一覧は、[huggingface.co/models](https://huggingface.co/models?filter=image-segmentation) をご覧ください。 #### __call__[[transformers.ImageSegmentationPipeline.__call__]] ```python __call__(inputs: typing.Union[str, ForwardRef('Image.Image'), list[str], list['Image.Image']], **kwargs: Any) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/image_segmentation.py#L101) **パラメータ:** 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`、*optional*、デフォルト値は 0.5) : 予測されたマスクをバイナリ値に変換する際に使用する閾値。 overlap_mask_area_threshold (`float`、*任意*、デフォルトは 0.5) : 小さい断片を除去するためのマスク重複の閾値。 timeout (`float`、*任意*、デフォルトは None) : ウェブから画像を取得する際に待機する最大時間（秒）。None の場合はタイムアウトが設定されず、呼び出しが永久にブロックされる可能性があります。 **戻り値:** 入力が単一の画像の場合、辞書のリストを返します。入力が複数の画像のリストの場合、各画像に対応する辞書のリストのリストを返します。 辞書には、検出された各オブジェクトのマスク、ラベル、スコア（該当する場合）が含まれており、以下のキーを保持します。 - **label** (`str`) -- モデルによって識別されたクラスラベル。 - **mask** (`PIL.Image`) -- 検出されたオブジェクトのバイナリマスク。元の画像の形状 (width, height) を持つ PIL Image として返されます。オブジェクトが検出されない場合は、ゼロで埋められたマスクを返します。 - **score** (*任意* `float`) -- ラベルとマスクで記述される「オブジェクト」の信頼度をモデルが推定できる場合、任意で指定します。 入力として渡された画像に対してセグメンテーション（マスクとクラスの検出）を実行します。 ### KeypointMatchingPipeline[[transformers.KeypointMatchingPipeline]] #### transformers.KeypointMatchingPipeline[[transformers.KeypointMatchingPipeline]] ```python transformers.KeypointMatchingPipeline(*args, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/keypoint_matching.py#L67) `AutoModelForKeypointMatching` を使用したキーポイントマッチングのパイプラインです。このパイプラインは、2つの画像間のキーポイントをマッチングします。 #### __call__[[transformers.KeypointMatchingPipeline.__call__]] ```python __call__(inputs: list[collections.abc.Sequence[typing.Union[ForwardRef('Image.Image'), str]]] | collections.abc.Sequence[typing.Union[ForwardRef('Image.Image'), str]], threshold: float = 0.0, **kwargs: Any) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/keypoint_matching.py#L96) **パラメータ:** inputs (`str`、`list[str]`、`PIL.Image`、または `list[PIL.Image]`) : パイプラインは、以下の3種類の画像を処理します。 - 画像を指す http リンクを含む文字列 - 画像のローカルパスを含む文字列 - PIL で直接読み込まれた画像 パイプラインは、単一の画像ペアまたは画像ペアのバッチを受け取ります。バッチの場合は、文字列として渡す必要があります。バッチ内の画像はすべて同じ形式である必要があります。すなわち、すべて http リンク、すべてローカルパス、またはすべて PIL 画像である必要があります。 threshold (`float`、*任意*、デフォルト値は 0.0) : キーポイントのマッチングに使用する閾値です。マッチングスコアがこれより低いキーポイントは除外されます。0 を指定すると、マッチングされたすべてのキーポイントが返されます。 kwargs : `timeout (`float`, *optional*, defaults to None)` Web から画像を取得する際に待機する最大時間（秒）。None の場合、タイムアウトは設定されず、呼び出しが永久にブロックされる可能性があります。 **戻り値:** Union[list[Match], list[list[Match]]] 単一の画像ペアが提供された場合はマッチのリスト、画像ペアのバッチが提供された場合はマッチのリストのリストを返します。各マッチは、以下のキーを含む辞書です。 - **keypoint_image_0** (`Keypoint`): 最初の画像におけるキーポイント（x、y 座標）。 - **keypoint_image_1** (`Keypoint`): 2番目の画像におけるキーポイント（x、y座標）。 - **score** (`float`): 2つのキーポイント間のマッチングスコア。 2つの画像間のキーポイントの一致を検出します。 ### ObjectDetectionPipeline[[transformers.ObjectDetectionPipeline]] #### transformers.ObjectDetectionPipeline[[transformers.ObjectDetectionPipeline]] ```python transformers.ObjectDetectionPipeline(*args, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/object_detection.py#L26) **パラメータ:** model ([PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)) : パイプラインが予測を行う際に使用するモデルです。[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承するモデルである必要があります。 image_processor ([BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor)) : パイプラインがモデル用のデータエンコードに使用する画像プロセッサです。このオブジェクトは [BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor) を継承しています。 task (`str`、デフォルトは `""`) : パイプラインのタスク識別子です。 num_workers (`int`、*任意*、デフォルトは 8) : パイプラインが *DataLoader* を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）、使用するワーカーの数。 batch_size (`int`、*optional*、デフォルトは 1) : パイプラインが*DataLoader*を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）に、使用するバッチサイズです。推論では常に有益とは限らないため、[Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching)をお読みください。 args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/ja/internal/pipelines_utils#transformers.pipelines.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` を使用したオブジェクト検出パイプラインです。このパイプラインは、オブジェクトのバウンディングボックスとそのクラスを予測します。 例: ```python >>> from transformers import pipeline >>> detector = pipeline(model="facebook/detr-resnet-50") >>> detector("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png") [{'score': 0.997, 'label': 'bird', 'box': {'xmin': 69, 'ymin': 171, 'xmax': 396, 'ymax': 507}}, {'score': 0.999, 'label': 'bird', 'box': {'xmin': 398, 'ymin': 105, 'xmax': 767, 'ymax': 507}}] >>> # x, y are expressed relative to the top left hand corner. ``` [pipeline チュートリアル](../pipeline_tutorial)で、pipeline の基本的な使用方法について詳しく学んでください。 このオブジェクト検出パイプラインは、現在、[pipeline()](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.pipeline)から、次のタスク識別子 `"object-detection"` を使用して読み込むことができます。 利用可能なモデルの一覧は、[huggingface.co/models](https://huggingface.co/models?filter=object-detection) をご覧ください。 #### __call__[[transformers.ObjectDetectionPipeline.__call__]] ```python __call__(*args, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/object_detection.py#L81) **パラメータ:** inputs (`str`、`list[str]`、`PIL.Image` または `list[PIL.Image]`) : パイプラインは、以下の3種類の画像を処理します。 - 画像を指す HTTP(S) リンクを含む文字列 - 画像のローカルパスを含む文字列 - PIL で直接読み込まれた画像 パイプラインは、単一の画像または画像のバッチを受け取ります。バッチ内の画像はすべて同じ形式である必要があります。すなわち、すべて HTTP(S) リンク、すべてローカルパス、またはすべて PIL 画像である必要があります。 threshold (`float`、*任意*、デフォルト値は 0.5) : 予測を行うために必要な確率。 timeout (`float`、*任意*、デフォルトは None) : ウェブから画像を取得する際に待機する最大時間（秒）。None の場合はタイムアウトが設定されず、呼び出しが永久にブロックされる可能性があります。 **戻り値:** 結果を含む辞書のリスト、または辞書のリストのリストです。入力が単一の画像の場合は辞書のリストを返し、入力が複数の画像のリストの場合は、各画像に対応する辞書のリストのリストを返します。 辞書には、以下のキーが含まれています。 - **label** (`str`) -- モデルによって識別されたクラスラベル。 - **score** (`float`) -- モデルがそのラベルに付与したスコア。 - **box** (`list[dict[str, int]]`) -- 画像の元のサイズにおける、検出されたオブジェクトのバウンディングボックス。 入力として渡された画像内のオブジェクト（バウンディングボックスとクラス）を検出します。 ### VideoClassificationPipeline[[transformers.VideoClassificationPipeline]] #### transformers.VideoClassificationPipeline[[transformers.VideoClassificationPipeline]] ```python transformers.VideoClassificationPipeline(*args, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/video_classification.py#L41) **パラメータ:** model ([PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)) : パイプラインが予測を行う際に使用するモデルです。[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承するモデルである必要があります。 image_processor ([BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor)) : パイプラインがモデル用のデータエンコードに使用する画像プロセッサです。このオブジェクトは [BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor) を継承しています。 video_processor ([BaseVideoProcessor](/docs/transformers/v5.23.0/ja/main_classes/video_processor#transformers.BaseVideoProcessor)) : パイプラインがモデル用の動画データをエンコードするために使用する動画プロセッサです。このオブジェクトは [BaseVideoProcessor](/docs/transformers/v5.23.0/ja/main_classes/video_processor#transformers.BaseVideoProcessor) を継承しています。 task (`str`、デフォルトは `""`) : パイプラインのタスク識別子です。 num_workers (`int`、*任意*、デフォルトは 8) : パイプラインが *DataLoader* を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）、使用するワーカーの数。 batch_size (`int`、*optional*、デフォルトは 1) : パイプラインが*DataLoader*を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）に、使用するバッチサイズです。推論では常に有益とは限らないため、[Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching)をお読みください。 args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/ja/internal/pipelines_utils#transformers.pipelines.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()](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.pipeline)から、以下のタスク識別子 `"video-classification"` を使用して読み込むことができます。 利用可能なモデルの一覧は、[huggingface.co/models](https://huggingface.co/models?filter=video-classification) をご覧ください。 パイプラインは、画像プロセッサ（VideoMAE、ViViT、TimeSformer などのレガシーな動画モデル）または動画プロセッサ（VJEPA2 などの新しいモデル）を使用するモデルをサポートしています。両方が存在する場合は動画プロセッサが優先され、どちらも見つからない場合はパイプラインがエラーを送出します。 #### __call__[[transformers.VideoClassificationPipeline.__call__]] ```python __call__(inputs: str | list[str] | None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/video_classification.py#L103) **パラメータ:** inputs (`str`, `list[str]`) : パイプラインは3種類の動画を処理します: - 動画への http リンクを含む文字列 - 動画へのローカルパスを含む文字列 パイプラインは、単一の動画または動画のバッチを受け取ります。バッチとして渡す場合は、文字列として渡す必要があります。バッチ内の動画はすべて同じ形式である必要があります。つまり、すべて http リンクであるか、すべてローカルパスであるかのどちらかです。 top_k (`int`、*optional*、デフォルト値は 5) : パイプラインが返す上位ラベルの数です。指定した数がモデル設定で利用可能なラベル数より大きい場合、ラベル数にデフォルトされます。 num_frames (`int`、*任意*、デフォルトは `self.model.config.num_frames`) : 分類を実行するために動画からサンプリングするフレーム数です。指定しない場合、モデル設定で指定されたフレーム数がデフォルトとして使用されます。 frame_sampling_rate (`int`、*optional*、デフォルトは 1) : ビデオからフレームを選択するために使用されるサンプリングレートです。指定されない場合、デフォルトで 1 になり、すべてのフレームが使用されます。 function_to_apply (`str`, *任意*) : モデルの出力に適用する関数。デフォルト値は、回帰問題では "none"、マルチラベル分類では "sigmoid"、それ以外の場合は "softmax" です。有効なオプション: ["softmax", "sigmoid", "none"]。初期化時または呼び出し時に明示的に指定された値は、これらのデフォルト値を上書きします。後処理を無効にするには、文字列 "none" を渡してください。 **戻り値:** 結果を含む辞書のリスト、または辞書のリストのリスト。入力が単一の動画の場合は`top_k`個の辞書のリストを返し、入力が複数の動画のリストの場合は、各動画に対応する`top_k`個の辞書のリストのリストを返します。 辞書には、以下のキーが含まれています。 - **label** (`str`) -- モデルによって識別されたラベル。 - **score** (`int`) -- モデルがそのラベルに付与したスコア。 入力として渡された動画にラベルを割り当てます。 ### ZeroShotImageClassificationPipeline[[transformers.ZeroShotImageClassificationPipeline]] #### transformers.ZeroShotImageClassificationPipeline[[transformers.ZeroShotImageClassificationPipeline]] ```python transformers.ZeroShotImageClassificationPipeline(**kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/zero_shot_image_classification.py#L29) **パラメータ:** model ([PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)) : パイプラインが予測を行う際に使用するモデルです。[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承するモデルである必要があります。 image_processor ([BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor)) : パイプラインがモデル用のデータエンコードに使用する画像プロセッサです。このオブジェクトは [BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor) を継承しています。 task (`str`、デフォルトは `""`) : パイプラインのタスク識別子です。 num_workers (`int`、*任意*、デフォルトは 8) : パイプラインが *DataLoader* を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）、使用するワーカーの数。 batch_size (`int`、*optional*、デフォルトは 1) : パイプラインが*DataLoader*を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）に、使用するバッチサイズです。推論では常に有益とは限らないため、[Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching)をお読みください。 args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/ja/internal/pipelines_utils#transformers.pipelines.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`のセットを指定すると、画像のクラスを予測します。 例: ```python >>> from transformers import pipeline >>> classifier = pipeline(model="google/siglip-so400m-patch14-384") >>> classifier( ... "https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png", ... candidate_labels=["animals", "humans", "landscape"], ... ) [{'score': 0.965, 'label': 'animals'}, {'score': 0.03, 'label': 'humans'}, {'score': 0.005, 'label': 'landscape'}] >>> classifier( ... "https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png", ... candidate_labels=["black and white", "photorealist", "painting"], ... ) [{'score': 0.996, 'label': 'black and white'}, {'score': 0.003, 'label': 'photorealist'}, {'score': 0.0, 'label': 'painting'}] ``` [pipeline チュートリアル](../pipeline_tutorial)で、pipeline の基本的な使用方法について詳しく学んでください。 この画像分類パイプラインは、現在、[pipeline()](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.pipeline)から、以下のタスク識別子 `"zero-shot-image-classification"` を使用して読み込むことができます。 利用可能なモデルの一覧は、[huggingface.co/models](https://huggingface.co/models?filter=zero-shot-image-classification) をご覧ください。 #### __call__[[transformers.ZeroShotImageClassificationPipeline.__call__]] ```python __call__(image: typing.Union[str, list[str], ForwardRef('Image.Image'), list['Image.Image']], candidate_labels: list[str], **kwargs: Any) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/zero_shot_image_classification.py#L83) **パラメータ:** 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) : ウェブから画像を取得する際に待機する最大時間（秒）。None の場合はタイムアウトが設定されず、呼び出しが永久にブロックされる可能性があります。 **戻り値:** 提案ラベルごとに1つのエントリを含む辞書のリストです。各辞書には、以下のキーが含まれます。 - **label** (`str`) -- *candidate_labels* のいずれか。 - **score** (`float`) -- モデルがそのラベルに付与したスコアです。`logits_per_image` の `softmax` として計算される 0 から 1 までの値です。 入力として渡された画像にラベルを割り当てます。 ### ZeroShotObjectDetectionPipeline[[transformers.ZeroShotObjectDetectionPipeline]] #### transformers.ZeroShotObjectDetectionPipeline[[transformers.ZeroShotObjectDetectionPipeline]] ```python transformers.ZeroShotObjectDetectionPipeline(**kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/zero_shot_object_detection.py#L23) **パラメータ:** model ([PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)) : パイプラインが予測を行う際に使用するモデルです。[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承するモデルである必要があります。 image_processor ([BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor)) : パイプラインがモデル用のデータエンコードに使用する画像プロセッサです。このオブジェクトは [BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor) を継承しています。 task (`str`、デフォルトは `""`) : パイプラインのタスク識別子です。 num_workers (`int`、*任意*、デフォルトは 8) : パイプラインが *DataLoader* を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）、使用するワーカーの数。 batch_size (`int`、*optional*、デフォルトは 1) : パイプラインが*DataLoader*を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）に、使用するバッチサイズです。推論では常に有益とは限らないため、[Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching)をお読みください。 args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/ja/internal/pipelines_utils#transformers.pipelines.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`のセットを指定すると、オブジェクトのバウンディングボックスを予測します。 例: ```python >>> from transformers import pipeline >>> detector = pipeline(model="google/owlvit-base-patch32", task="zero-shot-object-detection") >>> detector( ... "http://images.cocodataset.org/val2017/000000039769.jpg", ... candidate_labels=["cat", "couch"], ... ) [{'score': 0.287, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}}, {'score': 0.254, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}}, {'score': 0.121, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}}] >>> detector( ... "https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png", ... candidate_labels=["head", "bird"], ... ) [{'score': 0.119, 'label': 'bird', 'box': {'xmin': 71, 'ymin': 170, 'xmax': 410, 'ymax': 508}}] ``` [pipeline チュートリアル](../pipeline_tutorial)で、pipeline の基本的な使用方法について詳しく学んでください。 このオブジェクト検出パイプラインは、現在、[pipeline()](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.pipeline)から、次のタスク識別子 `"zero-shot-object-detection"` を使用して読み込むことができます。 利用可能なモデルの一覧は、[huggingface.co/models](https://huggingface.co/models?filter=zero-shot-object-detection) をご覧ください。 #### __call__[[transformers.ZeroShotObjectDetectionPipeline.__call__]] ```python __call__(image: typing.Union[str, ForwardRef('Image.Image'), list[dict[str, typing.Any]]], candidate_labels: str | list[str] | None = None, **kwargs: Any) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/zero_shot_object_detection.py#L75) **パラメータ:** image (`str`、`PIL.Image`、または `list[dict[str, Any]]`) : パイプラインは、以下の3種類の画像を処理します。 - 画像を指す http URL を含む文字列 - 画像のローカルパスを含む文字列 - PIL で直接読み込まれた画像 このパラメータを使用して、画像のリスト、データセット、ジェネレーターを直接送信できます。例: ```python >>> from transformers import pipeline >>> detector = pipeline(model="google/owlvit-base-patch32", task="zero-shot-object-detection") >>> detector( ... [ ... { ... "image": "http://images.cocodataset.org/val2017/000000039769.jpg", ... "candidate_labels": ["cat", "couch"], ... }, ... { ... "image": "http://images.cocodataset.org/val2017/000000039769.jpg", ... "candidate_labels": ["cat", "couch"], ... }, ... ] ... ) [[{'score': 0.287, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}}, {'score': 0.25, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}}, {'score': 0.121, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}}], [{'score': 0.287, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}}, {'score': 0.254, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}}, {'score': 0.121, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}}]] ``` candidate_labels (`str` または `list[str]` または `list[list[str]]`) : モデルが画像内で認識すべき内容。 threshold (`float`、*任意*、デフォルト値は 0.1) : 予測を行うために必要な確率。 top_k (`int`、*任意*、デフォルトは None) : パイプラインが返す上位予測の数を指定します。指定した値が `None` の場合、または利用可能な予測数を超える場合は、利用可能な予測数がデフォルトとして使用されます。 timeout (`float`、*任意*、デフォルトは None) : ウェブから画像を取得する際に待機する最大時間（秒）。None の場合はタイムアウトが設定されず、呼び出しが永久にブロックされる可能性があります。 **戻り値:** 予測結果を含むリストのリストです。入力画像ごとに1つのリストが含まれます。各リストには、以下のキーを持つ辞書が含まれます: - **label** (`str`) -- 検出されたオブジェクトに対応するテキストクエリ。 - **score** (`float`) -- オブジェクトに対応するスコア（0から1の間）。 - **box** (`dict[str,int]`) -- 画像の元のサイズにおける検出されたオブジェクトのバウンディングボックス。`x_min`、`x_max`、`y_min`、`y_max` をキーとする辞書です。 入力として渡された画像内のオブジェクト（バウンディングボックスとクラス）を検出します。 ## 自然言語処理 自然言語処理タスクで利用可能なPipelinesには、以下が含まれます。 ### DecisionPipeline[[transformers.DecisionPipeline]] > [!WARNING] > 決定モデル、`decision` パイプライン、および `DecisionConfig` は実験的な機能です。これらの API は、非推奨化なしにいつでも変更される可能性があります。 各呼び出しは、その質問を尋ねます: リクエスト `{"state": ..., "questions": ...}`、または `questions` を持つ状態: ```python 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 であり、モデルには画像を処理するプロセッサが必要です。 ```python 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[[transformers.DecisionPipeline]] ```python transformers.DecisionPipeline(*args, decision_config: transformers.decision.configuration_utils.DecisionConfig | str | None = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/decision.py#L15) **パラメータ:** model ([PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)) : パイプラインが予測を行う際に使用するモデルです。[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承するモデルである必要があります。 tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend)) : パイプラインがモデル用のデータエンコードに使用するトークナイザーです。このオブジェクトは [PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend) を継承しています。 task (`str`、デフォルトは `""`) : パイプラインのタスク識別子です。 num_workers (`int`、*任意*、デフォルトは 8) : パイプラインが *DataLoader* を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）、使用するワーカーの数。 batch_size (`int`、*optional*、デフォルトは 1) : パイプラインが*DataLoader*を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）に、使用するバッチサイズです。推論では常に有益とは限らないため、[Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching)をお読みください。 args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/ja/internal/pipelines_utils#transformers.pipelines.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](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.DecisionConfig) を参照) は、モデルの隣に配置するか、 `decision_config` として指定されたリポジトリに配置します。決定モデル (`XxxForDecision`) は選択肢を自らスコアリングしますが、その他のモデルはラベルの次のトークンのロジットによってスコアリングするため、任意のチャットモデルが回答できます。 例: ```python >>> 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__[[transformers.DecisionPipeline.__call__]] ```python __call__(inputs, *args, num_workers = None, batch_size = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/base.py#L1239) #### transformers.DecisionConfig[[transformers.DecisionConfig]] ```python transformers.DecisionConfig(labels: dict[str, list[str]] = , temperature: dict[str, float | int] = , chat_template: str | None = None, noul_options: list[str] = , sanitize_control_tokens: bool = True, adapter: str | None = None) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/decision/configuration_utils.py#L30) **パラメータ:** labels (`dict[str, list[str]]`、*任意*) : 各問題タイプごとの選択肢の単一トークンラベル。logits からそれらを読み取るヘッド用です。`noul` の場合はデフォルトで `Yes`/`No`、それ以外は `A`、`B`、`C`、... となります。 temperature (`dict[str, float]`, *optional*) : 質問タイプごとの温度。softmaxの前に選択肢のスコアに適用されます。デフォルト値は1です。 chat_template (`str`, *任意*) : `question`（1つの質問ごとに1つのプロンプト）または `questions`（すべての質問を1つのプロンプトにまとめる）で `state` をレンダリングする Jinja テンプレート。デフォルトでは、トークナイザーのチャットテンプレートにある汎用的なプロンプトが使用されます。 noul_options (`list[str]`、*optional*、デフォルトは`["true", "false"]`) : `noul` 質問の2つの選択肢をテンプレートが受け取る順序。 sanitize_control_tokens (`bool`、*任意*、デフォルトは`True`) : リクエスト内の制御トークンをテキストとしてエンコードするかどうか。それらを自分でエスケープするテンプレートは、元のコードの input ids を保持するためにこれを無効にします。 adapter (`str`, *任意*) : リポジトリのルートに LoRA が配置されていない場合、パイプラインがモデルに読み込む LoRA のサブフォルダ。 `decision.json` として保存される決定モデルの設定（そのチャットテンプレートは `decision_template.jinja` として保存されます）。 #### get_logits_processor[[transformers.DecisionConfig.get_logits_processor]] ```python get_logits_processor(question_type: str) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/decision/configuration_utils.py#L63) `question_type` 型の質問の選択肢スコアに適用される [LogitsProcessorList](/docs/transformers/v5.23.0/ja/internal/generation_utils#transformers.LogitsProcessorList)。 #### prepare_inputs[[transformers.DecisionConfig.prepare_inputs]] ```python prepare_inputs(request, processor) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/decision/configuration_utils.py#L78) `request` の各プロンプトのトークン化された`(inputs, questions)`。詳細は`prepare_inputs()`を参照してください。 #### 検証[[transformers.DecisionConfig.validate]] ```python validate() ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/huggingface_hub/dataclasses.py#L247) インスタンスに対してクラスバリデータを実行します。 ### FillMaskPipeline[[transformers.FillMaskPipeline]] #### transformers.FillMaskPipeline[[transformers.FillMaskPipeline]] ```python transformers.FillMaskPipeline(model: PreTrainedModel, tokenizer: PreTrainedTokenizer | None = None, feature_extractor: PreTrainedFeatureExtractor | None = None, image_processor: BaseImageProcessor | None = None, video_processor: BaseVideoProcessor | None = None, processor: ProcessorMixin | None = None, task: str = '', device: int | torch.device | None = None, binary_output: bool = False, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/fill_mask.py#L28) **パラメータ:** model ([PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)) : パイプラインが予測を行う際に使用するモデルです。[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承するモデルである必要があります。 tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend)) : パイプラインがモデル用のデータエンコードに使用するトークナイザーです。このオブジェクトは [PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend) を継承しています。 task (`str`、デフォルトは `""`) : パイプラインのタスク識別子です。 num_workers (`int`、*任意*、デフォルトは 8) : パイプラインが *DataLoader* を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）、使用するワーカーの数。 batch_size (`int`、*optional*、デフォルトは 1) : パイプラインが*DataLoader*を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）に、使用するバッチサイズです。推論では常に有益とは限らないため、[Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching)をお読みください。 args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/ja/internal/pipelines_utils#transformers.pipelines.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]`、*省略可能*) : 指定された場合、モデルはスコアを全語彙の検索ではなく、渡されたターゲットに限定します。提供されたターゲットがモデルの語彙に存在しない場合、それらはトークン化され、結果として得られた最初のトークンが使用されます（警告が表示され、処理が遅くなる可能性があります）。 tokenizer_kwargs (`dict`, *任意*) : トークナイザーに渡される追加のキーワード引数の辞書。 #### __call__[[transformers.FillMaskPipeline.__call__]] ```python __call__(inputs: str | list[str], **kwargs: Any) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/fill_mask.py#L234) **パラメータ:** inputs (`str` または `list[str]`) : マスクされたトークンを含む1つ以上のテキスト（またはプロンプトのリスト1つ）。 targets (`str` または `list[str]`、*省略可能*) : 指定された場合、モデルはスコアを全語彙の検索ではなく、渡されたターゲットに限定します。提供されたターゲットがモデルの語彙に存在しない場合、それらはトークン化され、結果として得られた最初のトークンが使用されます（警告が表示され、処理が遅くなる可能性があります）。 top_k (`int`, *任意*) : 指定された場合、返す予測の数を上書きします。 **戻り値:** `dict` のリスト、または `dict` のリストのリスト 各結果は、以下のキーを持つ辞書のリストとして返されます。 - **sequence** (`str`) -- マスクトークンの予測を含む対応する入力。 - **score** (`float`) -- 対応する確率。 - **token** (`int`) -- 予測されたトークン ID（マスクされたトークンを置き換えるもの）。 - **token_str** (`str`) -- 予測されたトークン（マスクされたトークンを置き換えるもの）。 入力として与えられたテキスト内のマスクされたトークンを埋めてください。 ### TableQuestionAnsweringPipeline[[transformers.TableQuestionAnsweringPipeline]] #### transformers.TableQuestionAnsweringPipeline[[transformers.TableQuestionAnsweringPipeline]] ```python transformers.TableQuestionAnsweringPipeline(args_parser = , **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/table_question_answering.py#L78) **パラメータ:** model ([PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)) : パイプラインが予測を行う際に使用するモデルです。[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承するモデルである必要があります。 tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend)) : パイプラインがモデル用のデータエンコードに使用するトークナイザーです。このオブジェクトは [PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend) を継承しています。 task (`str`、デフォルトは `""`) : パイプラインのタスク識別子です。 num_workers (`int`、*任意*、デフォルトは 8) : パイプラインが *DataLoader* を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）、使用するワーカーの数。 batch_size (`int`、*optional*、デフォルトは 1) : パイプラインが*DataLoader*を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）に、使用するバッチサイズです。推論では常に有益とは限らないため、[Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching)をお読みください。 args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/ja/internal/pipelines_utils#transformers.pipelines.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 例: ```python >>> from transformers import pipeline >>> oracle = pipeline(model="google/tapas-base-finetuned-wtq") >>> table = { ... "Repository": ["Transformers", "Datasets", "Tokenizers"], ... "Stars": ["36542", "4512", "3934"], ... "Contributors": ["651", "77", "34"], ... "Programming language": ["Python", "Python", "Rust, Python and NodeJS"], ... } >>> oracle(query="How many stars does the transformers repository have?", table=table) {'answer': 'AVERAGE > 36542', 'coordinates': [(0, 1)], 'cells': ['36542'], 'aggregator': 'AVERAGE'} ``` [pipeline チュートリアル](../pipeline_tutorial)で、pipeline の基本的な使用方法について詳しく学んでください。 この表形式の質問応答パイプラインは、現在、[pipeline()](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.pipeline)から、以下のタスク識別子 `"table-question-answering"` を使用して読み込むことができます。 このパイプラインで使用できるモデルは、表形式の質問応答タスクでファインチューニングされたモデルです。利用可能なモデルの最新リストは、[huggingface.co/models](https://huggingface.co/models?filter=table-question-answering)でご覧いただけます。 #### __call__[[transformers.TableQuestionAnsweringPipeline.__call__]] ```python __call__(*args, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/table_question_answering.py#L208) **パラメータ:** table (`pd.DataFrame` または `Dict`) : テーブルのすべての値を含む DataFrame に変換される Pandas DataFrame または辞書です。辞書の例については上記を参照してください。 query (`str` または `list[str]`) : テーブルとともにモデルに送信されるクエリ、またはクエリのリスト。 sequential (`bool`、*任意*、デフォルトは`False`) : 推論を逐次的に行うか、バッチとして行うかを指定します。バッチ処理の方が高速ですが、SQAのようなモデルは、対話的な性質から、シーケンス内の関係を抽出するために逐次的な推論を行う必要があります。 padding (`bool`、`str`または[PaddingStrategy](/docs/transformers/v5.23.0/ja/internal/file_utils#transformers.utils.PaddingStrategy)、*optional*、デフォルトは`False`) : パディングの有効化と制御を行います。以下の値を受け取ります: - `True`または`'longest'`: バッチ内の最長のシーケンスの長さにパディングします（単一のシーケンスのみが提供された場合は、パディングを行いません）。 - `'max_length'`: 引数`max_length`で指定された最大長、またはその引数が提供されていない場合はモデルが受け入れ可能な最大入力長までパディングします。 - `False`または`'do_not_pad'`（デフォルト）: パディングを行いません（つまり、長さが異なるシーケンスのバッチを出力できます）。 truncation (`bool`、`str`または`TapasTruncationStrategy`、*optional*、デフォルトは`False`) : トランケーションを有効化し、制御します。以下の値を受け取ります: - `True`または`'drop_rows_to_fit'`: 引数`max_length`で指定された最大長、またはその引数が提供されていない場合はモデルが許容する最大入力長まで、行単位で切り詰め、テーブルから行を削除します。 - `False`または`'do_not_truncate'`（デフォルト）: トランケーションを行いません（つまり、モデルが許容する最大入力サイズを超えるシーケンス長を持つバッチを出力する可能性があります）。 **戻り値:** `A dictionary or a list of dictionaries containing results` 各結果は、以下のキーを持つ辞書です: - **answer** (`str`) -- テーブルを前提としたクエリの答えです。アグリゲーターがある場合、答えの前に`AGGREGATOR >`が付きます。 - **coordinates** (`list[tuple[int, int]]`) -- 回答のセルの座標。 - **cells** (`list[str]`) -- 回答セルの値で構成された文字列のリスト。 - **aggregator** (`str`) -- モデルに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 を指定します: 例: ```python data = { "actors": ["brad pitt", "leonardo di caprio", "george clooney"], "age": ["56", "45", "59"], "number of movies": ["87", "53", "69"], "date of birth": ["7 february 1967", "10 june 1996", "28 november 1967"], } ``` この辞書はそのまま渡すことも、pandas の DataFrame に変換することもできます。 例: ```python import pandas as pd table = pd.DataFrame.from_dict(data) ``` ### TextClassificationPipeline[[transformers.TextClassificationPipeline]] #### transformers.TextClassificationPipeline[[transformers.TextClassificationPipeline]] ```python transformers.TextClassificationPipeline(**kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/text_classification.py#L43) **パラメータ:** model ([PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)) : パイプラインが予測を行う際に使用するモデルです。[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承するモデルである必要があります。 tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend)) : パイプラインがモデル用のデータエンコードに使用するトークナイザーです。このオブジェクトは [PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend) を継承しています。 task (`str`、デフォルトは `""`) : パイプラインのタスク識別子です。 num_workers (`int`、*任意*、デフォルトは 8) : パイプラインが *DataLoader* を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）、使用するワーカーの数。 batch_size (`int`、*optional*、デフォルトは 1) : パイプラインが*DataLoader*を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）に、使用するバッチサイズです。推論では常に有益とは限らないため、[Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching)をお読みください。 args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/ja/internal/pipelines_utils#transformers.pipelines.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"`: モデルが単一のラベルを持つ場合、出力にシグモイド関数を適用します。複数のラベルを持つ場合、出力にソフトマックス関数を適用します。回帰タスクの場合、出力には関数を適用しません。 - `"sigmoid"`: 出力にシグモイド関数を適用します。 - `"softmax"`: 出力にソフトマックス関数を適用します。 - `"none"`: 出力には関数を適用しません。 `ModelForSequenceClassification` を使用したテキスト分類パイプラインです。詳細については、[シーケンス分類の例](../task_summary#sequence-classification)を参照してください。 例: ```python >>> from transformers import pipeline >>> classifier = pipeline(model="distilbert/distilbert-base-uncased-finetuned-sst-2-english") >>> classifier("This movie is disgustingly good !") [{'label': 'POSITIVE', 'score': 1.0}] >>> classifier("Director tried too much.") [{'label': 'NEGATIVE', 'score': 0.996}] ``` [pipeline チュートリアル](../pipeline_tutorial)で、pipeline の基本的な使用方法について詳しく学んでください。 このテキスト分類パイプラインは、現在、[pipeline()](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.pipeline)から、以下のタスク識別子 `"sentiment-analysis"` を使用して読み込むことができます（ポジティブまたはネガティブの感情に基づいてシーケンスを分類する場合）。 複数の分類ラベルが利用可能な場合（`model.config.num_labels >= 2`）、pipeline は結果に対して softmax を実行します。ラベルが1つのみの場合、pipeline は結果に対して sigmoid を実行します。回帰タスクの場合（`model.config.problem_type == "regression"`）、出力には関数を適用しません。 このパイプラインで使用できるモデルは、シーケンス分類タスクでファインチューニングされたモデルです。利用可能なモデルの最新リストは、[huggingface.co/models](https://huggingface.co/models?filter=text-classification)を参照してください。 #### __call__[[transformers.TextClassificationPipeline.__call__]] ```python __call__(inputs: str | list[str] | dict[str, str] | list[dict[str, str]], **kwargs: Any) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/text_classification.py#L105) **パラメータ:** inputs (`str` または `list[str]` または `dict[str]`、または `list[dict[str]]`) : 分類対象のテキストを1つ以上指定します。分類にテキストペアを使用するには、`{"text", "text_pair"}` キーを含む辞書、またはそのリストを渡すことができます。 top_k (`int`、*任意*、デフォルトは`1`) : 返す結果の数。 function_to_apply (`str`、*任意*、デフォルトは`"default"`) : モデルの出力に適用してスコアを取得するための関数です。4つの異なる値を受け取ります: この引数が指定されない場合、ラベルの数に応じて以下の関数が適用されます: - 問題の種類が回帰の場合、出力には関数を適用しません。 - モデルが単一のラベルを持つ場合、出力にシグモイド関数を適用します。 - モデルが複数のラベルを持つ場合、出力にソフトマックス関数を適用します。 指定可能な値は以下の通りです: - `"sigmoid"`: 出力にシグモイド関数を適用します。 - `"softmax"`: 出力にソフトマックス関数を適用します。 - `"none"`: 出力には関数を適用しません。 **戻り値:** `dict`のリスト 各結果は、以下のキーを持つ辞書のリストとして返されます。 - **label** (`str`) -- 予測されたラベル。 - **score** (`float`) -- 対応する確率。 `top_k`が使用されている場合、ラベルごとに1つの辞書が返されます。 入力として与えられたテキストを分類します。 ### TextGenerationPipeline[[transformers.TextGenerationPipeline]] #### transformers.TextGenerationPipeline[[transformers.TextGenerationPipeline]] ```python transformers.TextGenerationPipeline(*args, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/text_generation.py#L23) **パラメータ:** model ([PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)) : パイプラインが予測を行う際に使用するモデルです。[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承するモデルである必要があります。 tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend)) : パイプラインがモデル用のデータエンコードに使用するトークナイザーです。このオブジェクトは [PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend) を継承しています。 task (`str`、デフォルトは `""`) : パイプラインのタスク識別子です。 num_workers (`int`、*任意*、デフォルトは 8) : パイプラインが *DataLoader* を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）、使用するワーカーの数。 batch_size (`int`、*optional*、デフォルトは 1) : パイプラインが*DataLoader*を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）に、使用するバッチサイズです。推論では常に有益とは限らないため、[Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching)をお読みください。 args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/ja/internal/pipelines_utils#transformers.pipelines.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 例: ```python >>> from transformers import pipeline >>> generator = pipeline(model="openai-community/gpt2") >>> generator("I can't believe you did such a ", do_sample=False) [{'generated_text': "I can't believe you did such a icky thing to me. I'm so sorry. I'm so sorry. I'm so sorry. I'm so sorry. I'm so sorry. I'm so sorry. I'm so sorry. I"}] >>> # These parameters will return suggestions, and only the newly created text making it easier for prompting suggestions. >>> outputs = generator("My tart needs some", num_return_sequences=4, return_full_text=False) ``` ```python >>> from transformers import pipeline >>> generator = pipeline(model="HuggingFaceH4/zephyr-7b-beta") >>> # Zephyr-beta is a conversational model, so let's pass it a chat instead of a single string >>> generator([{"role": "user", "content": "What is the capital of France? Answer in one word."}], do_sample=False, max_new_tokens=2) [{'generated_text': [{'role': 'user', 'content': 'What is the capital of France? Answer in one word.'}, {'role': 'assistant', 'content': 'Paris'}]}] ``` パイプラインの基本的な使い方については、[パイプラインのチュートリアル](../pipeline_tutorial)を参照してください。このパイプラインには、停止条件やデコーディング戦略などを制御するために、テキスト生成のパラメータを渡すことができます。テキスト生成のパラメータについては、[Text generation strategies](../generation_strategies)および[Text generation](text_generation)を参照してください。 この言語生成パイプラインは、現在、[pipeline()](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.pipeline)から、以下のタスク識別子 `"text-generation"` を使用して読み込むことができます。 このパイプラインで使用できるモデルは、自己回帰型言語モデリングの目的で学習されたモデルです。[huggingface.co/models] にある利用可能な[テキスト補完モデル](https://huggingface.co/models?filter=text-generation)のリストと、[対話型モデル](https://huggingface.co/models?other=conversational)のリストを参照してください。 #### __call__[[transformers.TextGenerationPipeline.__call__]] ```python __call__(text_inputs, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/text_generation.py#L253) **パラメータ:** text_inputs (`str`、`list[str]`、`ChatType`、または `list[ChatType]`) : 補完する 1 つ以上のプロンプト（またはプロンプトのリスト 1 つ）です。文字列または文字列のリストが渡された場合、このパイプラインは各プロンプトを補完します。代わりに、"role" と "content" キーを持つ dict のリストという形式の "chat"、またはそのようなチャットのリストを渡すこともできます。チャットが渡された場合、モデルのチャットテンプレートを使用して整形してから、モデルに渡されます。 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`, *任意*) : 入力チャットの最後のメッセージを新しいメッセージとして開始するのではなく、その続きを生成することをモデルに指示します。これにより、応答を「プリフィル」できます。デフォルトでは、入力チャットの最後のメッセージが`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 メソッドの詳細は[こちら](./text_generation)を参照）。 **戻り値:** `dict` のリスト、または `dict` のリストのリスト `generated_text`と`generated_token_ids`の両方を組み合わせた形で返すことはできず、以下のいずれかの辞書を返します。 - **generated_text** (`str`、`return_text=True` の場合のみ存在) -- 生成されたテキスト。 - **generated_token_ids** (`torch.Tensor`、`return_tensors=True` の場合に存在) -- 生成されたテキストのトークン ID です。 入力として与えられたプロンプトを補完します。 ### TokenClassificationPipeline[[transformers.TokenClassificationPipeline]] #### transformers.TokenClassificationPipeline[[transformers.TokenClassificationPipeline]] ```python transformers.TokenClassificationPipeline(args_parser = , **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/token_classification.py#L91) **パラメータ:** model ([PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)) : パイプラインが予測を行う際に使用するモデルです。[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承するモデルである必要があります。 tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend)) : パイプラインがモデル用のデータエンコードに使用するトークナイザーです。このオブジェクトは [PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend) を継承しています。 task (`str`、デフォルトは `""`) : パイプラインのタスク識別子です。 num_workers (`int`、*任意*、デフォルトは 8) : パイプラインが *DataLoader* を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）、使用するワーカーの数。 batch_size (`int`、*optional*、デフォルトは 1) : パイプラインが*DataLoader*を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）に、使用するバッチサイズです。推論では常に有益とは限らないため、[Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching)をお読みください。 args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/ja/internal/pipelines_utils#transformers.pipelines.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" : (単語ベースのモデルでのみ機能) `SIMPLE` 戦略を使用しますが、単語が異なるタグを持つことはありません。スコアはまずトークン間で平均化され、その後、最大ラベルが適用されます。 - "max" : (単語ベースのモデルでのみ機能) `SIMPLE` 戦略を使用しますが、単語が異なるタグを持つことはありません。単語のエンティティは単に最大スコアを持つトークンになります。 `ModelForTokenClassification` を使用した Named Entity Recognition パイプラインです。詳細は [named entity recognition examples](../task_summary#named-entity-recognition) を参照してください。 例: ```python >>> from transformers import pipeline >>> token_classifier = pipeline(model="Jean-Baptiste/camembert-ner", aggregation_strategy="simple") >>> sentence = "Je m'appelle jean-baptiste et je vis à montréal" >>> tokens = token_classifier(sentence) >>> tokens [{'entity_group': 'PER', 'score': 0.9931, 'word': 'jean-baptiste', 'start': 12, 'end': 26}, {'entity_group': 'LOC', 'score': 0.998, 'word': 'montréal', 'start': 38, 'end': 47}] >>> token = tokens[0] >>> # Start and end provide an easy way to highlight words in the original text. >>> sentence[token["start"] : token["end"]] ' jean-baptiste' >>> # Some models use the same idea to do part of speech. >>> syntaxer = pipeline(model="vblagoje/bert-english-uncased-finetuned-pos", aggregation_strategy="simple") >>> syntaxer("My name is Sarah and I live in London") [{'entity_group': 'PRON', 'score': 0.999, 'word': 'my', 'start': 0, 'end': 2}, {'entity_group': 'NOUN', 'score': 0.997, 'word': 'name', 'start': 3, 'end': 7}, {'entity_group': 'AUX', 'score': 0.994, 'word': 'is', 'start': 8, 'end': 10}, {'entity_group': 'PROPN', 'score': 0.999, 'word': 'sarah', 'start': 11, 'end': 16}, {'entity_group': 'CCONJ', 'score': 0.999, 'word': 'and', 'start': 17, 'end': 20}, {'entity_group': 'PRON', 'score': 0.999, 'word': 'i', 'start': 21, 'end': 22}, {'entity_group': 'VERB', 'score': 0.998, 'word': 'live', 'start': 23, 'end': 27}, {'entity_group': 'ADP', 'score': 0.999, 'word': 'in', 'start': 28, 'end': 30}, {'entity_group': 'PROPN', 'score': 0.999, 'word': 'london', 'start': 31, 'end': 37}] ``` [pipeline チュートリアル](../pipeline_tutorial)で、pipeline の基本的な使用方法について詳しく学んでください。 このトークン認識パイプラインは、現在、[pipeline()](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.pipeline)から、以下のタスク識別子 `"ner"` を使用して読み込むことができます（シーケンス内のトークンのクラスを予測します：人物、組織、場所、その他）。 このパイプラインで使用できるモデルは、トークン分類タスクでファインチューニングされたモデルです。利用可能なモデルの最新リストは、[huggingface.co/models](https://huggingface.co/models?filter=token-classification)を参照してください。 #### __call__[[transformers.TokenClassificationPipeline.__call__]] ```python __call__(inputs: str | list[str], **kwargs: Any) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/token_classification.py#L210) **パラメータ:** 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[[transformers.TokenClassificationPipeline.aggregate_words]] ```python aggregate_words(entities: list[dict], aggregation_strategy: AggregationStrategy) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/token_classification.py#L522) 単語境界での一致を強制するために、一致しない指定された単語のトークンを上書きします。 例: micro|soft| com|pany| B-ENT I-NAME I-ENT I-ENT は、最初の戦略によって micro|soft| company| B-ENT I-ENT に書き換えられます。 #### gather_pre_entities[[transformers.TokenClassificationPipeline.gather_pre_entities]] ```python gather_pre_entities(sentence: str, input_ids: ndarray, scores: ndarray, offset_mapping: list[tuple[int, int]] | None, special_tokens_mask: ndarray, aggregation_strategy: AggregationStrategy, word_ids: list[int | None] | None = None, word_to_chars_map: list[tuple[int, int]] | None = None) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/token_classification.py#L398) numpy配列を融合し、集計に必要なすべての情報を含む辞書に変換します #### group_entities[[transformers.TokenClassificationPipeline.group_entities]] ```python group_entities(entities: list[dict]) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/token_classification.py#L585) **パラメータ:** entities (`dict`) : パイプラインによって予測されたエンティティ。 予測されたエンティティが同じである隣接するトークンを特定し、グループ化します。 #### group_sub_entities[[transformers.TokenClassificationPipeline.group_sub_entities]] ```python group_sub_entities(entities: list[dict]) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/token_classification.py#L550) **パラメータ:** entities (`dict`) : パイプラインによって予測されたエンティティ。 予測されたエンティティが同じである隣接するトークンをグループ化します。 ### ZeroShotClassificationPipeline[[transformers.ZeroShotClassificationPipeline]] #### transformers.ZeroShotClassificationPipeline[[transformers.ZeroShotClassificationPipeline]] ```python transformers.ZeroShotClassificationPipeline(args_parser = , **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/zero_shot_classification.py#L44) **パラメータ:** model ([PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)) : パイプラインが予測を行う際に使用するモデルです。[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承するモデルである必要があります。 tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend)) : パイプラインがモデル用のデータエンコードに使用するトークナイザーです。このオブジェクトは [PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend) を継承しています。 task (`str`、デフォルトは `""`) : パイプラインのタスク識別子です。 num_workers (`int`、*任意*、デフォルトは 8) : パイプラインが *DataLoader* を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）、使用するワーカーの数。 batch_size (`int`、*optional*、デフォルトは 1) : パイプラインが*DataLoader*を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）に、使用するバッチサイズです。推論では常に有益とは限らないため、[Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching)をお読みください。 args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/ja/internal/pipelines_utils#transformers.pipelines.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モデルは任意のものを使用できますが、モデル設定の:attr:*~transformers.PreTrainedConfig.label2id*に*entailment*ラベルのidが含まれている必要があります。 例: ```python >>> from transformers import pipeline >>> oracle = pipeline(model="facebook/bart-large-mnli") >>> oracle( ... "I have a problem with my iphone that needs to be resolved asap!!", ... candidate_labels=["urgent", "not urgent", "phone", "tablet", "computer"], ... ) {'sequence': 'I have a problem with my iphone that needs to be resolved asap!!', 'labels': ['urgent', 'phone', 'computer', 'not urgent', 'tablet'], 'scores': [0.504, 0.479, 0.013, 0.003, 0.002]} >>> oracle( ... "I have a problem with my iphone that needs to be resolved asap!!", ... candidate_labels=["english", "german"], ... ) {'sequence': 'I have a problem with my iphone that needs to be resolved asap!!', 'labels': ['english', 'german'], 'scores': [0.814, 0.186]} ``` [pipeline チュートリアル](../pipeline_tutorial)で、pipeline の基本的な使用方法について詳しく学んでください。 この NLI パイプラインは、現在、[pipeline()](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.pipeline) から、次のタスク識別子 `"zero-shot-classification"` を使用して読み込むことができます。 このパイプラインで使用できるモデルは、NLIタスクでファインチューニングされたモデルです。利用可能なモデルの最新リストは、[huggingface.co/models](https://huggingface.co/models?search=nli)でご覧いただけます。 #### __call__[[transformers.ZeroShotClassificationPipeline.__call__]] ```python __call__(sequences: str | list[str], *args, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/zero_shot_classification.py#L159) **パラメータ:** sequences (`str` または `list[str]`) : 分類対象のシーケンスです。モデルの入力が大きすぎる場合は切り詰められます。 candidate_labels (`str` または `list[str]`) : 各シーケンスを分類するための候補となるクラスラベルの集合です。単一のラベル、カンマ区切りのラベル文字列、またはラベルのリストを指定できます。 hypothesis_template (`str`、*任意*、デフォルトは `"This example is {}."`) : 各ラベルを NLI スタイルの仮説に変換するために使用されるテンプレートです。このテンプレートには、候補ラベルを挿入するための {} または同様の構文を含める必要があります。例えば、デフォルトのテンプレートは `"This example is {}."` であり、候補ラベルが `"sports"` の場合、モデルには `" sequence to classify This example is sports . "` のように渡されます。デフォルトのテンプレートは多くのケースで機能しますが、タスクの状況に応じて、異なるテンプレートを試す価値がある場合があります。 multi_label (`bool`、*任意*、デフォルトは`False`) : 複数の候補ラベルが同時に真になり得るかどうかを指定します。`False`の場合、各シーケンスにおけるラベルの尤度の合計が1になるようにスコアが正規化されます。`True`の場合、ラベルは独立であるとみなされ、エンタイルメントスコアとコントラディクションスコアに対してsoftmaxを適用することで、各候補ごとに確率が正規化されます。 **戻り値:** `dict` または `dict` のリスト 各結果は、以下のキーを持つ辞書として返されます。 - **sequence** (`str`) -- この出力が対応するシーケンス。 - **labels** (`list[str]`) -- 可能性の高い順に並べられたラベルのリストです。 - **scores** (`list[float]`) -- 各ラベルの確率。 入力として与えられたシーケンスを分類します。詳細については、[ZeroShotClassificationPipeline](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.ZeroShotClassificationPipeline)のドキュメントを参照してください。 ## マルチモーダル マルチモーダルタスクで利用可能なパイプラインには、次のものがあります。 ### DocumentQuestionAnsweringPipeline[[transformers.DocumentQuestionAnsweringPipeline]] #### transformers.DocumentQuestionAnsweringPipeline[[transformers.DocumentQuestionAnsweringPipeline]] ```python transformers.DocumentQuestionAnsweringPipeline(*args, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/document_question_answering.py#L206) **パラメータ:** model ([PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)) : パイプラインが予測を行う際に使用するモデルです。[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承するモデルである必要があります。 tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend)) : パイプラインがモデル用のデータエンコードに使用するトークナイザーです。このオブジェクトは [PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend) を継承しています。 image_processor ([BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor)) : パイプラインがモデル用のデータエンコードに使用する画像プロセッサです。このオブジェクトは [BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor) を継承しています。 task (`str`、デフォルトは `""`) : パイプラインのタスク識別子です。 num_workers (`int`、*任意*、デフォルトは 8) : パイプラインが *DataLoader* を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）、使用するワーカーの数。 batch_size (`int`、*optional*、デフォルトは 1) : パイプラインが*DataLoader*を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）に、使用するバッチサイズです。推論では常に有益とは限らないため、[Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching)をお読みください。 args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/ja/internal/pipelines_utils#transformers.pipelines.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`を使用してドキュメント質問応答パイプラインを実行します。入力/出力は（抽出型）質問応答パイプラインと似ていますが、テキストコンテキストの代わりに画像（および任意のOCR済み単語/ボックス）を入力として受け取ります。 使用しているモデルが設定ファイル（`generation_config.json`）でこれらの生成パラメータを明示的に設定していない場合、以下のデフォルト値が使用されます。 - max_new_tokens: 256 例: ```python >>> from transformers import pipeline >>> document_qa = pipeline(model="impira/layoutlm-document-qa") >>> document_qa( ... image="https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/invoice_docquery_a.png", ... question="What is the invoice number?", ... ) [{'score': 0.425, 'answer': 'us-001', 'start': 16, 'end': 16}] ``` [pipeline チュートリアル](../pipeline_tutorial)で、pipeline の基本的な使用方法について詳しく学んでください。 この文書質問応答パイプラインは、現在、[pipeline()](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.pipeline)から、以下のタスク識別子 `"document-question-answering"` を使用して読み込むことができます。 このパイプラインで使用できるモデルは、文書質問応答タスクでファインチューニングされたモデルです。利用可能なモデルの最新リストは、[huggingface.co/models](https://huggingface.co/models?filter=document-question-answering)でご覧いただけます。 #### __call__[[transformers.DocumentQuestionAnsweringPipeline.__call__]] ```python __call__(image: typing.Union[ForwardRef('Image.Image'), str, list[dict[str, typing.Any]]], question: str | None = None, word_boxes: tuple[str, list[float]] | None = None, **kwargs: Any) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/document_question_answering.py#L338) **パラメータ:** 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`、*optional*、デフォルトは 1) : 返す回答の数（確率の高い順に選択されます）。コンテキスト内に十分な選択肢がない場合は、top_k より少ない数の回答が返されます。 doc_stride (`int`, *optional*, デフォルトは 128) : ドキュメント内の単語が長すぎて、モデルの質問と合わせて収まらない場合、ある程度の重複を伴って複数のチャンクに分割されます。この引数は、その重複のサイズを制御します。 max_answer_len (`int`、*optional*、デフォルトは 15) : 予測される回答の最大長（例：より短い長さの回答のみが対象とされる）。 max_seq_len (`int`, *optional*, デフォルトは 384) : モデルに渡される各チャンクにおける、文全体（コンテキスト + 質問）の最大トークン数です。必要に応じて、コンテキストは `doc_stride` を重複部分として使用して複数のチャンクに分割されます。 max_question_len (`int`、*optional*、デフォルトは 64) : トークナイズ後の質問の最大長です。必要に応じて切り詰められます。 handle_impossible_answer (`bool`、*任意*、デフォルトは `False`) : 不可能を回答として受け入れるかどうか。 lang (`str`, *任意*) : OCR 実行時に使用する言語。デフォルトは english です。 tesseract_config (`str`, *任意*) : OCR 実行時に tesseract に渡す追加フラグ。 timeout (`float`、*任意*、デフォルトは None) : ウェブから画像を取得する際に待機する最大時間（秒）。None の場合はタイムアウトが設定されず、呼び出しが永久にブロックされる可能性があります。 **戻り値:** `dict` または `dict` のリスト 各結果は、以下のキーを持つ辞書として返されます。 - **score** (`float`) -- 回答に関連付けられた確率。 - **start** (`int`) -- 回答の開始単語インデックス（入力または提供された`word_boxes`のOCR済みバージョンにおけるもの）。 - **end** (`int`) -- 回答の終了単語インデックス（入力または提供された`word_boxes`のOCR済みバージョンにおけるもの）。 - **answer** (`str`) -- 質問に対する回答。 - **words** (`list[int]`) -- 回答に含まれる各単語/ボックスペアのインデックス 入力として与えられた質問に、ドキュメントを用いて答えます。ドキュメントは、画像と、ドキュメント内のテキストを表す（単語、ボックス）のタプルの任意のリストで定義されます。`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[[transformers.FeatureExtractionPipeline]] #### transformers.FeatureExtractionPipeline[[transformers.FeatureExtractionPipeline]] ```python transformers.FeatureExtractionPipeline(model: PreTrainedModel, tokenizer: PreTrainedTokenizer | None = None, feature_extractor: PreTrainedFeatureExtractor | None = None, image_processor: BaseImageProcessor | None = None, video_processor: BaseVideoProcessor | None = None, processor: ProcessorMixin | None = None, task: str = '', device: int | torch.device | None = None, binary_output: bool = False, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/feature_extraction.py#L15) **パラメータ:** model ([PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)) : パイプラインが予測を行う際に使用するモデルです。[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承するモデルである必要があります。 tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend)) : パイプラインがモデル用のデータエンコードに使用するトークナイザーです。このオブジェクトは [PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend) を継承しています。 task (`str`、デフォルトは `""`) : パイプラインのタスク識別子です。 num_workers (`int`、*任意*、デフォルトは 8) : パイプラインが *DataLoader* を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）、使用するワーカーの数。 batch_size (`int`、*optional*、デフォルトは 1) : パイプラインが*DataLoader*を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）に、使用するバッチサイズです。推論では常に有益とは限らないため、[Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching)をお読みください。 args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/ja/internal/pipelines_utils#transformers.pipelines.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 から隠れ状態を抽出し、それを下流タスクの機能として利用できます。 例: ```python >>> from transformers import pipeline >>> extractor = pipeline(model="google-bert/bert-base-uncased", task="feature-extraction") >>> result = extractor("This is a simple test.", return_tensors=True) >>> result.shape # This is a tensor of shape [1, sequence_length, hidden_dimension] representing the input string. torch.Size([1, 8, 768]) ``` [pipeline チュートリアル](../pipeline_tutorial)で、pipeline の基本的な使用方法について詳しく学んでください。 この特徴抽出パイプラインは、現在、タスク識別子 `"feature-extraction"` を使用して [pipeline()](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.pipeline) から読み込むことができます。 このパイプラインにはすべてのモデルを使用できます。コミュニティが貢献したモデルを含むすべてのモデルの一覧は、[huggingface.co/models](https://huggingface.co/models)を参照してください。 #### __call__[[transformers.FeatureExtractionPipeline.__call__]] ```python __call__(*args: str | list[str], **kwargs: Any) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/feature_extraction.py#L78) **パラメータ:** args (`str` または `list[str]`) : 特徴量を取得するテキスト1つ以上（またはテキストのリスト1つ）。 **戻り値:** `float` のネストされたリスト モデルによって計算される特徴量。 入力テキストの特徴量を抽出します。 ### ImageFeatureExtractionPipeline[[transformers.ImageFeatureExtractionPipeline]] #### transformers.ImageFeatureExtractionPipeline[[transformers.ImageFeatureExtractionPipeline]] ```python transformers.ImageFeatureExtractionPipeline(model: PreTrainedModel, tokenizer: PreTrainedTokenizer | None = None, feature_extractor: PreTrainedFeatureExtractor | None = None, image_processor: BaseImageProcessor | None = None, video_processor: BaseVideoProcessor | None = None, processor: ProcessorMixin | None = None, task: str = '', device: int | torch.device | None = None, binary_output: bool = False, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/image_feature_extraction.py#L23) **パラメータ:** model ([PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)) : パイプラインが予測を行う際に使用するモデルです。[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承するモデルである必要があります。 image_processor ([BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor)) : パイプラインがモデル用のデータエンコードに使用する画像プロセッサです。このオブジェクトは [BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor) を継承しています。 task (`str`、デフォルトは `""`) : パイプラインのタスク識別子です。 num_workers (`int`、*任意*、デフォルトは 8) : パイプラインが *DataLoader* を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）、使用するワーカーの数。 batch_size (`int`、*optional*、デフォルトは 1) : パイプラインが*DataLoader*を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）に、使用するバッチサイズです。推論では常に有益とは限らないため、[Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching)をお読みください。 args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/ja/internal/pipelines_utils#transformers.pipelines.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 パイプラインはモデルヘッドを使用しません。このパイプラインはベースの Transformer から隠れ状態を抽出し、それを下流タスクの機能として利用できます。 例: ```python >>> from transformers import pipeline >>> extractor = pipeline(model="google/vit-base-patch16-224", task="image-feature-extraction") >>> result = extractor("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png", return_tensors=True) >>> result.shape # This is a tensor of shape [1, sequence_length, hidden_dimension] representing the input image. torch.Size([1, 197, 768]) ``` [pipeline チュートリアル](../pipeline_tutorial)で、pipeline の基本的な使用方法について詳しく学んでください。 この画像特徴抽出パイプラインは、現在、タスク識別子 `"image-feature-extraction"` を使用して [pipeline()](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.pipeline) から読み込むことができます。 このパイプラインには、すべてのビジョンモデルを使用できます。コミュニティが貢献したモデルを含むすべてのモデルのリストは、[huggingface.co/models](https://huggingface.co/models)を参照してください。 #### __call__[[transformers.ImageFeatureExtractionPipeline.__call__]] ```python __call__(*args: typing.Union[str, ForwardRef('Image.Image'), list['Image.Image'], list[str]], **kwargs: Any) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/image_feature_extraction.py#L94) **パラメータ:** images (`str`、`list[str]`、`PIL.Image` または `list[PIL.Image]`) : パイプラインは、以下の 3 種類の画像を処理します。 - 画像を指す http リンクを含む文字列 - 画像のローカルパスを含む文字列 - PIL で直接読み込まれた画像 パイプラインは、単一の画像または画像のバッチを受け取ります。バッチとして渡す場合は、文字列として渡す必要があります。バッチ内の画像はすべて同じ形式である必要があります。すなわち、すべて http リンク、すべてローカルパス、またはすべて PIL 画像である必要があります。 timeout (`float`、*optional*、デフォルトは None) : Web から画像を取得する際に待機する最大時間（秒）。None の場合はタイムアウトが設定されず、呼び出しが永久にブロックされる可能性があります。 **戻り値:** `float` のネストされたリスト モデルによって計算される特徴量。 入力の特徴量を抽出します。 ### ImageTextToTextPipeline[[transformers.ImageTextToTextPipeline]] #### transformers.ImageTextToTextPipeline[[transformers.ImageTextToTextPipeline]] ```python transformers.ImageTextToTextPipeline(*args, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/image_text_to_text.py#L53) **パラメータ:** model ([PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)) : パイプラインが予測を行う際に使用するモデルです。[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承するモデルである必要があります。 processor ([ProcessorMixin](/docs/transformers/v5.23.0/ja/main_classes/processors#transformers.ProcessorMixin)) : パイプラインがモデル用のデータエンコードに使用するプロセッサです。このオブジェクトは [ProcessorMixin](/docs/transformers/v5.23.0/ja/main_classes/processors#transformers.ProcessorMixin) を継承しています。プロセッサは複合オブジェクトであり、`tokenizer`、`feature_extractor`、`image_processor` を含める場合があります。 task (`str`、デフォルトは `""`) : パイプラインのタスク識別子です。 num_workers (`int`、*任意*、デフォルトは 8) : パイプラインが *DataLoader* を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）、使用するワーカーの数。 batch_size (`int`、*optional*、デフォルトは 1) : パイプラインが*DataLoader*を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）に、使用するバッチサイズです。推論では常に有益とは限らないため、[Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching)をお読みください。 args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/ja/internal/pipelines_utils#transformers.pipelines.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 例: ```python >>> from transformers import pipeline >>> pipe = pipeline(task="image-text-to-text", model="Salesforce/blip-image-captioning-base") >>> pipe("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png", text="A photo of") [{'generated_text': 'a photo of two birds'}] ``` ```python >>> from transformers import pipeline >>> pipe = pipeline("image-text-to-text", model="llava-hf/llava-interleave-qwen-0.5b-hf") >>> messages = [ >>> { >>> "role": "user", >>> "content": [ >>> { >>> "type": "image", >>> "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/qwen_vl_demo.jpeg", >>> }, >>> {"type": "text", "text": "Describe this image."}, >>> ], >>> }, >>> { >>> "role": "assistant", >>> "content": [ >>> {"type": "text", "text": "There is a dog and"}, >>> ], >>> }, >>> ] >>> pipe(text=messages, max_new_tokens=20, return_full_text=False) [{'input_text': [{'role': 'user', 'content': [{'type': 'image', 'url': 'https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/qwen_vl_demo.jpeg'}, {'type': 'text', 'text': 'Describe this image.'}]}, {'role': 'assistant', 'content': [{'type': 'text', 'text': 'There is a dog and'}]}], 'generated_text': ' a person in the image. The dog is sitting on the sand, and the person is sitting on'}] ``` [pipeline チュートリアル](../pipeline_tutorial)で、pipeline の基本的な使用方法について詳しく学んでください。 この画像・テキストからテキストへのパイプラインは、現在、pipeline() を使用して、次のタスク識別子 "image-text-to-text" で読み込むことができます。 利用可能なモデルの一覧は、[huggingface.co/models](https://huggingface.co/models?pipeline_tag=image-text-to-text) をご覧ください。 #### __call__[[transformers.ImageTextToTextPipeline.__call__]] ```python __call__(images: typing.Union[str, list[str], list[list[str]], ForwardRef('Image.Image'), list['Image.Image'], list[list['Image.Image']], list[dict], NoneType] = None, text: str | list[str] | list[dict] | None = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/image_text_to_text.py#L217) **パラメータ:** images (`str`, `list[str]`, `PIL.Image, `list[PIL.Image]`, `list[dict[str, Union[str, PIL.Image]]]`) : The pipeline handles three types of images: - A string containing a HTTP(s) link pointing to an image - A string containing a local path to an image - An image loaded in PIL directly The pipeline accepts either a single image or a batch of images. Finally, this pipeline also supports the chat format (see `text`) containing images and text in this argument. text (str, list[str], `list[dict[str, Union[str, PIL.Image]]]`) : 生成に使用するテキスト。文字列のリストが渡される場合、リストの長さは画像の数と一致する必要があります。テキストはチャット形式でも指定できます。これは、各辞書が会話内のメッセージを表す辞書のリストです。各辞書には 'role' と 'content' という2つのキーが必要です。'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`, *任意*) : 入力チャットの最後のメッセージを新しいメッセージとして開始するのではなく、その続きを生成することをモデルに指示します。これにより、応答を「プリフィル」できます。デフォルトでは、入力チャットの最後のメッセージが`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[[transformers.AnyToAnyPipeline]] #### transformers.AnyToAnyPipeline[[transformers.AnyToAnyPipeline]] ```python transformers.AnyToAnyPipeline(*args, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/any_to_any.py#L67) **パラメータ:** model ([PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)) : パイプラインが予測を行う際に使用するモデルです。[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承するモデルである必要があります。 processor ([ProcessorMixin](/docs/transformers/v5.23.0/ja/main_classes/processors#transformers.ProcessorMixin)) : パイプラインがモデル用のデータエンコードに使用するプロセッサです。このオブジェクトは [ProcessorMixin](/docs/transformers/v5.23.0/ja/main_classes/processors#transformers.ProcessorMixin) を継承しています。プロセッサは複合オブジェクトであり、`tokenizer`、`feature_extractor`、`image_processor` を含める場合があります。 task (`str`、デフォルトは `""`) : パイプラインのタスク識別子です。 num_workers (`int`、*任意*、デフォルトは 8) : パイプラインが *DataLoader* を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）、使用するワーカーの数。 batch_size (`int`、*optional*、デフォルトは 1) : パイプラインが*DataLoader*を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）に、使用するバッチサイズです。推論では常に有益とは限らないため、[Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching)をお読みください。 args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/ja/internal/pipelines_utils#transformers.pipelines.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 例: ```python >>> from transformers import pipeline >>> pipe = pipeline(task="any-to-any", model="google/gemma-3n-E4B-it") >>> pipe("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png", text="A photo of") [{'generated_text': 'a photo of two birds'}] ``` ```python >>> from transformers import pipeline >>> pipe = pipeline("any-to-any", model="google/gemma-3n-E4B-it") >>> messages = [ >>> { >>> "role": "user", >>> "content": [ >>> { >>> "type": "image", >>> "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/qwen_vl_demo.jpeg", >>> }, >>> {"type": "text", "text": "Describe this image."}, >>> ], >>> }, >>> { >>> "role": "assistant", >>> "content": [ >>> {"type": "text", "text": "There is a dog and"}, >>> ], >>> }, >>> ] >>> pipe(text=messages, max_new_tokens=20, return_full_text=False) [{'input_text': [{'role': 'user', 'content': [{'type': 'image', 'url': 'https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/qwen_vl_demo.jpeg'}, {'type': 'text', 'text': 'Describe this image.'}]}, {'role': 'assistant', 'content': [{'type': 'text', 'text': 'There is a dog and'}]}], 'generated_text': ' a person in the image. The dog is sitting on the sand, and the person is sitting on'}] ``` [pipeline チュートリアル](../pipeline_tutorial)で、pipeline の基本的な使用方法について詳しく学んでください。 このマルチモーダルパイプラインは、現在、pipeline()から、次のタスク識別子 "any-to-any" を使用して読み込むことができます。 利用可能なモデルの一覧は、[huggingface.co/models](https://huggingface.co/models?pipeline_tag=any-to-any) をご覧ください。 #### __call__[[transformers.AnyToAnyPipeline.__call__]] ```python __call__(text: str | list[str] | list[dict], images: typing.Union[str, list[str], list[list[str]], ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, videos: typing.Union[str, list[str], list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, audio: typing.Union[str, list[str], numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/any_to_any.py#L258) **パラメータ:** text (`str`、`list[str]`、`list[dict]`) : 生成に使用されるテキスト。文字列のリストが渡される場合、リストの長さは画像の数と一致する必要があります。テキストはチャット形式に従うこともできます。これは、各辞書が会話内のメッセージを表す辞書のリストです。各辞書には 2 つのキーが必要です: 'role' と 'content'。'role' は 'user'、'system'、'assistant' のいずれかである必要があります。'content' は、メッセージのテキストとメッセージの種類を含む辞書のリストである必要があります。 images (`str`, `list[str]`, `ImageInput`) : このパイプラインは、3種類の画像を処理します。 - 画像を指す HTTP(s) リンクを含む文字列 - 画像のローカルパスを含む文字列 - PIL で直接読み込まれた画像 パイプラインは、単一の画像または画像のバッチを受け取ります。最後に、このパイプラインは、この引数に画像とテキストを含むチャット形式（`text` を参照）もサポートします。 videos (`str`, `list[str]`, `VideoInput`) : このパイプラインは、以下の3種類の動画を処理します。 - 動画へのHTTP(s)リンクを含む文字列 - ローカルパスを含む文字列 - 読み込み済みかつ配列形式にデコードされた動画 パイプラインは、単一の動画または動画のバッチを受け取ります。また、このパイプラインは、この引数に動画とテキストを含むチャット形式（`text`を参照）にも対応しています。 audio (`str`、`list[str]`、`AudioInput`) : このパイプラインは、以下の3種類のオーディオを処理します。 - オーディオを指す HTTP(s) リンクを含む文字列 - ローカルオーディオへのパスを含む文字列 - PIL に直接読み込まれたオーディオ パイプラインは、単一のオーディオまたはオーディオのバッチを受け取ります。また、このパイプラインは、この引数にオーディオとテキストを含むチャット形式（`text` を参照）にも対応しています。 return_tensors (`bool`、*任意*、デフォルトは`False`) : 出力に予測のテンソル（トークンインデックスとして）を返すかどうかを指定します。`True`に設定すると、デコードされたテキストは返されません。 return_text (`bool`, *任意*) : 出力にデコードされたテキストを返します。 return_full_text (`bool`、*任意*、デフォルトは`True`) : `False`に設定すると追加されたテキストのみが返され、それ以外の場合は完全なテキストが返されます。`return_text`と同時に指定することはできません。 clean_up_tokenization_spaces (`bool`, *任意*) : テキスト出力に含まれる可能性のある余分なスペースをクリーンアップするかどうか。デフォルトでは、トークナイザーの `clean_up_tokenization_spaces` 設定が使用されます。 continue_final_message( `bool`, *任意*) : 入力チャットの最後のメッセージを新しいメッセージとして開始するのではなく、その続きを生成することをモデルに指示します。これにより、応答を「プリフィル」できます。デフォルトでは、入力チャットの最後のメッセージが`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[[transformers.MaskGenerationPipeline]] #### transformers.MaskGenerationPipeline[[transformers.MaskGenerationPipeline]] ```python transformers.MaskGenerationPipeline(**kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/mask_generation.py#L36) **パラメータ:** model ([PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)) : パイプラインが予測を行う際に使用するモデルです。[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承するモデルである必要があります。 image_processor ([BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor)) : パイプラインがモデル用のデータエンコードに使用する画像プロセッサです。このオブジェクトは [BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor) を継承しています。 task (`str`、デフォルトは `""`) : パイプラインのタスク識別子です。 num_workers (`int`、*任意*、デフォルトは 8) : パイプラインが *DataLoader* を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）、使用するワーカーの数。 batch_size (`int`、*optional*、デフォルトは 1) : パイプラインが*DataLoader*を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）に、使用するバッチサイズです。推論では常に有益とは限らないため、[Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching)をお読みください。 args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/ja/internal/pipelines_utils#transformers.pipelines.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` を使用した画像のマスク自動生成。このパイプラインは、画像を入力として、その画像に対するバイナリマスクを予測します。ミニバッチ内の点を分離して OOM 問題を回避できるため、`ChunkPipeline` です。同時に処理する点の数は、`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 を適用して、関連するマスクのみを保持します。 例: ```python >>> from transformers import pipeline >>> generator = pipeline(model="facebook/sam-vit-base", task="mask-generation") >>> outputs = generator( ... "http://images.cocodataset.org/val2017/000000039769.jpg", ... ) >>> outputs = generator( ... "https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png", points_per_batch=128 ... ) ``` [pipeline チュートリアル](../pipeline_tutorial)で、pipeline の基本的な使用方法について詳しく学んでください。 このセグメンテーションパイプラインは、現在、[pipeline()](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.pipeline)から、次のタスク識別子 `"mask-generation"` を使用して読み込むことができます。 利用可能なモデルの一覧は、[huggingface.co/models](https://huggingface.co/models?filter=mask-generation) をご覧ください。 #### __call__[[transformers.MaskGenerationPipeline.__call__]] ```python __call__(image: typing.Union[str, ForwardRef('Image.Image'), list[str], list['Image.Image']], *args: Any, **kwargs: Any) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/mask_generation.py#L143) **パラメータ:** image (`str`、`List[str]`、`PIL.Image` または `List[PIL.Image]`) : 画像または画像のリスト。 mask_threshold (`float`、*optional*、デフォルト値は 0.0) : 予測されたマスクをバイナリ値に変換する際に使用する閾値。 pred_iou_thresh (`float`、*任意*、デフォルト値は 0.88) : モデルが予測したマスクの品質に対して適用される、`[0,1]` 範囲のフィルタリング閾値。 stability_score_thresh (`float`、*任意*、デフォルト値は 0.95) : モデルのマスク予測を二値化するために使用されるカットオフ値の変化に対するマスクの安定性を用いた、`[0,1]` 範囲のフィルタリング閾値です。 stability_score_offset (`int`、*optional*、デフォルトは 1) : 安定性スコアを計算する際に、カットオフをシフトする量です。 crops_nms_thresh (`float`、*optional*、デフォルトは 0.7) : 重複するマスクをフィルタリングするために、non-maximal suppression が使用する box IoU のカットオフ値。 crops_n_layers (`int`、*optional*、デフォルト値は 0) : `crops_n_layers>0` の場合、画像のクロップに対してマスク予測が再度実行されます。実行するレイヤー数を設定します。各レイヤーには 2**i_layer 個の画像クロップが含まれます。 crop_overlap_ratio (`float`、*optional*、デフォルトは `512 / 1500`) : クロップの重複度を設定します。最初のクロップ層では、この分数だけ画像の長さにわたってクロップが重複します。クロップ数が多い後続の層では、この重複度を縮小します。 crop_n_points_downscale_factor (`int`, *任意*, デフォルトは `1`) : レイヤー n でサンプリングされる辺あたりの点数は、crop_n_points_downscale_factor**n 倍に縮小されます。 timeout (`float`、*任意*、デフォルトは None) : ウェブから画像を取得する際に待機する最大時間（秒）。None の場合はタイムアウトが設定されず、呼び出しが永久にブロックされる可能性があります。 **戻り値:** `Dict` 以下のキーを持つ辞書: - **mask** (`PIL.Image`) -- 検出されたオブジェクトのバイナリマスク。元の画像の形状 `(width, height)` を持つ PIL Image です。オブジェクトが検出されない場合は、ゼロで埋められたマスクを返します。 - **score** (*任意* `float`) -- ラベルとマスクで記述される「オブジェクト」の信頼度をモデルが推定できる場合、任意で指定します。 バイナリセグメンテーションマスクを生成します ## 親クラス: `Pipeline`[[transformers.Pipeline]] #### transformers.Pipeline[[transformers.Pipeline]] ```python transformers.Pipeline(model: PreTrainedModel, tokenizer: PreTrainedTokenizer | None = None, feature_extractor: PreTrainedFeatureExtractor | None = None, image_processor: BaseImageProcessor | None = None, video_processor: BaseVideoProcessor | None = None, processor: ProcessorMixin | None = None, task: str = '', device: int | torch.device | None = None, binary_output: bool = False, **kwargs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/base.py#L763) **パラメータ:** model ([PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel)) : パイプラインが予測を行う際に使用するモデルです。[PreTrainedModel](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.PreTrainedModel) を継承するモデルである必要があります。 tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend)) : パイプラインがモデル用のデータエンコードに使用するトークナイザーです。このオブジェクトは [PreTrainedTokenizer](/docs/transformers/v5.23.0/ja/main_classes/tokenizer#transformers.PythonBackend) を継承しています。 feature_extractor ([SequenceFeatureExtractor](/docs/transformers/v5.23.0/ja/main_classes/feature_extractor#transformers.SequenceFeatureExtractor)) : パイプラインがモデル用のデータエンコードに使用するフィーチャーエクストラクター。このオブジェクトは [SequenceFeatureExtractor](/docs/transformers/v5.23.0/ja/main_classes/feature_extractor#transformers.SequenceFeatureExtractor) を継承します。 image_processor ([BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor)) : パイプラインがモデル用のデータエンコードに使用する画像プロセッサです。このオブジェクトは [BaseImageProcessor](/docs/transformers/v5.23.0/ja/main_classes/image_processor#transformers.BaseImageProcessor) を継承しています。 processor ([ProcessorMixin](/docs/transformers/v5.23.0/ja/main_classes/processors#transformers.ProcessorMixin)) : パイプラインがモデル用のデータエンコードに使用するプロセッサです。このオブジェクトは [ProcessorMixin](/docs/transformers/v5.23.0/ja/main_classes/processors#transformers.ProcessorMixin) を継承しています。プロセッサは複合オブジェクトであり、`tokenizer`、`feature_extractor`、`image_processor` を含める場合があります。 task (`str`、デフォルトは `""`) : パイプラインのタスク識別子です。 num_workers (`int`、*任意*、デフォルトは 8) : パイプラインが *DataLoader* を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）、使用するワーカーの数。 batch_size (`int`、*optional*、デフォルトは 1) : パイプラインが*DataLoader*を使用する場合（データセットを渡す場合、または Pytorch モデルで GPU を使用する場合）に、使用するバッチサイズです。推論では常に有益とは限らないため、[Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching)をお読みください。 args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/ja/internal/pipelines_utils#transformers.pipelines.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](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.FeatureExtractionPipeline)（`'feature-extraction'`）などの一部の pipeline は、ネストされたリストとして大きなテンソルオブジェクトを出力します。このような大きな構造をテキストデータとしてダンプすることを避けるため、`binary_output` というコンストラクタ引数を提供しています。`True` に設定すると、出力は pickle 形式で保存されます。 #### check_model_type[[transformers.Pipeline.check_model_type]] ```python check_model_type(supported_models: list[str] | dict) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/base.py#L1126) **パラメータ:** supported_models (`list[str]` または `dict`) : パイプラインがサポートするモデルのリスト、またはモデルクラスの値を持つ辞書。 モデルクラスがpipelineでサポートされているかどうかを確認します。 #### device_placement[[transformers.Pipeline.device_placement]] ```python device_placement() ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/base.py#L1012) **戻り値:** コンテキストマネージャー ユーザーが指定したデバイス上でテンソルの割り込みを許可するコンテキストマネージャー。 例: ```python # Explicitly ask for tensor allocation on CUDA device :0 pipe = pipeline(..., device=0) with pipe.device_placement(): # Every tensor allocation will be done on the request device output = pipe(...) ``` #### ensure_tensor_on_device[[transformers.Pipeline.ensure_tensor_on_device]] ```python ensure_tensor_on_device(**inputs) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/base.py#L1094) **パラメータ:** inputs `torch.Tensor` であるべきキーワード引数。それ以外は無視されます) : `self.device` に配置するテンソル。 リストに対してのみ再帰的に適用します。**only** -- **戻り値:** `dict[str, torch.Tensor]` `inputs`と同じですが、適切なデバイス上に配置されたものです。 PyTorch テンソルが指定されたデバイス上にあることを確認します。 #### postprocess[[transformers.Pipeline.postprocess]] ```python postprocess(model_outputs: ModelOutput, **postprocess_parameters: dict) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/base.py#L1193) Postprocess は `_forward` メソッドの生出力（一般的にはテンソル）を受け取り、より扱いやすい形式に整形します。一般的には、結果のリストや辞書（文字列と数値のみを含む）を出力します。 #### predict[[transformers.Pipeline.predict]] ```python predict(X) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/base.py#L991) Transformers のパイプラインに対する Scikit / Keras インターフェース。このメソッドは __call__() にフォワードします。 #### preprocess[[transformers.Pipeline.preprocess]] ```python preprocess(input_: Any, **preprocess_parameters: dict) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/base.py#L1172) Preprocess は、特定の pipeline の `input_` を受け取り、`_forward` が正しく実行されるために必要なすべての要素を含む辞書を返します。少なくとも 1 つのテンソルを含む必要がありますが、その他の任意の項目も含む場合があります。 #### push_to_hub[[transformers.Pipeline.push_to_hub]] ```python push_to_hub(repo_id: str, commit_message: str | None = None, commit_description: str | None = None, private: bool | None = None, token: bool | str | None = None, revision: str | None = None, create_pr: bool = False, max_shard_size: int | str | None = '50GB', tags: list[str] | None = None) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/utils/hub.py#L822) **パラメータ:** repo_id (`str`) : パイプをプッシュするリポジトリの名前です。特定の組織にプッシュする場合は、組織名を含む必要があります。 commit_message (`str`, *任意*) : push 時にコミットするメッセージ。デフォルトは `"Upload pipe"` です。 commit_description (`str`, *任意*) : 作成されるコミットの説明 private (`bool`, *optional*) : リポジトリを非公開にするかどうか。`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にアップロードします。 例: ```python from transformers import pipeline pipe = pipeline("google-bert/bert-base-cased") # Push the pipe to your namespace with the name "my-finetuned-bert". pipe.push_to_hub("my-finetuned-bert") # Push the pipe to an organization with the name "my-finetuned-bert". pipe.push_to_hub("huggingface/my-finetuned-bert") ``` #### save_pretrained[[transformers.Pipeline.save_pretrained]] ```python save_pretrained(save_directory: str | os.PathLike, **kwargs: Any) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/base.py#L939) **パラメータ:** save_directory (`str` または `os.PathLike`) : 保存先ディレクトリのパスです。存在しない場合は作成されます。 kwargs (`dict[str, Any]`、*省略可*) : [push_to_hub()](/docs/transformers/v5.23.0/ja/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub) メソッドに渡される追加のキーワード引数。 パイプラインのモデルとトークナイザーを保存します。 #### transform[[transformers.Pipeline.transform]] ```python transform(X) ``` [ソース](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/base.py#L985) Transformers のパイプラインに対する Scikit / Keras インターフェース。このメソッドは __call__() にフォワードします。