# Pipelines Pipelines adalah cara yang hebat dan mudah untuk menggunakan model dalam inferensi. Pipelines ini adalah objek yang mengabstraksi sebagian besar kode kompleks dari pustaka, menawarkan API sederhana yang didedikasikan untuk beberapa tugas, termasuk Named Entity Recognition, Masked Language Modeling, Sentiment Analysis, Feature Extraction, dan Question Answering. Lihat [daftar tugas](https://huggingface.co/tasks) untuk contoh penggunaan. Ada dua kategori abstraksi pipeline yang perlu diperhatikan: - [pipeline()](/docs/transformers/main/id/main_classes/pipelines#transformers.pipeline) adalah objek paling ampuh yang mengenkapsulasi semua pipeline lainnya. - Pipeline khusus tugas tersedia untuk tugas [audio](#audio), [computer vision](#computer-vision), [natural language processing](#natural-language-processing), dan [multimodal](#multimodal). ## Abstraksi pipeline[[transformers.pipeline]] Abstraksi *pipeline* adalah pembungkus di sekitar semua pipeline lain yang tersedia. Abstraksi ini diinstansiasi seperti pipeline lainnya, tetapi dapat menyediakan peningkatan kenyamanan tambahan. Panggilan sederhana pada satu item: ```python >>> pipe = pipeline("text-classification") >>> pipe("This restaurant is awesome") [{'label': 'POSITIVE', 'score': 0.9998743534088135}] ``` Jika Anda ingin menggunakan model tertentu dari [hub](https://huggingface.co), Anda dapat mengabaikan tugas jika model di hub sudah mendefinisikannya: ```python >>> pipe = pipeline(model="FacebookAI/roberta-large-mnli") >>> pipe("This restaurant is awesome") [{'label': 'NEUTRAL', 'score': 0.7313136458396912}] ``` Untuk memanggil pipeline pada banyak item, Anda dapat memanggilnya dengan *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}] ``` Untuk mengiterasi dataset penuh, disarankan untuk menggunakan `dataset` secara langsung. Artinya, Anda tidak perlu mengalokasikan seluruh dataset sekaligus, dan tidak perlu melakukan batching secara manual. Cara ini seharusnya berjalan sama cepatnya dengan loop kustom di GPU. Jika tidak, jangan ragu untuk membuat 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": ....} # .... ``` Untuk kemudahan penggunaan, generator juga tersedia: ```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) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/__init__.py#L745) **Parameter:** task (`str`) : Tugas yang menentukan pipeline mana yang akan dikembalikan. Tugas yang saat ini diterima adalah: - `"audio-classification"`: akan mengembalikan [AudioClassificationPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.AudioClassificationPipeline). - `"automatic-speech-recognition"`: akan mengembalikan [AutomaticSpeechRecognitionPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.AutomaticSpeechRecognitionPipeline). - `"depth-estimation"`: akan mengembalikan [DepthEstimationPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.DepthEstimationPipeline). - `"document-question-answering"`: akan mengembalikan [DocumentQuestionAnsweringPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.DocumentQuestionAnsweringPipeline). - `"feature-extraction"`: akan mengembalikan [FeatureExtractionPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.FeatureExtractionPipeline). - `"fill-mask"`: akan mengembalikan [FillMaskPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.FillMaskPipeline):. - `"image-classification"`: akan mengembalikan [ImageClassificationPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.ImageClassificationPipeline). - `"image-feature-extraction"`: akan mengembalikan [ImageFeatureExtractionPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.ImageFeatureExtractionPipeline). - `"image-segmentation"`: akan mengembalikan [ImageSegmentationPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.ImageSegmentationPipeline). - `"image-text-to-text"`: akan mengembalikan [ImageTextToTextPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.ImageTextToTextPipeline). - `"keypoint-matching"`: akan mengembalikan [KeypointMatchingPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.KeypointMatchingPipeline). - `"mask-generation"`: akan mengembalikan [MaskGenerationPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.MaskGenerationPipeline). - `"object-detection"`: akan mengembalikan [ObjectDetectionPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.ObjectDetectionPipeline). - `"table-question-answering"`: akan mengembalikan [TableQuestionAnsweringPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.TableQuestionAnsweringPipeline). - `"text-classification"` (alias `"sentiment-analysis"` tersedia): akan mengembalikan [TextClassificationPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.TextClassificationPipeline). - `"text-generation"`: akan mengembalikan [TextGenerationPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.TextGenerationPipeline):. - `"text-to-audio"` (alias `"text-to-speech"` tersedia): akan mengembalikan [TextToAudioPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.TextToAudioPipeline):. - `"token-classification"` (alias `"ner"` tersedia): akan mengembalikan [TokenClassificationPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.TokenClassificationPipeline). - `"video-classification"`: akan mengembalikan [VideoClassificationPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.VideoClassificationPipeline). - `"zero-shot-classification"`: akan mengembalikan [ZeroShotClassificationPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.ZeroShotClassificationPipeline). - `"zero-shot-image-classification"`: akan mengembalikan [ZeroShotImageClassificationPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.ZeroShotImageClassificationPipeline). - `"zero-shot-audio-classification"`: akan mengembalikan [ZeroShotAudioClassificationPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.ZeroShotAudioClassificationPipeline). - `"zero-shot-object-detection"`: akan mengembalikan [ZeroShotObjectDetectionPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.ZeroShotObjectDetectionPipeline). model (`str` atau [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel), *opsional*) : Model yang akan digunakan oleh pipeline untuk membuat prediksi. Ini bisa berupa pengidentifikasi model atau instance aktual dari model pretrained yang mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). Jika tidak disediakan, default untuk `task` akan dimuat. config (`str` atau [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig), *opsional*) : Konfigurasi yang akan digunakan oleh pipeline untuk menginstansiasi model. Ini bisa berupa pengidentifikasi model atau konfigurasi model pretrained yang diwarisi dari [PreTrainedConfig](/docs/transformers/main/id/main_classes/configuration#transformers.PreTrainedConfig). Jika tidak disediakan, file konfigurasi default untuk model yang diminta akan digunakan. Artinya, jika `model` diberikan, konfigurasi defaultnya akan digunakan. Namun, jika `model` tidak disediakan, konfigurasi model default untuk `task` ini akan digunakan sebagai gantinya. tokenizer (`str` atau [PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend), *opsional*) : Tokenizer yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Ini bisa berupa pengidentifikasi model atau tokenizer pretrained yang mewarisi dari [PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend). Jika tidak disediakan, tokenizer default untuk `model` yang diberikan akan dimuat (jika berupa string). Jika `model` tidak ditentukan atau bukan string, maka tokenizer default untuk `config` akan dimuat (jika berupa string). Namun, jika `config` juga tidak diberikan atau bukan string, maka tokenizer default untuk `task` yang diberikan akan dimuat. feature_extractor (`str` atau [FeatureExtractionMixin](/docs/transformers/main/id/main_classes/feature_extractor#transformers.FeatureExtractionMixin), *opsional*) : Feature extractor yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Ini bisa berupa pengidentifikasi model atau feature extractor pretrained yang diwarisi dari [FeatureExtractionMixin](/docs/transformers/main/id/main_classes/feature_extractor#transformers.FeatureExtractionMixin). Feature extractor digunakan untuk model non-NLP, seperti model Speech atau Vision, serta model multi-modal. Model multi-modal juga memerlukan tokenizer untuk diteruskan. Jika tidak disediakan, feature extractor default untuk `model` yang diberikan akan dimuat (jika berupa string). Jika `model` tidak ditentukan atau bukan string, maka feature extractor default untuk `config` akan dimuat (jika berupa string). Namun, jika `config` juga tidak diberikan atau bukan string, maka feature extractor default untuk `task` yang diberikan akan dimuat. image_processor (`str` atau [BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor), *opsional*) : Pemroses gambar yang akan digunakan oleh pipeline untuk mempreproses gambar bagi model. Ini dapat berupa pengidentifikasi model atau pemroses gambar aktual yang mewarisi dari [BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor). Pemroses gambar digunakan untuk model Vision dan model multi-modal yang memerlukan input gambar. Model multi-modal juga akan memerlukan tokenizer untuk diteruskan. Jika tidak disediakan, pemroses gambar default untuk `model` yang diberikan akan dimuat (jika berupa string). Jika `model` tidak ditentukan atau bukan string, maka pemroses gambar default untuk `config` akan dimuat (jika berupa string). processor (`str` atau [ProcessorMixin](/docs/transformers/main/id/main_classes/processors#transformers.ProcessorMixin), *opsional*) : Prosesor yang akan digunakan oleh pipeline untuk memproses data awal untuk model. Ini bisa berupa pengidentifikasi model atau prosesor aktual yang mewarisi dari [ProcessorMixin](/docs/transformers/main/id/main_classes/processors#transformers.ProcessorMixin). Prosesor digunakan untuk model multi-modal yang memerlukan input multi-modal, misalnya, model yang memerlukan input teks dan gambar. Jika tidak disediakan, prosesor default untuk `model` yang diberikan akan dimuat (jika berupa string). Jika `model` tidak ditentukan atau bukan string, maka prosesor default untuk `config` akan dimuat (jika berupa string). revision (`str`, *opsional*, defaultnya `"main"`) : Saat meneruskan nama tugas atau pengidentifikasi model berupa string: Versi model spesifik yang akan digunakan. Ini bisa berupa nama branch, nama tag, atau id commit, karena kami menggunakan sistem berbasis git untuk menyimpan model dan artefak lainnya di huggingface.co, sehingga `revision` dapat berupa pengidentifikasi apa pun yang diizinkan oleh git. use_fast (`bool`, *opsional*, defaultnya `True`) : Apakah akan menggunakan tokenizer Fast jika memungkinkan (sebuah [PreTrainedTokenizerFast](/docs/transformers/main/id/main_classes/tokenizer#transformers.TokenizersBackend)). token (`str` atau *bool*, *opsional*) : Token yang digunakan sebagai otorisasi bearer HTTP untuk file jarak jauh. Jika `True`, akan menggunakan token yang dihasilkan saat menjalankan `hf auth login`. device (`int` atau `str` atau `torch.device`, *opsional*) : Menentukan perangkat (*mis.*, `"cpu"`, `"cuda:1"`, `"mps"`, atau peringkat ordinal GPU seperti `1`) tempat pipeline ini akan dialokasikan. Jika tidak disetel, pipeline secara otomatis ditempatkan pada akselerator pertama yang tersedia (CUDA, MPS, XPU, ...) dan hanya beralih ke CPU jika tidak ada yang tersedia; model akan dipindahkan ke sana untuk Anda. Lewati `device="cpu"` (atau `-1`) untuk memaksa CPU. Tidak dapat digunakan bersamaan dengan `device_map`. device_map (`str` atau `dict[str, Union[int, str, torch.device]`, *opsional*) : Dikirim langsung sebagai `model_kwargs` (hanya pintasan yang lebih sederhana). Jika pustaka `accelerate` hadir, atur `device_map="auto"` untuk menghitung `device_map` paling optimal secara otomatis (lihat [di sini](https://huggingface.co/docs/accelerate/main/en/package_reference/big_modeling#accelerate.cpu_offload) untuk informasi lebih lanjut). Jangan gunakan `device_map` dan `device` secara bersamaan karena keduanya akan saling bertentangan dtype (`str` atau `torch.dtype`, *opsional*, defaultnya `"auto"`) : Presisi saat model dimuat, diteruskan ke `from_pretrained`. Defaultnya `"auto"`, yang memuat model dalam dtype tempat model disimpan. Berikan `torch.float16`, `torch.bfloat16`, `torch.float32`, ... secara eksplisit untuk menimpanya. trust_remote_code (`bool`, *opsional*, defaultnya `False`) : Apakah mengizinkan kode kustom yang didefinisikan di Hub dalam file modeling, konfigurasi, tokenisasi, atau bahkan pipeline mereka. Opsi ini hanya harus diset ke `True` untuk repositori yang Anda percaya dan yang kodenya telah Anda baca, karena opsi ini akan mengeksekusi kode yang ada di Hub pada mesin lokal Anda. model_kwargs (`dict[str, Any]`, *opsional*) : Kamus tambahan berisi argumen kata kunci yang diteruskan ke fungsi `from_pretrained(..., **model_kwargs)` model. kwargs (`dict[str, Any]`, *opsional*) : Argumen kata kunci tambahan yang diteruskan ke inisialisasi pipeline tertentu (lihat dokumentasi untuk kelas pipeline yang sesuai untuk nilai yang mungkin). **Mengembalikan:** [Pipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.Pipeline) Pipeline yang sesuai untuk tugas tersebut. Metode pabrik utilitas untuk membangun [Pipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.Pipeline). Sebuah pipeline terdiri dari: - Satu atau lebih komponen untuk pra-pemrosesan input model, seperti [tokenizer](tokenizer), [image_processor](image_processor), [feature_extractor](feature_extractor), atau [processor](processors). - [Model](model) yang menghasilkan prediksi dari input. - Langkah-langkah pascapemrosesan opsional untuk menyempurnakan keluaran model, yang juga dapat ditangani oleh prosesor. Meskipun terdapat argumen opsional seperti `tokenizer`, `feature_extractor`, `image_processor`, dan `processor`, komponen-komponen ini tidak boleh ditentukan sekaligus. Jika komponen-komponen ini tidak disediakan, `pipeline` akan mencoba memuat komponen yang diperlukan secara otomatis. Jika Anda ingin menyediakan komponen-komponen ini secara eksplisit, silakan merujuk ke pipeline tertentu untuk mendapatkan detail lebih lanjut mengenai komponen apa saja yang diperlukan. Contoh: ```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) ``` ## Batching pipeline Semua pipeline dapat menggunakan batching. Hal ini akan berfungsi setiap kali pipeline menggunakan kemampuan streaming-nya (yaitu saat meneruskan daftar atau `Dataset` atau `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 ``` Namun, hal ini tidak otomatis menjadi keuntungan untuk performa. Hasilnya bisa berupa percepatan 10x atau perlambatan 5x, tergantung pada perangkat keras, data, dan model yang sebenarnya digunakan. Contoh di mana sebagian besar berupa peningkatan kecepatan: ```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) ``` Contoh di mana sebagian besar adalah perlambatan: ```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 ``` Ini adalah kalimat yang sangat panjang secara tidak biasa dibandingkan yang lain. Dalam kasus tersebut, **seluruh** batch harus memiliki panjang 400 token, sehingga seluruh batch akan menjadi [64, 400] alih-alih [64, 4], yang menyebabkan perlambatan yang signifikan. Lebih buruk lagi, pada batch yang lebih besar, program langsung crash. ```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) ``` Tidak ada solusi (umum) yang baik untuk masalah ini, dan hasilnya dapat bervariasi tergantung pada kasus penggunaan Anda. Aturan praktisnya: Bagi pengguna, aturan praktisnya adalah: - **Ukur kinerja pada beban kerja Anda, dengan perangkat keras Anda. Ukur, ukur, dan teruslah mengukur. Angka nyata adalah satu-satunya cara.** - Jika Anda memiliki batasan latensi (produk live yang melakukan inferensi), jangan gunakan batch. - Jika Anda menggunakan CPU, jangan lakukan batching. - Jika Anda menggunakan throughput (Anda ingin menjalankan model Anda pada sejumlah data statis), di GPU, maka: - Jika Anda tidak memiliki gambaran tentang ukuran sequence_length (data "alami"), secara default jangan lakukan batching, ukur, dan coba tambahkan secara sementara, serta tambahkan pemeriksaan OOM untuk pulih saat gagal (dan akan gagal pada suatu titik jika Anda tidak mengontrol sequence_length.) - Jika sequence_length Anda sangat teratur, maka batching kemungkinan besar akan menjadi SANGAT menarik, ukur dan dorong hingga Anda mengalami OOM. - Semakin besar GPU, semakin menarik penerapan batching - Begitu Anda mengaktifkan batching, pastikan Anda dapat menangani OOM dengan baik. ## Batching chunk Pipeline `zero-shot-classification` dan `question-answering` sedikit lebih spesifik, karena satu input dapat menghasilkan beberapa forward pass dari sebuah model. Dalam kondisi normal, hal ini akan menimbulkan masalah pada argumen `batch_size`. Untuk menghindari masalah ini, kedua pipeline ini sedikit spesifik, yaitu `ChunkPipeline` alih-alih `Pipeline` biasa. Singkatnya: ```python preprocessed = pipe.preprocess(inputs) model_outputs = pipe.forward(preprocessed) outputs = pipe.postprocess(model_outputs) ``` Sekarang menjadi: ```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) ``` Hal ini seharusnya sangat transparan bagi kode Anda karena pipeline digunakan dengan cara yang sama. Ini adalah tampilan yang disederhanakan, karena pipeline dapat menangani batch secara otomatis untuk Anda! Artinya, Anda tidak perlu khawatir tentang berapa banyak forward pass yang sebenarnya akan dipicu oleh input Anda; Anda dapat mengoptimalkan `batch_size` secara independen dari input. Catatan dari bagian sebelumnya tetap berlaku. ## Pipeline inferensi FP16 Model dapat dijalankan dalam FP16 yang dapat jauh lebih cepat di GPU sambil menghemat memori. Sebagian besar model tidak akan mengalami penurunan kinerja yang signifikan dari hal ini. Semakin besar modelnya, semakin kecil kemungkinan hal itu terjadi. Untuk mengaktifkan inferensi FP16, Anda cukup meneruskan `dtype=torch.float16` atau `dtype='float16'` ke konstruktor pipeline. Perhatikan bahwa ini hanya berfungsi untuk model dengan backend PyTorch. Input Anda akan dikonversi ke FP16 secara internal. ## Kode kustom Pipeline Jika Anda ingin menimpa pipeline tertentu. Jangan ragu untuk membuat issue untuk tugas yang sedang Anda kerjakan, karena tujuan dari pipeline adalah agar mudah digunakan dan mendukung sebagian besar kasus, sehingga `transformers` mungkin bisa mendukung use case Anda. Jika Anda ingin mencobanya, Anda dapat: - Subclass pipeline pilihan Anda ```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) ``` Hal tersebut seharusnya memungkinkan Anda untuk menulis semua kode kustom yang Anda inginkan. ## Menerapkan pipeline [Mengimplementasikan pipeline baru](../add_new_pipeline) ## Audio Pipelines yang tersedia untuk tugas audio mencakup yang berikut. ### AudioClassificationPipeline[[transformers.AudioClassificationPipeline]] #### transformers.AudioClassificationPipeline[[transformers.AudioClassificationPipeline]] ```python transformers.AudioClassificationPipeline(*args, **kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/audio_classification.py#L68) **Parameter:** model ([PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel)) : Model yang akan digunakan oleh pipeline untuk membuat prediksi. Ini harus berupa model yang mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). feature_extractor ([SequenceFeatureExtractor](/docs/transformers/main/id/main_classes/feature_extractor#transformers.SequenceFeatureExtractor)) : Ekstraktor fitur yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Objek ini mewarisi dari [SequenceFeatureExtractor](/docs/transformers/main/id/main_classes/feature_extractor#transformers.SequenceFeatureExtractor). task (`str`, defaultnya `""`) : Pengidentifikasi tugas untuk pipeline. num_workers (`int`, *opsional*, default 8) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), jumlah worker yang akan digunakan. batch_size (`int`, *opsional*, default 1) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), ukuran batch yang akan digunakan. Untuk inferensi, ini tidak selalu menguntungkan, silakan baca [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/id/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opsional*) : Referensi ke objek yang bertanggung jawab untuk mengurai parameter pipeline yang diberikan. device (`int` atau `str` atau `torch.device`, *opsional*) : Perangkat tempat pipeline dialokasikan. Jika tidak disetel, pipeline ditempatkan pada akselerator pertama yang tersedia (CUDA, MPS, XPU, ...) dan hanya kembali ke CPU jika tidak ada yang tersedia; model dipindahkan ke sana secara otomatis. Lewatkan `device="cpu"` (atau `-1`) untuk memaksa CPU, ordinal positif atau `"cuda:1"` untuk memilih akselerator tertentu, atau `torch.device`/`str` asli. Argumen ini tidak dapat digabungkan dengan model yang sudah dimuat melalui `accelerate` (yaitu model dengan `hf_device_map`). dtype (`str` atau `torch.dtype`, *opsional*, defaultnya `"auto"`) : Presisi saat model dimuat, diteruskan ke `from_pretrained`. Defaultnya `"auto"`, yang memuat model dalam dtype tempat model disimpan (dibaca dari `config.dtype` checkpoint, jika tidak ada, disimpulkan dari bobot). Berikan `torch.float16`, `torch.bfloat16`, `torch.float32`, ... secara eksplisit untuk menimpanya. binary_output (`bool`, *opsional*, defaultnya `False`) : Flag yang menunjukkan apakah output pipeline harus terjadi dalam format terserialisasi (yaitu, pickle) atau sebagai data output mentah, misalnya teks. Pipeline klasifikasi audio menggunakan `AutoModelForAudioClassification` apa pun. Pipeline ini memprediksi kelas dari gelombang mentah atau file audio. Untuk file audio, ffmpeg harus diinstal untuk mendukung berbagai format audio. Contoh: ```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'}] ``` Pelajari lebih lanjut tentang dasar-dasar penggunaan pipeline di [tutorial pipeline](../pipeline_tutorial) Pipeline ini saat ini dapat dimuat dari [pipeline()](/docs/transformers/main/id/main_classes/pipelines#transformers.pipeline) menggunakan pengidentifikasi tugas berikut: `"audio-classification"`. Lihat daftar model yang tersedia di [huggingface.co/models](https://huggingface.co/models?filter=audio-classification). #### __call__[[transformers.AudioClassificationPipeline.__call__]] ```python __call__(inputs: numpy.ndarray | bytes | str | dict, **kwargs: Any) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/audio_classification.py#L110) **Parameter:** inputs (`np.ndarray` atau `bytes` atau `str` atau `dict`) : Input-nya adalah salah satu dari: - `str` yang merupakan nama file audio; file akan dibaca pada sampling rate yang benar untuk mendapatkan waveform menggunakan *ffmpeg*. Hal ini memerlukan *ffmpeg* terinstal di sistem. - `bytes` yang seharusnya berisi konten file audio dan ditafsirkan oleh *ffmpeg* dengan cara yang sama. - (`np.ndarray` dengan bentuk (n, ) bertipe `np.float32` atau `np.float64`) Audio mentah pada sampling rate yang benar (tidak akan dilakukan pemeriksaan lebih lanjut) - Bentuk `dict` dapat digunakan untuk meneruskan audio mentah yang disampel pada `sampling_rate` apa pun dan membiarkan pipeline ini melakukan resampling. Dict tersebut harus dalam format `{"sampling_rate": int, "raw": np.array}`, atau `{"sampling_rate": int, "array": np.array}`, di mana kunci `"raw"` atau `"array"` digunakan untuk menunjukkan waveform audio mentah. top_k (`int`, *opsional*, defaultnya None) : Jumlah label teratas yang akan dikembalikan oleh pipeline. Jika jumlah yang diberikan adalah `None` atau lebih besar dari jumlah label yang tersedia dalam konfigurasi model, nilainya akan default ke jumlah label. function_to_apply (`str`, *opsional*, defaultnya "softmax") : Fungsi yang diterapkan ke output model. Secara default, pipeline akan menerapkan fungsi softmax ke output model. Opsi yang valid: ["softmax", "sigmoid", "none"]. Perhatikan bahwa meneruskan `None` bawaan Python akan default ke "softmax", sehingga Anda perlu meneruskan string "none" untuk menonaktifkan pascapemrosesan apa pun. **Mengembalikan:** Daftar `dict` dengan kunci berikut - **label** (`str`) -- Label yang diprediksi. - **score** (`float`) -- Probabilitas yang sesuai. Klasifikasikan urutan yang diberikan sebagai input. Lihat dokumentasi [AutomaticSpeechRecognitionPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.AutomaticSpeechRecognitionPipeline) untuk informasi lebih lanjut. ### 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) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/automatic_speech_recognition.py#L147) **Parameter:** model ([PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel)) : Model yang akan digunakan oleh pipeline untuk membuat prediksi. Ini harus berupa model yang mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). feature_extractor ([SequenceFeatureExtractor](/docs/transformers/main/id/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), *opsional*) : Ekstraktor fitur yang akan digunakan oleh pipeline untuk mengkodekan waveform untuk model. tokenizer ([PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend), *opsional*) : Tokenizer yang akan digunakan oleh pipeline untuk mengkodekan data untuk model. Objek ini mewarisi dari [PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend). decoder (`pyctcdecode.BeamSearchDecoderCTC`, *opsional*) : [BeamSearchDecoderCTC dari PyCTCDecode](https://github.com/kensho-technologies/pyctcdecode/blob/2fd33dc37c4111417e08d89ccd23d28e9b308d19/pyctcdecode/decoder.py#L180) dapat diteruskan untuk decoding yang ditingkatkan dengan model bahasa. Lihat [Wav2Vec2ProcessorWithLM](/docs/transformers/main/id/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM) untuk informasi lebih lanjut. device (Union[`int`, `torch.device`], *opsional*) : Ordinal perangkat untuk dukungan CPU/GPU. Mengatur ini ke `None` akan memanfaatkan CPU, sedangkan nilai positif akan menjalankan model pada id perangkat CUDA yang terkait. Pipeline yang bertujuan untuk mengekstrak teks ucapan yang terkandung di dalam beberapa audio. Input dapat berupa gelombang mentah atau file audio. Dalam kasus file audio, ffmpeg harus diinstal untuk mendukung berbagai format audio Kecuali model yang Anda gunakan secara eksplisit mengatur parameter generasi ini di file konfigurasinya (`generation_config.json`), nilai default berikut akan digunakan: - max_new_tokens: 256 - num_beams: 5 Contoh: ```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.'} ``` Pelajari lebih lanjut tentang dasar-dasar penggunaan pipeline di [tutorial pipeline](../pipeline_tutorial) #### __call__[[transformers.AutomaticSpeechRecognitionPipeline.__call__]] ```python __call__(inputs: numpy.ndarray | bytes | str | dict, **kwargs: Any) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/automatic_speech_recognition.py#L232) **Parameter:** inputs (`np.ndarray` atau `bytes` atau `str` atau `dict`) : Inputnya adalah salah satu dari: - `str` yang merupakan nama file audio lokal, atau alamat URL publik untuk mengunduh file audio. File akan dibaca pada laju sampling yang benar untuk mendapatkan waveform menggunakan *ffmpeg*. Hal ini memerlukan *ffmpeg* terinstal di sistem. - `bytes` seharusnya berisi konten file audio dan ditafsirkan oleh *ffmpeg* dengan cara yang sama. - (`np.ndarray` dengan bentuk (n, ) bertipe `np.float32` atau `np.float64`) Audio mentah pada laju sampling yang benar (tidak akan dilakukan pemeriksaan lebih lanjut) - Bentuk `dict` dapat digunakan untuk meneruskan audio mentah yang disampel pada `sampling_rate` arbitrer dan membiarkan pipeline ini melakukan resampling. Dict harus dalam format `{"sampling_rate": int, "raw": np.array}` dengan opsional `"stride": (left: int, right: int)` yang dapat meminta pipeline untuk mengabaikan `left` sampel pertama dan `right` sampel terakhir dalam decoding (tetapi digunakan saat inferensi untuk menyediakan lebih banyak konteks ke model). Hanya gunakan `stride` dengan model CTC. return_timestamps (*opsional*, `str` atau `bool`) : Hanya tersedia untuk model CTC murni (Wav2Vec2, HuBERT, dll) dan model Whisper. Tidak tersedia untuk model sequence-to-sequence lainnya. Untuk model CTC, timestamp dapat mengambil salah satu dari dua format: - `"char"`: pipeline akan mengembalikan timestamp di sepanjang teks untuk setiap karakter dalam teks. Misalnya, jika Anda mendapatkan `[{"text": "h", "timestamp": (0.5, 0.6)}, {"text": "i", "timestamp": (0.7, 0.9)}]`, maka artinya model memprediksi bahwa huruf "h" diucapkan setelah `0.5` dan sebelum `0.6` detik. - `"word"`: pipeline akan mengembalikan timestamp di sepanjang teks untuk setiap kata dalam teks. Misalnya, jika Anda mendapatkan `[{"text": "hi ", "timestamp": (0.5, 0.9)}, {"text": "there", "timestamp": (1.0, 1.5)}]`, maka artinya model memprediksi bahwa kata "hi" diucapkan setelah `0.5` dan sebelum `0.9` detik. Untuk model Whisper, timestamp dapat mengambil salah satu dari dua format: - `"word"`: sama seperti di atas untuk timestamp CTC tingkat kata. Timestamp tingkat kata diprediksi melalui algoritma *dynamic-time warping (DTW)*, yaitu pendekatan aproksimasi untuk timestamp tingkat kata dengan memeriksa bobot cross-attention. - `True`: pipeline akan mengembalikan timestamp di sepanjang teks untuk *segmen* kata dalam teks. Misalnya, jika Anda mendapatkan `[{"text": " Hi there!", "timestamp": (0.5, 1.5)}]`, maka artinya model memprediksi bahwa segmen "Hi there!" diucapkan setelah `0.5` dan sebelum `1.5` detik. Perhatikan bahwa segmen teks merujuk pada urutan satu atau lebih kata, bukan kata individual seperti pada timestamp tingkat kata. generate_kwargs (`dict`, *opsional*) : Kamus parametrisasi ad-hoc untuk `generate_config` yang akan digunakan untuk panggilan generation. Untuk gambaran lengkap tentang generate, periksa [panduan berikut](https://huggingface.co/docs/transformers/en/main_classes/text_generation). **Mengembalikan:** `Dict` Kamus dengan kunci-kunci berikut: - **text** (`str`): Teks yang dikenali. - **chunks** (*opsional(, `list[Dict]`) Saat menggunakan `return_timestamps`, `chunks` akan menjadi daftar yang berisi semua potongan teks yang diidentifikasi oleh model, *misalnya* `[{"text": "hi ", "timestamp": (0.5, 0.9)}, {"text": "there", "timestamp": (1.0, 1.5)}]`. Teks lengkap asli dapat dipulihkan secara kasar dengan melakukan `"".join(chunk["text"] for chunk in output["chunks"])`. Transkripsikan urutan audio yang diberikan sebagai input ke dalam teks. Lihat dokumentasi [AutomaticSpeechRecognitionPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.AutomaticSpeechRecognitionPipeline) untuk informasi lebih lanjut. ### TextToAudioPipeline[[transformers.TextToAudioPipeline]] #### transformers.TextToAudioPipeline[[transformers.TextToAudioPipeline]] ```python transformers.TextToAudioPipeline(*args, vocoder = None, sampling_rate = None, noise_scheduler = None, **kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/text_to_audio.py#L46) Pipeline generasi teks-ke-audio menggunakan `AutoModelForTextToWaveform` atau `AutoModelForTextToSpectrogram` apa pun. Pipeline ini menghasilkan file audio dari teks input dan input kondisional opsional lainnya. Kecuali model yang Anda gunakan secara eksplisit mengatur parameter generasi di `generation_config.json`, nilai default dari `generation.configuration_utils.py._get_default_generation_params()` akan digunakan. - max_new_tokens: 256 Contoh: ```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"] ``` Pelajari lebih lanjut tentang dasar-dasar penggunaan pipeline di [tutorial pipeline](../pipeline_tutorial) Anda dapat menentukan parameter yang diteruskan ke model dengan menggunakan `TextToAudioPipeline.__call__.forward_params` atau `TextToAudioPipeline.__call__.generate_kwargs`. Contoh: ```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 ini saat ini dapat dimuat dari [pipeline()](/docs/transformers/main/id/main_classes/pipelines#transformers.pipeline) menggunakan pengidentifikasi tugas berikut: `"text-to-speech"` atau `"text-to-audio"`. Lihat daftar model yang tersedia di [huggingface.co/models](https://huggingface.co/models?filter=text-to-speech). #### __call__[[transformers.TextToAudioPipeline.__call__]] ```python __call__(text_inputs, **forward_params) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/text_to_audio.py#L260) **Parameter:** text_inputs (`str`, `list[str]`, `ChatType`, atau `list[ChatType]`) : Satu atau beberapa teks untuk dihasilkan. Jika string atau daftar string diteruskan, pipeline ini akan menghasilkan teks yang sesuai. Sebagai alternatif, sebuah "chat", dalam bentuk daftar dict dengan kunci "role" dan "content", dapat diteruskan, atau daftar dari chat semacam itu. Ketika chat diteruskan, template chat model akan digunakan untuk memformatnya sebelum diteruskan ke model. forward_params (`dict`, *opsional*) : Parameter yang diteruskan ke metode generasi/forward model. `forward_params` selalu diteruskan ke model yang mendasarinya. generate_kwargs (`dict`, *opsional*) : Kamus parametrisasi ad-hoc untuk `generate_config` yang akan digunakan untuk panggilan generation. Untuk gambaran lengkap tentang generate, periksa [panduan berikut](https://huggingface.co/docs/transformers/en/main_classes/text_generation). `generate_kwargs` hanya diteruskan ke model dasar jika model tersebut adalah model generatif, dan memiliki prioritas lebih tinggi daripada `forward_params`. **Mengembalikan:** `AudioOutput` atau daftar `AudioOutput`, yang merupakan `TypedDict` dengan dua kunci - **audio** (`np.ndarray` dengan bentuk `(nb_channels, audio_length)`) -- Gelombang audio yang dihasilkan. - **sampling_rate** (`int`) -- Laju sampling dari waveform audio yang dihasilkan. Membuat ucapan/audio dari input. Lihat dokumentasi [TextToAudioPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.TextToAudioPipeline) untuk informasi lebih lanjut. ### ZeroShotAudioClassificationPipeline[[transformers.ZeroShotAudioClassificationPipeline]] #### transformers.ZeroShotAudioClassificationPipeline[[transformers.ZeroShotAudioClassificationPipeline]] ```python transformers.ZeroShotAudioClassificationPipeline(**kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/zero_shot_audio_classification.py#L32) **Parameter:** model ([PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel)) : Model yang akan digunakan oleh pipeline untuk membuat prediksi. Ini harus berupa model yang mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend)) : Tokenizer yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Objek ini mewarisi dari [PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend). feature_extractor ([SequenceFeatureExtractor](/docs/transformers/main/id/main_classes/feature_extractor#transformers.SequenceFeatureExtractor)) : Ekstraktor fitur yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Objek ini mewarisi dari [SequenceFeatureExtractor](/docs/transformers/main/id/main_classes/feature_extractor#transformers.SequenceFeatureExtractor). task (`str`, defaultnya `""`) : Pengidentifikasi tugas untuk pipeline. num_workers (`int`, *opsional*, default 8) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), jumlah worker yang akan digunakan. batch_size (`int`, *opsional*, default 1) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), ukuran batch yang akan digunakan. Untuk inferensi, ini tidak selalu menguntungkan, silakan baca [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/id/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opsional*) : Referensi ke objek yang bertanggung jawab untuk mengurai parameter pipeline yang diberikan. device (`int` atau `str` atau `torch.device`, *opsional*) : Perangkat tempat pipeline dialokasikan. Jika tidak disetel, pipeline ditempatkan pada akselerator pertama yang tersedia (CUDA, MPS, XPU, ...) dan hanya kembali ke CPU jika tidak ada yang tersedia; model dipindahkan ke sana secara otomatis. Lewatkan `device="cpu"` (atau `-1`) untuk memaksa CPU, ordinal positif atau `"cuda:1"` untuk memilih akselerator tertentu, atau `torch.device`/`str` asli. Argumen ini tidak dapat digabungkan dengan model yang sudah dimuat melalui `accelerate` (yaitu model dengan `hf_device_map`). dtype (`str` atau `torch.dtype`, *opsional*, defaultnya `"auto"`) : Presisi saat model dimuat, diteruskan ke `from_pretrained`. Defaultnya `"auto"`, yang memuat model dalam dtype tempat model disimpan (dibaca dari `config.dtype` checkpoint, jika tidak ada, disimpulkan dari bobot). Berikan `torch.float16`, `torch.bfloat16`, `torch.float32`, ... secara eksplisit untuk menimpanya. binary_output (`bool`, *opsional*, defaultnya `False`) : Flag yang menunjukkan apakah output pipeline harus terjadi dalam format terserialisasi (yaitu, pickle) atau sebagai data output mentah, misalnya teks. Pipeline klasifikasi audio zero shot menggunakan `ClapModel`. Pipeline ini memprediksi kelas dari sebuah audio ketika Anda menyediakan audio dan seperangkat `candidate_labels`. `hypothesis_template` bawaan adalah : `"This is a sound of {}."`. Pastikan Anda memperbaruinya sesuai penggunaan Anda. Contoh: ```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'}] ``` Pelajari lebih lanjut tentang dasar-dasar penggunaan pipeline di [tutorial pipeline](../pipeline_tutorial). Pipeline klasifikasi audio ini saat ini dapat dimuat dari [pipeline()](/docs/transformers/main/id/main_classes/pipelines#transformers.pipeline) menggunakan pengidentifikasi tugas berikut: `"zero-shot-audio-classification"`. Lihat daftar model yang tersedia di [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) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/zero_shot_audio_classification.py#L70) **Parameter:** audios (`str`, `list[str]`, `np.array` atau `list[np.array]`) : Pipeline menangani tiga jenis input: - String yang berisi tautan http yang mengarah ke audio - String yang berisi path lokal ke audio - Audio yang dimuat dalam numpy candidate_labels (`list[str]`) : Label kandidat untuk audio ini. Label tersebut akan diformat menggunakan *hypothesis_template*. hypothesis_template (`str`, *opsional*, defaultnya `"This is a sound of {}"`) : Format yang digunakan bersama dengan *candidate_labels* untuk mencoba klasifikasi audio dengan mengganti placeholder dengan candidate_labels. Kirim "{}" jika *candidate_labels* sudah diformat. **Mengembalikan:** Daftar kamus yang berisi satu entri per label yang diusulkan. Setiap kamus berisi kunci-kunci berikut: - **label** (`str`) -- Salah satu dari *candidate_labels* yang disarankan. - **score** (`float`) -- Skor yang diberikan model untuk label tersebut. Nilainya berada di antara 0 dan 1, dihitung sebagai `softmax` dari `logits_per_audio`. Beri label pada audio yang diteruskan sebagai input. ## Visi komputer Pipelines yang tersedia untuk tugas computer vision meliputi hal-hal berikut. ### DepthEstimationPipeline[[transformers.DepthEstimationPipeline]] #### transformers.DepthEstimationPipeline[[transformers.DepthEstimationPipeline]] ```python transformers.DepthEstimationPipeline(*args, **kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/depth_estimation.py#L25) **Parameter:** model ([PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel)) : Model yang akan digunakan oleh pipeline untuk membuat prediksi. Ini harus berupa model yang mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor)) : Pemroses gambar yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Objek ini mewarisi dari [BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, defaultnya `""`) : Pengidentifikasi tugas untuk pipeline. num_workers (`int`, *opsional*, default 8) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), jumlah worker yang akan digunakan. batch_size (`int`, *opsional*, default 1) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), ukuran batch yang akan digunakan. Untuk inferensi, ini tidak selalu menguntungkan, silakan baca [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/id/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opsional*) : Referensi ke objek yang bertanggung jawab untuk mengurai parameter pipeline yang diberikan. device (`int` atau `str` atau `torch.device`, *opsional*) : Perangkat tempat pipeline dialokasikan. Jika tidak disetel, pipeline ditempatkan pada akselerator pertama yang tersedia (CUDA, MPS, XPU, ...) dan hanya kembali ke CPU jika tidak ada yang tersedia; model dipindahkan ke sana secara otomatis. Lewatkan `device="cpu"` (atau `-1`) untuk memaksa CPU, ordinal positif atau `"cuda:1"` untuk memilih akselerator tertentu, atau `torch.device`/`str` asli. Argumen ini tidak dapat digabungkan dengan model yang sudah dimuat melalui `accelerate` (yaitu model dengan `hf_device_map`). dtype (`str` atau `torch.dtype`, *opsional*, defaultnya `"auto"`) : Presisi saat model dimuat, diteruskan ke `from_pretrained`. Defaultnya `"auto"`, yang memuat model dalam dtype tempat model disimpan (dibaca dari `config.dtype` checkpoint, jika tidak ada, disimpulkan dari bobot). Berikan `torch.float16`, `torch.bfloat16`, `torch.float32`, ... secara eksplisit untuk menimpanya. binary_output (`bool`, *opsional*, defaultnya `False`) : Flag yang menunjukkan apakah output pipeline harus terjadi dalam format terserialisasi (yaitu, pickle) atau sebagai data output mentah, misalnya teks. Pipeline estimasi kedalaman menggunakan `AutoModelForDepthEstimation` apa pun. Pipeline ini memprediksi kedalaman sebuah gambar. Contoh: ```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]) ``` Pelajari lebih lanjut tentang dasar-dasar penggunaan pipeline di [tutorial pipeline](../pipeline_tutorial) Pipeline estimasi kedalaman ini saat ini dapat dimuat dari [pipeline()](/docs/transformers/main/id/main_classes/pipelines#transformers.pipeline) menggunakan pengidentifikasi tugas berikut: `"depth-estimation"`. Lihat daftar model yang tersedia di [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) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/depth_estimation.py#L66) **Parameter:** inputs (`str`, `list[str]`, `PIL.Image` atau `list[PIL.Image]`) : Pipeline menangani tiga jenis gambar: - String yang berisi tautan http yang mengarah ke gambar - String yang berisi path lokal ke gambar - Gambar yang dimuat langsung dalam PIL Pipeline menerima satu gambar tunggal atau batch gambar, yang kemudian harus diteruskan sebagai string. Gambar-gambar dalam batch harus semuanya dalam format yang sama: semuanya sebagai tautan http, semuanya sebagai path lokal, atau semuanya sebagai gambar PIL. parameters (`Dict`, *opsional*) : Kamus nama argumen ke nilai parameter, untuk mengontrol perilaku pipeline. Satu-satunya parameter yang tersedia saat ini adalah `timeout`, yaitu durasi waktu, dalam detik, yang harus ditunggu pipeline sebelum menyerah dalam upaya mengunduh gambar. timeout (`float`, *opsional*, defaultnya None) : Waktu maksimum dalam detik untuk menunggu pengambilan gambar dari web. Jika None, tidak ada batas waktu yang ditetapkan dan panggilan dapat memblokir selamanya. **Mengembalikan:** Kamus atau daftar kamus yang berisi hasil. Jika inputnya adalah satu gambar, akan mengembalikan sebuah kamus; jika inputnya adalah daftar beberapa gambar, akan mengembalikan daftar kamus yang sesuai dengan gambar-gambar tersebut. Kamus-kamus tersebut berisi kunci-kunci berikut: - **predicted_depth** (`torch.Tensor`) -- Kedalaman yang diprediksi oleh model sebagai `torch.Tensor`. - **depth** (`PIL.Image`) -- Kedalaman yang diprediksi oleh model sebagai `PIL.Image`. Prediksi kedalaman dari gambar yang diberikan sebagai input. ### ImageClassificationPipeline[[transformers.ImageClassificationPipeline]] #### transformers.ImageClassificationPipeline[[transformers.ImageClassificationPipeline]] ```python transformers.ImageClassificationPipeline(*args, **kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/image_classification.py#L73) **Parameter:** model ([PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel)) : Model yang akan digunakan oleh pipeline untuk membuat prediksi. Ini harus berupa model yang mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor)) : Pemroses gambar yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Objek ini mewarisi dari [BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, defaultnya `""`) : Pengidentifikasi tugas untuk pipeline. num_workers (`int`, *opsional*, default 8) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), jumlah worker yang akan digunakan. batch_size (`int`, *opsional*, default 1) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), ukuran batch yang akan digunakan. Untuk inferensi, ini tidak selalu menguntungkan, silakan baca [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/id/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opsional*) : Referensi ke objek yang bertanggung jawab untuk mengurai parameter pipeline yang diberikan. device (`int` atau `str` atau `torch.device`, *opsional*) : Perangkat tempat pipeline dialokasikan. Jika tidak disetel, pipeline ditempatkan pada akselerator pertama yang tersedia (CUDA, MPS, XPU, ...) dan hanya kembali ke CPU jika tidak ada yang tersedia; model dipindahkan ke sana secara otomatis. Lewatkan `device="cpu"` (atau `-1`) untuk memaksa CPU, ordinal positif atau `"cuda:1"` untuk memilih akselerator tertentu, atau `torch.device`/`str` asli. Argumen ini tidak dapat digabungkan dengan model yang sudah dimuat melalui `accelerate` (yaitu model dengan `hf_device_map`). dtype (`str` atau `torch.dtype`, *opsional*, defaultnya `"auto"`) : Presisi saat model dimuat, diteruskan ke `from_pretrained`. Defaultnya `"auto"`, yang memuat model dalam dtype tempat model disimpan (dibaca dari `config.dtype` checkpoint, jika tidak ada, disimpulkan dari bobot). Berikan `torch.float16`, `torch.bfloat16`, `torch.float32`, ... secara eksplisit untuk menimpanya. binary_output (`bool`, *opsional*, defaultnya `False`) : Flag yang menunjukkan apakah output pipeline harus terjadi dalam format terserialisasi (yaitu, pickle) atau sebagai data output mentah, misalnya teks. function_to_apply (`str`, *opsional*, defaultnya `"default"`) : Fungsi yang diterapkan pada output model untuk mengambil skor. Menerima empat nilai yang berbeda: - `"default"`: jika model memiliki satu label, fungsi sigmoid akan diterapkan pada output. Jika model memiliki beberapa label, fungsi softmax akan diterapkan pada output. - `"sigmoid"`: Menerapkan fungsi sigmoid pada output. - `"softmax"`: Menerapkan fungsi softmax pada output. - `"none"`: Tidak menerapkan fungsi apa pun pada output. Pipeline klasifikasi gambar menggunakan `AutoModelForImageClassification` apa pun. Pipeline ini memprediksi kelas dari sebuah gambar. Contoh: ```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'}] ``` Pelajari lebih lanjut tentang dasar-dasar penggunaan pipeline di [tutorial pipeline](../pipeline_tutorial) Pipeline klasifikasi gambar ini saat ini dapat dimuat dari [pipeline()](/docs/transformers/main/id/main_classes/pipelines#transformers.pipeline) menggunakan pengidentifikasi tugas berikut: `"image-classification"`. Lihat daftar model yang tersedia di [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) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/image_classification.py#L127) **Parameter:** inputs (`str`, `list[str]`, `PIL.Image` atau `list[PIL.Image]`) : Pipeline menangani tiga jenis gambar: - String yang berisi tautan http yang mengarah ke gambar - String yang berisi path lokal ke gambar - Gambar yang dimuat langsung dalam PIL Pipeline menerima satu gambar tunggal atau batch gambar, yang kemudian harus diteruskan sebagai string. Gambar-gambar dalam batch harus semuanya dalam format yang sama: semuanya sebagai tautan http, semuanya sebagai path lokal, atau semuanya sebagai gambar PIL. function_to_apply (`str`, *opsional*, defaultnya `"default"`) : Fungsi yang diterapkan pada keluaran model untuk mengambil skor. Menerima empat nilai yang berbeda: Jika argumen ini tidak ditentukan, maka fungsi berikut akan diterapkan sesuai dengan jumlah label: - Jika model memiliki satu label, fungsi sigmoid akan diterapkan pada keluaran. - Jika model memiliki beberapa label, fungsi softmax akan diterapkan pada keluaran. Nilai yang mungkin adalah: - `"sigmoid"`: Menerapkan fungsi sigmoid pada keluaran. - `"softmax"`: Menerapkan fungsi softmax pada keluaran. - `"none"`: Tidak menerapkan fungsi apa pun pada keluaran. top_k (`int`, *opsional*, defaultnya 5) : Jumlah label teratas yang akan dikembalikan oleh pipeline. Jika jumlah yang diberikan lebih tinggi dari jumlah label yang tersedia dalam konfigurasi model, nilainya akan kembali ke jumlah label tersebut. timeout (`float`, *opsional*, defaultnya None) : Waktu maksimum dalam detik untuk menunggu pengambilan gambar dari web. Jika None, tidak ada batas waktu yang ditetapkan dan panggilan dapat memblokir selamanya. **Mengembalikan:** Kamus atau daftar kamus yang berisi hasil. Jika inputnya adalah satu gambar, akan mengembalikan sebuah kamus; jika inputnya adalah daftar beberapa gambar, akan mengembalikan daftar kamus yang sesuai dengan gambar-gambar tersebut. Kamus-kamus tersebut berisi kunci-kunci berikut: - **label** (`str`) -- Label yang diidentifikasi oleh model. - **score** (`int`) -- Skor yang diberikan oleh model untuk label tersebut. Tugaskan label ke gambar yang diteruskan sebagai input. ### ImageSegmentationPipeline[[transformers.ImageSegmentationPipeline]] #### transformers.ImageSegmentationPipeline[[transformers.ImageSegmentationPipeline]] ```python transformers.ImageSegmentationPipeline(*args, **kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/image_segmentation.py#L27) **Parameter:** model ([PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel)) : Model yang akan digunakan oleh pipeline untuk membuat prediksi. Ini harus berupa model yang mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor)) : Pemroses gambar yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Objek ini mewarisi dari [BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, defaultnya `""`) : Pengidentifikasi tugas untuk pipeline. num_workers (`int`, *opsional*, default 8) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), jumlah worker yang akan digunakan. batch_size (`int`, *opsional*, default 1) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), ukuran batch yang akan digunakan. Untuk inferensi, ini tidak selalu menguntungkan, silakan baca [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/id/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opsional*) : Referensi ke objek yang bertanggung jawab untuk mengurai parameter pipeline yang diberikan. device (`int` atau `str` atau `torch.device`, *opsional*) : Perangkat tempat pipeline dialokasikan. Jika tidak disetel, pipeline ditempatkan pada akselerator pertama yang tersedia (CUDA, MPS, XPU, ...) dan hanya kembali ke CPU jika tidak ada yang tersedia; model dipindahkan ke sana secara otomatis. Lewatkan `device="cpu"` (atau `-1`) untuk memaksa CPU, ordinal positif atau `"cuda:1"` untuk memilih akselerator tertentu, atau `torch.device`/`str` asli. Argumen ini tidak dapat digabungkan dengan model yang sudah dimuat melalui `accelerate` (yaitu model dengan `hf_device_map`). dtype (`str` atau `torch.dtype`, *opsional*, defaultnya `"auto"`) : Presisi saat model dimuat, diteruskan ke `from_pretrained`. Defaultnya `"auto"`, yang memuat model dalam dtype tempat model disimpan (dibaca dari `config.dtype` checkpoint, jika tidak ada, disimpulkan dari bobot). Berikan `torch.float16`, `torch.bfloat16`, `torch.float32`, ... secara eksplisit untuk menimpanya. binary_output (`bool`, *opsional*, defaultnya `False`) : Flag yang menunjukkan apakah output pipeline harus terjadi dalam format terserialisasi (yaitu, pickle) atau sebagai data output mentah, misalnya teks. Pipeline segmentasi gambar menggunakan `AutoModelForXXXSegmentation` apa pun. Pipeline ini memprediksi mask objek beserta kelasnya. Contoh: ```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 segmentasi gambar ini saat ini dapat dimuat dari [pipeline()](/docs/transformers/main/id/main_classes/pipelines#transformers.pipeline) menggunakan pengidentifikasi tugas berikut: `"image-segmentation"`. Lihat daftar model yang tersedia di [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) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/image_segmentation.py#L101) **Parameter:** inputs (`str`, `list[str]`, `PIL.Image` atau `list[PIL.Image]`) : Pipeline menangani tiga jenis gambar: - String yang berisi tautan HTTP(S) yang mengarah ke gambar - String yang berisi path lokal ke gambar - Gambar yang dimuat langsung dalam PIL Pipeline menerima satu gambar tunggal atau batch gambar. Gambar dalam batch harus semuanya dalam format yang sama: semuanya sebagai tautan HTTP(S), semuanya sebagai path lokal, atau semuanya sebagai gambar PIL. subtask (`str`, *opsional*) : Tugas segmentasi yang akan dilakukan, pilih [`semantic`, `instance` dan `panoptic`] sesuai dengan kemampuan model. Jika tidak diatur, pipeline akan mencoba menyelesaikan dalam urutan berikut: `panoptic`, `instance`, `semantic`. threshold (`float`, *opsional*, default 0.9) : Ambang probabilitas untuk menyaring mask prediksi. mask_threshold (`float`, *opsional*, default 0.5) : Ambang batas yang digunakan saat mengubah maska prediksi menjadi nilai biner. overlap_mask_area_threshold (`float`, *opsional*, default 0.5) : Ambang batas tumpang tindih masker untuk menghilangkan segmen kecil yang tidak terhubung. timeout (`float`, *opsional*, defaultnya None) : Waktu maksimum dalam detik untuk menunggu pengambilan gambar dari web. Jika None, tidak ada batas waktu yang ditetapkan dan panggilan dapat memblokir selamanya. **Mengembalikan:** Jika inputnya adalah satu gambar, akan mengembalikan daftar kamus; jika inputnya adalah daftar beberapa gambar, akan mengembalikan daftar dari daftar kamus yang sesuai dengan masing-masing gambar. Kamus-kamus tersebut berisi mask, label, dan skor (jika berlaku) dari setiap objek yang terdeteksi dan memuat kunci-kunci berikut: - **label** (`str`) -- Label kelas yang diidentifikasi oleh model. - **mask** (`PIL.Image`) -- Mask biner dari objek yang terdeteksi sebagai Pil Image dengan bentuk (width, height) dari gambar asli. Mengembalikan mask yang diisi dengan nol jika tidak ada objek yang ditemukan. - **score** (*opsional* `float`) -- Secara opsional, ketika model mampu memperkirakan tingkat kepercayaan terhadap "objek" yang dijelaskan oleh label dan mask. Lakukan segmentasi (deteksi masker & kelas) pada gambar yang diberikan sebagai input. ### KeypointMatchingPipeline[[transformers.KeypointMatchingPipeline]] #### transformers.KeypointMatchingPipeline[[transformers.KeypointMatchingPipeline]] ```python transformers.KeypointMatchingPipeline(*args, **kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/keypoint_matching.py#L67) Pipeline pencocokan titik kunci menggunakan `AutoModelForKeypointMatching` apa pun. Pipeline ini mencocokkan titik kunci antara dua gambar. #### __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) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/keypoint_matching.py#L96) **Parameter:** inputs (`str`, `list[str]`, `PIL.Image` atau `list[PIL.Image]`) : Pipeline menangani tiga jenis gambar: - String yang berisi tautan http yang mengarah ke gambar - String yang berisi path lokal ke gambar - Gambar yang dimuat langsung dalam PIL Pipeline menerima satu pasangan gambar tunggal atau batch pasangan gambar, yang kemudian harus diteruskan sebagai string. Gambar dalam batch harus semuanya dalam format yang sama: semuanya sebagai tautan http, semuanya sebagai path lokal, atau semuanya sebagai gambar PIL. threshold (`float`, *opsional*, default 0.0) : Ambang batas yang digunakan untuk pencocokan titik kunci. Titik kunci yang dicocokkan dengan skor pencocokan yang lebih rendah akan disaring. Nilai 0 berarti semua titik kunci yang dicocokkan akan dikembalikan. kwargs : `timeout (`float`, *optional*, defaults to None)` The maximum time in seconds to wait for fetching images from the web. If None, no timeout is set and the call may block forever. **Mengembalikan:** Union[list[Match], list[list[Match]]] Daftar kecocokan atau daftar jika satu pasangan gambar diberikan, atau daftar dari daftar kecocokan jika batch pasangan gambar diberikan. Setiap kecocokan adalah kamus yang berisi kunci-kunci berikut: - **keypoint_image_0** (`Keypoint`): Titik kunci pada gambar pertama (koordinat x, y). - **keypoint_image_1** (`Keypoint`): Titik kunci pada gambar kedua (koordinat x, y). - **score** (`float`): Skor kecocokan antara dua titik kunci. Temukan kecocokan antara titik-titik kunci dalam dua gambar. ### ObjectDetectionPipeline[[transformers.ObjectDetectionPipeline]] #### transformers.ObjectDetectionPipeline[[transformers.ObjectDetectionPipeline]] ```python transformers.ObjectDetectionPipeline(*args, **kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/object_detection.py#L26) **Parameter:** model ([PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel)) : Model yang akan digunakan oleh pipeline untuk membuat prediksi. Ini harus berupa model yang mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor)) : Pemroses gambar yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Objek ini mewarisi dari [BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, defaultnya `""`) : Pengidentifikasi tugas untuk pipeline. num_workers (`int`, *opsional*, default 8) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), jumlah worker yang akan digunakan. batch_size (`int`, *opsional*, default 1) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), ukuran batch yang akan digunakan. Untuk inferensi, ini tidak selalu menguntungkan, silakan baca [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/id/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opsional*) : Referensi ke objek yang bertanggung jawab untuk mengurai parameter pipeline yang diberikan. device (`int` atau `str` atau `torch.device`, *opsional*) : Perangkat tempat pipeline dialokasikan. Jika tidak disetel, pipeline ditempatkan pada akselerator pertama yang tersedia (CUDA, MPS, XPU, ...) dan hanya kembali ke CPU jika tidak ada yang tersedia; model dipindahkan ke sana secara otomatis. Lewatkan `device="cpu"` (atau `-1`) untuk memaksa CPU, ordinal positif atau `"cuda:1"` untuk memilih akselerator tertentu, atau `torch.device`/`str` asli. Argumen ini tidak dapat digabungkan dengan model yang sudah dimuat melalui `accelerate` (yaitu model dengan `hf_device_map`). dtype (`str` atau `torch.dtype`, *opsional*, defaultnya `"auto"`) : Presisi saat model dimuat, diteruskan ke `from_pretrained`. Defaultnya `"auto"`, yang memuat model dalam dtype tempat model disimpan (dibaca dari `config.dtype` checkpoint, jika tidak ada, disimpulkan dari bobot). Berikan `torch.float16`, `torch.bfloat16`, `torch.float32`, ... secara eksplisit untuk menimpanya. binary_output (`bool`, *opsional*, defaultnya `False`) : Flag yang menunjukkan apakah output pipeline harus terjadi dalam format terserialisasi (yaitu, pickle) atau sebagai data output mentah, misalnya teks. Pipeline deteksi objek menggunakan `AutoModelForObjectDetection` apa pun. Pipeline ini memprediksi kotak pembatas objek beserta kelasnya. Contoh: ```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. ``` Pelajari lebih lanjut tentang dasar-dasar penggunaan pipeline di [tutorial pipeline](../pipeline_tutorial) Pipeline deteksi objek ini saat ini dapat dimuat dari [pipeline()](/docs/transformers/main/id/main_classes/pipelines#transformers.pipeline) menggunakan pengidentifikasi tugas berikut: `"object-detection"`. Lihat daftar model yang tersedia di [huggingface.co/models](https://huggingface.co/models?filter=object-detection). #### __call__[[transformers.ObjectDetectionPipeline.__call__]] ```python __call__(*args, **kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/object_detection.py#L81) **Parameter:** inputs (`str`, `list[str]`, `PIL.Image` atau `list[PIL.Image]`) : Pipeline menangani tiga jenis gambar: - String yang berisi tautan HTTP(S) yang mengarah ke gambar - String yang berisi path lokal ke gambar - Gambar yang dimuat langsung dalam PIL Pipeline menerima satu gambar tunggal atau batch gambar. Gambar dalam batch harus semuanya dalam format yang sama: semuanya sebagai tautan HTTP(S), semuanya sebagai path lokal, atau semuanya sebagai gambar PIL. threshold (`float`, *opsional*, default 0.5) : Probabilitas yang diperlukan untuk membuat prediksi. timeout (`float`, *opsional*, defaultnya None) : Waktu maksimum dalam detik untuk menunggu pengambilan gambar dari web. Jika None, tidak ada batas waktu yang ditetapkan dan panggilan dapat memblokir selamanya. **Mengembalikan:** Daftar dari kamus atau daftar dari daftar kamus yang berisi hasil. Jika input adalah satu gambar, akan mengembalikan daftar dari kamus; jika input adalah daftar dari beberapa gambar, akan mengembalikan daftar dari daftar kamus yang sesuai dengan masing-masing gambar. Kamus-kamus tersebut berisi kunci-kunci berikut: - **label** (`str`) -- Label kelas yang diidentifikasi oleh model. - **score** (`float`) -- Skor yang diberikan oleh model untuk label tersebut. - **box** (`list[dict[str, int]]`) -- Kotak batas (bounding box) dari objek yang terdeteksi pada ukuran asli gambar. Deteksi objek (kotak pembatas & kelas) pada gambar yang diberikan sebagai input. ### VideoClassificationPipeline[[transformers.VideoClassificationPipeline]] #### transformers.VideoClassificationPipeline[[transformers.VideoClassificationPipeline]] ```python transformers.VideoClassificationPipeline(*args, **kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/video_classification.py#L41) **Parameter:** model ([PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel)) : Model yang akan digunakan oleh pipeline untuk membuat prediksi. Ini harus berupa model yang mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor)) : Pemroses gambar yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Objek ini mewarisi dari [BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor). video_processor ([BaseVideoProcessor](/docs/transformers/main/id/main_classes/video_processor#transformers.BaseVideoProcessor)) : Pemroses video yang akan digunakan oleh pipeline untuk mengkodekan data video untuk model. Objek ini mewarisi dari [BaseVideoProcessor](/docs/transformers/main/id/main_classes/video_processor#transformers.BaseVideoProcessor). task (`str`, defaultnya `""`) : Pengidentifikasi tugas untuk pipeline. num_workers (`int`, *opsional*, default 8) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), jumlah worker yang akan digunakan. batch_size (`int`, *opsional*, default 1) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), ukuran batch yang akan digunakan. Untuk inferensi, ini tidak selalu menguntungkan, silakan baca [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/id/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opsional*) : Referensi ke objek yang bertanggung jawab untuk mengurai parameter pipeline yang diberikan. device (`int` atau `str` atau `torch.device`, *opsional*) : Perangkat tempat pipeline dialokasikan. Jika tidak disetel, pipeline ditempatkan pada akselerator pertama yang tersedia (CUDA, MPS, XPU, ...) dan hanya kembali ke CPU jika tidak ada yang tersedia; model dipindahkan ke sana secara otomatis. Lewatkan `device="cpu"` (atau `-1`) untuk memaksa CPU, ordinal positif atau `"cuda:1"` untuk memilih akselerator tertentu, atau `torch.device`/`str` asli. Argumen ini tidak dapat digabungkan dengan model yang sudah dimuat melalui `accelerate` (yaitu model dengan `hf_device_map`). dtype (`str` atau `torch.dtype`, *opsional*, defaultnya `"auto"`) : Presisi saat model dimuat, diteruskan ke `from_pretrained`. Defaultnya `"auto"`, yang memuat model dalam dtype tempat model disimpan (dibaca dari `config.dtype` checkpoint, jika tidak ada, disimpulkan dari bobot). Berikan `torch.float16`, `torch.bfloat16`, `torch.float32`, ... secara eksplisit untuk menimpanya. binary_output (`bool`, *opsional*, defaultnya `False`) : Flag yang menunjukkan apakah output pipeline harus terjadi dalam format terserialisasi (yaitu, pickle) atau sebagai data output mentah, misalnya teks. Pipeline klasifikasi video menggunakan `AutoModelForVideoClassification` apa pun. Pipeline ini memprediksi kelas dari sebuah video. Pipeline klasifikasi video ini saat ini dapat dimuat dari [pipeline()](/docs/transformers/main/id/main_classes/pipelines#transformers.pipeline) menggunakan pengidentifikasi tugas berikut: `"video-classification"`. Lihat daftar model yang tersedia di [huggingface.co/models](https://huggingface.co/models?filter=video-classification). Pipeline mendukung model yang menggunakan image processor (model video lama seperti VideoMAE, ViViT, dan TimeSformer) atau video processor (model yang lebih baru seperti VJEPA2). Jika keduanya ada, video processor yang diprioritaskan; jika keduanya tidak ditemukan, pipeline akan melempar error. #### __call__[[transformers.VideoClassificationPipeline.__call__]] ```python __call__(inputs: str | list[str] | None, **kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/video_classification.py#L105) **Parameter:** inputs (`str`, `list[str]`) : Pipeline menangani tiga jenis video: - String yang berisi tautan http yang mengarah ke video - String yang berisi path lokal ke video Pipeline menerima satu video atau batch video, yang harus diteruskan sebagai string. Video dalam batch harus semuanya dalam format yang sama: semuanya sebagai tautan http atau semuanya sebagai path lokal. top_k (`int`, *opsional*, defaultnya 5) : Jumlah label teratas yang akan dikembalikan oleh pipeline. Jika jumlah yang diberikan lebih tinggi dari jumlah label yang tersedia dalam konfigurasi model, nilainya akan kembali ke jumlah label tersebut. num_frames (`int`, *opsional*, defaultnya `self.model.config.num_frames`) : Jumlah frame yang diambil dari video untuk menjalankan klasifikasi. Jika tidak diberikan, akan menggunakan jumlah frame yang ditentukan dalam konfigurasi model. frame_sampling_rate (`int`, *opsional*, default 1) : Laju sampling yang digunakan untuk memilih frame dari video. Jika tidak diberikan, akan default ke 1, yaitu setiap frame akan digunakan. function_to_apply(`str`, *opsional*, defaultnya "softmax") : Fungsi yang akan diterapkan ke output model. Secara default, pipeline akan menerapkan fungsi softmax ke output model. Opsi yang valid: ["softmax", "sigmoid", "none"]. Perhatikan bahwa jika Anda melewatkan `None` bawaan Python, nilai defaultnya akan menjadi "softmax", sehingga Anda perlu melewatkan string "none" untuk menonaktifkan semua pascaproses. **Mengembalikan:** Daftar dari kamus atau daftar dari daftar kamus yang berisi hasil. Jika input adalah satu video, akan mengembalikan daftar berisi `top_k` kamus; jika input adalah daftar beberapa video, akan mengembalikan daftar dari daftar berisi `top_k` kamus yang sesuai dengan video tersebut. Kamus-kamus tersebut berisi kunci-kunci berikut: - **label** (`str`) -- Label yang diidentifikasi oleh model. - **score** (`int`) -- Skor yang diberikan oleh model untuk label tersebut. Tugaskan label ke video yang diteruskan sebagai input. ### ZeroShotImageClassificationPipeline[[transformers.ZeroShotImageClassificationPipeline]] #### transformers.ZeroShotImageClassificationPipeline[[transformers.ZeroShotImageClassificationPipeline]] ```python transformers.ZeroShotImageClassificationPipeline(**kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/zero_shot_image_classification.py#L29) **Parameter:** model ([PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel)) : Model yang akan digunakan oleh pipeline untuk membuat prediksi. Ini harus berupa model yang mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor)) : Pemroses gambar yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Objek ini mewarisi dari [BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, defaultnya `""`) : Pengidentifikasi tugas untuk pipeline. num_workers (`int`, *opsional*, default 8) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), jumlah worker yang akan digunakan. batch_size (`int`, *opsional*, default 1) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), ukuran batch yang akan digunakan. Untuk inferensi, ini tidak selalu menguntungkan, silakan baca [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/id/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opsional*) : Referensi ke objek yang bertanggung jawab untuk mengurai parameter pipeline yang diberikan. device (`int` atau `str` atau `torch.device`, *opsional*) : Perangkat tempat pipeline dialokasikan. Jika tidak disetel, pipeline ditempatkan pada akselerator pertama yang tersedia (CUDA, MPS, XPU, ...) dan hanya kembali ke CPU jika tidak ada yang tersedia; model dipindahkan ke sana secara otomatis. Lewatkan `device="cpu"` (atau `-1`) untuk memaksa CPU, ordinal positif atau `"cuda:1"` untuk memilih akselerator tertentu, atau `torch.device`/`str` asli. Argumen ini tidak dapat digabungkan dengan model yang sudah dimuat melalui `accelerate` (yaitu model dengan `hf_device_map`). dtype (`str` atau `torch.dtype`, *opsional*, defaultnya `"auto"`) : Presisi saat model dimuat, diteruskan ke `from_pretrained`. Defaultnya `"auto"`, yang memuat model dalam dtype tempat model disimpan (dibaca dari `config.dtype` checkpoint, jika tidak ada, disimpulkan dari bobot). Berikan `torch.float16`, `torch.bfloat16`, `torch.float32`, ... secara eksplisit untuk menimpanya. binary_output (`bool`, *opsional*, defaultnya `False`) : Flag yang menunjukkan apakah output pipeline harus terjadi dalam format terserialisasi (yaitu, pickle) atau sebagai data output mentah, misalnya teks. Pipeline klasifikasi gambar zero shot menggunakan `CLIPModel`. Pipeline ini memprediksi kelas dari sebuah gambar ketika Anda menyediakan gambar dan seperangkat `candidate_labels`. Contoh: ```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'}] ``` Pelajari lebih lanjut tentang dasar-dasar penggunaan pipeline di [tutorial pipeline](../pipeline_tutorial) Pipeline klasifikasi gambar ini saat ini dapat dimuat dari [pipeline()](/docs/transformers/main/id/main_classes/pipelines#transformers.pipeline) menggunakan pengidentifikasi tugas berikut: `"zero-shot-image-classification"`. Lihat daftar model yang tersedia di [huggingface.co/models](https://huggingface.co/models?filter=zero-shot-image-classification). #### __call__[[transformers.ZeroShotImageClassificationPipeline.__call__]] ```python __call__(image: typing.Union[str, list[str], ForwardRef('Image.Image'), list['Image.Image']], candidate_labels: list, **kwargs: Any) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/zero_shot_image_classification.py#L83) **Parameter:** image (`str`, `list[str]`, `PIL.Image` atau `list[PIL.Image]`) : Pipeline menangani tiga jenis gambar: - String yang berisi tautan http yang mengarah ke gambar - String yang berisi path lokal ke gambar - Gambar yang dimuat langsung dalam PIL candidate_labels (`list[str]`) : Label kandidat untuk gambar ini. Label tersebut akan diformat menggunakan *hypothesis_template*. hypothesis_template (`str`, *opsional*, defaultnya `"This is a photo of {}"`) : Format yang digunakan bersama dengan *candidate_labels* untuk mencoba klasifikasi gambar dengan mengganti placeholder dengan candidate_labels. Kirim "{}" jika *candidate_labels* sudah diformat. timeout (`float`, *opsional*, defaultnya None) : Waktu maksimum dalam detik untuk menunggu pengambilan gambar dari web. Jika None, tidak ada batas waktu yang ditetapkan dan panggilan dapat memblokir selamanya. **Mengembalikan:** Daftar kamus yang berisi satu entri per label yang diusulkan. Setiap kamus berisi kunci-kunci berikut: - **label** (`str`) -- Salah satu dari *candidate_labels* yang disarankan. - **score** (`float`) -- Skor yang diberikan model untuk label tersebut. Nilainya berada di antara 0 dan 1, dihitung sebagai `softmax` dari `logits_per_image`. Tugaskan label ke gambar yang diteruskan sebagai input. ### ZeroShotObjectDetectionPipeline[[transformers.ZeroShotObjectDetectionPipeline]] #### transformers.ZeroShotObjectDetectionPipeline[[transformers.ZeroShotObjectDetectionPipeline]] ```python transformers.ZeroShotObjectDetectionPipeline(**kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/zero_shot_object_detection.py#L23) **Parameter:** model ([PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel)) : Model yang akan digunakan oleh pipeline untuk membuat prediksi. Ini harus berupa model yang mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor)) : Pemroses gambar yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Objek ini mewarisi dari [BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, defaultnya `""`) : Pengidentifikasi tugas untuk pipeline. num_workers (`int`, *opsional*, default 8) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), jumlah worker yang akan digunakan. batch_size (`int`, *opsional*, default 1) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), ukuran batch yang akan digunakan. Untuk inferensi, ini tidak selalu menguntungkan, silakan baca [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/id/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opsional*) : Referensi ke objek yang bertanggung jawab untuk mengurai parameter pipeline yang diberikan. device (`int` atau `str` atau `torch.device`, *opsional*) : Perangkat tempat pipeline dialokasikan. Jika tidak disetel, pipeline ditempatkan pada akselerator pertama yang tersedia (CUDA, MPS, XPU, ...) dan hanya kembali ke CPU jika tidak ada yang tersedia; model dipindahkan ke sana secara otomatis. Lewatkan `device="cpu"` (atau `-1`) untuk memaksa CPU, ordinal positif atau `"cuda:1"` untuk memilih akselerator tertentu, atau `torch.device`/`str` asli. Argumen ini tidak dapat digabungkan dengan model yang sudah dimuat melalui `accelerate` (yaitu model dengan `hf_device_map`). dtype (`str` atau `torch.dtype`, *opsional*, defaultnya `"auto"`) : Presisi saat model dimuat, diteruskan ke `from_pretrained`. Defaultnya `"auto"`, yang memuat model dalam dtype tempat model disimpan (dibaca dari `config.dtype` checkpoint, jika tidak ada, disimpulkan dari bobot). Berikan `torch.float16`, `torch.bfloat16`, `torch.float32`, ... secara eksplisit untuk menimpanya. binary_output (`bool`, *opsional*, defaultnya `False`) : Flag yang menunjukkan apakah output pipeline harus terjadi dalam format terserialisasi (yaitu, pickle) atau sebagai data output mentah, misalnya teks. Pipeline deteksi objek zero shot menggunakan `OwlViTForObjectDetection`. Pipeline ini memprediksi kotak pembatas objek ketika Anda menyediakan gambar dan seperangkat `candidate_labels`. Contoh: ```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}}] ``` Pelajari lebih lanjut tentang dasar-dasar penggunaan pipeline di [tutorial pipeline](../pipeline_tutorial) Pipeline deteksi objek ini saat ini dapat dimuat dari [pipeline()](/docs/transformers/main/id/main_classes/pipelines#transformers.pipeline) menggunakan pengidentifikasi tugas berikut: `"zero-shot-object-detection"`. Lihat daftar model yang tersedia di [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) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/zero_shot_object_detection.py#L75) **Parameter:** image (`str`, `PIL.Image` atau `list[dict[str, Any]]`) : Pipeline menangani tiga jenis gambar: - String yang berisi url http yang menunjuk ke sebuah gambar - String yang berisi path lokal ke sebuah gambar - Gambar yang dimuat langsung dalam PIL Anda dapat menggunakan parameter ini untuk mengirim langsung daftar gambar, atau dataset atau generator seperti berikut: ```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` atau `list[str]` atau `list[list[str]]`) : Apa yang harus dikenali model dalam gambar. threshold (`float`, *opsional*, default 0.1) : Probabilitas yang diperlukan untuk membuat prediksi. top_k (`int`, *opsional*, defaultnya None) : Jumlah prediksi teratas yang akan dikembalikan oleh pipeline. Jika jumlah yang diberikan adalah `None` atau lebih besar dari jumlah prediksi yang tersedia, nilainya akan direset menjadi jumlah prediksi. timeout (`float`, *opsional*, defaultnya None) : Waktu maksimum dalam detik untuk menunggu pengambilan gambar dari web. Jika None, tidak ada batas waktu yang ditetapkan dan panggilan dapat memblokir selamanya. **Mengembalikan:** Daftar dari daftar yang berisi hasil prediksi, satu daftar per gambar input. Setiap daftar berisi kamus dengan kunci-kunci berikut: - **label** (`str`) -- Kueri teks yang sesuai dengan objek yang ditemukan. - **score** (`float`) -- Skor yang sesuai dengan objek (antara 0 dan 1). - **box** (`dict[str,int]`) -- Kotak pembatas objek yang terdeteksi pada ukuran asli gambar. Ini adalah kamus dengan kunci `x_min`, `x_max`, `y_min`, `y_max`. Deteksi objek (kotak pembatas & kelas) pada gambar yang diberikan sebagai input. ## Pemrosesan Bahasa Alami Pipelines yang tersedia untuk tugas pemrosesan bahasa alami mencakup yang berikut. ### 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) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/fill_mask.py#L28) **Parameter:** model ([PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel)) : Model yang akan digunakan oleh pipeline untuk membuat prediksi. Ini harus berupa model yang mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend)) : Tokenizer yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Objek ini mewarisi dari [PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend). task (`str`, defaultnya `""`) : Pengidentifikasi tugas untuk pipeline. num_workers (`int`, *opsional*, default 8) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), jumlah worker yang akan digunakan. batch_size (`int`, *opsional*, default 1) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), ukuran batch yang akan digunakan. Untuk inferensi, ini tidak selalu menguntungkan, silakan baca [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/id/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opsional*) : Referensi ke objek yang bertanggung jawab untuk mengurai parameter pipeline yang diberikan. device (`int` atau `str` atau `torch.device`, *opsional*) : Perangkat tempat pipeline dialokasikan. Jika tidak disetel, pipeline ditempatkan pada akselerator pertama yang tersedia (CUDA, MPS, XPU, ...) dan hanya kembali ke CPU jika tidak ada yang tersedia; model dipindahkan ke sana secara otomatis. Lewatkan `device="cpu"` (atau `-1`) untuk memaksa CPU, ordinal positif atau `"cuda:1"` untuk memilih akselerator tertentu, atau `torch.device`/`str` asli. Argumen ini tidak dapat digabungkan dengan model yang sudah dimuat melalui `accelerate` (yaitu model dengan `hf_device_map`). dtype (`str` atau `torch.dtype`, *opsional*, defaultnya `"auto"`) : Presisi saat model dimuat, diteruskan ke `from_pretrained`. Defaultnya `"auto"`, yang memuat model dalam dtype tempat model disimpan (dibaca dari `config.dtype` checkpoint, jika tidak ada, disimpulkan dari bobot). Berikan `torch.float16`, `torch.bfloat16`, `torch.float32`, ... secara eksplisit untuk menimpanya. binary_output (`bool`, *opsional*, defaultnya `False`) : Flag yang menunjukkan apakah output pipeline harus terjadi dalam format terserialisasi (yaitu, pickle) atau sebagai data output mentah, misalnya teks. top_k (`int`, *opsional*, defaultnya 5) : Jumlah prediksi yang akan dikembalikan. targets (`str` atau `list[str]`, *opsional*) : Jika diberikan, model akan membatasi skor pada target yang diberikan alih-alih mencari di seluruh kosakata. Jika target yang diberikan tidak ada dalam kosakata model, target tersebut akan ditokenisasi dan token pertama yang dihasilkan akan digunakan (dengan peringatan, dan hal itu mungkin lebih lambat). tokenizer_kwargs (`dict`, *opsional*) : Kamus tambahan berisi argumen kata kunci yang diteruskan ke tokenizer. #### __call__[[transformers.FillMaskPipeline.__call__]] ```python __call__(inputs: str | list[str], **kwargs: Any) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/fill_mask.py#L234) **Parameter:** inputs (`str` atau `list[str]`) : Satu atau beberapa teks (atau satu daftar prompt) dengan token yang dimasker. targets (`str` atau `list[str]`, *opsional*) : Jika diberikan, model akan membatasi skor pada target yang diberikan alih-alih mencari di seluruh kosakata. Jika target yang diberikan tidak ada dalam kosakata model, target tersebut akan ditokenisasi dan token pertama yang dihasilkan akan digunakan (dengan peringatan, dan hal itu mungkin lebih lambat). top_k (`int`, *opsional*) : Jika diberikan, menimpa jumlah prediksi yang dikembalikan. **Mengembalikan:** Daftar atau daftar dari daftar `dict` Setiap hasil berupa daftar kamus dengan kunci berikut: - **sequence** (`str`) -- Input yang sesuai dengan prediksi token mask. - **score** (`float`) -- Probabilitas yang sesuai. - **token** (`int`) -- ID token yang diprediksi (untuk menggantikan token yang ter-mask). - **token_str** (`str`) -- Token yang diprediksi (untuk menggantikan token yang ter-mask). Isi token yang tersembunyi dalam teks yang diberikan sebagai input. ### TableQuestionAnsweringPipeline[[transformers.TableQuestionAnsweringPipeline]] #### transformers.TableQuestionAnsweringPipeline[[transformers.TableQuestionAnsweringPipeline]] ```python transformers.TableQuestionAnsweringPipeline(args_parser = , **kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/table_question_answering.py#L78) **Parameter:** model ([PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel)) : Model yang akan digunakan oleh pipeline untuk membuat prediksi. Ini harus berupa model yang mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend)) : Tokenizer yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Objek ini mewarisi dari [PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend). task (`str`, defaultnya `""`) : Pengidentifikasi tugas untuk pipeline. num_workers (`int`, *opsional*, default 8) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), jumlah worker yang akan digunakan. batch_size (`int`, *opsional*, default 1) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), ukuran batch yang akan digunakan. Untuk inferensi, ini tidak selalu menguntungkan, silakan baca [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/id/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opsional*) : Referensi ke objek yang bertanggung jawab untuk mengurai parameter pipeline yang diberikan. device (`int` atau `str` atau `torch.device`, *opsional*) : Perangkat tempat pipeline dialokasikan. Jika tidak disetel, pipeline ditempatkan pada akselerator pertama yang tersedia (CUDA, MPS, XPU, ...) dan hanya kembali ke CPU jika tidak ada yang tersedia; model dipindahkan ke sana secara otomatis. Lewatkan `device="cpu"` (atau `-1`) untuk memaksa CPU, ordinal positif atau `"cuda:1"` untuk memilih akselerator tertentu, atau `torch.device`/`str` asli. Argumen ini tidak dapat digabungkan dengan model yang sudah dimuat melalui `accelerate` (yaitu model dengan `hf_device_map`). dtype (`str` atau `torch.dtype`, *opsional*, defaultnya `"auto"`) : Presisi saat model dimuat, diteruskan ke `from_pretrained`. Defaultnya `"auto"`, yang memuat model dalam dtype tempat model disimpan (dibaca dari `config.dtype` checkpoint, jika tidak ada, disimpulkan dari bobot). Berikan `torch.float16`, `torch.bfloat16`, `torch.float32`, ... secara eksplisit untuk menimpanya. binary_output (`bool`, *opsional*, defaultnya `False`) : Flag yang menunjukkan apakah output pipeline harus terjadi dalam format terserialisasi (yaitu, pickle) atau sebagai data output mentah, misalnya teks. Pipeline Table Question Answering menggunakan `ModelForTableQuestionAnswering`. Pipeline ini hanya tersedia di PyTorch. Kecuali model yang Anda gunakan secara eksplisit mengatur parameter generasi ini di file konfigurasinya (`generation_config.json`), nilai default berikut akan digunakan: - max_new_tokens: 256 Contoh: ```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'} ``` Pelajari lebih lanjut tentang dasar-dasar penggunaan pipeline di [tutorial pipeline](../pipeline_tutorial) Pipeline penjawab pertanyaan tabular ini saat ini dapat dimuat dari [pipeline()](/docs/transformers/main/id/main_classes/pipelines#transformers.pipeline) menggunakan pengidentifikasi tugas berikut: `"table-question-answering"`. Model yang dapat digunakan oleh pipeline ini adalah model yang telah dihaluskan (fine-tuned) pada tugas menjawab pertanyaan tabular. Lihat daftar model yang tersedia dan terkini di [huggingface.co/models](https://huggingface.co/models?filter=table-question-answering). #### __call__[[transformers.TableQuestionAnsweringPipeline.__call__]] ```python __call__(*args, **kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/table_question_answering.py#L208) **Parameter:** table (`pd.DataFrame` atau `Dict`) : Pandas DataFrame atau dictionary yang akan dikonversi menjadi DataFrame yang berisi semua nilai tabel. Lihat di atas untuk contoh dictionary. query (`str` atau `list[str]`) : Query atau daftar query yang akan dikirim ke model bersama tabel. sequential (`bool`, *opsional*, defaultnya `False`) : Apakah melakukan inferensi secara berurutan atau sebagai batch. Batching lebih cepat, tetapi model seperti SQA memerlukan inferensi dilakukan secara berurutan untuk mengekstrak relasi di dalam urutan, mengingat sifat percakapannya. padding (`bool`, `str` atau [PaddingStrategy](/docs/transformers/main/id/internal/file_utils#transformers.utils.PaddingStrategy), *opsional*, defaultnya `False`) : Mengaktifkan dan mengontrol padding. Menerima nilai-nilai berikut: - `True` atau `'longest'`: Pad hingga urutan terpanjang dalam batch (atau tanpa padding jika hanya satu urutan yang diberikan). - `'max_length'`: Pad hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima oleh model jika argumen tersebut tidak diberikan. - `False` atau `'do_not_pad'` (default): Tanpa padding (yaitu, dapat menghasilkan batch dengan urutan yang panjangnya berbeda-beda). truncation (`bool`, `str` atau `TapasTruncationStrategy`, *opsional*, defaultnya `False`) : Mengaktifkan dan mengontrol pemotongan. Menerima nilai-nilai berikut: - `True` atau `'drop_rows_to_fit'`: Memotong hingga panjang maksimum yang ditentukan dengan argumen `max_length` atau hingga panjang input maksimum yang dapat diterima untuk model jika argumen tersebut tidak diberikan. Ini akan memotong baris per baris, menghapus baris dari tabel. - `False` atau `'do_not_truncate'` (default): Tidak ada pemotongan (yaitu, dapat menghasilkan batch dengan panjang sekuens yang lebih besar dari ukuran input maksimum yang diizinkan model). **Mengembalikan:** `A dictionary or a list of dictionaries containing results` Setiap hasil adalah kamus dengan kunci-kunci berikut: - **answer** (`str`) -- Jawaban dari kueri berdasarkan tabel. Jika ada agregator, jawaban akan didahului oleh `AGGREGATOR >`. - **koordinat** (`list[tuple[int, int]]`) -- Koordinat sel-sel jawaban. - **cells** (`list[str]`) -- Daftar string yang terdiri dari nilai sel jawaban. - **aggregator** (`str`) -- Jika model memiliki aggregator, ini mengembalikan aggregator tersebut. Menjawab kueri berdasarkan tabel. Pipeline menerima beberapa jenis input yang dirinci di bawah ini: - `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}])` Argumen `table` harus berupa dict atau DataFrame yang dibangun dari dict tersebut, yang berisi seluruh tabel: Contoh: ```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"], } ``` Kamus ini dapat diteruskan apa adanya, atau dapat dikonversi menjadi DataFrame pandas: Contoh: ```python import pandas as pd table = pd.DataFrame.from_dict(data) ``` ### TextClassificationPipeline[[transformers.TextClassificationPipeline]] #### transformers.TextClassificationPipeline[[transformers.TextClassificationPipeline]] ```python transformers.TextClassificationPipeline(**kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/text_classification.py#L43) **Parameter:** model ([PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel)) : Model yang akan digunakan oleh pipeline untuk membuat prediksi. Ini harus berupa model yang mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend)) : Tokenizer yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Objek ini mewarisi dari [PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend). task (`str`, defaultnya `""`) : Pengidentifikasi tugas untuk pipeline. num_workers (`int`, *opsional*, default 8) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), jumlah worker yang akan digunakan. batch_size (`int`, *opsional*, default 1) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), ukuran batch yang akan digunakan. Untuk inferensi, ini tidak selalu menguntungkan, silakan baca [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/id/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opsional*) : Referensi ke objek yang bertanggung jawab untuk mengurai parameter pipeline yang diberikan. device (`int` atau `str` atau `torch.device`, *opsional*) : Perangkat tempat pipeline dialokasikan. Jika tidak disetel, pipeline ditempatkan pada akselerator pertama yang tersedia (CUDA, MPS, XPU, ...) dan hanya kembali ke CPU jika tidak ada yang tersedia; model dipindahkan ke sana secara otomatis. Lewatkan `device="cpu"` (atau `-1`) untuk memaksa CPU, ordinal positif atau `"cuda:1"` untuk memilih akselerator tertentu, atau `torch.device`/`str` asli. Argumen ini tidak dapat digabungkan dengan model yang sudah dimuat melalui `accelerate` (yaitu model dengan `hf_device_map`). dtype (`str` atau `torch.dtype`, *opsional*, defaultnya `"auto"`) : Presisi saat model dimuat, diteruskan ke `from_pretrained`. Defaultnya `"auto"`, yang memuat model dalam dtype tempat model disimpan (dibaca dari `config.dtype` checkpoint, jika tidak ada, disimpulkan dari bobot). Berikan `torch.float16`, `torch.bfloat16`, `torch.float32`, ... secara eksplisit untuk menimpanya. binary_output (`bool`, *opsional*, defaultnya `False`) : Flag yang menunjukkan apakah output pipeline harus terjadi dalam format terserialisasi (yaitu, pickle) atau sebagai data output mentah, misalnya teks. function_to_apply (`str`, *opsional*, defaultnya `"default"`) : Fungsi yang diterapkan pada output model untuk mengambil skor. Menerima empat nilai yang berbeda: - `"default"`: jika model memiliki satu label, fungsi sigmoid akan diterapkan pada output. Jika model memiliki beberapa label, fungsi softmax akan diterapkan pada output. Untuk tugas regresi, tidak ada fungsi yang diterapkan pada output. - `"sigmoid"`: Menerapkan fungsi sigmoid pada output. - `"softmax"`: Menerapkan fungsi softmax pada output. - `"none"`: Tidak menerapkan fungsi apa pun pada output. Pipeline klasifikasi teks menggunakan `ModelForSequenceClassification` apa pun. Lihat [contoh klasifikasi sekuens](../task_summary#sequence-classification) untuk informasi lebih lanjut. Contoh: ```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}] ``` Pelajari lebih lanjut tentang dasar-dasar penggunaan pipeline di [tutorial pipeline](../pipeline_tutorial) Pipeline klasifikasi teks ini saat ini dapat dimuat dari [pipeline()](/docs/transformers/main/id/main_classes/pipelines#transformers.pipeline) menggunakan pengidentifikasi tugas berikut: `"sentiment-analysis"` (untuk mengklasifikasikan urutan berdasarkan sentimen positif atau negatif). Jika beberapa label klasifikasi tersedia (`model.config.num_labels >= 2`, pipeline akan menjalankan softmax pada hasil. Jika hanya ada satu label, pipeline akan menjalankan sigmoid pada hasil. Untuk tugas regresi (`model.config.problem_type == "regression"`, tidak akan diterapkan fungsi apa pun pada output. Model yang dapat digunakan oleh pipeline ini adalah model yang telah dihaluskan (fine-tuned) pada tugas klasifikasi sekuens. Lihat daftar model yang tersedia dan terkini di [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) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/text_classification.py#L105) **Parameter:** inputs (`str` atau `list[str]` atau `dict[str]`, atau `list[dict[str]]`) : Satu atau beberapa teks untuk diklasifikasikan. Untuk menggunakan pasangan teks dalam klasifikasi Anda, Anda dapat mengirim kamus yang berisi kunci `{"text", "text_pair"}`, atau daftar dari kunci-kunci tersebut. top_k (`int`, *opsional*, defaultnya `1`) : Berapa banyak hasil yang akan dikembalikan. function_to_apply (`str`, *opsional*, defaultnya `"default"`) : Fungsi yang diterapkan pada keluaran model untuk mengambil skor. Menerima empat nilai yang berbeda: Jika argumen ini tidak ditentukan, maka fungsi berikut akan diterapkan sesuai dengan jumlah label: - Jika tipe masalah adalah regresi, tidak akan menerapkan fungsi apa pun pada keluaran. - Jika model memiliki satu label, akan menerapkan fungsi sigmoid pada keluaran. - Jika model memiliki beberapa label, akan menerapkan fungsi softmax pada keluaran. Nilai yang mungkin adalah: - `"sigmoid"`: Menerapkan fungsi sigmoid pada keluaran. - `"softmax"`: Menerapkan fungsi softmax pada keluaran. - `"none"`: Tidak menerapkan fungsi apa pun pada keluaran. **Mengembalikan:** Daftar `dict` Setiap hasil berupa daftar kamus dengan kunci berikut: - **label** (`str`) -- Label yang diprediksi. - **score** (`float`) -- Probabilitas yang sesuai. Jika `top_k` digunakan, satu kamus seperti itu dikembalikan untuk setiap label. Klasifikasikan teks yang diberikan sebagai input. ### TextGenerationPipeline[[transformers.TextGenerationPipeline]] #### transformers.TextGenerationPipeline[[transformers.TextGenerationPipeline]] ```python transformers.TextGenerationPipeline(*args, **kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/text_generation.py#L23) **Parameter:** model ([PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel)) : Model yang akan digunakan oleh pipeline untuk membuat prediksi. Ini harus berupa model yang mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend)) : Tokenizer yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Objek ini mewarisi dari [PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend). task (`str`, defaultnya `""`) : Pengidentifikasi tugas untuk pipeline. num_workers (`int`, *opsional*, default 8) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), jumlah worker yang akan digunakan. batch_size (`int`, *opsional*, default 1) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), ukuran batch yang akan digunakan. Untuk inferensi, ini tidak selalu menguntungkan, silakan baca [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/id/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opsional*) : Referensi ke objek yang bertanggung jawab untuk mengurai parameter pipeline yang diberikan. device (`int` atau `str` atau `torch.device`, *opsional*) : Perangkat tempat pipeline dialokasikan. Jika tidak disetel, pipeline ditempatkan pada akselerator pertama yang tersedia (CUDA, MPS, XPU, ...) dan hanya kembali ke CPU jika tidak ada yang tersedia; model dipindahkan ke sana secara otomatis. Lewatkan `device="cpu"` (atau `-1`) untuk memaksa CPU, ordinal positif atau `"cuda:1"` untuk memilih akselerator tertentu, atau `torch.device`/`str` asli. Argumen ini tidak dapat digabungkan dengan model yang sudah dimuat melalui `accelerate` (yaitu model dengan `hf_device_map`). dtype (`str` atau `torch.dtype`, *opsional*, defaultnya `"auto"`) : Presisi saat model dimuat, diteruskan ke `from_pretrained`. Defaultnya `"auto"`, yang memuat model dalam dtype tempat model disimpan (dibaca dari `config.dtype` checkpoint, jika tidak ada, disimpulkan dari bobot). Berikan `torch.float16`, `torch.bfloat16`, `torch.float32`, ... secara eksplisit untuk menimpanya. binary_output (`bool`, *opsional*, defaultnya `False`) : Flag yang menunjukkan apakah output pipeline harus terjadi dalam format terserialisasi (yaitu, pickle) atau sebagai data output mentah, misalnya teks. Pipeline generasi bahasa menggunakan `ModelWithLMHead` atau `ModelForCausalLM` apa pun. Pipeline ini memprediksi kata-kata yang akan mengikuti prompt teks tertentu. Ketika model dasarnya adalah model percakapan, pipeline ini juga dapat menerima satu atau lebih chat, di mana pipeline akan beroperasi dalam mode chat dan melanjutkan chat tersebut dengan menambahkan responsnya. Setiap chat berbentuk daftar dict, di mana setiap dict berisi kunci "role" dan "content". Kecuali model yang Anda gunakan secara eksplisit mengatur parameter generasi ini di file konfigurasinya (`generation_config.json`), nilai default berikut akan digunakan: - max_new_tokens: 256 - do_sample: True - temperature: 0.7 Contoh: ```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'}]}] ``` Pelajari lebih lanjut tentang dasar-dasar penggunaan pipeline di [tutorial pipeline](../pipeline_tutorial). Anda dapat meneruskan parameter generasi teks ke pipeline ini untuk mengontrol kriteria penghentian, strategi decoding, dan lainnya. Pelajari lebih lanjut tentang parameter generasi teks di [Strategi generasi teks](../generation_strategies) dan [Generasi teks](text_generation). Pipeline generasi bahasa ini saat ini dapat dimuat dari [pipeline()](/docs/transformers/main/id/main_classes/pipelines#transformers.pipeline) menggunakan pengidentifikasi tugas berikut: `"text-generation"`. Model yang dapat digunakan oleh pipeline ini adalah model yang telah dilatih dengan tujuan pemodelan bahasa autoregresif. Lihat daftar [model pelengkapan teks](https://huggingface.co/models?filter=text-generation) yang tersedia dan daftar [model percakapan](https://huggingface.co/models?other=conversational) di [huggingface.co/models]. #### __call__[[transformers.TextGenerationPipeline.__call__]] ```python __call__(text_inputs, **kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/text_generation.py#L251) **Parameter:** text_inputs (`str`, `list[str]`, `ChatType`, atau `list[ChatType]`) : Satu atau beberapa prompt (atau satu daftar prompt) untuk diselesaikan. Jika string atau daftar string yang dilewatkan, pipeline ini akan melanjutkan setiap prompt. Sebagai alternatif, sebuah "chat", dalam bentuk daftar dict dengan kunci "role" dan "content", dapat dilewatkan, atau daftar dari chat semacam itu. Ketika chat dilewatkan, template chat model akan digunakan untuk memformatnya sebelum melewatkan ke model. return_tensors (`bool`, *opsional*, defaultnya `False`) : Mengembalikan tensor prediksi (sebagai indeks token) dalam output. Jika diatur ke `True`, teks yang didekodekan tidak dikembalikan. return_text (`bool`, *opsional*) : Mengembalikan teks yang telah didekodekan dalam output. return_full_text (`bool`, *opsional*, defaultnya `True`) : Jika diatur ke `False`, hanya teks yang ditambahkan yang dikembalikan, selain itu teks lengkap yang dikembalikan. Tidak dapat ditentukan bersamaan dengan `return_text`. clean_up_tokenization_spaces (`bool`, *opsional*) : Apakah akan membersihkan spasi ekstra potensial dalam output teks. Bawaan ke pengaturan `clean_up_tokenization_spaces` tokenizer. continue_final_message( `bool`, *opsional*) : Ini menunjukkan bahwa Anda ingin model melanjutkan pesan terakhir dalam chat input alih-alih memulai pesan baru, sehingga memungkinkan Anda untuk "prefill" responsnya. Secara default, ini adalah `True` ketika pesan terakhir dalam chat input memiliki peran `assistant` dan `False` selain itu, tetapi Anda dapat menimpa perilaku tersebut secara manual dengan mengatur flag ini. prefix (`str`, *opsional*) : Prefiks yang ditambahkan ke prompt. stop_sequence (`str` atau `list[str]`, *opsional*) : Satu atau lebih string yang menghentikan generasi setelah dihasilkan. String penghenti disertakan dalam output. handle_long_generation (`str`, *opsional*) : Secara default, pipeline ini tidak menangani generasi panjang (yang melampaui panjang maksimum model dalam bentuk apa pun). Tidak ada cara sempurna untuk mengatasi hal ini (info lebih lanjut :https://github.com/huggingface/transformers/issues/14033#issuecomment-948385227). Ini menyediakan strategi umum untuk mengatasi masalah tersebut tergantung pada kasus penggunaan Anda. - `None` : strategi default di mana tidak ada yang terjadi secara khusus - `"hole"`: Memotong bagian kiri input, dan menyisakan celah yang cukup lebar agar generasi dapat terjadi (mungkin memotong banyak bagian dari prompt dan tidak cocok ketika generasi melampaui kapasitas model) tokenizer_encode_kwargs (`dict`, *opsional*) : Argumen kata kunci tambahan untuk diteruskan ke langkah encoding tokenizer. Jika input teks berupa chat, argumen ini diteruskan ke `apply_chat_template`. Sebaliknya, argumen ini diteruskan ke `__call__`. generate_kwargs (`dict`, *opsional*) : Argumen kata kunci tambahan untuk diteruskan ke metode generate dari model (lihat metode generate [di sini](./text_generation)). **Mengembalikan:** Daftar atau daftar dari daftar `dict` Mengembalikan salah satu dari kamus berikut (tidak dapat mengembalikan kombinasi `generated_text` dan `generated_token_ids`): - **generated_text** (`str`, ada ketika `return_text=True`) -- Teks yang dihasilkan. - **generated_token_ids** (`torch.Tensor`, ada ketika `return_tensors=True`) -- ID token dari teks yang dihasilkan. Lengkapi prompt yang diberikan sebagai input. ### TokenClassificationPipeline[[transformers.TokenClassificationPipeline]] #### transformers.TokenClassificationPipeline[[transformers.TokenClassificationPipeline]] ```python transformers.TokenClassificationPipeline(args_parser = , **kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/token_classification.py#L91) **Parameter:** model ([PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel)) : Model yang akan digunakan oleh pipeline untuk membuat prediksi. Ini harus berupa model yang mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend)) : Tokenizer yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Objek ini mewarisi dari [PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend). task (`str`, defaultnya `""`) : Pengidentifikasi tugas untuk pipeline. num_workers (`int`, *opsional*, default 8) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), jumlah worker yang akan digunakan. batch_size (`int`, *opsional*, default 1) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), ukuran batch yang akan digunakan. Untuk inferensi, ini tidak selalu menguntungkan, silakan baca [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/id/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opsional*) : Referensi ke objek yang bertanggung jawab untuk mengurai parameter pipeline yang diberikan. device (`int` atau `str` atau `torch.device`, *opsional*) : Perangkat tempat pipeline dialokasikan. Jika tidak disetel, pipeline ditempatkan pada akselerator pertama yang tersedia (CUDA, MPS, XPU, ...) dan hanya kembali ke CPU jika tidak ada yang tersedia; model dipindahkan ke sana secara otomatis. Lewatkan `device="cpu"` (atau `-1`) untuk memaksa CPU, ordinal positif atau `"cuda:1"` untuk memilih akselerator tertentu, atau `torch.device`/`str` asli. Argumen ini tidak dapat digabungkan dengan model yang sudah dimuat melalui `accelerate` (yaitu model dengan `hf_device_map`). dtype (`str` atau `torch.dtype`, *opsional*, defaultnya `"auto"`) : Presisi saat model dimuat, diteruskan ke `from_pretrained`. Defaultnya `"auto"`, yang memuat model dalam dtype tempat model disimpan (dibaca dari `config.dtype` checkpoint, jika tidak ada, disimpulkan dari bobot). Berikan `torch.float16`, `torch.bfloat16`, `torch.float32`, ... secara eksplisit untuk menimpanya. binary_output (`bool`, *opsional*, defaultnya `False`) : Flag yang menunjukkan apakah output pipeline harus terjadi dalam format terserialisasi (yaitu, pickle) atau sebagai data output mentah, misalnya teks. ignore_labels (`list[str]`, defaultnya `["O"]`) : Daftar label yang akan diabaikan. stride (`int`, *opsional*) : Jika stride diberikan, pipeline diterapkan pada seluruh teks. Teks dipecah menjadi potongan berukuran model_max_length. Hanya berfungsi dengan fast tokenizers dan `aggregation_strategy` yang berbeda dari `NONE`. Nilai argumen ini menentukan jumlah token yang tumpang tindih antar-potongan. Dengan kata lain, model akan bergeser maju sebanyak `tokenizer.model_max_length - stride` token pada setiap langkah. aggregation_strategy (`str`, *opsional*, defaultnya `"none"`) : Strategi untuk menggabungkan (atau tidak) token berdasarkan prediksi model. - "none" : Tidak akan melakukan agregasi apa pun dan hanya mengembalikan hasil mentah dari model - "simple" : Akan mencoba mengelompokkan entitas mengikuti skema default. (A, B-TAG), (B, I-TAG), (C, I-TAG), (D, B-TAG2) (E, B-TAG2) akan berakhir menjadi [{"word": ABC, "entity": "TAG"}, {"word": "D", "entity": "TAG2"}, {"word": "E", "entity": "TAG2"}] Perhatikan bahwa dua tag B yang berurutan akan berakhir sebagai entitas yang berbeda. Pada bahasa berbasis kata, kita mungkin berakhir dengan pemecahan kata yang tidak diinginkan : Bayangkan Microsoft diberi tag sebagai [{"word": "Micro", "entity": "ENTERPRISE"}, {"word": "soft", "entity": "NAME"}]. Cari FIRST, MAX, AVERAGE untuk cara memitigasi hal tersebut dan mendiskriminasi kata (pada bahasa yang mendukung makna tersebut, yang pada dasarnya adalah token yang dipisahkan oleh spasi). Mitigasi ini hanya akan berfungsi pada kata-kata asli, "New york" mungkin masih diberi tag dengan dua entitas yang berbeda. - "first" : (hanya berfungsi pada model berbasis kata) Akan menggunakan strategi `SIMPLE` kecuali bahwa kata-kata tidak dapat berakhir dengan tag yang berbeda. Kata-kata akan menggunakan tag dari token pertama kata tersebut ketika ada ambiguitas. - "average" : (hanya berfungsi pada model berbasis kata) Akan menggunakan strategi `SIMPLE` kecuali bahwa kata-kata tidak dapat berakhir dengan tag yang berbeda. skor akan dirata-ratakan terlebih dahulu di antara token, dan kemudian label maksimum diterapkan. - "max" : (hanya berfungsi pada model berbasis kata) Akan menggunakan strategi `SIMPLE` kecuali bahwa kata-kata tidak dapat berakhir dengan tag yang berbeda. Entitas kata akan menjadi token dengan skor maksimum. Pipeline Named Entity Recognition menggunakan `ModelForTokenClassification` apa pun. Lihat [contoh named entity recognition](../task_summary#named-entity-recognition) untuk informasi lebih lanjut. Contoh: ```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}] ``` Pelajari lebih lanjut tentang dasar-dasar penggunaan pipeline di [tutorial pipeline](../pipeline_tutorial) Pipeline pengenalan token ini saat ini dapat dimuat dari [pipeline()](/docs/transformers/main/id/main_classes/pipelines#transformers.pipeline) menggunakan pengidentifikasi tugas berikut: `"ner"` (untuk memprediksi kelas token dalam sebuah urutan: person, organisation, location, atau miscellaneous). Model yang dapat digunakan oleh pipeline ini adalah model yang telah dihaluskan (fine-tuned) pada tugas klasifikasi token. Lihat daftar model yang tersedia dan terkini di [huggingface.co/models](https://huggingface.co/models?filter=token-classification). #### __call__[[transformers.TokenClassificationPipeline.__call__]] ```python __call__(inputs: str | list[str], **kwargs: Any) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/token_classification.py#L210) **Parameter:** inputs (`str` atau `List[str]`) : Satu atau beberapa teks (atau satu daftar teks) untuk klasifikasi token. Dapat berupa token yang sudah dipecah saat `is_split_into_words=True`. **Mengembalikan:** Daftar atau daftar dari daftar `dict` Setiap hasil berupa daftar kamus (satu untuk setiap token dalam input yang sesuai, atau setiap entitas jika pipeline ini diinstansiasi dengan aggregation_strategy) dengan kunci berikut: - **word** (`str`) -- Token/kata yang diklasifikasikan. Ini diperoleh dengan mendekode token yang dipilih. Jika Anda ingin memiliki string persis di kalimat asli, gunakan `start` dan `end`. - **score** (`float`) -- Probabilitas yang sesuai untuk `entity`. - **entity** (`str`) -- Entitas yang diprediksi untuk token/kata tersebut (dinamakan *entity_group* ketika *aggregation_strategy* bukan `"none"`. - **index** (`int`, hanya ada ketika `aggregation_strategy="none"`) -- Indeks dari token yang sesuai dalam kalimat. - **start** (`int`, *opsional*) -- Indeks awal entitas yang sesuai dalam kalimat. Hanya ada jika offset tersedia di dalam tokenizer - **end** (`int`, *opsional*) -- Indeks akhir entitas yang sesuai dalam kalimat. Hanya ada jika offset tersedia di dalam tokenizer Klasifikasikan setiap token dari teks yang diberikan sebagai input. #### aggregate_words[[transformers.TokenClassificationPipeline.aggregate_words]] ```python aggregate_words(entities: list, aggregation_strategy: AggregationStrategy) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/token_classification.py#L522) Override token dari kata tertentu yang tidak sesuai untuk memaksa kesesuaian pada batas kata. Contoh: micro|soft| com|pany| B-ENT I-NAME I-ENT I-ENT akan ditulis ulang dengan strategi pertama sebagai microsoft| company| B-ENT I-ENT #### gather_pre_entities[[transformers.TokenClassificationPipeline.gather_pre_entities]] ```python gather_pre_entities(sentence: str, input_ids: ndarray, scores: ndarray, offset_mapping: list[tuple[int, int]] | None, special_tokens_mask: ndarray, aggregation_strategy: AggregationStrategy, word_ids: list[int | None] | None = None, word_to_chars_map: list[tuple[int, int]] | None = None) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/token_classification.py#L398) Gabungkan berbagai array numpy menjadi dict dengan semua informasi yang diperlukan untuk agregasi #### group_entities[[transformers.TokenClassificationPipeline.group_entities]] ```python group_entities(entities: list) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/token_classification.py#L585) **Parameter:** entities (`dict`) : Entitas yang diprediksi oleh pipeline. Temukan dan kelompokkan token-token bersebelahan yang memiliki prediksi entitas yang sama. #### group_sub_entities[[transformers.TokenClassificationPipeline.group_sub_entities]] ```python group_sub_entities(entities: list) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/token_classification.py#L550) **Parameter:** entities (`dict`) : Entitas yang diprediksi oleh pipeline. Kelompokkan token-token bersebelahan yang memiliki prediksi entitas yang sama. ### ZeroShotClassificationPipeline[[transformers.ZeroShotClassificationPipeline]] #### transformers.ZeroShotClassificationPipeline[[transformers.ZeroShotClassificationPipeline]] ```python transformers.ZeroShotClassificationPipeline(args_parser = , **kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/zero_shot_classification.py#L44) **Parameter:** model ([PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel)) : Model yang akan digunakan oleh pipeline untuk membuat prediksi. Ini harus berupa model yang mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend)) : Tokenizer yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Objek ini mewarisi dari [PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend). task (`str`, defaultnya `""`) : Pengidentifikasi tugas untuk pipeline. num_workers (`int`, *opsional*, default 8) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), jumlah worker yang akan digunakan. batch_size (`int`, *opsional*, default 1) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), ukuran batch yang akan digunakan. Untuk inferensi, ini tidak selalu menguntungkan, silakan baca [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/id/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opsional*) : Referensi ke objek yang bertanggung jawab untuk mengurai parameter pipeline yang diberikan. device (`int` atau `str` atau `torch.device`, *opsional*) : Perangkat tempat pipeline dialokasikan. Jika tidak disetel, pipeline ditempatkan pada akselerator pertama yang tersedia (CUDA, MPS, XPU, ...) dan hanya kembali ke CPU jika tidak ada yang tersedia; model dipindahkan ke sana secara otomatis. Lewatkan `device="cpu"` (atau `-1`) untuk memaksa CPU, ordinal positif atau `"cuda:1"` untuk memilih akselerator tertentu, atau `torch.device`/`str` asli. Argumen ini tidak dapat digabungkan dengan model yang sudah dimuat melalui `accelerate` (yaitu model dengan `hf_device_map`). dtype (`str` atau `torch.dtype`, *opsional*, defaultnya `"auto"`) : Presisi saat model dimuat, diteruskan ke `from_pretrained`. Defaultnya `"auto"`, yang memuat model dalam dtype tempat model disimpan (dibaca dari `config.dtype` checkpoint, jika tidak ada, disimpulkan dari bobot). Berikan `torch.float16`, `torch.bfloat16`, `torch.float32`, ... secara eksplisit untuk menimpanya. binary_output (`bool`, *opsional*, defaultnya `False`) : Flag yang menunjukkan apakah output pipeline harus terjadi dalam format terserialisasi (yaitu, pickle) atau sebagai data output mentah, misalnya teks. Pipeline klasifikasi zero-shot berbasis NLI menggunakan `ModelForSequenceClassification` yang dilatih pada tugas NLI (natural language inference). Ekuivalen dari pipeline `text-classification`, tetapi model-model ini tidak memerlukan jumlah kelas potensial yang di-hardcode; kelas dapat dipilih saat runtime. Ini biasanya berarti lebih lambat, tetapi **jauh** lebih fleksibel. Kombinasi apa pun dari urutan dan label dapat diteruskan, dan setiap kombinasi akan diposisikan sebagai pasangan premis/hipotesis lalu diteruskan ke model pretrained. Kemudian, logit untuk *entailment* diambil sebagai logit untuk validitas label kandidat. Model NLI apa pun dapat digunakan, tetapi id label *entailment* harus disertakan dalam :attr:*~transformers.PreTrainedConfig.label2id* dari konfigurasi model. Contoh: ```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]} ``` Pelajari lebih lanjut tentang dasar-dasar penggunaan pipeline di [tutorial pipeline](../pipeline_tutorial) Pipeline NLI ini saat ini dapat dimuat dari [pipeline()](/docs/transformers/main/id/main_classes/pipelines#transformers.pipeline) menggunakan pengidentifikasi tugas berikut: `"zero-shot-classification"`. Model yang dapat digunakan oleh pipeline ini adalah model yang telah dihaluskan (fine-tuned) pada tugas NLI. Lihat daftar model yang tersedia dan terkini di [huggingface.co/models](https://huggingface.co/models?search=nli). #### __call__[[transformers.ZeroShotClassificationPipeline.__call__]] ```python __call__(sequences: str | list[str], *args, **kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/zero_shot_classification.py#L159) **Parameter:** sequences (`str` atau `list[str]`) : Urutan yang akan diklasifikasikan, akan dipangkas jika input model terlalu besar. candidate_labels (`str` atau `list[str]`) : Himpunan label kelas yang mungkin untuk mengklasifikasikan setiap urutan. Bisa berupa satu label, string berisi label yang dipisahkan koma, atau daftar label. hypothesis_template (`str`, *opsional*, defaultnya `"This example is {}."`) : Template yang digunakan untuk mengubah setiap label menjadi hipotesis bergaya NLI. Template ini harus menyertakan sintaks {} atau serupa untuk label kandidat yang akan disisipkan ke dalam template. Misalnya, template default adalah `"This example is {}."` Dengan label kandidat `"sports"`, ini akan dimasukkan ke model seperti `" sequence to classify This example is sports . "`. Template default bekerja dengan baik dalam banyak kasus, tetapi mungkin layak untuk bereksperimen dengan template yang berbeda tergantung pada pengaturan tugas. multi_label (`bool`, *opsional*, defaultnya `False`) : Apakah beberapa label kandidat dapat benar secara bersamaan. Jika `False`, skor dinormalisasi sehingga jumlah kemungkinan label untuk setiap urutan adalah 1. Jika `True`, label dianggap independen dan probabilitas dinormalisasi untuk setiap kandidat dengan melakukan softmax pada skor entailment terhadap skor contradiction. **Mengembalikan:** Sebuah `dict` atau daftar `dict` Setiap hasil hadir sebagai kamus dengan kunci-kunci berikut: - **sequence** (`str`) -- Urutan yang menjadi sumber output ini. - **labels** (`list[str]`) -- Label yang diurutkan berdasarkan urutan kemungkinan. - **scores** (`list[float]`) -- Probabilitas untuk masing-masing label. Klasifikasikan urutan yang diberikan sebagai input. Lihat dokumentasi [ZeroShotClassificationPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.ZeroShotClassificationPipeline) untuk informasi lebih lanjut. ## Multimodal Pipelines yang tersedia untuk tugas multimodal mencakup yang berikut. ### DocumentQuestionAnsweringPipeline[[transformers.DocumentQuestionAnsweringPipeline]] #### transformers.DocumentQuestionAnsweringPipeline[[transformers.DocumentQuestionAnsweringPipeline]] ```python transformers.DocumentQuestionAnsweringPipeline(*args, **kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/document_question_answering.py#L206) **Parameter:** model ([PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel)) : Model yang akan digunakan oleh pipeline untuk membuat prediksi. Ini harus berupa model yang mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend)) : Tokenizer yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Objek ini mewarisi dari [PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend). image_processor ([BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor)) : Pemroses gambar yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Objek ini mewarisi dari [BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, defaultnya `""`) : Pengidentifikasi tugas untuk pipeline. num_workers (`int`, *opsional*, default 8) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), jumlah worker yang akan digunakan. batch_size (`int`, *opsional*, default 1) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), ukuran batch yang akan digunakan. Untuk inferensi, ini tidak selalu menguntungkan, silakan baca [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/id/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opsional*) : Referensi ke objek yang bertanggung jawab untuk mengurai parameter pipeline yang diberikan. device (`int` atau `str` atau `torch.device`, *opsional*) : Perangkat tempat pipeline dialokasikan. Jika tidak disetel, pipeline ditempatkan pada akselerator pertama yang tersedia (CUDA, MPS, XPU, ...) dan hanya kembali ke CPU jika tidak ada yang tersedia; model dipindahkan ke sana secara otomatis. Lewatkan `device="cpu"` (atau `-1`) untuk memaksa CPU, ordinal positif atau `"cuda:1"` untuk memilih akselerator tertentu, atau `torch.device`/`str` asli. Argumen ini tidak dapat digabungkan dengan model yang sudah dimuat melalui `accelerate` (yaitu model dengan `hf_device_map`). dtype (`str` atau `torch.dtype`, *opsional*, defaultnya `"auto"`) : Presisi saat model dimuat, diteruskan ke `from_pretrained`. Defaultnya `"auto"`, yang memuat model dalam dtype tempat model disimpan (dibaca dari `config.dtype` checkpoint, jika tidak ada, disimpulkan dari bobot). Berikan `torch.float16`, `torch.bfloat16`, `torch.float32`, ... secara eksplisit untuk menimpanya. binary_output (`bool`, *opsional*, defaultnya `False`) : Flag yang menunjukkan apakah output pipeline harus terjadi dalam format terserialisasi (yaitu, pickle) atau sebagai data output mentah, misalnya teks. Pipeline Document Question Answering menggunakan `AutoModelForDocumentQuestionAnswering` apa pun. Input/output-nya mirip dengan pipeline question answering (ekstraktif); namun, pipeline ini mengambil gambar (dan kata-kotak hasil OCR opsional) sebagai input, bukan konteks teks. Kecuali model yang Anda gunakan secara eksplisit mengatur parameter generasi ini di file konfigurasinya (`generation_config.json`), nilai default berikut akan digunakan: - max_new_tokens: 256 Contoh: ```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}] ``` Pelajari lebih lanjut tentang dasar-dasar penggunaan pipeline di [tutorial pipeline](../pipeline_tutorial) Pipeline question answering dokumen ini saat ini dapat dimuat dari [pipeline()](/docs/transformers/main/id/main_classes/pipelines#transformers.pipeline) menggunakan pengidentifikasi tugas berikut: `"document-question-answering"`. Model yang dapat digunakan oleh pipeline ini adalah model yang telah dihaluskan (fine-tuned) pada tugas question answering dokumen. Lihat daftar model yang tersedia dan terkini di [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) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/document_question_answering.py#L338) **Parameter:** image (`str` atau `PIL.Image`) : Pipeline menangani tiga jenis gambar: - String yang berisi tautan http yang mengarah ke gambar - String yang berisi path lokal ke gambar - Gambar yang dimuat langsung dalam PIL Pipeline menerima satu gambar tunggal atau batch gambar. Jika diberikan satu gambar, gambar tersebut dapat di-broadcast ke beberapa pertanyaan. question (`str`) : Pertanyaan yang akan diajukan terhadap dokumen. word_boxes (`list[str, tuple[float, float, float, float]]`, *opsional*) : Daftar kata dan kotak pembatas (dinormalisasi 0->1000). Jika Anda menyediakan input opsional ini, pipeline akan menggunakan kata dan kotak ini alih-alih menjalankan OCR pada gambar untuk menurunkannya untuk model yang membutuhkannya (mis. LayoutLM). Hal ini memungkinkan Anda untuk menggunakan kembali hasil OCR di banyak pemanggilan pipeline tanpa harus menjalankannya ulang setiap kali. top_k (`int`, *opsional*, default 1) : Jumlah jawaban yang akan dikembalikan (akan dipilih berdasarkan urutan kemungkinan). Perhatikan bahwa kami mengembalikan kurang dari top_k jawaban jika tidak ada cukup opsi yang tersedia dalam konteks. doc_stride (`int`, *opsional*, default 128) : Jika kata-kata dalam dokumen terlalu panjang untuk muat bersama pertanyaan bagi model, dokumen tersebut akan dipecah menjadi beberapa chunk dengan beberapa tumpang tindih. Argumen ini mengontrol ukuran tumpang tindih tersebut. max_answer_len (`int`, *opsional*, default 15) : Panjang maksimum dari jawaban yang diprediksi (misalnya, hanya jawaban dengan panjang yang lebih pendek yang dipertimbangkan). max_seq_len (`int`, *opsional*, default 384) : Panjang maksimum kalimat total (konteks + pertanyaan) dalam token untuk setiap chunk yang diteruskan ke model. Konteks akan dipecah menjadi beberapa chunk (menggunakan `doc_stride` sebagai overlap) jika diperlukan. max_question_len (`int`, *opsional*, defaultnya 64) : Panjang maksimum pertanyaan setelah tokenisasi. Akan dipangkas jika diperlukan. handle_impossible_answer (`bool`, *opsional*, defaultnya `False`) : Apakah kita menerima "mustahil" sebagai jawaban. lang (`str`, *opsional*) : Bahasa yang digunakan saat menjalankan OCR. Bawaan adalah english. tesseract_config (`str`, *opsional*) : Flag tambahan untuk diteruskan ke tesseract saat menjalankan OCR. timeout (`float`, *opsional*, defaultnya None) : Waktu maksimum dalam detik untuk menunggu pengambilan gambar dari web. Jika None, tidak ada batas waktu yang ditetapkan dan panggilan dapat memblokir selamanya. **Mengembalikan:** Sebuah `dict` atau daftar `dict` Setiap hasil hadir sebagai kamus dengan kunci-kunci berikut: - **score** (`float`) -- Probabilitas yang terkait dengan jawaban. - **start** (`int`) -- Indeks kata awal dari jawaban (dalam versi OCR dari input atau `word_boxes` yang disediakan). - **end** (`int`) -- Indeks kata akhir dari jawaban (dalam versi OCR dari input atau `word_boxes` yang disediakan). - **answer** (`str`) -- Jawaban atas pertanyaan tersebut. - **words** (`list[int]`) -- Indeks dari setiap pasangan kata/kotak yang ada dalam jawaban Jawab pertanyaan yang diberikan sebagai input dengan menggunakan dokumen. Sebuah dokumen didefinisikan sebagai gambar dan daftar opsional tuple (kata, kotak) yang merepresentasikan teks dalam dokumen. Jika `word_boxes` tidak disediakan, mesin OCR Tesseract (jika tersedia) akan digunakan untuk mengekstrak kata dan kotak secara otomatis untuk model mirip LayoutLM yang membutuhkannya sebagai input. Untuk Donut, tidak ada OCR yang dijalankan. Anda dapat memanggil pipeline dengan beberapa cara: - `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) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/feature_extraction.py#L15) **Parameter:** model ([PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel)) : Model yang akan digunakan oleh pipeline untuk membuat prediksi. Ini harus berupa model yang mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend)) : Tokenizer yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Objek ini mewarisi dari [PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend). task (`str`, defaultnya `""`) : Pengidentifikasi tugas untuk pipeline. num_workers (`int`, *opsional*, default 8) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), jumlah worker yang akan digunakan. batch_size (`int`, *opsional*, default 1) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), ukuran batch yang akan digunakan. Untuk inferensi, ini tidak selalu menguntungkan, silakan baca [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/id/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opsional*) : Referensi ke objek yang bertanggung jawab untuk mengurai parameter pipeline yang diberikan. device (`int` atau `str` atau `torch.device`, *opsional*) : Perangkat tempat pipeline dialokasikan. Jika tidak disetel, pipeline ditempatkan pada akselerator pertama yang tersedia (CUDA, MPS, XPU, ...) dan hanya kembali ke CPU jika tidak ada yang tersedia; model dipindahkan ke sana secara otomatis. Lewatkan `device="cpu"` (atau `-1`) untuk memaksa CPU, ordinal positif atau `"cuda:1"` untuk memilih akselerator tertentu, atau `torch.device`/`str` asli. Argumen ini tidak dapat digabungkan dengan model yang sudah dimuat melalui `accelerate` (yaitu model dengan `hf_device_map`). dtype (`str` atau `torch.dtype`, *opsional*, defaultnya `"auto"`) : Presisi saat model dimuat, diteruskan ke `from_pretrained`. Defaultnya `"auto"`, yang memuat model dalam dtype tempat model disimpan (dibaca dari `config.dtype` checkpoint, jika tidak ada, disimpulkan dari bobot). Berikan `torch.float16`, `torch.bfloat16`, `torch.float32`, ... secara eksplisit untuk menimpanya. tokenize_kwargs (`dict`, *opsional*) : Kamus tambahan berisi argumen kata kunci yang diteruskan ke tokenizer. return_tensors (`bool`, *opsional*) : Jika `True`, mengembalikan tensor sesuai dengan framework yang ditentukan, selain itu mengembalikan daftar. Pipeline ekstraksi fitur tidak menggunakan model head. Pipeline ini mengekstrak hidden states dari transformer dasar, yang dapat digunakan sebagai fitur dalam tugas downstream. Contoh: ```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]) ``` Pelajari lebih lanjut tentang dasar-dasar penggunaan pipeline di [tutorial pipeline](../pipeline_tutorial) Pipeline ekstraksi fitur ini saat ini dapat dimuat dari [pipeline()](/docs/transformers/main/id/main_classes/pipelines#transformers.pipeline) menggunakan pengidentifikasi tugas: `"feature-extraction"`. Semua model dapat digunakan untuk pipeline ini. Lihat daftar semua model, termasuk model yang disumbangkan oleh komunitas di [huggingface.co/models](https://huggingface.co/models). #### __call__[[transformers.FeatureExtractionPipeline.__call__]] ```python __call__(*args: str | list[str], **kwargs: Any) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/feature_extraction.py#L78) **Parameter:** args (`str` atau `list[str]`) : Satu atau beberapa teks (atau satu daftar teks) untuk diambil fiturnya. **Mengembalikan:** Daftar bersarang dari `float` Fitur yang dihitung oleh model. Ekstrak fitur dari teks input. ### 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) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/image_feature_extraction.py#L23) **Parameter:** model ([PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel)) : Model yang akan digunakan oleh pipeline untuk membuat prediksi. Ini harus berupa model yang mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor)) : Pemroses gambar yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Objek ini mewarisi dari [BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, defaultnya `""`) : Pengidentifikasi tugas untuk pipeline. num_workers (`int`, *opsional*, default 8) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), jumlah worker yang akan digunakan. batch_size (`int`, *opsional*, default 1) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), ukuran batch yang akan digunakan. Untuk inferensi, ini tidak selalu menguntungkan, silakan baca [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/id/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opsional*) : Referensi ke objek yang bertanggung jawab untuk mengurai parameter pipeline yang diberikan. device (`int` atau `str` atau `torch.device`, *opsional*) : Perangkat tempat pipeline dialokasikan. Jika tidak disetel, pipeline ditempatkan pada akselerator pertama yang tersedia (CUDA, MPS, XPU, ...) dan hanya kembali ke CPU jika tidak ada yang tersedia; model dipindahkan ke sana secara otomatis. Lewatkan `device="cpu"` (atau `-1`) untuk memaksa CPU, ordinal positif atau `"cuda:1"` untuk memilih akselerator tertentu, atau `torch.device`/`str` asli. Argumen ini tidak dapat digabungkan dengan model yang sudah dimuat melalui `accelerate` (yaitu model dengan `hf_device_map`). dtype (`str` atau `torch.dtype`, *opsional*, defaultnya `"auto"`) : Presisi saat model dimuat, diteruskan ke `from_pretrained`. Defaultnya `"auto"`, yang memuat model dalam dtype tempat model disimpan (dibaca dari `config.dtype` checkpoint, jika tidak ada, disimpulkan dari bobot). Berikan `torch.float16`, `torch.bfloat16`, `torch.float32`, ... secara eksplisit untuk menimpanya. binary_output (`bool`, *opsional*, defaultnya `False`) : Flag yang menunjukkan apakah output pipeline harus terjadi dalam format terserialisasi (yaitu, pickle) atau sebagai data output mentah, misalnya teks. image_processor_kwargs (`dict`, *opsional*) : Kamus tambahan berisi argumen kata kunci yang diteruskan ke image processor, misalnya {"size": {"height": 100, "width": 100}} pool (`bool`, *opsional*, defaultnya `False`) : Apakah akan mengembalikan output yang dipooling. Jika `False`, model akan mengembalikan hidden states mentah. Pipeline ekstraksi fitur gambar tidak menggunakan model head. Pipeline ini mengekstrak hidden states dari transformer dasar, yang dapat digunakan sebagai fitur dalam tugas downstream. Contoh: ```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]) ``` Pelajari lebih lanjut tentang dasar-dasar penggunaan pipeline di [tutorial pipeline](../pipeline_tutorial) Pipeline ekstraksi fitur gambar ini saat ini dapat dimuat dari [pipeline()](/docs/transformers/main/id/main_classes/pipelines#transformers.pipeline) menggunakan pengidentifikasi tugas: `"image-feature-extraction"`. Semua model visi dapat digunakan untuk pipeline ini. Lihat daftar semua model, termasuk model yang disumbangkan oleh komunitas di [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) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/image_feature_extraction.py#L94) **Parameter:** images (`str`, `list[str]`, `PIL.Image` atau `list[PIL.Image]`) : Pipeline menangani tiga jenis gambar: - String yang berisi tautan http yang mengarah ke gambar - String yang berisi path lokal ke gambar - Gambar yang dimuat langsung dalam PIL Pipeline menerima satu gambar tunggal atau batch gambar, yang kemudian harus diteruskan sebagai string. Gambar-gambar dalam batch harus semuanya dalam format yang sama: semuanya sebagai tautan http, semuanya sebagai path lokal, atau semuanya sebagai gambar PIL. timeout (`float`, *opsional*, defaultnya None) : Waktu maksimum dalam detik untuk menunggu pengambilan gambar dari web. Jika None, tidak ada timeout yang digunakan dan panggilan dapat memblokir selamanya. **Mengembalikan:** Daftar bersarang dari `float` Fitur yang dihitung oleh model. Ekstrak fitur dari input. ### ImageTextToTextPipeline[[transformers.ImageTextToTextPipeline]] #### transformers.ImageTextToTextPipeline[[transformers.ImageTextToTextPipeline]] ```python transformers.ImageTextToTextPipeline(*args, **kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/image_text_to_text.py#L53) **Parameter:** model ([PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel)) : Model yang akan digunakan oleh pipeline untuk membuat prediksi. Ini harus berupa model yang mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). processor ([ProcessorMixin](/docs/transformers/main/id/main_classes/processors#transformers.ProcessorMixin)) : Prosesor yang akan digunakan oleh pipeline untuk mengkodekan data untuk model. Objek ini mewarisi dari [ProcessorMixin](/docs/transformers/main/id/main_classes/processors#transformers.ProcessorMixin). Processor adalah objek komposit yang mungkin berisi `tokenizer`, `feature_extractor`, dan `image_processor`. task (`str`, defaultnya `""`) : Pengidentifikasi tugas untuk pipeline. num_workers (`int`, *opsional*, default 8) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), jumlah worker yang akan digunakan. batch_size (`int`, *opsional*, default 1) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), ukuran batch yang akan digunakan. Untuk inferensi, ini tidak selalu menguntungkan, silakan baca [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/id/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opsional*) : Referensi ke objek yang bertanggung jawab untuk mengurai parameter pipeline yang diberikan. device (`int` atau `str` atau `torch.device`, *opsional*) : Perangkat tempat pipeline dialokasikan. Jika tidak disetel, pipeline ditempatkan pada akselerator pertama yang tersedia (CUDA, MPS, XPU, ...) dan hanya kembali ke CPU jika tidak ada yang tersedia; model dipindahkan ke sana secara otomatis. Lewatkan `device="cpu"` (atau `-1`) untuk memaksa CPU, ordinal positif atau `"cuda:1"` untuk memilih akselerator tertentu, atau `torch.device`/`str` asli. Argumen ini tidak dapat digabungkan dengan model yang sudah dimuat melalui `accelerate` (yaitu model dengan `hf_device_map`). dtype (`str` atau `torch.dtype`, *opsional*, defaultnya `"auto"`) : Presisi saat model dimuat, diteruskan ke `from_pretrained`. Defaultnya `"auto"`, yang memuat model dalam dtype tempat model disimpan (dibaca dari `config.dtype` checkpoint, jika tidak ada, disimpulkan dari bobot). Berikan `torch.float16`, `torch.bfloat16`, `torch.float32`, ... secara eksplisit untuk menimpanya. binary_output (`bool`, *opsional*, defaultnya `False`) : Flag yang menunjukkan apakah output pipeline harus terjadi dalam format terserialisasi (yaitu, pickle) atau sebagai data output mentah, misalnya teks. Pipeline image-text-to-text menggunakan `AutoModelForImageTextToText`. Pipeline ini menghasilkan teks berdasarkan gambar dan teks. Ketika model dasarnya adalah model percakapan, pipeline ini juga dapat menerima satu atau lebih chat, di mana pipeline akan beroperasi dalam mode chat dan melanjutkan chat tersebut dengan menambahkan responsnya. Setiap chat berbentuk daftar dict, di mana setiap dict berisi kunci "role" dan "content". Kecuali model yang Anda gunakan secara eksplisit mengatur parameter generasi ini di file konfigurasinya (`generation_config.json`), nilai default berikut akan digunakan: - max_new_tokens: 256 Contoh: ```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'}] ``` Pelajari lebih lanjut tentang dasar-dasar penggunaan pipeline di [tutorial pipeline](../pipeline_tutorial) Pipeline gambar-teks ke teks ini saat ini dapat dimuat dari pipeline() menggunakan pengidentifikasi tugas berikut: "image-text-to-text". Lihat daftar model yang tersedia di [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) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/image_text_to_text.py#L215) **Parameter:** 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]]]`) : Teks yang akan digunakan untuk generasi. Jika daftar string dilewatkan, panjang daftar harus sama dengan jumlah gambar. Teks juga dapat mengikuti format chat: daftar kamus di mana setiap kamus mewakili pesan dalam percakapan. Setiap kamus harus memiliki dua kunci: 'role' dan 'content'. 'role' harus salah satu dari 'user', 'system', atau 'assistant'. 'content' harus berupa daftar kamus yang berisi teks pesan dan jenis pesan. Jenis pesan dapat berupa 'text' atau 'image'. Jika jenisnya 'image', teks tidak diperlukan. return_tensors (`bool`, *opsional*, defaultnya `False`) : Mengembalikan tensor prediksi (sebagai indeks token) dalam output. Jika diatur ke `True`, teks yang didekodekan tidak dikembalikan. return_text (`bool`, *opsional*) : Mengembalikan teks yang telah didekodekan dalam output. return_full_text (`bool`, *opsional*, defaultnya `True`) : Jika diatur ke `False`, hanya teks yang ditambahkan yang dikembalikan, selain itu teks lengkap yang dikembalikan. Tidak dapat ditentukan bersamaan dengan `return_text`. clean_up_tokenization_spaces (`bool`, *opsional*) : Apakah akan membersihkan spasi ekstra potensial dalam output teks. Bawaan ke pengaturan `clean_up_tokenization_spaces` tokenizer. continue_final_message( `bool`, *opsional*) : Ini menunjukkan bahwa Anda ingin model melanjutkan pesan terakhir dalam chat input alih-alih memulai pesan baru, sehingga memungkinkan Anda untuk "prefill" responsnya. Secara default, ini adalah `True` ketika pesan terakhir dalam chat input memiliki peran `assistant` dan `False` selain itu, tetapi Anda dapat menimpa perilaku tersebut secara manual dengan mengatur flag ini. **Mengembalikan:** Daftar atau daftar dari daftar `dict` Setiap hasil berupa kamus dengan kunci berikut (tidak dapat mengembalikan kombinasi `generated_text` dan `generated_token_ids`): - **generated_text** (`str`, ada ketika `return_text=True`) -- Teks yang dihasilkan. - **generated_token_ids** (`torch.Tensor`, ada ketika `return_tensors=True`) -- ID token dari teks yang dihasilkan. - **input_text** (`str`) -- Teks input. Membuat teks berdasarkan teks dan gambar yang diberikan sebagai input. ### AnyToAnyPipeline[[transformers.AnyToAnyPipeline]] #### transformers.AnyToAnyPipeline[[transformers.AnyToAnyPipeline]] ```python transformers.AnyToAnyPipeline(*args, **kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/any_to_any.py#L67) **Parameter:** model ([PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel)) : Model yang akan digunakan oleh pipeline untuk membuat prediksi. Ini harus berupa model yang mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). processor ([ProcessorMixin](/docs/transformers/main/id/main_classes/processors#transformers.ProcessorMixin)) : Prosesor yang akan digunakan oleh pipeline untuk mengkodekan data untuk model. Objek ini mewarisi dari [ProcessorMixin](/docs/transformers/main/id/main_classes/processors#transformers.ProcessorMixin). Processor adalah objek komposit yang mungkin berisi `tokenizer`, `feature_extractor`, dan `image_processor`. task (`str`, defaultnya `""`) : Pengidentifikasi tugas untuk pipeline. num_workers (`int`, *opsional*, default 8) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), jumlah worker yang akan digunakan. batch_size (`int`, *opsional*, default 1) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), ukuran batch yang akan digunakan. Untuk inferensi, ini tidak selalu menguntungkan, silakan baca [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/id/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opsional*) : Referensi ke objek yang bertanggung jawab untuk mengurai parameter pipeline yang diberikan. device (`int` atau `str` atau `torch.device`, *opsional*) : Perangkat tempat pipeline dialokasikan. Jika tidak disetel, pipeline ditempatkan pada akselerator pertama yang tersedia (CUDA, MPS, XPU, ...) dan hanya kembali ke CPU jika tidak ada yang tersedia; model dipindahkan ke sana secara otomatis. Lewatkan `device="cpu"` (atau `-1`) untuk memaksa CPU, ordinal positif atau `"cuda:1"` untuk memilih akselerator tertentu, atau `torch.device`/`str` asli. Argumen ini tidak dapat digabungkan dengan model yang sudah dimuat melalui `accelerate` (yaitu model dengan `hf_device_map`). dtype (`str` atau `torch.dtype`, *opsional*, defaultnya `"auto"`) : Presisi saat model dimuat, diteruskan ke `from_pretrained`. Defaultnya `"auto"`, yang memuat model dalam dtype tempat model disimpan (dibaca dari `config.dtype` checkpoint, jika tidak ada, disimpulkan dari bobot). Berikan `torch.float16`, `torch.bfloat16`, `torch.float32`, ... secara eksplisit untuk menimpanya. binary_output (`bool`, *opsional*, defaultnya `False`) : Flag yang menunjukkan apakah output pipeline harus terjadi dalam format terserialisasi (yaitu, pickle) atau sebagai data output mentah, misalnya teks. Pipeline Generasi Multimodal menggunakan `AutoModelForMultimodalLM`. Pipeline ini menghasilkan teks berdasarkan kombinasi apa pun dari data multimodal dan teks. Ketika model dasarnya adalah model percakapan, pipeline ini juga dapat menerima satu atau lebih chat, di mana pipeline akan beroperasi dalam mode chat dan melanjutkan chat tersebut dengan menambahkan responsnya. Setiap chat berbentuk daftar dict, di mana setiap dict berisi kunci "role" dan "content". Kecuali model yang Anda gunakan secara eksplisit mengatur parameter generasi ini di file konfigurasinya (`generation_config.json`), nilai default berikut akan digunakan: - max_new_tokens: 256 Contoh: ```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'}] ``` Pelajari lebih lanjut tentang dasar-dasar penggunaan pipeline di [tutorial pipeline](../pipeline_tutorial) Pipeline multimodal ini saat ini dapat dimuat dari pipeline() menggunakan pengidentifikasi tugas berikut: "any-to-any". Lihat daftar model yang tersedia di [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) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/any_to_any.py#L258) **Parameter:** text (`str`, `list[str]`, `list[dict]`) : Teks yang akan digunakan untuk generasi. Jika daftar string dilewatkan, panjang daftar harus sama dengan jumlah gambar. Teks juga dapat mengikuti format chat: daftar kamus di mana setiap kamus mewakili pesan dalam percakapan. Setiap kamus harus memiliki dua kunci: 'role' dan 'content'. 'role' harus salah satu dari 'user', 'system', atau 'assistant'. 'content' harus berupa daftar kamus yang berisi teks pesan dan jenis pesan. images (`str`, `list[str]`, `ImageInput`) : Pipeline ini menangani tiga jenis gambar: - String yang berisi tautan HTTP(s) yang mengarah ke gambar - String yang berisi path lokal ke gambar - Gambar yang dimuat langsung dalam PIL Pipeline ini menerima satu gambar tunggal atau batch gambar. Terakhir, pipeline ini juga mendukung format chat (lihat `text`) yang berisi gambar dan teks dalam argumen ini. videos (`str`, `list[str]`, `VideoInput`) : Pipeline ini menangani tiga jenis video: - String yang berisi tautan HTTP(s) yang mengarah ke video - String yang berisi path lokal ke video - Video yang dimuat dan didekode ke format array Pipeline menerima satu video tunggal atau batch video. Terakhir, pipeline ini juga mendukung format chat (lihat `text`) yang berisi video dan teks dalam argumen ini. audio (`str`, `list[str]`, `AudioInput`) : Pipeline ini menangani tiga jenis audio: - String yang berisi tautan HTTP(s) yang mengarah ke audio - String yang berisi path lokal ke audio - Audio yang dimuat langsung dalam PIL Pipeline menerima satu audio tunggal atau batch audio. Terakhir, pipeline ini juga mendukung format chat (lihat `text`) yang berisi audio dan teks dalam argumen ini. return_tensors (`bool`, *opsional*, defaultnya `False`) : Mengembalikan tensor prediksi (sebagai indeks token) dalam output. Jika diatur ke `True`, teks yang didekodekan tidak dikembalikan. return_text (`bool`, *opsional*) : Mengembalikan teks yang telah didekodekan dalam output. return_full_text (`bool`, *opsional*, defaultnya `True`) : Jika diatur ke `False`, hanya teks yang ditambahkan yang dikembalikan, selain itu teks lengkap yang dikembalikan. Tidak dapat ditentukan bersamaan dengan `return_text`. clean_up_tokenization_spaces (`bool`, *opsional*) : Apakah akan membersihkan spasi ekstra potensial dalam output teks. Bawaan ke pengaturan `clean_up_tokenization_spaces` tokenizer. continue_final_message( `bool`, *opsional*) : Ini menunjukkan bahwa Anda ingin model melanjutkan pesan terakhir dalam chat input alih-alih memulai pesan baru, sehingga memungkinkan Anda untuk "prefill" responsnya. Secara default, ini adalah `True` ketika pesan terakhir dalam chat input memiliki peran `assistant` dan `False` selain itu, tetapi Anda dapat menimpa perilaku tersebut secara manual dengan mengatur flag ini. **Mengembalikan:** Daftar atau daftar dari daftar `dict` Setiap hasil berupa kamus dengan kunci berikut (tidak dapat mengembalikan kombinasi `generated_text` dan `generated_token_ids`): - **generated_text** (`str`, ada ketika `return_text=True` dan `generation_mode="text"`) -- Teks yang dihasilkan. - **generated_audio** (`np.ndarray`, ada ketika `generation_mode="audio"`) -- Audio yang dihasilkan. - **generated_image** (`PIL.Image.Image`, ada ketika `generation_mode="image"`) -- Gambar yang dihasilkan. - **generated_token_ids** (`torch.Tensor`, ada ketika `return_tensors=True` dan `generation_mode="text"`) -- ID token dari teks yang dihasilkan. - **input_text** (`str`) -- Teks input. Membuat teks berdasarkan teks dan, secara opsional, data multimodal yang diberikan sebagai input. ### MaskGenerationPipeline[[transformers.MaskGenerationPipeline]] #### transformers.MaskGenerationPipeline[[transformers.MaskGenerationPipeline]] ```python transformers.MaskGenerationPipeline(**kwargs) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/mask_generation.py#L36) **Parameter:** model ([PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel)) : Model yang akan digunakan oleh pipeline untuk membuat prediksi. Ini harus berupa model yang mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor)) : Pemroses gambar yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Objek ini mewarisi dari [BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, defaultnya `""`) : Pengidentifikasi tugas untuk pipeline. num_workers (`int`, *opsional*, default 8) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), jumlah worker yang akan digunakan. batch_size (`int`, *opsional*, default 1) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), ukuran batch yang akan digunakan. Untuk inferensi, ini tidak selalu menguntungkan, silakan baca [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/id/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opsional*) : Referensi ke objek yang bertanggung jawab untuk mengurai parameter pipeline yang diberikan. device (`int` atau `str` atau `torch.device`, *opsional*) : Perangkat tempat pipeline dialokasikan. Jika tidak disetel, pipeline ditempatkan pada akselerator pertama yang tersedia (CUDA, MPS, XPU, ...) dan hanya kembali ke CPU jika tidak ada yang tersedia; model dipindahkan ke sana secara otomatis. Lewatkan `device="cpu"` (atau `-1`) untuk memaksa CPU, ordinal positif atau `"cuda:1"` untuk memilih akselerator tertentu, atau `torch.device`/`str` asli. Argumen ini tidak dapat digabungkan dengan model yang sudah dimuat melalui `accelerate` (yaitu model dengan `hf_device_map`). dtype (`str` atau `torch.dtype`, *opsional*, defaultnya `"auto"`) : Presisi saat model dimuat, diteruskan ke `from_pretrained`. Defaultnya `"auto"`, yang memuat model dalam dtype tempat model disimpan (dibaca dari `config.dtype` checkpoint, jika tidak ada, disimpulkan dari bobot). Berikan `torch.float16`, `torch.bfloat16`, `torch.float32`, ... secara eksplisit untuk menimpanya. binary_output (`bool`, *opsional*, defaultnya `False`) : Flag yang menunjukkan apakah output pipeline harus terjadi dalam format terserialisasi (yaitu, pickle) atau sebagai data output mentah, misalnya teks. points_per_batch (*opsional*, int, default 64) : Menetapkan jumlah titik yang dijalankan secara bersamaan oleh model. Angka yang lebih tinggi mungkin lebih cepat tetapi menggunakan lebih banyak memori GPU. output_bboxes_mask (`bool`, *opsional*, default `False`) : Apakah akan mengoutputkan prediksi kotak pembatas (bounding box) atau tidak. output_rle_masks (`bool`, *opsional*, default `False`) : Apakah akan mengoutputkan mask dalam format `RLE` Pembuatan maska otomatis untuk gambar menggunakan `SamForMaskGeneration`. Pipeline ini memprediksi maska biner untuk sebuah gambar, berdasarkan gambar yang diberikan. Ini adalah `ChunkPipeline` karena Anda dapat memisahkan titik-titik dalam mini-batch untuk menghindari masalah OOM. Gunakan argumen `points_per_batch` untuk mengontrol jumlah titik yang akan diproses secara bersamaan. Nilai defaultnya adalah `64`. Pipeline bekerja dalam 3 langkah: 1. `preprocess`: Grid berisi 1024 titik yang terpisah secara merata dihasilkan bersama dengan bounding box dan label titik. Untuk detail lebih lanjut tentang cara titik dan bounding box dibuat, periksa fungsi `_generate_crop_boxes`. Gambar juga dipreprocess menggunakan `image_processor`. Fungsi ini `yields` minibatch berisi `points_per_batch`. 2. `forward`: memberikan keluaran dari `preprocess` ke model. Embedding gambar dihitung hanya sekali. Memanggil `self.model.get_image_embeddings` dan memastikan bahwa gradien tidak dihitung, serta tensor dan model berada di perangkat yang sama. 3. `postprocess`: Bagian terpenting dari pembuatan mask otomatis terjadi di sini. Tiga langkah diinduksi: - image_processor.postprocess_masks (dijalankan pada setiap loop minibatch): menerima mask output mentah, mengubah ukurannya sesuai ukuran gambar, dan mengubahnya menjadi mask biner. - image_processor.filter_masks (pada setiap loop minibatch): menggunakan `pred_iou_thresh` dan `stability_scores`. Juga menerapkan berbagai filter berdasarkan non maximum suppression untuk menghapus mask yang buruk. - image_processor.postprocess_masks_for_amg menerapkan NSM pada mask agar hanya mask yang relevan yang dipertahankan. Contoh: ```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 ... ) ``` Pelajari lebih lanjut tentang dasar-dasar penggunaan pipeline di [tutorial pipeline](../pipeline_tutorial) Pipeline segmentasi ini saat ini dapat dimuat dari [pipeline()](/docs/transformers/main/id/main_classes/pipelines#transformers.pipeline) menggunakan pengidentifikasi tugas berikut: `"mask-generation"`. Lihat daftar model yang tersedia di [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) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/mask_generation.py#L143) **Parameter:** image (`str`, `List[str]`, `PIL.Image` atau `List[PIL.Image]`) : Gambar atau daftar gambar. mask_threshold (`float`, *opsional*, default 0.0) : Ambang batas yang digunakan saat mengubah maska prediksi menjadi nilai biner. pred_iou_thresh (`float`, *opsional*, default 0.88) : Ambang batas penyaringan dalam `[0,1]` yang diterapkan pada kualitas mask yang diprediksi oleh model. stability_score_thresh (`float`, *opsional*, default 0.95) : Ambang batas penyaringan dalam `[0,1]`, menggunakan stabilitas mask terhadap perubahan cutoff yang digunakan untuk mambinarisasi prediksi mask model. stability_score_offset (`int`, *opsional*, default 1) : Jumlah pergeseran cutoff saat menghitung skor stabilitas. crops_nms_thresh (`float`, *opsional*, default 0.7) : Batasan IoU kotak yang digunakan oleh non-maximal suppression untuk menyaring mask duplikat. crops_n_layers (`int`, *opsional*, default 0) : Jika `crops_n_layers>0`, prediksi mask akan dijalankan kembali pada potongan (crops) gambar. Menetapkan jumlah lapisan yang akan dijalankan, di mana setiap lapisan memiliki 2**i_layer jumlah potongan gambar. crop_overlap_ratio (`float`, *opsional*, defaultnya `512 / 1500`) : Menetapkan tingkat tumpang tindih antar crop. Pada lapisan crop pertama, crop akan tumpang tindih sebesar fraksi ini dari panjang gambar. Lapisan-lapisan berikutnya dengan lebih banyak crop akan menurunkan tumpang tindih ini. crop_n_points_downscale_factor (`int`, *opsional*, defaultnya `1`) : Jumlah titik per sisi yang disampelkan di lapisan n diskalakan ke bawah dengan crop_n_points_downscale_factor**n. timeout (`float`, *opsional*, defaultnya None) : Waktu maksimum dalam detik untuk menunggu pengambilan gambar dari web. Jika None, tidak ada batas waktu yang ditetapkan dan panggilan dapat memblokir selamanya. **Mengembalikan:** `Dict` Kamus dengan kunci-kunci berikut: - **mask** (`PIL.Image`) -- Mask biner dari objek yang terdeteksi sebagai PIL Image dengan bentuk `(width, height)` dari gambar asli. Mengembalikan mask yang diisi dengan nol jika tidak ada objek yang ditemukan. - **score** (*opsional* `float`) -- Secara opsional, ketika model mampu memperkirakan tingkat kepercayaan terhadap "objek" yang dijelaskan oleh label dan mask. Membuat mask segmentasi biner ## Kelas induk: `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) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L763) **Parameter:** model ([PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel)) : Model yang akan digunakan oleh pipeline untuk membuat prediksi. Ini harus berupa model yang mewarisi dari [PreTrainedModel](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend)) : Tokenizer yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Objek ini mewarisi dari [PreTrainedTokenizer](/docs/transformers/main/id/main_classes/tokenizer#transformers.PythonBackend). feature_extractor ([SequenceFeatureExtractor](/docs/transformers/main/id/main_classes/feature_extractor#transformers.SequenceFeatureExtractor)) : Ekstraktor fitur yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Objek ini mewarisi dari [SequenceFeatureExtractor](/docs/transformers/main/id/main_classes/feature_extractor#transformers.SequenceFeatureExtractor). image_processor ([BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor)) : Pemroses gambar yang akan digunakan oleh pipeline untuk mengkodekan data bagi model. Objek ini mewarisi dari [BaseImageProcessor](/docs/transformers/main/id/main_classes/image_processor#transformers.BaseImageProcessor). processor ([ProcessorMixin](/docs/transformers/main/id/main_classes/processors#transformers.ProcessorMixin)) : Prosesor yang akan digunakan oleh pipeline untuk mengkodekan data untuk model. Objek ini mewarisi dari [ProcessorMixin](/docs/transformers/main/id/main_classes/processors#transformers.ProcessorMixin). Processor adalah objek komposit yang mungkin berisi `tokenizer`, `feature_extractor`, dan `image_processor`. task (`str`, defaultnya `""`) : Pengidentifikasi tugas untuk pipeline. num_workers (`int`, *opsional*, default 8) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), jumlah worker yang akan digunakan. batch_size (`int`, *opsional*, default 1) : Saat pipeline akan menggunakan *DataLoader* (ketika meneruskan dataset, pada GPU untuk model Pytorch), ukuran batch yang akan digunakan. Untuk inferensi, ini tidak selalu menguntungkan, silakan baca [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/id/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opsional*) : Referensi ke objek yang bertanggung jawab untuk mengurai parameter pipeline yang diberikan. device (`int` atau `str` atau `torch.device`, *opsional*) : Perangkat tempat pipeline dialokasikan. Jika tidak disetel, pipeline ditempatkan pada akselerator pertama yang tersedia (CUDA, MPS, XPU, ...) dan hanya kembali ke CPU jika tidak ada yang tersedia; model dipindahkan ke sana secara otomatis. Lewatkan `device="cpu"` (atau `-1`) untuk memaksa CPU, ordinal positif atau `"cuda:1"` untuk memilih akselerator tertentu, atau `torch.device`/`str` asli. Argumen ini tidak dapat digabungkan dengan model yang sudah dimuat melalui `accelerate` (yaitu model dengan `hf_device_map`). dtype (`str` atau `torch.dtype`, *opsional*, defaultnya `"auto"`) : Presisi saat model dimuat, diteruskan ke `from_pretrained`. Defaultnya `"auto"`, yang memuat model dalam dtype tempat model disimpan (dibaca dari `config.dtype` checkpoint, jika tidak ada, disimpulkan dari bobot). Berikan `torch.float16`, `torch.bfloat16`, `torch.float32`, ... secara eksplisit untuk menimpanya. binary_output (`bool`, *opsional*, defaultnya `False`) : Flag yang menunjukkan apakah output pipeline harus terjadi dalam format terserialisasi (yaitu, pickle) atau sebagai data output mentah, misalnya teks. Kelas Pipeline adalah kelas yang menjadi induk bagi semua pipeline. Rujuk kelas ini untuk metode yang dibagikan di antara berbagai pipeline. Kelas dasar yang mengimplementasikan operasi berpipelining. Alur kerja pipeline didefinisikan sebagai urutan dari operasi-operasi berikut: Input -> Tokenisasi -> Inferensi Model -> Pemrosesan Pasca (bergantung pada tugas) -> Output Pipeline mendukung eksekusi di CPU atau GPU melalui argumen device (lihat di bawah). Beberapa pipeline, misalnya [FeatureExtractionPipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.FeatureExtractionPipeline) (`'feature-extraction'`), menghasilkan objek tensor besar sebagai nested-lists. Untuk menghindari penulisan struktur besar tersebut sebagai data teks, kami menyediakan argumen konstruktor `binary_output`. Jika diset ke `True`, output akan disimpan dalam format pickle. #### check_model_type[[transformers.Pipeline.check_model_type]] ```python check_model_type(supported_models: list[str] | dict) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L1126) **Parameter:** supported_models (`list[str]` atau `dict`) : Daftar model yang didukung oleh pipeline, atau kamus dengan nilai kelas model. Periksa apakah kelas model didukung oleh pipeline. #### device_placement[[transformers.Pipeline.device_placement]] ```python device_placement() ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L1012) **Mengembalikan:** Manajer konteks Context Manager yang memungkinkan alokasi tensor pada perangkat yang ditentukan pengguna. Contoh: ```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) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L1094) **Parameter:** inputs (argument kata kunci yang harus berupa `torch.Tensor`, sisanya diabaikan) : Tensor yang akan ditempatkan di `self.device`. Rekursif pada daftar **saja**. -- **Mengembalikan:** `dict[str, torch.Tensor]` Sama seperti `inputs` tetapi pada perangkat yang tepat. Pastikan tensor PyTorch berada pada perangkat yang ditentukan. #### postprocess[[transformers.Pipeline.postprocess]] ```python postprocess(model_outputs: ModelOutput, **postprocess_parameters: dict) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L1193) Postprocess akan menerima output mentah dari metode `_forward`, umumnya berupa tensor, dan memformat ulang menjadi sesuatu yang lebih ramah. Umumnya, metode ini akan menghasilkan list atau dict dari hasil (yang hanya berisi string dan angka). #### predict[[transformers.Pipeline.predict]] ```python predict(X) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L991) Antarmuka Scikit / Keras untuk pipeline transformers. Metode ini akan meneruskan ke __call__(). #### preprocess[[transformers.Pipeline.preprocess]] ```python preprocess(input_: Any, **preprocess_parameters: dict) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L1172) Preprocess akan mengambil `input_` dari pipeline tertentu dan mengembalikan kamus berisi semua yang diperlukan agar `_forward` dapat berjalan dengan baik. Kamus ini harus berisi setidaknya satu tensor, tetapi mungkin juga memiliki item lain yang sembarang. #### 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) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/hub.py#L822) **Parameter:** repo_id (`str`) : Nama repositori tempat Anda ingin mendorong pipe Anda. Seharusnya berisi nama organisasi Anda saat mendorong ke organisasi tertentu. commit_message (`str`, *opsional*) : Pesan untuk commit saat push. Akan default ke `"Upload pipe"`. commit_description (`str`, *opsional*) : Deskripsi dari commit yang akan dibuat private (`bool`, *opsional*) : Apakah akan membuat repo menjadi privat. Jika `None` (default), repo akan bersifat publik kecuali default organisasi adalah privat. Nilai ini diabaikan jika repo sudah ada. token (`bool` atau `str`, *opsional*) : Token yang akan digunakan sebagai otorisasi bearer HTTP untuk file jarak jauh. Jika `True` (default), akan menggunakan token yang dihasilkan saat menjalankan `hf auth login` (disimpan di `~/.huggingface`). revision (`str`, *opsional*) : Cabang untuk mendorong file yang diunggah. create_pr (`bool`, *opsional*, default `False`) : Apakah akan membuat PR dengan file yang diunggah atau langsung melakukan commit. max_shard_size (`int` atau `str`, *opsional*, default `"50GB"`) : Hanya berlaku untuk model. Ukuran maksimum untuk checkpoint sebelum dipecah menjadi shard. Setiap shard checkpoint akan memiliki ukuran lebih kecil dari nilai ini. Jika dinyatakan sebagai string, harus berupa angka diikuti satuan (seperti `"5MB"`). tags (`list[str]`, *opsional*) : Daftar tag untuk didorong ke Hub. Unggah file pipeline ke 🤗 Model Hub. Contoh: ```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) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L939) **Parameter:** save_directory (`str` atau `os.PathLike`) : Path ke direktori tempat penyimpanan. Direktori akan dibuat jika belum ada. kwargs (`dict[str, Any]`, *opsional*) : Argumen kata kunci tambahan yang diteruskan ke metode [push_to_hub()](/docs/transformers/main/id/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub). Simpan model dan tokenizer pipeline. #### transform[[transformers.Pipeline.transform]] ```python transform(X) ``` [Sumber](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L985) Antarmuka Scikit / Keras untuk pipeline transformers. Metode ini akan meneruskan ke __call__().