Hugging Face's logo

Transformers documentation

Pipelines

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Pipelines

파이프라인은 모델을 추론에 활용하는 훌륭하고 간편한 방법입니다. 이러한 파이프라인은 라이브러리의 복잡한 코드를 대부분 추상화한 객체로, Named Entity Recognition, Masked Language Modeling, Sentiment Analysis, Feature Extraction, Question Answering 등 여러 작업을 위한 단순한 API를 제공합니다. 사용 예시는 작업 목록을 참고하세요.

pipeline 추상화에는 두 가지 범주가 있습니다:

파이프라인 추상화

pipeline 추상화는 사용 가능한 모든 다른 파이프라인을 감싸는 래퍼입니다. 다른 파이프라인과 동일한 방식으로 인스턴스화되며, 추가적인 편의 기능을 제공할 수 있습니다.

단일 항목에 대한 간단한 호출:

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

hub의 특정 모델을 사용하려는 경우, hub에 있는 모델에 이미 해당 작업이 정의되어 있다면 작업을 무시할 수 있습니다:

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

여러 항목에 대해 파이프라인을 호출하려면 list를 전달하여 호출할 수 있습니다.

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

전체 데이터셋을 반복하려면 dataset을 직접 사용하는 것이 권장됩니다. 이렇게 하면 전체 데이터셋을 한 번에 할당할 필요가 없으며, 배치 처리도 직접 수행할 필요가 없습니다. GPU에서 사용자 정의 루프와 동일한 속도로 동작해야 합니다. 그렇지 않다면 주저하지 말고 이슈를 생성해 주세요.

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

사용 편의성을 위해 생성자(generator)도 가능합니다:

from transformers import pipeline

pipe = pipeline("text-classification")


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


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

transformers.pipeline

< >

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

매개변수

반환값

파이프라인

해당 작업에 적합한 pipeline입니다.

Pipeline를 생성하는 유틸리티 팩토리 메서드입니다.

파이프라인은 다음으로 구성됩니다:

  • 모델 입력을 전처리하는 하나 이상의 구성 요소, 예: tokenizer, image_processor, feature_extractor, 또는 processor.
  • 입력으로부터 예측을 생성하는 모델입니다.
  • 모델의 출력을 정제하기 위한 선택적 후처리 단계로, 프로세서로 처리할 수도 있습니다.
While there are such optional arguments as `tokenizer`, `feature_extractor`, `image_processor`, and `processor`, they shouldn't be specified all at once. If these components are not provided, `pipeline` will try to load required ones automatically. In case you want to provide these components explicitly, please refer to a specific pipeline in order to get more details regarding what components are required.

예:

>>> from transformers import pipeline, AutoModelForTokenClassification, AutoTokenizer

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

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

Pipeline 배치

모든 pipeline은 배치 처리를 사용할 수 있습니다. pipeline이 스트리밍 기능을 사용하는 경우(즉, 리스트나 Dataset 또는 generator를 전달하는 경우)에 이 기능이 작동합니다.

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

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

그러나 이것이 자동으로 성능 향상을 의미하는 것은 아닙니다. 하드웨어, 데이터, 그리고 실제로 사용되는 모델에 따라 10배 빨라지거나 5배 느려질 수 있습니다.

속도가 크게 향상되는 예시:

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

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


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

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


dataset = MyDataset()

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

대부분 성능 저하가 발생하는 예시:

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

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

이것은 다른 문장에 비해 가끔 매우 긴 문장입니다. 이 경우 전체 배치의 길이가 400 토큰이 되어야 하므로, 배치 전체가 [64, 4] 대신 [64, 400]이 되어 성능 저하가 크게 발생합니다. 더 나쁜 점은, 더 큰 배치에서는 프로그램이 단순히 충돌한다는 것입니다.

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

이 문제에 대한 좋은(일반적인) 해결책은 없으며, 사용 사례에 따라 결과가 달라질 수 있습니다. 일반적인 규칙:

사용자를 위한 경험칙은 다음과 같습니다:

  • 자신의 워크로드와 하드웨어에서 성능을 측정하세요. 측정하고, 측정하고, 계속 측정하세요. 실제 수치가 유일한 방법입니다.

  • 레이턴시 제약이 있는 경우(추론을 수행하는 라이브 제품)에는 배치 처리를 하지 마세요.

  • CPU를 사용하는 경우 배치 처리를 하지 마세요.

  • 처리량(throughput)을 사용하고 있으며(정적 데이터 세트로 모델을 실행하려는 경우), GPU를 사용하는 경우:

    • sequence_length(“natural” 데이터)의 크기에 대해 전혀 알 수 없다면, 기본적으로 배치 처리를 하지 말고 측정하여 임시로 추가해 보세요. 실패할 때 복구할 수 있도록 OOM 체크를 추가하세요(만약 sequence_length를 제어하지 않으면 언젠가 실패할 것입니다).
    • sequence_length가 매우 규칙적이라면, batching이 매우 흥미로울 가능성이 높으므로, OOM이 발생할 때까지 측정하고 batching을 계속 늘려 보세요.
    • GPU가 클수록 배칭이 더 흥미로워질 가능성이 높습니다

  • batching을 활성화한 후에는 OOM을 적절하게 처리할 수 있는지 확인하세요.

Pipeline 청크 배치

zero-shot-classification와 question-answering은 단일 입력이 모델의 여러 forward pass를 생성할 수 있다는 점에서 다소 특수합니다. 일반적인 상황에서는 batch_size 인자와 관련하여 문제가 발생할 수 있습니다.

이 문제를 우회하기 위해, 이 두 파이프라인은 일반적인 Pipeline이 아닌 ChunkPipeline으로, 다소 특수하게 구현되어 있습니다. 간단히 설명하면 다음과 같습니다:

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

이제 다음과 같이 변경됩니다:

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

파이프라인은 동일한 방식으로 사용되므로, 이는 코드에 매우 투명하게 적용됩니다.

파이프라인이 자동으로 배치를 처리하므로, 이는 단순화된 뷰입니다. 즉, 입력이 실제로 몇 번의 forward pass를 트리거하는지에 대해 신경 쓸 필요가 없으며, 입력과 독립적으로 batch_size를 최적화할 수 있습니다. 이전 섹션의 주의 사항은 여전히 적용됩니다.

Pipeline FP16 추론

모델은 FP16으로 실행할 수 있으며, 이를 통해 GPU에서 메모리를 절약하면서 훨씬 더 빠르게 동작할 수 있습니다. 대부분의 모델은 이로 인해 눈에 띄는 성능 저하가 발생하지 않습니다. 모델이 클수록 성능 저하가 발생할 가능성은 낮아집니다.

FP16 추론을 활성화하려면 파이프라인 생성자에 dtype=torch.float16 또는 dtype='float16'를 전달하면 됩니다. PyTorch 백엔드를 사용하는 모델에서만 작동합니다. 입력은 내부적으로 FP16으로 변환됩니다.

Pipeline 사용자 정의 코드

특정 pipeline을 오버라이드하려면

현재 진행 중인 작업에 대해 이슈를 생성하는 것을 주저하지 마세요. pipeline의 목표는 사용이 간편하고 대부분의 경우를 지원하는 것이므로, transformers가 사용자의 사용 사례를 지원할 수 있을 것입니다.

간단히 시도해 보려면:

  • 원하는 pipeline을 서브클래스화하세요
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)

이를 통해 원하는 모든 커스텀 코드를 작성할 수 있습니다.

파이프라인 구현

새로운 pipeline 구현

오디오

음성 작업에 사용할 수 있는 Pipelines는 다음과 같습니다.

AudioClassificationPipeline

class transformers.AudioClassificationPipeline

< >

( *args**kwargs )

매개변수

  • model (PreTrainedModel) — 파이프라인이 예측을 수행하는 데 사용할 모델입니다. PreTrainedModel을 상속하는 모델이어야 합니다.
  • feature_extractor (SequenceFeatureExtractor) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 피처 추출기입니다. 이 객체는 SequenceFeatureExtractor를 상속합니다.
  • task (str, 기본값 "") — pipeline의 작업 식별자입니다.
  • num_workers (int, 선택, 기본값 8) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우) 사용할 워커 수입니다.
  • batch_size (int, 선택 사항, 기본값 1) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우)에 사용할 배치 크기입니다. 추론에서는 항상 이롭지 않을 수 있으므로 파이프라인을 사용한 배치 처리를 읽어보십시오.
  • args_parser (ArgumentHandler, 선택 사항) — 공급된 파이프라인 매개변수를 파싱하는 책임을 지는 객체에 대한 참조입니다.
  • device (int 또는 str 또는 torch.device, 선택 사항) — 파이프라인이 할당되는 디바이스입니다. 설정하지 않으면 파이프라인은 첫 번째 사용 가능한 가속기(CUDA, MPS, XPU, …)에 배치되고, 사용 가능한 가속기가 없으면 CPU로 폴백됩니다. 모델은 자동으로 해당 디바이스로 이동합니다. CPU를 강제하려면 device="cpu"(또는 -1)을 전달하고, 특정 가속기를 선택하려면 양의 순번 또는 "cuda:1"을 전달하며, 네이티브 torch.device/str도 사용할 수 있습니다. 이 인수는 accelerate를 통해 이미 로드된 모델(즉, hf_device_map이 있는 모델)과 함께 사용할 수 없습니다.
  • dtype (str 또는 torch.dtype, 선택 사항, 기본값 "auto") — 모델이 로드되는 정밀도로, from_pretrained로 전달됩니다. 기본값은 "auto"이며, 모델이 저장된 dtype로 로드합니다(체크포인트의 config.dtype에서 읽거나, 그렇지 않으면 가중치에서 추론). 명시적으로 torch.float16, torch.bfloat16, torch.float32, ...를 전달하여 이를 재정의할 수 있습니다.
  • binary_output (bool, 선택 사항, 기본값 False) — 파이프라인의 출력이 직렬화 형식(예: pickle)으로 생성되어야 하는지, 아니면 텍스트와 같은 원시 출력 데이터로 생성되어야 하는지를 나타내는 플래그입니다.

AutoModelForAudioClassification을 사용하여 오디오 분류를 수행하는 파이프라인입니다. 이 파이프라인은 원시 웨이브폼이나 오디오 파일의 클래스를 예측합니다. 오디오 파일의 경우, 여러 오디오 형식을 지원하기 위해 ffmpeg가 설치되어 있어야 합니다.

예:

>>> from transformers import pipeline

>>> classifier = pipeline(model="superb/wav2vec2-base-superb-ks")
>>> classifier("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/1.flac")
[{'score': 0.997, 'label': '_unknown_'}, {'score': 0.002, 'label': 'left'}, {'score': 0.0, 'label': 'yes'}, {'score': 0.0, 'label': 'down'}, {'score': 0.0, 'label': 'stop'}]

pipeline 튜토리얼에서 pipeline 사용의 기본 사항에 대해 자세히 알아보세요.

이 파이프라인은 현재 pipeline()에서 다음 작업 식별자를 사용하여 로드할 수 있습니다: "audio-classification".

huggingface.co/models에서 사용 가능한 모델 목록을 확인하세요.

__call__

< >

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

매개변수

  • inputs (np.ndarray 또는 bytes 또는 str 또는 dict) — inputs는 다음 중 하나입니다:
    • str 형식의 오디오 파일 이름입니다. ffmpeg를 사용하여 올바른 샘플링 레이트로 파일을 읽어 웨이브폼을 얻습니다. 이를 위해 시스템에 ffmpeg가 설치되어 있어야 합니다.
    • bytes는 오디오 파일의 콘텐츠여야 하며, ffmpeg에 의해 동일한 방식으로 해석됩니다.
    • (np.ndarray, shape (n, ), type np.float32 또는 np.float64) 올바른 샘플링 레이트의 원시 오디오 (추가 검증은 수행되지 않음)
    • dict 형식은 임의의 sampling_rate로 샘플링된 원시 오디오를 전달하여 이 파이프라인이 리샘플링을 수행하도록 할 수 있습니다. dict는 {"sampling_rate": int, "raw": np.array} 또는 {"sampling_rate": int, "array": np.array} 형식이어야 하며, 여기서 "raw" 또는 "array" 키는 원시 오디오 웨이브폼을 나타내는 데 사용됩니다.
  • top_k (int, 선택 사항, 기본값 None) — 파이프라인이 반환할 상위 라벨의 개수입니다. 제공된 값이 None이거나 모델 구성에 사용 가능한 라벨 수보다 크면, 라벨 수를 기본값으로 사용합니다.
  • function_to_apply (str, 선택 사항) — 모델 출력에 적용할 함수입니다. 회귀 문제의 경우 기본값은 “none”, 다중 레이블 분류의 경우 “sigmoid”, 그 외의 경우 “softmax”입니다. 유효한 옵션: [“softmax”, “sigmoid”, “none”]. 초기화 또는 호출 시 명시적으로 제공된 값은 이러한 기본값을 덮어씁니다. 후처리(post-processing)를 비활성화하려면 문자열 “none”을 전달하세요.

반환값

다음 키를 가진 dict의 목록

  • label (str) — 예측된 라벨.
  • score (float) — 해당 확률입니다.

입력으로 주어진 시퀀스를 분류합니다. 자세한 내용은 AutomaticSpeechRecognitionPipeline 문서를 참고하세요.

AutomaticSpeechRecognitionPipeline

class transformers.AutomaticSpeechRecognitionPipeline

< >

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

매개변수

  • model (PreTrainedModel) — 파이프라인이 예측을 수행하는 데 사용할 모델입니다. PreTrainedModel을 상속하는 모델이어야 합니다.
  • feature_extractor (SequenceFeatureExtractor, 선택 사항) — 파이프라인이 모델을 위해 웨이브폼을 인코딩하는 데 사용할 특징 추출기입니다.
  • tokenizer (PreTrainedTokenizer, 선택 사항) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 토크나이저입니다. 이 객체는 PreTrainedTokenizer를 상속합니다.
  • decoder (pyctcdecode.BeamSearchDecoderCTC, 선택 사항) — PyCTCDecode의 BeamSearchDecoderCTC 를 전달하여 언어 모델 부스트 디코딩을 사용할 수 있습니다. 자세한 내용은 Wav2Vec2ProcessorWithLM을 참조하세요. 비추천되며, Transformers v6에서 제거됩니다.
  • device (Union[int, torch.device], 선택 사항) — CPU/GPU 지원에 사용할 장치 번호입니다. 이 값을 None으로 설정하면 CPU를 사용하며, 양의 정수를 지정하면 해당 CUDA 장치 ID에서 모델을 실행합니다.

… 오디오에 포함된 발화 텍스트를 추출하는 것을 목표로 하는 Pipeline입니다.

입력은 원시 웨이브폼(raw waveform) 또는 오디오 파일일 수 있습니다. 오디오 파일의 경우, 다양한 오디오 포맷을 지원하기 위해 ffmpeg가 설치되어 있어야 합니다.

사용 중인 모델의 설정 파일(generation_config.json)에서 이러한 생성 매개변수를 명시적으로 설정하지 않는 한, 다음 기본값이 사용됩니다:

  • max_new_tokens: 256
  • num_beams: 5

예:

>>> from transformers import pipeline

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

pipeline 튜토리얼에서 pipeline 사용의 기본 사항에 대해 자세히 알아보세요.

__call__

< >

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

매개변수

  • inputs (np.ndarray 또는 bytes 또는 str 또는 dict) — inputs는 다음 중 하나입니다:
    • 로컬 오디오 파일의 파일명 또는 오디오 파일을 다운로드할 공개 URL 주소인 str. ffmpeg를 사용하여 올바른 샘플링 레이트로 파일을 읽어 웨이브폼을 얻습니다. 이를 위해 시스템에 ffmpeg가 설치되어 있어야 합니다.
    • bytes는 오디오 파일의 콘텐츠여야 하며, ffmpeg에 의해 동일한 방식으로 해석됩니다.
    • (np.ndarray, shape (n, ), type np.float32 또는 np.float64) 올바른 샘플링 레이트의 원시 오디오 (추가 검증은 수행되지 않음)
    • dict 형식을 사용하면 임의의 sampling_rate로 샘플링된 원시 오디오를 전달하고, 이 파이프라인이 리샘플링을 수행하도록 할 수 있습니다. dict는 {"sampling_rate": int, "raw": np.array} 형식이어야 하며, 선택적으로 "stride": (left: int, right: int)를 포함할 수 있습니다. 이 경우 파이프라인이 디코딩 시 처음 left개 샘플과 마지막 right개 샘플을 무시하도록 요청할 수 있습니다(추론 시에는 모델에 더 많은 컨텍스트를 제공하기 위해 사용됨). stride는 CTC 모델에서만 사용하세요.
  • return_timestamps (선택 사항, str 또는 bool) — 순수 CTC 모델(Wav2Vec2, HuBERT 등)과 Whisper 모델에서만 사용할 수 있습니다. 다른 sequence-to-sequence 모델에서는 사용할 수 없습니다.

    CTC 모델의 경우, 타임스탬프는 두 가지 형식 중 하나를 사용할 수 있습니다:

    • "char": 파이프라인은 텍스트의 각 문자에 대해 텍스트와 함께 타임스탬프를 반환합니다. 예를 들어 [{"text": "h", "timestamp": (0.5, 0.6)}, {"text": "i", "timestamp": (0.7, 0.9)}]를 얻는다면, 모델이 문자 “h”가 0.5초 이후이고 0.6초 이전에 발음된 것으로 예측했다는 의미입니다.
    • "word": 파이프라인은 텍스트의 모든 단어에 대해 텍스트와 함께 타임스탬프를 반환합니다. 예를 들어 [{"text": "hi ", "timestamp": (0.5, 0.9)}, {"text": "there", "timestamp": (1.0, 1.5)}]를 얻는 경우, 이는 모델이 “hi”라는 단어가 0.5초 이후이고 0.9초 이전에 발화되었다고 예측한다는 의미입니다.

    Whisper 모델의 경우, 타임스탬프는 두 가지 형식 중 하나를 사용할 수 있습니다:

    • "word": 단어 수준 CTC 타임스탬프의 경우 위와 동일합니다. 단어 수준 타임스탬프는 동적 시간 왜곡(DTW) 알고리즘을 통해 예측되며, 크로스 어텐션 가중치를 검사하여 단어 수준 타임스탬프를 근사하는 방식입니다.
    • True: 파이프라인은 텍스트 내 단어의 segments에 대해 텍스트와 함께 타임스탬프를 반환합니다. 예를 들어 [{"text": " Hi there!", "timestamp": (0.5, 1.5)}]를 받는 경우, 이는 모델이 “Hi there!” 세그먼트가 0.5초 이후이고 1.5초 이전에 발화되었다고 예측한다는 의미입니다. 텍스트의 세그먼트는 개별 단어(워드 레벨 타임스탬프의 경우)가 아니라 하나 이상의 단어로 구성된 시퀀스를 가리킵니다.
  • generate_kwargs (dict, 선택) — 생성 호출에 사용할 generate_config의 임시 파라미터화를 정의하는 사전입니다. generate에 대한 전체적인 개요는 다음 가이드를 참고하세요.

반환값

Dict

다음 키를 가진 사전:

  • text (str): 인식된 텍스트.
  • chunks ((선택 사항, list[Dict]) return_timestamps를 사용할 때, chunks는 모델이 식별한 다양한 텍스트 청크를 모두 포함하는 리스트가 됩니다. 예를 들어, [{"text": "hi ", "timestamp": (0.5, 0.9)}, {"text": "there", "timestamp": (1.0, 1.5)}]. 원래의 전체 텍스트는 "".join(chunk["text"] for chunk in output["chunks"])를 실행하여 대략적으로 복원할 수 있습니다.

입력으로 주어진 오디오 시퀀스를 텍스트로 전사합니다. 자세한 내용은 AutomaticSpeechRecognitionPipeline 문서를 참조하세요.

TextToAudioPipeline

class transformers.TextToAudioPipeline

< >

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

AutoModelForTextToWaveform 또는 AutoModelForTextToSpectrogram을 사용하여 텍스트에서 오디오로 생성하는 파이프라인입니다. 이 파이프라인은 입력 텍스트와 선택적인 다른 조건 입력을 받아 오디오 파일을 생성합니다.

사용 중인 모델이 generation_config.json에서 생성 매개변수를 명시적으로 설정하지 않는 한, generation.configuration_utils.py._get_default_generation_params()의 기본값이 사용됩니다.

  • max_new_tokens: 256

예:

>>> from transformers import pipeline

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

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

pipeline 튜토리얼에서 pipeline 사용의 기본 사항에 대해 자세히 알아보세요.

TextToAudioPipeline.__call__.forward_params 또는 TextToAudioPipeline.__call__.generate_kwargs를 사용하여 모델에 전달할 매개변수를 지정할 수 있습니다.

예:

>>> from transformers import pipeline

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

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

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

이 파이프라인은 현재 pipeline()에서 다음 작업 식별자를 사용하여 로드할 수 있습니다: "text-to-speech" 또는 "text-to-audio".

huggingface.co/models에서 사용 가능한 모델 목록을 확인하세요.

__call__

< >

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

매개변수

  • text_inputs (str, list[str], ChatType, 또는 list[ChatType]) — 생성할 텍스트 하나 이상입니다. 문자열 또는 문자열 리스트가 전달되면, 이 파이프라인은 해당 텍스트를 생성합니다. 대신, “role”과 “content” 키를 가진 딕셔너리의 리스트인 “chat” 형식을 전달하거나, 이러한 채팅의 리스트를 전달할 수도 있습니다. 채팅이 전달되면, 모델의 채팅 템플릿을 사용하여 포맷팅한 후 모델에 전달됩니다.
  • forward_params (dict, 선택) — 모델의 생성/forward 메서드에 전달되는 매개변수입니다. forward_params는 항상 기반 모델에 전달됩니다.
  • generate_kwargs (dict, 선택) — 생성 호출에 사용할 generate_config의 임시 파라미터화를 정의하는 사전입니다. generate에 대한 전체적인 개요는 다음 가이드를 참고하세요. generate_kwargs는 기저 모델이 생성형 모델인 경우에만 해당 모델로 전달되며, forward_params보다 우선합니다.

반환값

AudioOutput 또는 AudioOutput의 목록이며, 두 개의 키를 가진 TypedDict입니다

  • audio (np.ndarray, shape (nb_channels, audio_length)) — 생성된 오디오 웨이브폼.
  • sampling_rate (int) — 생성된 오디오 웨이브폼의 샘플링 레이트입니다.

입력으로부터 음성/오디오를 생성합니다. 자세한 내용은 TextToAudioPipeline 문서를 참조하세요.

ZeroShotAudioClassificationPipeline

class transformers.ZeroShotAudioClassificationPipeline

< >

( **kwargs )

매개변수

  • model (PreTrainedModel) — 파이프라인이 예측을 수행하는 데 사용할 모델입니다. PreTrainedModel을 상속하는 모델이어야 합니다.
  • tokenizer (PreTrainedTokenizer) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 토크나이저입니다. 이 객체는 PreTrainedTokenizer를 상속합니다.
  • feature_extractor (SequenceFeatureExtractor) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 피처 추출기입니다. 이 객체는 SequenceFeatureExtractor를 상속합니다.
  • task (str, 기본값 "") — pipeline의 작업 식별자입니다.
  • num_workers (int, 선택, 기본값 8) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우) 사용할 워커 수입니다.
  • batch_size (int, 선택 사항, 기본값 1) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우)에 사용할 배치 크기입니다. 추론에서는 항상 이롭지 않을 수 있으므로 파이프라인을 사용한 배치 처리를 읽어보십시오.
  • args_parser (ArgumentHandler, 선택 사항) — 공급된 파이프라인 매개변수를 파싱하는 책임을 지는 객체에 대한 참조입니다.
  • device (int 또는 str 또는 torch.device, 선택 사항) — 파이프라인이 할당되는 디바이스입니다. 설정하지 않으면 파이프라인은 첫 번째 사용 가능한 가속기(CUDA, MPS, XPU, …)에 배치되고, 사용 가능한 가속기가 없으면 CPU로 폴백됩니다. 모델은 자동으로 해당 디바이스로 이동합니다. CPU를 강제하려면 device="cpu"(또는 -1)을 전달하고, 특정 가속기를 선택하려면 양의 순번 또는 "cuda:1"을 전달하며, 네이티브 torch.device/str도 사용할 수 있습니다. 이 인수는 accelerate를 통해 이미 로드된 모델(즉, hf_device_map이 있는 모델)과 함께 사용할 수 없습니다.
  • dtype (str 또는 torch.dtype, 선택 사항, 기본값 "auto") — 모델이 로드되는 정밀도로, from_pretrained로 전달됩니다. 기본값은 "auto"이며, 모델이 저장된 dtype로 로드합니다(체크포인트의 config.dtype에서 읽거나, 그렇지 않으면 가중치에서 추론). 명시적으로 torch.float16, torch.bfloat16, torch.float32, ...를 전달하여 이를 재정의할 수 있습니다.
  • binary_output (bool, 선택 사항, 기본값 False) — 파이프라인의 출력이 직렬화 형식(예: pickle)으로 생성되어야 하는지, 아니면 텍스트와 같은 원시 출력 데이터로 생성되어야 하는지를 나타내는 플래그입니다.

ClapModel을 사용한 Zero shot 오디오 분류 파이프라인입니다. 이 파이프라인은 오디오와 candidate_labels 집합을 제공하면 해당 오디오의 클래스를 예측합니다.

기본 hypothesis_template은 다음과 같습니다: "This is a sound of {}.". 사용 목적에 맞게 이를 업데이트해야 합니다.

예:

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

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

pipeline 튜토리얼에서 pipeline 사용의 기본 사항에 대해 자세히 알아보세요. 이 오디오 분류 pipeline은 현재 pipeline()에서 다음 작업 식별자를 사용하여 로드할 수 있습니다: "zero-shot-audio-classification". huggingface.co/models에서 사용 가능한 모델 목록을 확인하세요.

__call__

< >

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

매개변수

  • audios (str, list[str], np.array 또는 list[np.array]) — 파이프라인은 세 가지 유형의 입력을 처리합니다:
    • 오디오를 가리키는 http 링크가 포함된 문자열
    • 오디오에 대한 로컬 경로를 포함하는 문자열
    • numpy로 로드된 오디오
  • candidate_labels (list[str]) — 이 오디오의 후보 라벨입니다. hypothesis_template를 사용하여 포맷팅됩니다.
  • hypothesis_template (str, optional, defaults to "This is a sound of {}") — The format used in conjunction with candidate_labels to attempt the audio classification by replacing the placeholder with the candidate_labels. Pass ”{}” if candidate_labels are already formatted.

입력으로 전달된 오디오에 라벨을 할당합니다.

컴퓨터 비전

컴퓨터 비전 작업에 사용할 수 있는 파이프라인은 다음과 같습니다.

DepthEstimationPipeline

class transformers.DepthEstimationPipeline

< >

( *args**kwargs )

매개변수

  • model (PreTrainedModel) — 파이프라인이 예측을 수행하는 데 사용할 모델입니다. PreTrainedModel을 상속하는 모델이어야 합니다.
  • image_processor (BaseImageProcessor) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 이미지 프로세서입니다. 이 객체는 BaseImageProcessor를 상속합니다.
  • task (str, 기본값 "") — pipeline의 작업 식별자입니다.
  • num_workers (int, 선택, 기본값 8) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우) 사용할 워커 수입니다.
  • batch_size (int, 선택 사항, 기본값 1) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우)에 사용할 배치 크기입니다. 추론에서는 항상 이롭지 않을 수 있으므로 파이프라인을 사용한 배치 처리를 읽어보십시오.
  • args_parser (ArgumentHandler, 선택 사항) — 공급된 파이프라인 매개변수를 파싱하는 책임을 지는 객체에 대한 참조입니다.
  • device (int 또는 str 또는 torch.device, 선택 사항) — 파이프라인이 할당되는 디바이스입니다. 설정하지 않으면 파이프라인은 첫 번째 사용 가능한 가속기(CUDA, MPS, XPU, …)에 배치되고, 사용 가능한 가속기가 없으면 CPU로 폴백됩니다. 모델은 자동으로 해당 디바이스로 이동합니다. CPU를 강제하려면 device="cpu"(또는 -1)을 전달하고, 특정 가속기를 선택하려면 양의 순번 또는 "cuda:1"을 전달하며, 네이티브 torch.device/str도 사용할 수 있습니다. 이 인수는 accelerate를 통해 이미 로드된 모델(즉, hf_device_map이 있는 모델)과 함께 사용할 수 없습니다.
  • dtype (str 또는 torch.dtype, 선택 사항, 기본값 "auto") — 모델이 로드되는 정밀도로, from_pretrained로 전달됩니다. 기본값은 "auto"이며, 모델이 저장된 dtype로 로드합니다(체크포인트의 config.dtype에서 읽거나, 그렇지 않으면 가중치에서 추론). 명시적으로 torch.float16, torch.bfloat16, torch.float32, ...를 전달하여 이를 재정의할 수 있습니다.
  • binary_output (bool, 선택 사항, 기본값 False) — 파이프라인의 출력이 직렬화 형식(예: pickle)으로 생성되어야 하는지, 아니면 텍스트와 같은 원시 출력 데이터로 생성되어야 하는지를 나타내는 플래그입니다.

AutoModelForDepthEstimation을 사용하는 깊이 추정 파이프라인입니다. 이 파이프라인은 이미지의 깊이를 예측합니다.

예:

>>> from transformers import pipeline

>>> depth_estimator = pipeline(task="depth-estimation", model="LiheYoung/depth-anything-base-hf")
>>> output = depth_estimator("http://images.cocodataset.org/val2017/000000039769.jpg")
>>> # This is a tensor with the values being the depth expressed in meters for each pixel
>>> output["predicted_depth"].shape
torch.Size([1, 384, 384])

pipeline 튜토리얼에서 pipeline 사용의 기본 사항에 대해 자세히 알아보세요.

이 깊이 추정 파이프라인은 현재 pipeline()에서 다음 작업 식별자를 사용하여 로드할 수 있습니다: "depth-estimation".

huggingface.co/models에서 사용 가능한 모델 목록을 확인하세요.

__call__

< >

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

매개변수

  • inputs (str, list[str], PIL.Image 또는 list[PIL.Image]) — 파이프라인은 다음 세 가지 유형의 이미지를 처리합니다:
    • 이미지를 가리키는 http 링크가 포함된 문자열
    • 이미지의 로컬 경로를 포함하는 문자열
    • PIL에 직접 로드된 이미지

    pipeline은 단일 이미지 또는 이미지 배치(배치는 문자열로 전달해야 함)를 입력으로 받습니다. 배치 내의 모든 이미지는 동일한 형식이어야 합니다: 모두 http 링크, 모두 로컬 경로, 또는 모두 PIL 이미지여야 합니다.

  • parameters (Dict, 선택) — 파이프라인 동작을 제어하기 위해 인자 이름과 매개변수 값을 매핑한 사전입니다. 현재 사용 가능한 유일한 매개변수는 timeout이며, 이는 이미지 다운로드를 시도하다가 포기하기까지 파이프라인이 대기할 시간(초 단위)입니다.
  • timeout (float, 선택, 기본값 None) — 웹에서 이미지를 가져오는 데 대기할 최대 시간(초). None인 경우 타임아웃이 설정되지 않으며, 호출이 영원히 차단될 수 있습니다.

입력으로 전달된 이미지의 깊이를 예측합니다.

ImageClassificationPipeline

class transformers.ImageClassificationPipeline

< >

( *args**kwargs )

매개변수

  • model (PreTrainedModel) — 파이프라인이 예측을 수행하는 데 사용할 모델입니다. PreTrainedModel을 상속하는 모델이어야 합니다.
  • image_processor (BaseImageProcessor) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 이미지 프로세서입니다. 이 객체는 BaseImageProcessor를 상속합니다.
  • task (str, 기본값 "") — pipeline의 작업 식별자입니다.
  • num_workers (int, 선택, 기본값 8) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우) 사용할 워커 수입니다.
  • batch_size (int, 선택 사항, 기본값 1) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우)에 사용할 배치 크기입니다. 추론에서는 항상 이롭지 않을 수 있으므로 파이프라인을 사용한 배치 처리를 읽어보십시오.
  • args_parser (ArgumentHandler, 선택 사항) — 공급된 파이프라인 매개변수를 파싱하는 책임을 지는 객체에 대한 참조입니다.
  • device (int 또는 str 또는 torch.device, 선택 사항) — 파이프라인이 할당되는 디바이스입니다. 설정하지 않으면 파이프라인은 첫 번째 사용 가능한 가속기(CUDA, MPS, XPU, …)에 배치되고, 사용 가능한 가속기가 없으면 CPU로 폴백됩니다. 모델은 자동으로 해당 디바이스로 이동합니다. CPU를 강제하려면 device="cpu"(또는 -1)을 전달하고, 특정 가속기를 선택하려면 양의 순번 또는 "cuda:1"을 전달하며, 네이티브 torch.device/str도 사용할 수 있습니다. 이 인수는 accelerate를 통해 이미 로드된 모델(즉, hf_device_map이 있는 모델)과 함께 사용할 수 없습니다.
  • dtype (str 또는 torch.dtype, 선택 사항, 기본값 "auto") — 모델이 로드되는 정밀도로, from_pretrained로 전달됩니다. 기본값은 "auto"이며, 모델이 저장된 dtype로 로드합니다(체크포인트의 config.dtype에서 읽거나, 그렇지 않으면 가중치에서 추론). 명시적으로 torch.float16, torch.bfloat16, torch.float32, ...를 전달하여 이를 재정의할 수 있습니다.
  • binary_output (bool, 선택 사항, 기본값 False) — 파이프라인의 출력이 직렬화 형식(예: pickle)으로 생성되어야 하는지, 아니면 텍스트와 같은 원시 출력 데이터로 생성되어야 하는지를 나타내는 플래그입니다.
  • function_to_apply (str, 선택 사항, 기본값은 "default") — 모델 출력에 점수를 가져오기 위해 적용할 함수입니다. 다음 네 가지 값을 허용합니다: "default": 모델이 단일 라벨을 가진 경우 출력에 sigmoid 함수를 적용합니다. 모델이 여러 라벨을 가진 경우 출력에 softmax 함수를 적용합니다. 회귀 작업의 경우 출력에 어떤 함수도 적용하지 않습니다. "sigmoid": 출력에 sigmoid 함수를 적용합니다. "softmax": 출력에 softmax 함수를 적용합니다. "none": 출력에 어떤 함수도 적용하지 않습니다.
    • "default": 모델이 단일 라벨을 가지는 경우 출력에 sigmoid 함수를 적용합니다. 모델이 여러 라벨을 가지는 경우 출력에 softmax 함수를 적용합니다. 회귀 작업의 경우 출력에 어떤 함수도 적용하지 않습니다.
    • "sigmoid": 출력에 sigmoid 함수를 적용합니다.
    • "softmax": 출력에 softmax 함수를 적용합니다.
    • "none": 출력에 어떤 함수도 적용하지 않습니다.

AutoModelForImageClassification을 사용하여 이미지 분류를 수행하는 파이프라인입니다. 이 파이프라인은 이미지의 클래스를 예측합니다.

예:

>>> from transformers import pipeline

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

pipeline 튜토리얼에서 pipeline 사용의 기본 사항에 대해 자세히 알아보세요.

이 이미지 분류 파이프라인은 현재 pipeline()에서 다음 작업 식별자를 사용하여 로드할 수 있습니다: "image-classification".

huggingface.co/models에서 사용 가능한 모델 목록을 확인하세요.

__call__

< >

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

매개변수

  • inputs (str, list[str], PIL.Image 또는 list[PIL.Image]) — 파이프라인은 다음 세 가지 유형의 이미지를 처리합니다:
    • 이미지를 가리키는 http 링크가 포함된 문자열
    • 이미지의 로컬 경로를 포함하는 문자열
    • PIL에 직접 로드된 이미지

    pipeline은 단일 이미지 또는 이미지 배치(배치는 문자열로 전달해야 함)를 입력으로 받습니다. 배치 내의 모든 이미지는 동일한 형식이어야 합니다: 모두 http 링크, 모두 로컬 경로, 또는 모두 PIL 이미지여야 합니다.

  • function_to_apply (str, 선택 사항, 기본값은 "default") — 모델 출력에 점수를 추출하기 위해 적용할 함수입니다. 다음 네 가지 값을 허용합니다:

    이 인자가 지정되지 않으면, 레이블 수에 따라 다음 함수가 적용됩니다:

    • problem type이 regression인 경우, 출력에 어떤 함수도 적용하지 않습니다.
    • 모델에 단일 라벨이 있는 경우, 출력에 sigmoid 함수를 적용합니다.
    • 모델에 여러 라벨이 있는 경우, 출력에 softmax 함수를 적용합니다.

    가능한 값은 다음과 같습니다:

    • "sigmoid": 출력에 sigmoid 함수를 적용합니다.
    • "softmax": 출력에 softmax 함수를 적용합니다.
    • "none": 출력에 어떤 함수도 적용하지 않습니다.
  • top_k (int, 선택 사항, 기본값 5) — 파이프라인이 반환할 상위 라벨의 수입니다. 제공된 수가 모델 구성에 사용 가능한 라벨 수보다 크면, 사용 가능한 라벨 수로 기본값이 설정됩니다.
  • timeout (float, 선택, 기본값 None) — 웹에서 이미지를 가져오는 데 대기할 최대 시간(초). None인 경우 타임아웃이 설정되지 않으며, 호출이 영원히 차단될 수 있습니다.

입력으로 전달된 이미지에 라벨을 할당합니다.

ImageSegmentationPipeline

class transformers.ImageSegmentationPipeline

< >

( *args**kwargs )

매개변수

  • model (PreTrainedModel) — 파이프라인이 예측을 수행하는 데 사용할 모델입니다. PreTrainedModel을 상속하는 모델이어야 합니다.
  • image_processor (BaseImageProcessor) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 이미지 프로세서입니다. 이 객체는 BaseImageProcessor를 상속합니다.
  • task (str, 기본값 "") — pipeline의 작업 식별자입니다.
  • num_workers (int, 선택, 기본값 8) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우) 사용할 워커 수입니다.
  • batch_size (int, 선택 사항, 기본값 1) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우)에 사용할 배치 크기입니다. 추론에서는 항상 이롭지 않을 수 있으므로 파이프라인을 사용한 배치 처리를 읽어보십시오.
  • args_parser (ArgumentHandler, 선택 사항) — 공급된 파이프라인 매개변수를 파싱하는 책임을 지는 객체에 대한 참조입니다.
  • device (int 또는 str 또는 torch.device, 선택 사항) — 파이프라인이 할당되는 디바이스입니다. 설정하지 않으면 파이프라인은 첫 번째 사용 가능한 가속기(CUDA, MPS, XPU, …)에 배치되고, 사용 가능한 가속기가 없으면 CPU로 폴백됩니다. 모델은 자동으로 해당 디바이스로 이동합니다. CPU를 강제하려면 device="cpu"(또는 -1)을 전달하고, 특정 가속기를 선택하려면 양의 순번 또는 "cuda:1"을 전달하며, 네이티브 torch.device/str도 사용할 수 있습니다. 이 인수는 accelerate를 통해 이미 로드된 모델(즉, hf_device_map이 있는 모델)과 함께 사용할 수 없습니다.
  • dtype (str 또는 torch.dtype, 선택 사항, 기본값 "auto") — 모델이 로드되는 정밀도로, from_pretrained로 전달됩니다. 기본값은 "auto"이며, 모델이 저장된 dtype로 로드합니다(체크포인트의 config.dtype에서 읽거나, 그렇지 않으면 가중치에서 추론). 명시적으로 torch.float16, torch.bfloat16, torch.float32, ...를 전달하여 이를 재정의할 수 있습니다.
  • binary_output (bool, 선택 사항, 기본값 False) — 파이프라인의 출력이 직렬화 형식(예: pickle)으로 생성되어야 하는지, 아니면 텍스트와 같은 원시 출력 데이터로 생성되어야 하는지를 나타내는 플래그입니다.

AutoModelForXXXSegmentation을 사용하여 이미지 분할을 수행하는 파이프라인입니다. 이 파이프라인은 객체의 마스크와 해당 클래스를 예측합니다.

예:

>>> from transformers import pipeline

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

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

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

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

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

이 이미지 분할 파이프라인은 현재 pipeline()에서 다음 작업 식별자를 사용하여 로드할 수 있습니다: "image-segmentation".

huggingface.co/models에서 사용 가능한 모델 목록을 확인하세요.

__call__

< >

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

매개변수

  • inputs (str, list[str], PIL.Image 또는 list[PIL.Image]) — 파이프라인은 다음 세 가지 유형의 이미지를 처리합니다:
    • 이미지를 가리키는 HTTP(S) 링크를 포함하는 문자열
    • 이미지의 로컬 경로를 포함하는 문자열
    • PIL에 직접 로드된 이미지

    pipeline은 단일 이미지 또는 이미지 배치(batch)를 모두 받을 수 있습니다. 배치 내의 모든 이미지는 동일한 형식이어야 합니다: 모두 HTTP(S) 링크, 모두 로컬 경로, 또는 모두 PIL 이미지여야 합니다.

  • subtask (str, 선택 사항) — 모델의 기능에 따라 [semantic, instance, panoptic] 중 하나를 선택하여 수행할 분할 작업을 지정합니다. 설정하지 않으면 파이프라인은 panoptic, instance, semantic 순서로 해결을 시도합니다.
  • threshold (float, 선택 사항, 기본값 0.9) — 예측된 마스크를 필터링할 확률 임계값입니다.
  • mask_threshold (float, 선택 사항, 기본값 0.5) — 예측된 마스크를 이진 값으로 변환할 때 사용할 임계값.
  • overlap_mask_area_threshold (float, 선택 사항, 기본값 0.5) — 작고 분리된 세그먼트를 제거하기 위한 마스크 겹침 임계값입니다.
  • timeout (float, 선택, 기본값 None) — 웹에서 이미지를 가져오는 데 대기할 최대 시간(초). None인 경우 타임아웃이 설정되지 않으며, 호출이 영원히 차단될 수 있습니다.

입력으로 전달된 이미지에서 분할(마스크 및 클래스 감지)을 수행합니다.

KeypointMatchingPipeline

class transformers.KeypointMatchingPipeline

< >

( *args**kwargs )

AutoModelForKeypointMatching을 사용하여 임의의 keypoint matching pipeline을 구성합니다. 이 pipeline은 두 이미지 간의 keypoint를 매칭합니다.

__call__

< >

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

매개변수

  • inputs (str, list[str], PIL.Image 또는 list[PIL.Image]) — 파이프라인은 다음 세 가지 유형의 이미지를 처리합니다:
    • 이미지를 가리키는 http 링크가 포함된 문자열
    • 이미지의 로컬 경로를 포함하는 문자열
    • PIL에 직접 로드된 이미지

    pipeline은 단일 이미지 쌍 또는 이미지 쌍의 배치(batch)를 모두 받을 수 있으며, 이 경우 문자열로 전달해야 합니다. 배치 내의 모든 이미지는 동일한 형식이어야 합니다: 모두 http 링크, 모두 로컬 경로, 또는 모두 PIL 이미지여야 합니다.

  • threshold (float, 선택 사항, 기본값 0.0) — 키포인트 매칭에 사용할 임계값입니다. 매칭 점수가 이 값보다 낮은 키포인트는 필터링됩니다. 0으로 설정하면 모든 매칭된 키포인트가 반환됩니다.
  • kwargs — timeout (float, *optional*, defaults to None) 웹에서 이미지를 가져오는 데 대기할 최대 시간(초). None인 경우 타임아웃이 설정되지 않으며, 호출이 영원히 차단될 수 있습니다.

반환값

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

이미지 쌍 하나가 제공되면 매칭 목록, 이미지 쌍 배치(batch)가 제공되면 매칭 목록의 목록을 반환합니다. 각 매칭은 다음 키를 포함하는 딕셔너리입니다:

  • keypoint_image_0 (Keypoint): 첫 번째 이미지에서 키포인트의 좌표 (x, y).
  • keypoint_image_1 (Keypoint): 두 번째 이미지에서 키포인트의 (x, y) 좌표.
  • score (float): 두 keypoint 간의 매칭 점수.

두 이미지 간의 주요점 매칭을 찾습니다.

ObjectDetectionPipeline

class transformers.ObjectDetectionPipeline

< >

( *args**kwargs )

매개변수

  • model (PreTrainedModel) — 파이프라인이 예측을 수행하는 데 사용할 모델입니다. PreTrainedModel을 상속하는 모델이어야 합니다.
  • image_processor (BaseImageProcessor) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 이미지 프로세서입니다. 이 객체는 BaseImageProcessor를 상속합니다.
  • task (str, 기본값 "") — pipeline의 작업 식별자입니다.
  • num_workers (int, 선택, 기본값 8) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우) 사용할 워커 수입니다.
  • batch_size (int, 선택 사항, 기본값 1) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우)에 사용할 배치 크기입니다. 추론에서는 항상 이롭지 않을 수 있으므로 파이프라인을 사용한 배치 처리를 읽어보십시오.
  • args_parser (ArgumentHandler, 선택 사항) — 공급된 파이프라인 매개변수를 파싱하는 책임을 지는 객체에 대한 참조입니다.
  • device (int 또는 str 또는 torch.device, 선택 사항) — 파이프라인이 할당되는 디바이스입니다. 설정하지 않으면 파이프라인은 첫 번째 사용 가능한 가속기(CUDA, MPS, XPU, …)에 배치되고, 사용 가능한 가속기가 없으면 CPU로 폴백됩니다. 모델은 자동으로 해당 디바이스로 이동합니다. CPU를 강제하려면 device="cpu"(또는 -1)을 전달하고, 특정 가속기를 선택하려면 양의 순번 또는 "cuda:1"을 전달하며, 네이티브 torch.device/str도 사용할 수 있습니다. 이 인수는 accelerate를 통해 이미 로드된 모델(즉, hf_device_map이 있는 모델)과 함께 사용할 수 없습니다.
  • dtype (str 또는 torch.dtype, 선택 사항, 기본값 "auto") — 모델이 로드되는 정밀도로, from_pretrained로 전달됩니다. 기본값은 "auto"이며, 모델이 저장된 dtype로 로드합니다(체크포인트의 config.dtype에서 읽거나, 그렇지 않으면 가중치에서 추론). 명시적으로 torch.float16, torch.bfloat16, torch.float32, ...를 전달하여 이를 재정의할 수 있습니다.
  • binary_output (bool, 선택 사항, 기본값 False) — 파이프라인의 출력이 직렬화 형식(예: pickle)으로 생성되어야 하는지, 아니면 텍스트와 같은 원시 출력 데이터로 생성되어야 하는지를 나타내는 플래그입니다.

AutoModelForObjectDetection을 사용하여 객체 감지 파이프라인을 구성합니다. 이 파이프라인은 객체의 바운딩 박스와 해당 클래스를 예측합니다.

예:

>>> from transformers import pipeline

>>> detector = pipeline(model="facebook/detr-resnet-50")
>>> detector("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png")
[{'score': 0.997, 'label': 'bird', 'box': {'xmin': 69, 'ymin': 171, 'xmax': 396, 'ymax': 507}}, {'score': 0.999, 'label': 'bird', 'box': {'xmin': 398, 'ymin': 105, 'xmax': 767, 'ymax': 507}}]

>>> # x, y  are expressed relative to the top left hand corner.

pipeline 튜토리얼에서 pipeline 사용의 기본 사항에 대해 자세히 알아보세요.

이 객체 감지 파이프라인은 현재 pipeline()에서 다음 작업 식별자를 사용하여 로드할 수 있습니다: "object-detection".

huggingface.co/models에서 사용 가능한 모델 목록을 확인하세요.

__call__

< >

( *args**kwargs )

매개변수

  • inputs (str, list[str], PIL.Image 또는 list[PIL.Image]) — 파이프라인은 다음 세 가지 유형의 이미지를 처리합니다:
    • 이미지를 가리키는 HTTP(S) 링크를 포함하는 문자열
    • 이미지의 로컬 경로를 포함하는 문자열
    • PIL에 직접 로드된 이미지

    pipeline은 단일 이미지 또는 이미지 배치(batch)를 모두 받을 수 있습니다. 배치 내의 모든 이미지는 동일한 형식이어야 합니다: 모두 HTTP(S) 링크, 모두 로컬 경로, 또는 모두 PIL 이미지여야 합니다.

  • threshold (float, 선택 사항, 기본값 0.5) — 예측을 수행하는 데 필요한 확률입니다.
  • timeout (float, 선택, 기본값 None) — 웹에서 이미지를 가져오는 데 대기할 최대 시간(초). None인 경우 타임아웃이 설정되지 않으며, 호출이 영원히 차단될 수 있습니다.

입력으로 전달된 이미지에서 객체(바운딩 박스 및 클래스)를 감지합니다.

VideoClassificationPipeline

class transformers.VideoClassificationPipeline

< >

( *args**kwargs )

매개변수

  • model (PreTrainedModel) — 파이프라인이 예측을 수행하는 데 사용할 모델입니다. PreTrainedModel을 상속하는 모델이어야 합니다.
  • image_processor (BaseImageProcessor) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 이미지 프로세서입니다. 이 객체는 BaseImageProcessor를 상속합니다.
  • video_processor (BaseVideoProcessor) — 파이프라인이 모델을 위해 비디오 데이터를 인코딩하는 데 사용할 비디오 프로세서입니다. 이 객체는 BaseVideoProcessor를 상속합니다.
  • task (str, 기본값 "") — pipeline의 작업 식별자입니다.
  • num_workers (int, 선택, 기본값 8) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우) 사용할 워커 수입니다.
  • batch_size (int, 선택 사항, 기본값 1) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우)에 사용할 배치 크기입니다. 추론에서는 항상 이롭지 않을 수 있으므로 파이프라인을 사용한 배치 처리를 읽어보십시오.
  • args_parser (ArgumentHandler, 선택 사항) — 공급된 파이프라인 매개변수를 파싱하는 책임을 지는 객체에 대한 참조입니다.
  • device (int 또는 str 또는 torch.device, 선택 사항) — 파이프라인이 할당되는 디바이스입니다. 설정하지 않으면 파이프라인은 첫 번째 사용 가능한 가속기(CUDA, MPS, XPU, …)에 배치되고, 사용 가능한 가속기가 없으면 CPU로 폴백됩니다. 모델은 자동으로 해당 디바이스로 이동합니다. CPU를 강제하려면 device="cpu"(또는 -1)을 전달하고, 특정 가속기를 선택하려면 양의 순번 또는 "cuda:1"을 전달하며, 네이티브 torch.device/str도 사용할 수 있습니다. 이 인수는 accelerate를 통해 이미 로드된 모델(즉, hf_device_map이 있는 모델)과 함께 사용할 수 없습니다.
  • dtype (str 또는 torch.dtype, 선택 사항, 기본값 "auto") — 모델이 로드되는 정밀도로, from_pretrained로 전달됩니다. 기본값은 "auto"이며, 모델이 저장된 dtype로 로드합니다(체크포인트의 config.dtype에서 읽거나, 그렇지 않으면 가중치에서 추론). 명시적으로 torch.float16, torch.bfloat16, torch.float32, ...를 전달하여 이를 재정의할 수 있습니다.
  • binary_output (bool, 선택 사항, 기본값 False) — 파이프라인의 출력이 직렬화 형식(예: pickle)으로 생성되어야 하는지, 아니면 텍스트와 같은 원시 출력 데이터로 생성되어야 하는지를 나타내는 플래그입니다.

AutoModelForVideoClassification을 사용하여 비디오를 분류하는 파이프라인입니다. 이 파이프라인은 비디오의 클래스를 예측합니다.

이 비디오 분류 파이프라인은 현재 pipeline()에서 다음 작업 식별자를 사용하여 로드할 수 있습니다: "video-classification".

huggingface.co/models에서 사용 가능한 모델 목록을 확인하세요.

pipeline은 이미지 프로세서(VideoMAE, ViViT, TimeSformer와 같은 레거시 비디오 모델) 또는 비디오 프로세서(VJEPA2와 같은 최신 모델)를 사용하는 모델을 지원합니다. 두 프로세서가 모두 존재하는 경우 비디오 프로세서가 우선 적용되며, 둘 다 발견되지 않으면 pipeline은 오류를 발생시킵니다.

__call__

< >

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

매개변수

  • inputs (str, list[str]) — 파이프라인은 다음 세 가지 유형의 비디오를 처리합니다:
    • 비디오를 가리키는 http 링크가 포함된 문자열
    • 비디오의 로컬 경로를 포함하는 문자열

    pipeline은 단일 비디오 또는 비디오 배치(배치는 문자열로 전달해야 함)를 모두 받아들입니다. 배치 내의 모든 비디오는 동일한 형식이어야 합니다: 모두 http 링크이거나 모두 로컬 경로여야 합니다.

  • top_k (int, 선택 사항, 기본값 5) — 파이프라인이 반환할 상위 라벨의 수입니다. 제공된 수가 모델 구성에 사용 가능한 라벨 수보다 크면, 사용 가능한 라벨 수로 기본값이 설정됩니다.
  • num_frames (int, 선택 사항, 기본값 self.model.config.num_frames) — 분류를 실행하기 위해 비디오에서 샘플링할 프레임 수입니다. 지정하지 않으면 모델 구성에 명시된 프레임 수를 기본값으로 사용합니다.
  • frame_sampling_rate (int, 선택 사항, 기본값 1) — 비디오에서 프레임을 선택할 때 사용되는 샘플링 비율입니다. 지정하지 않으면 기본값인 1이 적용되어 모든 프레임이 사용됩니다.
  • function_to_apply (str, 선택 사항) — 모델 출력에 적용할 함수입니다. 회귀 문제의 경우 기본값은 “none”, 다중 레이블 분류의 경우 “sigmoid”, 그 외의 경우 “softmax”입니다. 유효한 옵션: [“softmax”, “sigmoid”, “none”]. 초기화 또는 호출 시 명시적으로 제공된 값은 이러한 기본값을 덮어씁니다. 후처리(post-processing)를 비활성화하려면 문자열 “none”을 전달하세요.

입력으로 전달된 비디오에 라벨을 할당합니다.

ZeroShotImageClassificationPipeline

class transformers.ZeroShotImageClassificationPipeline

< >

( **kwargs )

매개변수

  • model (PreTrainedModel) — 파이프라인이 예측을 수행하는 데 사용할 모델입니다. PreTrainedModel을 상속하는 모델이어야 합니다.
  • image_processor (BaseImageProcessor) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 이미지 프로세서입니다. 이 객체는 BaseImageProcessor를 상속합니다.
  • task (str, 기본값 "") — pipeline의 작업 식별자입니다.
  • num_workers (int, 선택, 기본값 8) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우) 사용할 워커 수입니다.
  • batch_size (int, 선택 사항, 기본값 1) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우)에 사용할 배치 크기입니다. 추론에서는 항상 이롭지 않을 수 있으므로 파이프라인을 사용한 배치 처리를 읽어보십시오.
  • args_parser (ArgumentHandler, 선택 사항) — 공급된 파이프라인 매개변수를 파싱하는 책임을 지는 객체에 대한 참조입니다.
  • device (int 또는 str 또는 torch.device, 선택 사항) — 파이프라인이 할당되는 디바이스입니다. 설정하지 않으면 파이프라인은 첫 번째 사용 가능한 가속기(CUDA, MPS, XPU, …)에 배치되고, 사용 가능한 가속기가 없으면 CPU로 폴백됩니다. 모델은 자동으로 해당 디바이스로 이동합니다. CPU를 강제하려면 device="cpu"(또는 -1)을 전달하고, 특정 가속기를 선택하려면 양의 순번 또는 "cuda:1"을 전달하며, 네이티브 torch.device/str도 사용할 수 있습니다. 이 인수는 accelerate를 통해 이미 로드된 모델(즉, hf_device_map이 있는 모델)과 함께 사용할 수 없습니다.
  • dtype (str 또는 torch.dtype, 선택 사항, 기본값 "auto") — 모델이 로드되는 정밀도로, from_pretrained로 전달됩니다. 기본값은 "auto"이며, 모델이 저장된 dtype로 로드합니다(체크포인트의 config.dtype에서 읽거나, 그렇지 않으면 가중치에서 추론). 명시적으로 torch.float16, torch.bfloat16, torch.float32, ...를 전달하여 이를 재정의할 수 있습니다.
  • binary_output (bool, 선택 사항, 기본값 False) — 파이프라인의 출력이 직렬화 형식(예: pickle)으로 생성되어야 하는지, 아니면 텍스트와 같은 원시 출력 데이터로 생성되어야 하는지를 나타내는 플래그입니다.

CLIPModel을 사용한 Zero shot 이미지 분류 파이프라인입니다. 이 파이프라인은 이미지와 candidate_labels 집합을 제공하면 이미지의 클래스를 예측합니다.

예:

>>> from transformers import pipeline

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

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

pipeline 튜토리얼에서 pipeline 사용의 기본 사항에 대해 자세히 알아보세요.

이 이미지 분류 파이프라인은 현재 pipeline()에서 다음 작업 식별자를 사용하여 로드할 수 있습니다: "zero-shot-image-classification".

huggingface.co/models에서 사용 가능한 모델 목록을 확인하세요.

__call__

< >

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

매개변수

  • image (str, list[str], PIL.Image 또는 list[PIL.Image]) — 파이프라인은 다음 세 가지 유형의 이미지를 처리합니다:
    • 이미지를 가리키는 http 링크가 포함된 문자열
    • 이미지의 로컬 경로를 포함하는 문자열
    • PIL에 직접 로드된 이미지
  • candidate_labels (list[str]) — 이 이미지의 후보 라벨입니다. hypothesis_template을(를) 사용하여 포맷팅됩니다.
  • hypothesis_template (str, 선택 사항, 기본값 "This is a photo of {}") — candidate_labels와 함께 이미지 분류를 시도할 때 사용되는 형식입니다. 플레이스홀더를 candidate_labels로 대체하여 사용합니다. 이미 포맷된 상태라면 ”{}”를 전달하세요.
  • timeout (float, 선택, 기본값 None) — 웹에서 이미지를 가져오는 데 대기할 최대 시간(초). None인 경우 타임아웃이 설정되지 않으며, 호출이 영원히 차단될 수 있습니다.

입력으로 전달된 이미지에 라벨을 할당합니다.

ZeroShotObjectDetectionPipeline

class transformers.ZeroShotObjectDetectionPipeline

< >

( **kwargs )

매개변수

  • model (PreTrainedModel) — 파이프라인이 예측을 수행하는 데 사용할 모델입니다. PreTrainedModel을 상속하는 모델이어야 합니다.
  • image_processor (BaseImageProcessor) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 이미지 프로세서입니다. 이 객체는 BaseImageProcessor를 상속합니다.
  • task (str, 기본값 "") — pipeline의 작업 식별자입니다.
  • num_workers (int, 선택, 기본값 8) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우) 사용할 워커 수입니다.
  • batch_size (int, 선택 사항, 기본값 1) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우)에 사용할 배치 크기입니다. 추론에서는 항상 이롭지 않을 수 있으므로 파이프라인을 사용한 배치 처리를 읽어보십시오.
  • args_parser (ArgumentHandler, 선택 사항) — 공급된 파이프라인 매개변수를 파싱하는 책임을 지는 객체에 대한 참조입니다.
  • device (int 또는 str 또는 torch.device, 선택 사항) — 파이프라인이 할당되는 디바이스입니다. 설정하지 않으면 파이프라인은 첫 번째 사용 가능한 가속기(CUDA, MPS, XPU, …)에 배치되고, 사용 가능한 가속기가 없으면 CPU로 폴백됩니다. 모델은 자동으로 해당 디바이스로 이동합니다. CPU를 강제하려면 device="cpu"(또는 -1)을 전달하고, 특정 가속기를 선택하려면 양의 순번 또는 "cuda:1"을 전달하며, 네이티브 torch.device/str도 사용할 수 있습니다. 이 인수는 accelerate를 통해 이미 로드된 모델(즉, hf_device_map이 있는 모델)과 함께 사용할 수 없습니다.
  • dtype (str 또는 torch.dtype, 선택 사항, 기본값 "auto") — 모델이 로드되는 정밀도로, from_pretrained로 전달됩니다. 기본값은 "auto"이며, 모델이 저장된 dtype로 로드합니다(체크포인트의 config.dtype에서 읽거나, 그렇지 않으면 가중치에서 추론). 명시적으로 torch.float16, torch.bfloat16, torch.float32, ...를 전달하여 이를 재정의할 수 있습니다.
  • binary_output (bool, 선택 사항, 기본값 False) — 파이프라인의 출력이 직렬화 형식(예: pickle)으로 생성되어야 하는지, 아니면 텍스트와 같은 원시 출력 데이터로 생성되어야 하는지를 나타내는 플래그입니다.

OwlViTForObjectDetection를 사용한 Zero shot 객체 감지 파이프라인입니다. 이 파이프라인은 이미지와 candidate_labels 집합을 제공하면 객체의 바운딩 박스를 예측합니다.

예:

>>> from transformers import pipeline

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

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

pipeline 튜토리얼에서 pipeline 사용의 기본 사항에 대해 자세히 알아보세요.

이 객체 감지 파이프라인은 현재 pipeline()에서 다음 작업 식별자를 사용하여 로드할 수 있습니다: "zero-shot-object-detection".

huggingface.co/models에서 사용 가능한 모델 목록을 확인하세요.

__call__

< >

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

매개변수

  • image (str, PIL.Image 또는 list[dict[str, Any]]) — 파이프라인은 세 가지 유형의 이미지를 처리합니다: 이미지로 가리키는 http URL을 포함하는 문자열, 이미지의 로컬 경로를 포함하는 문자열, PIL에 직접 로드된 이미지. 이 매개변수를 사용하여 이미지 목록, 데이터셋 또는 생성기를 직접 보낼 수 있습니다: >>> from transformers import pipeline >>> detector = pipeline(model="google/owlvit-base-patch32", task="zero-shot-object-detection") >>> detector( ... [ ... { ... "image": "http://images.cocodataset.org/val2017/000000039769.jpg", ... "candidate_labels": ["cat", "couch"], ... }, ... { ... "image": "http://images.cocodataset.org/val2017/000000039769.jpg", ... "candidate_labels": ["cat", "couch"], ... }, ... ] ... ) [[{'score': 0.287, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}&zwnj;}, {'score': 0.25, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}&zwnj;}, {'score': 0.121, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}&zwnj;}], [{'score': 0.287, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}&zwnj;}, {'score': 0.254, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}&zwnj;}, {'score': 0.121, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}&zwnj;}]]
    • 이미지를 가리키는 http URL을 포함하는 문자열
    • 이미지의 로컬 경로를 포함하는 문자열
    • PIL에 직접 로드된 이미지

    이 매개변수를 사용하여 이미지 목록을 직접 보내거나, 다음과 같이 데이터셋 또는 생성기를 보낼 수 있습니다:

    >>> from transformers import pipeline

>>> detector = pipeline(model="google/owlvit-base-patch32", task="zero-shot-object-detection")
>>> detector(
...     [
...         {
...             "image": "http://images.cocodataset.org/val2017/000000039769.jpg",
...             "candidate_labels": ["cat", "couch"],
...         },
...         {
...             "image": "http://images.cocodataset.org/val2017/000000039769.jpg",
...             "candidate_labels": ["cat", "couch"],
...         },
...     ]
... )
[[{'score': 0.287, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}&zwnj;}, {'score': 0.25, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}&zwnj;}, {'score': 0.121, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}&zwnj;}], [{'score': 0.287, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}&zwnj;}, {'score': 0.254, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}&zwnj;}, {'score': 0.121, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}&zwnj;}]]
  • candidate_labels (str 또는 list[str] 또는 list[list[str]]) — 모델이 이미지에서 인식해야 할 대상입니다.
  • threshold (float, 선택 사항, 기본값 0.1) — 예측을 수행하는 데 필요한 확률입니다.
  • top_k (int, 선택 사항, 기본값 None) — 파이프라인이 반환할 상위 예측의 개수입니다. 제공된 값이 None이거나 사용 가능한 예측의 개수보다 크면, 사용 가능한 예측의 개수가 기본값으로 사용됩니다.
  • timeout (float, 선택, 기본값 None) — 웹에서 이미지를 가져오는 데 대기할 최대 시간(초). None인 경우 타임아웃이 설정되지 않으며, 호출이 영원히 차단될 수 있습니다.

입력으로 전달된 이미지에서 객체(바운딩 박스 및 클래스)를 감지합니다.

자연어 처리

자연어 처리 작업에 사용할 수 있는 파이프라인은 다음과 같습니다.

DecisionPipeline

Decision 모델, decision 파이프라인 및 DecisionConfig는 실험적이며, 비추천(deprecation) 절차 없이 API가 언제든 변경될 수 있습니다.

각 호출은 질문을 요청합니다: {"state": ..., "questions": ...} 요청 또는 questions가 포함된 상태:

from transformers import pipeline

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

이미지는 System One API와 마찬가지로 assets로 제공됩니다. 상태, 지침 또는 기준에 있는 각 플레이스홀더는 해당 이미지로 대체됩니다. 에셋은 {"type": "image", "format": "png", "data_base64": ...}, PIL 이미지, 경로 또는 URL일 수 있으며, 모델에는 이미지를 처리할 프로세서가 필요합니다.

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

클래스 transformers.DecisionPipeline

< >

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

매개변수

  • model (PreTrainedModel) — 파이프라인이 예측을 수행하는 데 사용할 모델입니다. PreTrainedModel을 상속하는 모델이어야 합니다.
  • tokenizer (PreTrainedTokenizer) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 토크나이저입니다. 이 객체는 PreTrainedTokenizer를 상속합니다.
  • task (str, 기본값 "") — pipeline의 작업 식별자입니다.
  • num_workers (int, 선택, 기본값 8) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우) 사용할 워커 수입니다.
  • batch_size (int, 선택 사항, 기본값 1) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우)에 사용할 배치 크기입니다. 추론에서는 항상 이롭지 않을 수 있으므로 파이프라인을 사용한 배치 처리를 읽어보십시오.
  • args_parser (ArgumentHandler, 선택 사항) — 공급된 파이프라인 매개변수를 파싱하는 책임을 지는 객체에 대한 참조입니다.
  • device (int 또는 str 또는 torch.device, 선택 사항) — 파이프라인이 할당되는 디바이스입니다. 설정하지 않으면 파이프라인은 첫 번째 사용 가능한 가속기(CUDA, MPS, XPU, …)에 배치되고, 사용 가능한 가속기가 없으면 CPU로 폴백됩니다. 모델은 자동으로 해당 디바이스로 이동합니다. CPU를 강제하려면 device="cpu"(또는 -1)을 전달하고, 특정 가속기를 선택하려면 양의 순번 또는 "cuda:1"을 전달하며, 네이티브 torch.device/str도 사용할 수 있습니다. 이 인수는 accelerate를 통해 이미 로드된 모델(즉, hf_device_map이 있는 모델)과 함께 사용할 수 없습니다.
  • dtype (str 또는 torch.dtype, 선택 사항, 기본값 "auto") — 모델이 로드되는 정밀도로, from_pretrained로 전달됩니다. 기본값은 "auto"이며, 모델이 저장된 dtype로 로드합니다(체크포인트의 config.dtype에서 읽거나, 그렇지 않으면 가중치에서 추론). 명시적으로 torch.float16, torch.bfloat16, torch.float32, ...를 전달하여 이를 재정의할 수 있습니다.
  • binary_output (bool, 선택 사항, 기본값 False) — 파이프라인의 출력이 직렬화 형식(예: pickle)으로 생성되어야 하는지, 아니면 텍스트와 같은 원시 출력 데이터로 생성되어야 하는지를 나타내는 플래그입니다.

Decision pipeline: state에 대해 입력된 질문(choice, score, noul)에 대해 모든 옵션에 대한 확률을 반환합니다. 이는 프롬프트당 하나의 forward pass로 수행되며(Jev 유사 모델의 System One API) decision config(참고: DecisionConfig)은 모델 옆에 또는 decision_config로 지정된 repo에 위치합니다. decision model(XxxForDecision)은 옵션을 직접 점수화하며, 다른 모델은 라벨의 next-token logits를 통해 점수화하므로 모든 chat model이 답변할 수 있습니다.

예:

>>> from transformers import pipeline

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

Call arguments: inputs (dict, str 또는 list): {"state": ..., "questions": {name: {"type": ..., "instructions": ..., "criteria": ...}}} 또는 해당 JSON. 여기서 type은 choice (criteria가 옵션을 설명으로 매핑), score (criteria가 레벨을 나열하며 가장 낮은 레벨이 먼저 오거나) 또는 noul (선택적 criteria가 true와 false를 설명) 중 하나입니다. System One API와 마찬가지로 요청에 assets를 포함할 수 있습니다. questions (dict, 선택): 요청의 state로 입력에 대해 질문할 내용입니다. assets (dict, 선택): 플레이스홀더를 키로 하는 이미지입니다. state, instructions 또는 criteria의 문자열에서 플레이스홀더가 나타나는 모든 위치에서 모델은 해당 이미지를 확인합니다. 이미지는 System One 자산({"type": "image", "format": "png", "data_base64": ...}), PIL 이미지, 경로 또는 URL입니다. 이미지를 처리하는 프로세서가 있는 모델이 필요합니다.

dict(또는 dict 목록)를 반환합니다. System One 형식으로, 질문 이름이 키가 되는 답변입니다.

__call__

< >

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

클래스 transformers.DecisionConfig

< >

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

매개변수

  • labels (dict[str, list[str]], 선택 사항) — logits에서 라벨을 읽는 헤드를 위한 질문 유형별 옵션의 단일 토큰 라벨입니다. 기본값은 noul의 경우 Yes/No, 그 외의 경우 A, B, C, …입니다.
  • temperature (dict[str, float], 선택 사항) — 소프트맥스 적용 전 옵션 점수에 적용되는 질문 유형별 온도입니다. 기본값은 1입니다.
  • chat_template (str, 선택 사항) — question(질문당 하나의 프롬프트) 또는 questions(모든 질문에 대한 하나의 프롬프트)를 사용하여 state를 렌더링하는 Jinja 템플릿입니다. 기본값은 토크나이저의 채팅 템플릿에 있는 일반 프롬프트입니다.
  • noul_options (list[str], 선택, 기본값 ["true", "false"]) — noul 질문의 두 옵션을 템플릿이 받는 순서입니다.
  • sanitize_control_tokens (bool, 선택 사항, 기본값 True) — 요청 내 제어 토큰이 텍스트로 인코딩되는지 여부입니다. 자체적으로 이스케이프 처리하는 템플릿은 원래 코드의 입력 ID를 유지하기 위해 이 옵션을 비활성화합니다.
  • adapter (str, 선택 사항) — 루트에 LoRA를 저장하지 않는 저장소의 경우, 파이프라인이 모델에 로드할 LoRA의 서브폴더입니다.

decision.json (그리고 채팅 템플릿은 decision_template.jinja)로 저장되는 의사결정 모델의 설정입니다.

get_logits_processor

< >

( question_type: str )

question_type 유형의 질문의 선택지 점수에 적용되는 LogitsProcessorList.

prepare_inputs

< >

( requestprocessor )

request의 각 프롬프트에 대한 토큰화된 (inputs, questions)입니다. prepare_inputs()를 참조하세요.

validate

< >

( )

인스턴스에서 클래스 검증기를 실행합니다.

FillMaskPipeline

class transformers.FillMaskPipeline

< >

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

매개변수

  • model (PreTrainedModel) — 파이프라인이 예측을 수행하는 데 사용할 모델입니다. PreTrainedModel을 상속하는 모델이어야 합니다.
  • tokenizer (PreTrainedTokenizer) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 토크나이저입니다. 이 객체는 PreTrainedTokenizer를 상속합니다.
  • task (str, 기본값 "") — pipeline의 작업 식별자입니다.
  • num_workers (int, 선택, 기본값 8) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우) 사용할 워커 수입니다.
  • batch_size (int, 선택 사항, 기본값 1) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우)에 사용할 배치 크기입니다. 추론에서는 항상 이롭지 않을 수 있으므로 파이프라인을 사용한 배치 처리를 읽어보십시오.
  • args_parser (ArgumentHandler, 선택 사항) — 공급된 파이프라인 매개변수를 파싱하는 책임을 지는 객체에 대한 참조입니다.
  • device (int 또는 str 또는 torch.device, 선택 사항) — 파이프라인이 할당되는 디바이스입니다. 설정하지 않으면 파이프라인은 첫 번째 사용 가능한 가속기(CUDA, MPS, XPU, …)에 배치되고, 사용 가능한 가속기가 없으면 CPU로 폴백됩니다. 모델은 자동으로 해당 디바이스로 이동합니다. CPU를 강제하려면 device="cpu"(또는 -1)을 전달하고, 특정 가속기를 선택하려면 양의 순번 또는 "cuda:1"을 전달하며, 네이티브 torch.device/str도 사용할 수 있습니다. 이 인수는 accelerate를 통해 이미 로드된 모델(즉, hf_device_map이 있는 모델)과 함께 사용할 수 없습니다.
  • dtype (str 또는 torch.dtype, 선택 사항, 기본값 "auto") — 모델이 로드되는 정밀도로, from_pretrained로 전달됩니다. 기본값은 "auto"이며, 모델이 저장된 dtype로 로드합니다(체크포인트의 config.dtype에서 읽거나, 그렇지 않으면 가중치에서 추론). 명시적으로 torch.float16, torch.bfloat16, torch.float32, ...를 전달하여 이를 재정의할 수 있습니다.
  • binary_output (bool, 선택 사항, 기본값 False) — 파이프라인의 출력이 직렬화 형식(예: pickle)으로 생성되어야 하는지, 아니면 텍스트와 같은 원시 출력 데이터로 생성되어야 하는지를 나타내는 플래그입니다.
  • top_k (int, 선택 사항, 기본값 5) — 반환할 예측의 개수입니다.
  • targets (str 또는 list[str], 선택) — 이 인수가 전달되면, 모델은 전체 vocab을 검색하는 대신 전달된 targets에 한해 점수를 제한합니다. 제공된 targets가 모델의 vocab에 없으면, 해당 targets가 토큰화되고 그 결과 중 첫 번째 토큰이 사용됩니다(경고 메시지와 함께, 이 경우 속도가 느려질 수 있음).
  • tokenizer_kwargs (dict, 선택) — 토크나이저에 함께 전달되는 추가 키워드 인자 사전입니다.

__call__

< >

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

매개변수

  • inputs (str 또는 list[str]) — 마스크된 토큰이 포함된 텍스트 하나 이상(또는 프롬프트 목록 하나).
  • targets (str 또는 list[str], 선택) — 값이 전달되면, 모델은 전체 vocab을 검색하는 대신 전달된 targets로 점수를 제한합니다. 제공된 targets가 모델 vocab에 없으면, 해당 값이 토큰화되고 생성된 첫 번째 토큰이 사용됩니다(경고와 함께, 이 경우 속도가 느려질 수 있음).
  • top_k (int, 선택 사항) — 값이 전달되면 반환할 예측의 개수를 재정의합니다.

반환값

dict의 리스트 또는 dict 리스트의 리스트

각 결과는 다음 키를 가진 사전의 목록으로 제공됩니다:

  • sequence (str) — mask token 예측이 포함된 해당 입력입니다.
  • score (float) — 해당 확률입니다.
  • token (int) — 예측된 토큰 ID(마스크된 토큰을 대체하기 위한 값).
  • token_str (str) — 예측된 토큰(마스크된 토큰을 대체할 토큰).

입력으로 주어진 텍스트의 마스킹된 토큰을 채웁니다.

TableQuestionAnsweringPipeline

class transformers.TableQuestionAnsweringPipeline

< >

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

매개변수

  • model (PreTrainedModel) — 파이프라인이 예측을 수행하는 데 사용할 모델입니다. PreTrainedModel을 상속하는 모델이어야 합니다.
  • tokenizer (PreTrainedTokenizer) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 토크나이저입니다. 이 객체는 PreTrainedTokenizer를 상속합니다.
  • task (str, 기본값 "") — pipeline의 작업 식별자입니다.
  • num_workers (int, 선택, 기본값 8) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우) 사용할 워커 수입니다.
  • batch_size (int, 선택 사항, 기본값 1) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우)에 사용할 배치 크기입니다. 추론에서는 항상 이롭지 않을 수 있으므로 파이프라인을 사용한 배치 처리를 읽어보십시오.
  • args_parser (ArgumentHandler, 선택 사항) — 공급된 파이프라인 매개변수를 파싱하는 책임을 지는 객체에 대한 참조입니다.
  • device (int 또는 str 또는 torch.device, 선택 사항) — 파이프라인이 할당되는 디바이스입니다. 설정하지 않으면 파이프라인은 첫 번째 사용 가능한 가속기(CUDA, MPS, XPU, …)에 배치되고, 사용 가능한 가속기가 없으면 CPU로 폴백됩니다. 모델은 자동으로 해당 디바이스로 이동합니다. CPU를 강제하려면 device="cpu"(또는 -1)을 전달하고, 특정 가속기를 선택하려면 양의 순번 또는 "cuda:1"을 전달하며, 네이티브 torch.device/str도 사용할 수 있습니다. 이 인수는 accelerate를 통해 이미 로드된 모델(즉, hf_device_map이 있는 모델)과 함께 사용할 수 없습니다.
  • dtype (str 또는 torch.dtype, 선택 사항, 기본값 "auto") — 모델이 로드되는 정밀도로, from_pretrained로 전달됩니다. 기본값은 "auto"이며, 모델이 저장된 dtype로 로드합니다(체크포인트의 config.dtype에서 읽거나, 그렇지 않으면 가중치에서 추론). 명시적으로 torch.float16, torch.bfloat16, torch.float32, ...를 전달하여 이를 재정의할 수 있습니다.
  • binary_output (bool, 선택 사항, 기본값 False) — 파이프라인의 출력이 직렬화 형식(예: pickle)으로 생성되어야 하는지, 아니면 텍스트와 같은 원시 출력 데이터로 생성되어야 하는지를 나타내는 플래그입니다.

ModelForTableQuestionAnswering를 사용하는 Table Question Answering 파이프라인입니다. 이 파이프라인은 PyTorch에서만 사용할 수 있습니다.

사용 중인 모델의 설정 파일(generation_config.json)에서 이러한 생성 매개변수를 명시적으로 설정하지 않는 한, 다음 기본값이 사용됩니다:

  • max_new_tokens: 256

예:

>>> from transformers import pipeline

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

pipeline 튜토리얼에서 pipeline 사용의 기본 사항에 대해 자세히 알아보세요.

이 표 기반 질의응답 파이프라인은 현재 pipeline()에서 다음 작업 식별자를 사용하여 로드할 수 있습니다: "table-question-answering".

이 파이프라인에서 사용할 수 있는 모델은 표 형식 질의응답 작업으로 fine-tuning된 모델입니다. 사용 가능한 모델의 최신 목록은 huggingface.co/models에서 확인하세요.

__call__

< >

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

매개변수

  • table (pd.DataFrame 또는 Dict) — 모든 테이블 값을 포함하는 DataFrame으로 변환될 Pandas DataFrame 또는 딕셔너리. 딕셔너리 예제는 위를 참조하세요.
  • query (str 또는 list[str]) — 테이블과 함께 모델에 전송될 쿼리 또는 쿼리 목록입니다.
  • sequential (bool, 선택 사항, 기본값 False) — 추론을 순차적으로 수행할지 배치로 수행할지를 결정합니다. 배치 처리가 더 빠르지만, SQA와 같은 모델은 대화형 특성상 시퀀스 내 관계를 추출하려면 추론을 순차적으로 수행해야 합니다.
  • padding (bool, str 또는 PaddingStrategy, 선택 사항, 기본값은 False) — 패딩을 활성화하고 제어합니다. 다음 값을 받을 수 있습니다: True 또는 'longest': 배치 내 가장 긴 시퀀스 길이로 패딩합니다(단일 시퀀스만 제공된 경우 패딩하지 않음). 'max_length': max_length 인수로 지정된 최대 길이로 패딩하거나, 해당 인수가 제공되지 않은 경우 모델이 허용하는 최대 입력 길이로 패딩합니다. False 또는 'do_not_pad' (기본값): 패딩하지 않음(즉, 서로 다른 길이의 시퀀스로 구성된 배치 출력 가능).
    • True 또는 'longest': 배치 내 가장 긴 시퀀스 길이에 맞게 패딩을 수행합니다(단일 시퀀스만 제공된 경우 패딩을 하지 않음).
    • 'max_length': max_length 인수로 지정된 최대 길이로 패딩하거나, 해당 인수가 제공되지 않으면 모델이 허용하는 최대 입력 길이로 패딩합니다.
    • False 또는 'do_not_pad' (기본값): 패딩을 하지 않습니다(즉, 서로 다른 길이의 시퀀스로 구성된 배치로 출력할 수 있습니다).
  • truncation (bool, str 또는 TapasTruncationStrategy, 선택 사항, 기본값은 False) — 잘림을 활성화하고 제어합니다. 다음 값을 받을 수 있습니다:
    • True 또는 'drop_rows_to_fit': max_length 인수로 지정된 최대 길이로 잘라내거나, 해당 인수가 제공되지 않은 경우 모델이 허용하는 최대 입력 길이로 잘라냅니다. 이 경우 행 단위로 잘라내어 테이블에서 행을 제거합니다.
    • False 또는 'do_not_truncate' (기본값): 잘라내기 없음 (즉, 모델이 허용하는 최대 입력 크기보다 긴 시퀀스 길이를 가진 배치 출력 가능).

반환값

결과를 포함하는 사전 또는 사전 목록

각 결과는 다음 키를 포함하는 사전입니다:

  • answer (str) — 테이블을 기준으로 한 쿼리의 답변입니다. 어그리게이터가 있는 경우, 답변 앞에는 AGGREGATOR >가 붙습니다.
  • coordinates (list[tuple[int, int]]) — 정답 셀의 좌표입니다.
  • cells (list[str]) — 답변 셀 값으로 구성된 문자열 목록.
  • aggregator (str) — 모델에 aggregator가 있는 경우, aggregator를 반환합니다.

테이블에 따라 쿼리에 응답합니다. 이 파이프라인은 아래에 자세히 설명된 여러 유형의 입력을 받습니다:

  • pipeline(table, query)
  • pipeline(table, [query])
  • pipeline(table=table, query=query)
  • pipeline(table=table, query=[query])
  • pipeline({"table": table, "query": query})
  • pipeline({"table": table, "query": [query]})
  • pipeline([{"table": table, "query": query}, {"table": table, "query": query}])

table 인수는 전체 테이블을 포함하는 dict 또는 해당 dict에서 생성된 DataFrame이어야 합니다:

예:

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

이 사전은 그대로 전달하거나 pandas DataFrame으로 변환할 수 있습니다:

예:

import pandas as pd

table = pd.DataFrame.from_dict(data)

TextClassificationPipeline

class transformers.TextClassificationPipeline

< >

( **kwargs )

매개변수

  • model (PreTrainedModel) — 파이프라인이 예측을 수행하는 데 사용할 모델입니다. PreTrainedModel을 상속하는 모델이어야 합니다.
  • tokenizer (PreTrainedTokenizer) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 토크나이저입니다. 이 객체는 PreTrainedTokenizer를 상속합니다.
  • task (str, 기본값 "") — pipeline의 작업 식별자입니다.
  • num_workers (int, 선택, 기본값 8) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우) 사용할 워커 수입니다.
  • batch_size (int, 선택 사항, 기본값 1) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우)에 사용할 배치 크기입니다. 추론에서는 항상 이롭지 않을 수 있으므로 파이프라인을 사용한 배치 처리를 읽어보십시오.
  • args_parser (ArgumentHandler, 선택 사항) — 공급된 파이프라인 매개변수를 파싱하는 책임을 지는 객체에 대한 참조입니다.
  • device (int 또는 str 또는 torch.device, 선택 사항) — 파이프라인이 할당되는 디바이스입니다. 설정하지 않으면 파이프라인은 첫 번째 사용 가능한 가속기(CUDA, MPS, XPU, …)에 배치되고, 사용 가능한 가속기가 없으면 CPU로 폴백됩니다. 모델은 자동으로 해당 디바이스로 이동합니다. CPU를 강제하려면 device="cpu"(또는 -1)을 전달하고, 특정 가속기를 선택하려면 양의 순번 또는 "cuda:1"을 전달하며, 네이티브 torch.device/str도 사용할 수 있습니다. 이 인수는 accelerate를 통해 이미 로드된 모델(즉, hf_device_map이 있는 모델)과 함께 사용할 수 없습니다.
  • dtype (str 또는 torch.dtype, 선택 사항, 기본값 "auto") — 모델이 로드되는 정밀도로, from_pretrained로 전달됩니다. 기본값은 "auto"이며, 모델이 저장된 dtype로 로드합니다(체크포인트의 config.dtype에서 읽거나, 그렇지 않으면 가중치에서 추론). 명시적으로 torch.float16, torch.bfloat16, torch.float32, ...를 전달하여 이를 재정의할 수 있습니다.
  • binary_output (bool, 선택 사항, 기본값 False) — 파이프라인의 출력이 직렬화 형식(예: pickle)으로 생성되어야 하는지, 아니면 텍스트와 같은 원시 출력 데이터로 생성되어야 하는지를 나타내는 플래그입니다.
  • function_to_apply (str, 선택 사항, 기본값은 "default") — 모델 출력에 점수를 가져오기 위해 적용할 함수입니다. 다음 네 가지 값을 허용합니다: "default": 모델이 단일 라벨을 가진 경우 출력에 sigmoid 함수를 적용합니다. 모델이 여러 라벨을 가진 경우 출력에 softmax 함수를 적용합니다. 회귀 작업의 경우 출력에 어떤 함수도 적용하지 않습니다. "sigmoid": 출력에 sigmoid 함수를 적용합니다. "softmax": 출력에 softmax 함수를 적용합니다. "none": 출력에 어떤 함수도 적용하지 않습니다.
    • "default": 모델이 단일 라벨을 가지는 경우 출력에 sigmoid 함수를 적용합니다. 모델이 여러 라벨을 가지는 경우 출력에 softmax 함수를 적용합니다. 회귀 작업의 경우 출력에 어떤 함수도 적용하지 않습니다.
    • "sigmoid": 출력에 sigmoid 함수를 적용합니다.
    • "softmax": 출력에 softmax 함수를 적용합니다.
    • "none": 출력에 어떤 함수도 적용하지 않습니다.

ModelForSequenceClassification을 사용한 텍스트 분류 파이프라인입니다. 자세한 내용은 시퀀스 분류 예제를 참고하세요.

예:

>>> from transformers import pipeline

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

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

pipeline 튜토리얼에서 pipeline 사용의 기본 사항에 대해 자세히 알아보세요.

이 텍스트 분류 파이프라인은 현재 pipeline()에서 다음 작업 식별자를 사용하여 로드할 수 있습니다: "sentiment-analysis" (긍정적이거나 부정적인 감정에 따라 시퀀스를 분류하는 용도).

여러 분류 라벨이 사용 가능한 경우(model.config.num_labels >= 2) 파이프라인은 결과에 softmax를 적용합니다. 라벨이 하나인 경우 파이프라인은 결과에 sigmoid를 적용합니다. 회귀 작업(model.config.problem_type == "regression")의 경우 출력에 어떤 함수도 적용하지 않습니다.

이 파이프라인에서 사용할 수 있는 모델은 시퀀스 분류 작업으로 fine-tuning된 모델입니다. 현재 사용 가능한 모델 목록은 huggingface.co/models에서 확인하세요.

__call__

< >

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

매개변수

  • inputs (str 또는 list[str] 또는 dict[str], 또는 list[dict[str]]) — 분류할 텍스트 하나 이상입니다. 텍스트 쌍을 분류에 사용하려면 {"text", "text_pair"} 키를 포함하는 사전 또는 해당 사전의 리스트를 전달할 수 있습니다.
  • top_k (int, 선택 사항, 기본값 1) — 반환할 결과의 개수입니다.
  • function_to_apply (str, 선택 사항, 기본값은 "default") — 모델 출력에 점수를 추출하기 위해 적용할 함수입니다. 다음 네 가지 값을 허용합니다:

    이 인자가 지정되지 않으면, 레이블 수에 따라 다음 함수가 적용됩니다:

    • problem type이 regression인 경우, 출력에 어떤 함수도 적용하지 않습니다.
    • 모델에 단일 라벨이 있는 경우, 출력에 sigmoid 함수를 적용합니다.
    • 모델에 여러 라벨이 있는 경우, 출력에 softmax 함수를 적용합니다.

    가능한 값은 다음과 같습니다:

    • "sigmoid": 출력에 sigmoid 함수를 적용합니다.
    • "softmax": 출력에 softmax 함수를 적용합니다.
    • "none": 출력에 어떤 함수도 적용하지 않습니다.

반환값

dict의 목록

각 결과는 다음 키를 가진 사전의 목록으로 제공됩니다:

  • label (str) — 예측된 라벨.
  • score (float) — 해당 확률입니다.

top_k가 사용되면, 각 레이블별로 해당 사전이 하나씩 반환됩니다.

입력으로 주어진 텍스트를 분류합니다.

TextGenerationPipeline

클래스 transformers.TextGenerationPipeline

< >

( *args**kwargs )

매개변수

  • model (PreTrainedModel) — 파이프라인이 예측을 수행하는 데 사용할 모델입니다. PreTrainedModel을 상속하는 모델이어야 합니다.
  • tokenizer (PreTrainedTokenizer) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 토크나이저입니다. 이 객체는 PreTrainedTokenizer를 상속합니다.
  • task (str, 기본값 "") — pipeline의 작업 식별자입니다.
  • num_workers (int, 선택, 기본값 8) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우) 사용할 워커 수입니다.
  • batch_size (int, 선택 사항, 기본값 1) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우)에 사용할 배치 크기입니다. 추론에서는 항상 이롭지 않을 수 있으므로 파이프라인을 사용한 배치 처리를 읽어보십시오.
  • args_parser (ArgumentHandler, 선택 사항) — 공급된 파이프라인 매개변수를 파싱하는 책임을 지는 객체에 대한 참조입니다.
  • device (int 또는 str 또는 torch.device, 선택 사항) — 파이프라인이 할당되는 디바이스입니다. 설정하지 않으면 파이프라인은 첫 번째 사용 가능한 가속기(CUDA, MPS, XPU, …)에 배치되고, 사용 가능한 가속기가 없으면 CPU로 폴백됩니다. 모델은 자동으로 해당 디바이스로 이동합니다. CPU를 강제하려면 device="cpu"(또는 -1)을 전달하고, 특정 가속기를 선택하려면 양의 순번 또는 "cuda:1"을 전달하며, 네이티브 torch.device/str도 사용할 수 있습니다. 이 인수는 accelerate를 통해 이미 로드된 모델(즉, hf_device_map이 있는 모델)과 함께 사용할 수 없습니다.
  • dtype (str 또는 torch.dtype, 선택 사항, 기본값 "auto") — 모델이 로드되는 정밀도로, from_pretrained로 전달됩니다. 기본값은 "auto"이며, 모델이 저장된 dtype로 로드합니다(체크포인트의 config.dtype에서 읽거나, 그렇지 않으면 가중치에서 추론). 명시적으로 torch.float16, torch.bfloat16, torch.float32, ...를 전달하여 이를 재정의할 수 있습니다.
  • binary_output (bool, 선택 사항, 기본값 False) — 파이프라인의 출력이 직렬화 형식(예: pickle)으로 생성되어야 하는지, 아니면 텍스트와 같은 원시 출력 데이터로 생성되어야 하는지를 나타내는 플래그입니다.

ModelWithLMHead 또는 ModelForCausalLM을 사용하여 언어 생성을 수행하는 파이프라인입니다. 이 파이프라인은 지정된 텍스트 프롬프트 뒤에 이어질 단어를 예측합니다. 기반 모델이 대화형 모델인 경우, 하나 이상의 채팅을 입력으로 받을 수 있으며, 이 경우 파이프라인은 채팅 모드로 동작하여 자신의 응답을 추가해 채팅을 계속합니다. 각 채팅은 딕셔너리의 리스트 형태로 구성되며, 각 딕셔너리에는 “role”과 “content” 키가 포함됩니다.

사용 중인 모델의 설정 파일(generation_config.json)에서 이러한 생성 매개변수를 명시적으로 설정하지 않는 한, 다음 기본값이 사용됩니다:

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

예:

>>> from transformers import pipeline

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

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

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

pipeline 튜토리얼에서 파이프라인 사용의 기본 사항에 대해 자세히 알아보세요. 이 파이프라인에 텍스트 생성 매개변수를 전달하여 중단 기준, 디코딩 전략 등을 제어할 수 있습니다. 텍스트 생성 매개변수에 대해서는 Text generation strategies와 Text generation에서 자세히 알아보세요.

이 언어 생성 파이프라인은 현재 pipeline()에서 다음 작업 식별자를 사용하여 로드할 수 있습니다: "text-generation".

이 파이프라인에서 사용할 수 있는 모델은 자기회귀 언어 모델링(autoregressive language modeling) 목적함수로 학습된 모델입니다. [huggingface.co/models]에서 사용 가능한 텍스트 완성 모델 목록과 대화형 모델 목록을 확인하세요.

__call__

< >

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

매개변수

  • text_inputs (str, list[str], ChatType, 또는 list[ChatType]) — 완성할 하나 이상의 프롬프트(또는 프롬프트 목록 하나)입니다. 문자열 또는 문자열 목록이 전달되면, 이 파이프라인은 각 프롬프트를 계속 완성합니다. 대신, “role”과 “content” 키를 가진 dict 목록 형태의 “chat”을 전달할 수 있으며, 이러한 chat의 목록도 전달할 수 있습니다. chat이 전달되면, 모델의 chat template이 모델에 전달되기 전에 포맷팅에 사용됩니다.
  • return_tensors (bool, 선택 사항, 기본값 False) — 출력에서 예측 텐서(토큰 인덱스 형태)를 반환합니다. True로 설정하면 디코딩된 텍스트는 반환되지 않습니다.
  • return_text (bool, 선택 사항) — 출력에서 디코딩된 텍스트를 반환합니다.
  • return_full_text (bool, 선택 사항, 기본값 True) — False로 설정하면 추가된 텍스트만 반환되고, 그렇지 않으면 전체 텍스트가 반환됩니다. return_text와 동시에 지정할 수 없습니다.
  • clean_up_tokenization_spaces (bool, 선택) — 텍스트 출력에 포함된 잠재적인 추가 공백을 정리할지 여부입니다. 기본값은 토크나이저의 clean_up_tokenization_spaces 설정입니다.
  • continue_final_message( bool, optional) — 입력 채팅의 마지막 메시지를 새로운 메시지로 시작하는 대신 계속하도록 모델을 설정할지 여부를 나타냅니다. 이를 통해 응답을 “prefill”할 수 있습니다. 기본적으로 입력 채팅의 마지막 메시지가 assistant 역할을 가지는 경우 True, 그렇지 않은 경우 False로 설정되지만, 이 플래그를 설정하여 해당 동작을 수동으로 오버라이드할 수 있습니다.
  • prefix (str, 선택 사항) — 프롬프트에 추가되는 접두사.
  • stop_sequence (str 또는 list[str], 선택 사항) — 생성된 텍스트에 포함되면 생성을 중단하는 하나 이상의 문자열입니다. 중단 문자열은 출력에 포함됩니다.
  • handle_long_generation (str, 선택 사항) — 기본적으로 이 파이프라인은 긴 생성(모델 최대 길이를 어떤 형태로든 초과하는 생성)을 처리하지 않습니다. 이를 해결하는 완벽한 방법은 없으며(자세한 정보:https://github.com/huggingface/transformers/issues/14033#issuecomment-948385227). ). 사용 사례에 따라 이 문제를 우회하기 위한 일반적인 전략을 제공합니다.
    • None : 특별한 동작이 없는 기본 전략
    • "hole": 입력의 왼쪽을 잘라내고, 생성이 일어날 수 있을 만큼의 간격을 남깁니다(프롬프트의 상당 부분이 잘려 나갈 수 있으며, 생성이 모델 용량을 초과하는 경우 적합하지 않을 수 있음)
  • tokenizer_encode_kwargs (dict, 선택) — 토크나이저의 인코딩 단계에 전달할 추가 키워드 인자입니다. 텍스트 입력이 채팅인 경우 apply_chat_template에, 그렇지 않은 경우 __call__에 전달됩니다.
  • generate_kwargs (dict, 선택) — 모델의 generate 메서드에 전달할 추가 키워드 인자( 여기의 generate 메서드 참조).

반환값

dict의 목록 또는 dict 목록의 목록

다음 중 하나의 딕셔너리를 반환합니다(generated_text와 generated_token_ids를 함께 반환할 수 없음):

  • generated_text (str, return_text=True인 경우 존재) — 생성된 텍스트.
  • generated_token_ids (torch.Tensor, return_tensors=True일 때 존재) — 생성된 텍스트의 토큰 ID입니다.

입력으로 주어진 프롬프트를 완성합니다.

TokenClassificationPipeline

클래스 transformers.TokenClassificationPipeline

< >

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

매개변수

  • model (PreTrainedModel) — 파이프라인이 예측을 수행하는 데 사용할 모델입니다. PreTrainedModel을 상속하는 모델이어야 합니다.
  • tokenizer (PreTrainedTokenizer) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 토크나이저입니다. 이 객체는 PreTrainedTokenizer를 상속합니다.
  • task (str, 기본값 "") — pipeline의 작업 식별자입니다.
  • num_workers (int, 선택, 기본값 8) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우) 사용할 워커 수입니다.
  • batch_size (int, 선택 사항, 기본값 1) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우)에 사용할 배치 크기입니다. 추론에서는 항상 이롭지 않을 수 있으므로 파이프라인을 사용한 배치 처리를 읽어보십시오.
  • args_parser (ArgumentHandler, 선택 사항) — 공급된 파이프라인 매개변수를 파싱하는 책임을 지는 객체에 대한 참조입니다.
  • device (int 또는 str 또는 torch.device, 선택 사항) — 파이프라인이 할당되는 디바이스입니다. 설정하지 않으면 파이프라인은 첫 번째 사용 가능한 가속기(CUDA, MPS, XPU, …)에 배치되고, 사용 가능한 가속기가 없으면 CPU로 폴백됩니다. 모델은 자동으로 해당 디바이스로 이동합니다. CPU를 강제하려면 device="cpu"(또는 -1)을 전달하고, 특정 가속기를 선택하려면 양의 순번 또는 "cuda:1"을 전달하며, 네이티브 torch.device/str도 사용할 수 있습니다. 이 인수는 accelerate를 통해 이미 로드된 모델(즉, hf_device_map이 있는 모델)과 함께 사용할 수 없습니다.
  • dtype (str 또는 torch.dtype, 선택 사항, 기본값 "auto") — 모델이 로드되는 정밀도로, from_pretrained로 전달됩니다. 기본값은 "auto"이며, 모델이 저장된 dtype로 로드합니다(체크포인트의 config.dtype에서 읽거나, 그렇지 않으면 가중치에서 추론). 명시적으로 torch.float16, torch.bfloat16, torch.float32, ...를 전달하여 이를 재정의할 수 있습니다.
  • binary_output (bool, 선택 사항, 기본값 False) — 파이프라인의 출력이 직렬화 형식(예: pickle)으로 생성되어야 하는지, 아니면 텍스트와 같은 원시 출력 데이터로 생성되어야 하는지를 나타내는 플래그입니다.
  • ignore_labels (list[str], 기본값 ["O"]) — 무시할 라벨 목록입니다.
  • stride (int, 선택 사항) — stride가 지정된 경우, 파이프라인은 전체 텍스트에 적용됩니다. 텍스트는 model_max_length 크기의 청크로 나뉩니다. fast tokenizer와 aggregation_strategy가 NONE가 아닌 경우에만 작동합니다. 이 인수의 값은 청크 사이의 중복 토큰 수를 정의합니다. 즉, 모델은 각 단계마다 tokenizer.model_max_length - stride 토큰만큼 앞으로 이동합니다.
  • aggregation_strategy (str, 선택 사항, 기본값은 "none") — 모델 예측을 기반으로 토큰을 병합(또는 병합하지 않을) 전략입니다. “none”: 어떤 집계도 수행하지 않고 모델의 원시 결과를 그대로 반환합니다. “simple”: 기본 스키마에 따라 엔티티를 그룹화하려고 시도합니다. (A, B-TAG), (B, I-TAG), (C, I-TAG), (D, B-TAG2) (E, B-TAG2)는 [{“word”: ABC, “entity”: “TAG”}, {“word”: “D”, “entity”: “TAG2”}, {“word”: “E”, “entity”: “TAG2”}]로 처리됩니다. 연속된 두 개의 B 태그는 서로 다른 엔티티로 처리됩니다. 단어 기반 언어에서는 원치 않는 방식으로 단어가 분리될 수 있습니다: Microsoft가 [{“word”: “Micro”, “entity”: “ENTERPRISE”}, {“word”: “soft”, “entity”: “NAME”}]로 태그되는 경우를 상상해 보세요. FIRST, MAX, AVERAGE를 찾아 이러한 문제를 완화하고 단어를 명확히 구분하는 방법을 확인하세요 (공백으로 구분되는 토큰을 지원하는 언어, 즉 기본적으로 단어 기반 언어에 해당). 이러한 완화 조치는 실제 단어에만 적용되며, “New york”은 여전히 두 개의 서로 다른 엔티티로 태그될 수 있습니다. “first”: (단어 기반 모델에서만 작동) SIMPLE 전략을 사용하지만, 단어는 서로 다른 태그를 가질 수 없습니다. 모호한 경우 단어는 단순히 해당 단어의 첫 번째 토큰 태그를 사용합니다. “average”: (단어 기반 모델에서만 작동) SIMPLE 전략을 사용하지만, 단어는 서로 다른 태그를 가질 수 없습니다. 점수는 먼저 토큰 간에 평균을 낸 후, 최대 라벨이 적용됩니다. “max”: (단어 기반 모델에서만 작동) SIMPLE 전략을 사용하지만, 단어는 서로 다른 태그를 가질 수 없습니다. 단어 엔티티는 단순히 최대 점수를 가진 토큰입니다.
    • “none”: 어떤 집계도 수행하지 않고 모델의 원시 결과를 그대로 반환합니다
    • “simple”: 기본 스키마를 따르도록 엔티티를 그룹화하려고 시도합니다. (A, B-TAG), (B, I-TAG), (C, I-TAG), (D, B-TAG2) (E, B-TAG2)는 [{“word”: ABC, “entity”: “TAG”}, {“word”: “D”, “entity”: “TAG2”}, {“word”: “E”, “entity”: “TAG2”}]로 그룹화됩니다. 연속된 두 개의 B 태그는 서로 다른 엔티티로 처리된다는 점에 유의하세요. 단어 기반 언어에서는 원치 않는 방식으로 단어가 분리될 수 있습니다: Microsoft가 [{“word”: “Micro”, “entity”: “ENTERPRISE”}, {“word”: “soft”, “entity”: “NAME”}]로 태그되는 경우를 상상해 보세요. 이를 완화하고 단어를 명확히 구분하기(이 의미가 지원되는 언어, 즉 기본적으로 공백으로 구분된 토큰)에는 FIRST, MAX, AVERAGE를 찾아보세요. 이러한 완화 조치는 실제 단어에만 적용되며, “New york”은 여전히 두 개의 서로 다른 엔티티로 태그될 수 있습니다.
    • “first” : (단어 기반 모델에서만 작동) SIMPLE 전략을 사용하지만, 하나의 단어에 서로 다른 태그가 부여되지 않도록 합니다. 모호한 경우, 해당 단어의 첫 번째 토큰의 태그를 그대로 사용합니다.
    • “average”: (단어 기반 모델에서만 작동) SIMPLE 전략을 사용하지만, 단어는 서로 다른 태그를 가질 수 없습니다. 점수는 먼저 토큰 간에 평균을 낸 후, 최대 라벨이 적용됩니다.
    • “max”: (단어 기반 모델에서만 작동) SIMPLE 전략을 사용하지만, 단어는 서로 다른 태그로 끝나지 않습니다. 단어 엔티티는 단순히 점수가 가장 높은 토큰이 됩니다.

ModelForTokenClassification을 사용하여 Named Entity Recognition 파이프라인을 구성합니다. 자세한 내용은 named entity recognition 예제를 참고하세요.

예:

>>> from transformers import pipeline

>>> token_classifier = pipeline(model="Jean-Baptiste/camembert-ner", aggregation_strategy="simple")
>>> sentence = "Je m'appelle jean-baptiste et je vis à montréal"
>>> tokens = token_classifier(sentence)
>>> tokens
[{'entity_group': 'PER', 'score': 0.9931, 'word': 'jean-baptiste', 'start': 12, 'end': 26}, {'entity_group': 'LOC', 'score': 0.998, 'word': 'montréal', 'start': 38, 'end': 47}]

>>> token = tokens[0]
>>> # Start and end provide an easy way to highlight words in the original text.
>>> sentence[token["start"] : token["end"]]
' jean-baptiste'

>>> # Some models use the same idea to do part of speech.
>>> syntaxer = pipeline(model="vblagoje/bert-english-uncased-finetuned-pos", aggregation_strategy="simple")
>>> syntaxer("My name is Sarah and I live in London")
[{'entity_group': 'PRON', 'score': 0.999, 'word': 'my', 'start': 0, 'end': 2}, {'entity_group': 'NOUN', 'score': 0.997, 'word': 'name', 'start': 3, 'end': 7}, {'entity_group': 'AUX', 'score': 0.994, 'word': 'is', 'start': 8, 'end': 10}, {'entity_group': 'PROPN', 'score': 0.999, 'word': 'sarah', 'start': 11, 'end': 16}, {'entity_group': 'CCONJ', 'score': 0.999, 'word': 'and', 'start': 17, 'end': 20}, {'entity_group': 'PRON', 'score': 0.999, 'word': 'i', 'start': 21, 'end': 22}, {'entity_group': 'VERB', 'score': 0.998, 'word': 'live', 'start': 23, 'end': 27}, {'entity_group': 'ADP', 'score': 0.999, 'word': 'in', 'start': 28, 'end': 30}, {'entity_group': 'PROPN', 'score': 0.999, 'word': 'london', 'start': 31, 'end': 37}]

pipeline 튜토리얼에서 pipeline 사용의 기본 사항에 대해 자세히 알아보세요.

이 토큰 인식 파이프라인은 현재 pipeline()에서 다음 작업 식별자를 사용하여 로드할 수 있습니다: "ner" (시퀀스 내 토큰의 클래스를 예측하는 데 사용: 인물, 조직, 위치 또는 기타).

이 파이프라인에서 사용할 수 있는 모델은 토큰 분류 작업으로 fine-tuning된 모델입니다. 현재 사용 가능한 모델 목록은 huggingface.co/models에서 확인하세요.

__call__

< >

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

매개변수

  • inputs (str 또는 List[str]) — 토큰 분류를 위한 하나 이상의 텍스트(또는 텍스트 목록 하나). is_split_into_words=True인 경우 사전 토큰화된 형태로 전달할 수 있습니다.

반환값

dict의 리스트 또는 dict 리스트의 리스트

각 결과는 목록의 사전으로 제공됩니다(해당 입력의 각 토큰에 하나씩, 또는 이 파이프라인이 aggregation_strategy로 인스턴스화된 경우 각 엔티티에 하나씩)이며, 다음 키를 포함합니다:

  • word (str) — 분류된 토큰/단어입니다. 이는 선택된 토큰을 디코딩하여 얻습니다. 원문에서 정확한 문자열을 얻으려면 start와 end를 사용하세요.
  • score (float) — entity에 해당하는 확률입니다.
  • entity (str) — 해당 토큰/단어에 대해 예측된 엔티티입니다. aggregation_strategy가 "none"이(가) 아닌 경우 entity_group로 명명됩니다.
  • index (int, aggregation_strategy="none"일 때만 존재) — 해당 문장에서 대응하는 토큰의 인덱스입니다.
  • start (int, 선택 사항) — 해당 엔티티가 문장에서 시작되는 인덱스입니다. 토크나이저 내에서 오프셋이 사용 가능한 경우에만 존재합니다.
  • end (int, 선택 사항) — 해당 엔티티가 문장에서 끝나는 인덱스입니다. 토크나이저 내에서 오프셋이 사용 가능한 경우에만 존재합니다.

입력으로 주어진 텍스트의 각 토큰을 분류합니다.

aggregate_words

< >

( entities: list[dict]aggregation_strategy: AggregationStrategy )

단어 경계에서 일치하지 않는 주어진 단어의 토큰을 오버라이드하여 단어 경계에 대한 일치를 강제합니다.

예: micro|soft| com|pany| B-ENT I-NAME I-ENT I-ENT는 첫 번째 전략에 따라 microsoft| company| B-ENT I-ENT로 다시 작성됩니다.

gather_pre_entities

< >

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

여러 numpy 배열을 집계하는 데 필요한 모든 정보를 포함하는 dict로 병합합니다

group_entities

< >

( entities: list[dict] )

매개변수

  • entities (dict) — 파이프라인이 예측한 엔티티입니다.

같은 엔티티로 예측된 인접 토큰을 찾아 그룹화합니다.

group_sub_entities

< >

( entities: list[dict] )

매개변수

  • entities (dict) — 파이프라인이 예측한 엔티티입니다.

같은 엔티티가 예측된 인접 토큰을 그룹화합니다.

ZeroShotClassificationPipeline

class transformers.ZeroShotClassificationPipeline

< >

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

매개변수

  • model (PreTrainedModel) — 파이프라인이 예측을 수행하는 데 사용할 모델입니다. PreTrainedModel을 상속하는 모델이어야 합니다.
  • tokenizer (PreTrainedTokenizer) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 토크나이저입니다. 이 객체는 PreTrainedTokenizer를 상속합니다.
  • task (str, 기본값 "") — pipeline의 작업 식별자입니다.
  • num_workers (int, 선택, 기본값 8) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우) 사용할 워커 수입니다.
  • batch_size (int, 선택 사항, 기본값 1) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우)에 사용할 배치 크기입니다. 추론에서는 항상 이롭지 않을 수 있으므로 파이프라인을 사용한 배치 처리를 읽어보십시오.
  • args_parser (ArgumentHandler, 선택 사항) — 공급된 파이프라인 매개변수를 파싱하는 책임을 지는 객체에 대한 참조입니다.
  • device (int 또는 str 또는 torch.device, 선택 사항) — 파이프라인이 할당되는 디바이스입니다. 설정하지 않으면 파이프라인은 첫 번째 사용 가능한 가속기(CUDA, MPS, XPU, …)에 배치되고, 사용 가능한 가속기가 없으면 CPU로 폴백됩니다. 모델은 자동으로 해당 디바이스로 이동합니다. CPU를 강제하려면 device="cpu"(또는 -1)을 전달하고, 특정 가속기를 선택하려면 양의 순번 또는 "cuda:1"을 전달하며, 네이티브 torch.device/str도 사용할 수 있습니다. 이 인수는 accelerate를 통해 이미 로드된 모델(즉, hf_device_map이 있는 모델)과 함께 사용할 수 없습니다.
  • dtype (str 또는 torch.dtype, 선택 사항, 기본값 "auto") — 모델이 로드되는 정밀도로, from_pretrained로 전달됩니다. 기본값은 "auto"이며, 모델이 저장된 dtype로 로드합니다(체크포인트의 config.dtype에서 읽거나, 그렇지 않으면 가중치에서 추론). 명시적으로 torch.float16, torch.bfloat16, torch.float32, ...를 전달하여 이를 재정의할 수 있습니다.
  • binary_output (bool, 선택 사항, 기본값 False) — 파이프라인의 출력이 직렬화 형식(예: pickle)으로 생성되어야 하는지, 아니면 텍스트와 같은 원시 출력 데이터로 생성되어야 하는지를 나타내는 플래그입니다.

NLI(자연어 추론) 작업으로 학습된 ModelForSequenceClassification를 사용하는 NLI 기반 zero-shot 분류 파이프라인입니다. text-classification 파이프라인과 동등하지만, 이 모델들은 하드코딩된 잠재 클래스 수가 필요 없으며 런타임에 클래스를 선택할 수 있습니다. 일반적으로 속도는 느려지지만 훨씬 더 유연합니다.

시퀀스와 라벨의 어떤 조합이든 전달할 수 있으며, 각 조합은 전제/가설(premise/hypothesis) 쌍으로 구성되어 사전 학습된 모델에 전달됩니다. 그런 다음, entailment에 대한 logit을 해당 후보 라벨이 유효하다는 logit으로 사용합니다. 어떤 NLI 모델도 사용할 수 있지만, 모델 config의 :attr:~transformers.PreTrainedConfig.label2id에 entailment 라벨의 id가 포함되어 있어야 합니다.

예:

>>> from transformers import pipeline

>>> oracle = pipeline(model="facebook/bart-large-mnli")
>>> oracle(
...     "I have a problem with my iphone that needs to be resolved asap!!",
...     candidate_labels=["urgent", "not urgent", "phone", "tablet", "computer"],
... )
{'sequence': 'I have a problem with my iphone that needs to be resolved asap!!', 'labels': ['urgent', 'phone', 'computer', 'not urgent', 'tablet'], 'scores': [0.504, 0.479, 0.013, 0.003, 0.002]}

>>> oracle(
...     "I have a problem with my iphone that needs to be resolved asap!!",
...     candidate_labels=["english", "german"],
... )
{'sequence': 'I have a problem with my iphone that needs to be resolved asap!!', 'labels': ['english', 'german'], 'scores': [0.814, 0.186]}

pipeline 튜토리얼에서 pipeline 사용의 기본 사항에 대해 자세히 알아보세요.

이 NLI 파이프라인은 현재 pipeline()에서 다음 작업 식별자를 사용하여 로드할 수 있습니다: "zero-shot-classification".

이 파이프라인에서 사용할 수 있는 모델은 NLI 작업으로 fine-tuning된 모델입니다. 현재 사용 가능한 모델 목록은 huggingface.co/models에서 확인하세요.

__call__

< >

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

매개변수

  • sequences (str 또는 list[str]) — 분류할 시퀀스로, 모델 입력이 너무 크면 잘립니다.
  • candidate_labels (str 또는 list[str]) — 각 시퀀스를 분류할 수 있는 클래스 라벨의 집합입니다. 단일 라벨, 쉼표로 구분된 라벨 문자열, 또는 라벨 목록일 수 있습니다.
  • hypothesis_template (str, 선택 사항, 기본값 "This example is {}.") — 각 라벨을 NLI 스타일의 가설로 변환하는 데 사용되는 템플릿입니다. 이 템플릿에는 후보 라벨이 삽입될 위치를 나타내는 {} 또는 유사한 구문을 포함해야 합니다. 예를 들어, 기본 템플릿은 "This example is {}."입니다. 후보 라벨이 "sports"인 경우, 모델에는 "<cls> sequence to classify <sep> This example is sports . <sep>"과 같이 입력됩니다. 기본 템플릿은 많은 경우에 잘 작동하지만, 작업 설정에 따라 다른 템플릿을 실험해 보는 것이 가치가 있을 수 있습니다.
  • multi_label (bool, 선택 사항, 기본값 False) — 여러 후보 라벨이 동시에 참일 수 있는지 여부입니다. False인 경우, 각 시퀀스에 대해 라벨 가능성의 합이 1이 되도록 점수가 정규화됩니다. True인 경우, 라벨은 독립적으로 간주되며, 각 후보에 대해 수반(entailment) 점수와 모순(contradiction) 점수에 대한 softmax를 수행하여 확률을 정규화합니다.

반환값

dict 또는 dict의 리스트

각 결과는 다음 키를 포함하는 사전으로 반환됩니다:

  • sequence (str) — 이 출력이 해당하는 시퀀스.
  • labels (list[str]) — 가능성 순서로 정렬된 라벨.
  • scores (list[float]) — 각 라벨에 대한 확률.

입력으로 주어진 시퀀스를 분류합니다. 자세한 내용은 ZeroShotClassificationPipeline 문서를 참고하세요.

멀티모달

멀티모달 작업에 사용할 수 있는 파이프라인은 다음과 같습니다.

DocumentQuestionAnsweringPipeline

class transformers.DocumentQuestionAnsweringPipeline

< >

( *args**kwargs )

매개변수

  • model (PreTrainedModel) — 파이프라인이 예측을 수행하는 데 사용할 모델입니다. PreTrainedModel을 상속하는 모델이어야 합니다.
  • tokenizer (PreTrainedTokenizer) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 토크나이저입니다. 이 객체는 PreTrainedTokenizer를 상속합니다.
  • image_processor (BaseImageProcessor) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 이미지 프로세서입니다. 이 객체는 BaseImageProcessor를 상속합니다.
  • task (str, 기본값 "") — pipeline의 작업 식별자입니다.
  • num_workers (int, 선택, 기본값 8) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우) 사용할 워커 수입니다.
  • batch_size (int, 선택 사항, 기본값 1) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우)에 사용할 배치 크기입니다. 추론에서는 항상 이롭지 않을 수 있으므로 파이프라인을 사용한 배치 처리를 읽어보십시오.
  • args_parser (ArgumentHandler, 선택 사항) — 공급된 파이프라인 매개변수를 파싱하는 책임을 지는 객체에 대한 참조입니다.
  • device (int 또는 str 또는 torch.device, 선택 사항) — 파이프라인이 할당되는 디바이스입니다. 설정하지 않으면 파이프라인은 첫 번째 사용 가능한 가속기(CUDA, MPS, XPU, …)에 배치되고, 사용 가능한 가속기가 없으면 CPU로 폴백됩니다. 모델은 자동으로 해당 디바이스로 이동합니다. CPU를 강제하려면 device="cpu"(또는 -1)을 전달하고, 특정 가속기를 선택하려면 양의 순번 또는 "cuda:1"을 전달하며, 네이티브 torch.device/str도 사용할 수 있습니다. 이 인수는 accelerate를 통해 이미 로드된 모델(즉, hf_device_map이 있는 모델)과 함께 사용할 수 없습니다.
  • dtype (str 또는 torch.dtype, 선택 사항, 기본값 "auto") — 모델이 로드되는 정밀도로, from_pretrained로 전달됩니다. 기본값은 "auto"이며, 모델이 저장된 dtype로 로드합니다(체크포인트의 config.dtype에서 읽거나, 그렇지 않으면 가중치에서 추론). 명시적으로 torch.float16, torch.bfloat16, torch.float32, ...를 전달하여 이를 재정의할 수 있습니다.
  • binary_output (bool, 선택 사항, 기본값 False) — 파이프라인의 출력이 직렬화 형식(예: pickle)으로 생성되어야 하는지, 아니면 텍스트와 같은 원시 출력 데이터로 생성되어야 하는지를 나타내는 플래그입니다.

AutoModelForDocumentQuestionAnswering을 사용하여 Document Question Answering 파이프라인을 실행합니다. 입력/출력은 (추출형) question answering 파이프라인과 유사하지만, 텍스트 컨텍스트 대신 이미지(및 선택 사항인 OCR 처리된 단어/박스)를 입력으로 받습니다.

사용 중인 모델의 설정 파일(generation_config.json)에서 이러한 생성 매개변수를 명시적으로 설정하지 않는 한, 다음 기본값이 사용됩니다:

  • max_new_tokens: 256

예:

>>> from transformers import pipeline

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

pipeline 튜토리얼에서 pipeline 사용의 기본 사항에 대해 자세히 알아보세요.

이 문서 질의응답 파이프라인은 현재 pipeline()에서 다음 작업 식별자를 사용하여 로드할 수 있습니다: "document-question-answering".

이 파이프라인에서 사용할 수 있는 모델은 문서 질의응답 작업으로 fine-tuning된 모델입니다. 사용 가능한 모델의 최신 목록은 huggingface.co/models에서 확인하세요.

__call__

< >

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

매개변수

  • image (str 또는 PIL.Image) — 파이프라인은 다음 세 가지 유형의 이미지를 처리합니다:
    • 이미지를 가리키는 http 링크가 포함된 문자열
    • 이미지의 로컬 경로를 포함하는 문자열
    • PIL에 직접 로드된 이미지

    pipeline은 단일 이미지 또는 이미지 배치(batch)를 모두 받을 수 있습니다. 단일 이미지가 주어지면, 여러 질문으로 브로드캐스트할 수 있습니다.

  • question (str) — 문서에 대해 질문할 내용.
  • word_boxes (list[str, tuple[float, float, float, float]], 선택) — 단어와 바운딩 박스(0->1000으로 정규화된 값)의 목록입니다. 이 선택 입력을 제공하면, 해당 모델(예: LayoutLM)에 필요한 경우 이미지에서 OCR을 실행하여 값을 유도하는 대신 이 단어와 박스를 사용합니다. 이를 통해 매번 파이프라인을 다시 실행하지 않고도 여러 파이프라인 호출에 걸쳐 OCR 결과를 재사용할 수 있습니다.
  • top_k (int, 선택 사항, 기본값 1) — 반환할 답변의 개수입니다(가능성 순서대로 선택됩니다). 컨텍스트 내에서 사용할 수 있는 옵션이 충분하지 않으면 top_k보다 적은 답변이 반환됩니다.
  • doc_stride (int, 선택 사항, 기본값 128) — 문서의 단어가 모델의 질문과 함께 들어갈 수 없을 정도로 길면, 일부 중복을 포함하여 여러 청크로 나뉩니다. 이 인수는 해당 중복 크기를 제어합니다.
  • max_answer_len (int, 선택, 기본값 15) — 예측된 답변의 최대 길이입니다(예: 이 길이보다 짧은 답변만 고려됩니다).
  • max_seq_len (int, 선택 사항, 기본값 384) — 모델에 전달되는 각 chunk의 문장 전체(컨텍스트 + 질문)의 최대 토큰 길이입니다. 필요에 따라 컨텍스트는 여러 chunk로 나뉘며(중첩으로 doc_stride 사용) 처리됩니다.
  • max_question_len (int, 선택 사항, 기본값 64) — 토큰화 이후 질문의 최대 길이입니다. 필요할 경우 잘립니다.
  • handle_impossible_answer (bool, 선택 사항, 기본값 False) — impossible을 답변으로 허용할지 여부입니다.
  • lang (str, 선택 사항) — OCR 실행 시 사용할 언어입니다. 기본값은 영어입니다.
  • tesseract_config (str, 선택) — OCR 실행 시 tesseract에 전달할 추가 플래그.
  • timeout (float, 선택, 기본값 None) — 웹에서 이미지를 가져오는 데 대기할 최대 시간(초). None인 경우 타임아웃이 설정되지 않으며, 호출이 영원히 차단될 수 있습니다.

반환값

dict 또는 dict의 리스트

각 결과는 다음 키를 포함하는 사전으로 반환됩니다:

  • score (float) — 답변에 연결된 확률입니다.
  • start (int) — 답변의 시작 단어 인덱스(입력의 OCR 버전 또는 제공된 word_boxes 기준).
  • end (int) — 답변의 마지막 단어 인덱스 (입력의 OCR 버전 또는 제공된 word_boxes 기준).
  • answer (str) — 질문에 대한 답변.
  • words (list[int]) — 정답에 포함된 각 단어/박스 쌍의 인덱스

입력으로 주어진 질문에 주어진 문서를 활용하여 답변합니다. 문서는 이미지와 문서 내 텍스트를 나타내는 선택적 (word, box) 튜플 목록으로 정의됩니다. word_boxes가 제공되지 않으면, 이를 입력으로 요구하는 LayoutLM 계열 모델을 위해 Tesseract OCR 엔진(사용 가능한 경우)을 사용하여 단어와 박스를 자동으로 추출합니다. Donut의 경우 OCR이 실행되지 않습니다.

pipeline를 여러 가지 방법으로 호출할 수 있습니다:

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

FeatureExtractionPipeline

class transformers.FeatureExtractionPipeline

< >

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

매개변수

  • model (PreTrainedModel) — 파이프라인이 예측을 수행하는 데 사용할 모델입니다. PreTrainedModel을 상속하는 모델이어야 합니다.
  • tokenizer (PreTrainedTokenizer) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 토크나이저입니다. 이 객체는 PreTrainedTokenizer를 상속합니다.
  • task (str, 기본값 "") — pipeline의 작업 식별자입니다.
  • num_workers (int, 선택, 기본값 8) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우) 사용할 워커 수입니다.
  • batch_size (int, 선택 사항, 기본값 1) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우)에 사용할 배치 크기입니다. 추론에서는 항상 이롭지 않을 수 있으므로 파이프라인을 사용한 배치 처리를 읽어보십시오.
  • args_parser (ArgumentHandler, 선택 사항) — 공급된 파이프라인 매개변수를 파싱하는 책임을 지는 객체에 대한 참조입니다.
  • device (int 또는 str 또는 torch.device, 선택 사항) — 파이프라인이 할당되는 디바이스입니다. 설정하지 않으면 파이프라인은 첫 번째 사용 가능한 가속기(CUDA, MPS, XPU, …)에 배치되고, 사용 가능한 가속기가 없으면 CPU로 폴백됩니다. 모델은 자동으로 해당 디바이스로 이동합니다. CPU를 강제하려면 device="cpu"(또는 -1)을 전달하고, 특정 가속기를 선택하려면 양의 순번 또는 "cuda:1"을 전달하며, 네이티브 torch.device/str도 사용할 수 있습니다. 이 인수는 accelerate를 통해 이미 로드된 모델(즉, hf_device_map이 있는 모델)과 함께 사용할 수 없습니다.
  • dtype (str 또는 torch.dtype, 선택 사항, 기본값 "auto") — 모델이 로드되는 정밀도로, from_pretrained로 전달됩니다. 기본값은 "auto"이며, 모델이 저장된 dtype로 로드합니다(체크포인트의 config.dtype에서 읽거나, 그렇지 않으면 가중치에서 추론). 명시적으로 torch.float16, torch.bfloat16, torch.float32, ...를 전달하여 이를 재정의할 수 있습니다.
  • tokenize_kwargs (dict, 선택) — 토크나이저로 전달되는 추가 키워드 인자 딕셔너리.
  • return_tensors (bool, 선택 사항) — True인 경우 지정된 프레임워크에 해당하는 텐서를 반환하고, 그렇지 않으면 리스트를 반환합니다.

Feature extraction 파이프라인은 모델 헤드를 사용하지 않습니다. 이 파이프라인은 base transformer에서 hidden states를 추출하며, 이는 downstream task에서 feature로 사용할 수 있습니다.

예:

>>> from transformers import pipeline

>>> extractor = pipeline(model="google-bert/bert-base-uncased", task="feature-extraction")
>>> result = extractor("This is a simple test.", return_tensors=True)
>>> result.shape  # This is a tensor of shape [1, sequence_length, hidden_dimension] representing the input string.
torch.Size([1, 8, 768])

pipeline 튜토리얼에서 pipeline 사용의 기본 사항에 대해 자세히 알아보세요.

이 기능 추출 파이프라인은 현재 pipeline()에서 작업 식별자 "feature-extraction"을 사용하여 로드할 수 있습니다.

이 파이프라인에는 모든 모델을 사용할 수 있습니다. huggingface.co/models에서 커뮤니티에서 기여한 모델을 포함한 모든 모델 목록을 확인하세요.

__call__

< >

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

매개변수

  • args (str 또는 list[str]) — features를 추출할 텍스트 하나 이상(또는 텍스트 목록 하나).

반환값

float의 중첩된 리스트

모델이 계산한 특징(feature)입니다.

입력 텍스트의 특징을 추출합니다.

ImageFeatureExtractionPipeline

class transformers.ImageFeatureExtractionPipeline

< >

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

매개변수

  • model (PreTrainedModel) — 파이프라인이 예측을 수행하는 데 사용할 모델입니다. PreTrainedModel을 상속하는 모델이어야 합니다.
  • image_processor (BaseImageProcessor) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 이미지 프로세서입니다. 이 객체는 BaseImageProcessor를 상속합니다.
  • task (str, 기본값 "") — pipeline의 작업 식별자입니다.
  • num_workers (int, 선택, 기본값 8) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우) 사용할 워커 수입니다.
  • batch_size (int, 선택 사항, 기본값 1) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우)에 사용할 배치 크기입니다. 추론에서는 항상 이롭지 않을 수 있으므로 파이프라인을 사용한 배치 처리를 읽어보십시오.
  • args_parser (ArgumentHandler, 선택 사항) — 공급된 파이프라인 매개변수를 파싱하는 책임을 지는 객체에 대한 참조입니다.
  • device (int 또는 str 또는 torch.device, 선택 사항) — 파이프라인이 할당되는 디바이스입니다. 설정하지 않으면 파이프라인은 첫 번째 사용 가능한 가속기(CUDA, MPS, XPU, …)에 배치되고, 사용 가능한 가속기가 없으면 CPU로 폴백됩니다. 모델은 자동으로 해당 디바이스로 이동합니다. CPU를 강제하려면 device="cpu"(또는 -1)을 전달하고, 특정 가속기를 선택하려면 양의 순번 또는 "cuda:1"을 전달하며, 네이티브 torch.device/str도 사용할 수 있습니다. 이 인수는 accelerate를 통해 이미 로드된 모델(즉, hf_device_map이 있는 모델)과 함께 사용할 수 없습니다.
  • dtype (str 또는 torch.dtype, 선택 사항, 기본값 "auto") — 모델이 로드되는 정밀도로, from_pretrained로 전달됩니다. 기본값은 "auto"이며, 모델이 저장된 dtype로 로드합니다(체크포인트의 config.dtype에서 읽거나, 그렇지 않으면 가중치에서 추론). 명시적으로 torch.float16, torch.bfloat16, torch.float32, ...를 전달하여 이를 재정의할 수 있습니다.
  • binary_output (bool, 선택 사항, 기본값 False) — 파이프라인의 출력이 직렬화 형식(예: pickle)으로 생성되어야 하는지, 아니면 텍스트와 같은 원시 출력 데이터로 생성되어야 하는지를 나타내는 플래그입니다.
  • image_processor_kwargs (dict, 선택) — 이미지 프로세서에 함께 전달되는 추가 키워드 인자 딕셔너리. 예: {“size”: {“height”: 100, “width”: 100}‌}
  • pool (bool, 선택 사항, 기본값 False) — 풀링된 출력을 반환할지 여부입니다. False인 경우 모델은 원시 hidden states를 반환합니다.

Image feature extraction pipeline은 모델 헤드를 사용하지 않습니다. 이 파이프라인은 base transformer에서 hidden states를 추출하며, 이는 downstream task에서 feature로 사용할 수 있습니다.

예:

>>> from transformers import pipeline

>>> extractor = pipeline(model="google/vit-base-patch16-224", task="image-feature-extraction")
>>> result = extractor("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png", return_tensors=True)
>>> result.shape  # This is a tensor of shape [1, sequence_length, hidden_dimension] representing the input image.
torch.Size([1, 197, 768])

pipeline 튜토리얼에서 pipeline 사용의 기본 사항에 대해 자세히 알아보세요.

이 이미지 특징 추출 파이프라인은 현재 pipeline()에서 작업 식별자 "image-feature-extraction"를 사용하여 로드할 수 있습니다.

이 파이프라인에는 모든 비전 모델을 사용할 수 있습니다. huggingface.co/models에서 커뮤니티가 기여한 모델을 포함한 모든 모델 목록을 확인하세요.

__call__

< >

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

매개변수

  • images (str, list[str], PIL.Image 또는 list[PIL.Image]) — 파이프라인은 다음 세 가지 유형의 이미지를 처리합니다:
    • 이미지를 가리키는 http 링크가 포함된 문자열
    • 이미지의 로컬 경로를 포함하는 문자열
    • PIL에 직접 로드된 이미지

    pipeline은 단일 이미지 또는 이미지 배치(배치는 문자열로 전달해야 함)를 입력으로 받습니다. 배치 내의 모든 이미지는 동일한 형식이어야 합니다: 모두 http 링크, 모두 로컬 경로, 또는 모두 PIL 이미지여야 합니다.

  • timeout (float, 선택 사항, 기본값 None) — 웹에서 이미지를 가져오는 데 대기할 최대 시간(초)입니다. None인 경우 타임아웃이 적용되지 않으며 호출이 영원히 차단될 수 있습니다.

반환값

float의 중첩된 리스트

모델이 계산한 특징(feature)입니다.

입력의 특징을 추출합니다.

ImageTextToTextPipeline

class transformers.ImageTextToTextPipeline

< >

( *args**kwargs )

매개변수

  • model (PreTrainedModel) — 파이프라인이 예측을 수행하는 데 사용할 모델입니다. PreTrainedModel을 상속하는 모델이어야 합니다.
  • processor (ProcessorMixin) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 프로세서입니다. 이 객체는 ProcessorMixin을 상속합니다. Processor는 tokenizer, feature_extractor, image_processor를 포함할 수 있는 복합 객체입니다.
  • task (str, 기본값 "") — pipeline의 작업 식별자입니다.
  • num_workers (int, 선택, 기본값 8) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우) 사용할 워커 수입니다.
  • batch_size (int, 선택 사항, 기본값 1) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우)에 사용할 배치 크기입니다. 추론에서는 항상 이롭지 않을 수 있으므로 파이프라인을 사용한 배치 처리를 읽어보십시오.
  • args_parser (ArgumentHandler, 선택 사항) — 공급된 파이프라인 매개변수를 파싱하는 책임을 지는 객체에 대한 참조입니다.
  • device (int 또는 str 또는 torch.device, 선택 사항) — 파이프라인이 할당되는 디바이스입니다. 설정하지 않으면 파이프라인은 첫 번째 사용 가능한 가속기(CUDA, MPS, XPU, …)에 배치되고, 사용 가능한 가속기가 없으면 CPU로 폴백됩니다. 모델은 자동으로 해당 디바이스로 이동합니다. CPU를 강제하려면 device="cpu"(또는 -1)을 전달하고, 특정 가속기를 선택하려면 양의 순번 또는 "cuda:1"을 전달하며, 네이티브 torch.device/str도 사용할 수 있습니다. 이 인수는 accelerate를 통해 이미 로드된 모델(즉, hf_device_map이 있는 모델)과 함께 사용할 수 없습니다.
  • dtype (str 또는 torch.dtype, 선택 사항, 기본값 "auto") — 모델이 로드되는 정밀도로, from_pretrained로 전달됩니다. 기본값은 "auto"이며, 모델이 저장된 dtype로 로드합니다(체크포인트의 config.dtype에서 읽거나, 그렇지 않으면 가중치에서 추론). 명시적으로 torch.float16, torch.bfloat16, torch.float32, ...를 전달하여 이를 재정의할 수 있습니다.
  • binary_output (bool, 선택 사항, 기본값 False) — 파이프라인의 출력이 직렬화 형식(예: pickle)으로 생성되어야 하는지, 아니면 텍스트와 같은 원시 출력 데이터로 생성되어야 하는지를 나타내는 플래그입니다.

AutoModelForImageTextToText를 사용하는 이미지-텍스트-투-텍스트 파이프라인입니다. 이 파이프라인은 이미지와 텍스트를 입력으로 받아 텍스트를 생성합니다. 기저 모델이 대화형 모델인 경우, 하나 이상의 채팅도 받을 수 있으며, 이 경우 파이프라인은 채팅 모드로 동작하여 응답을 추가함으로써 채팅을 계속합니다. 각 채팅은 딕셔너리의 리스트 형태를 가지며, 각 딕셔너리는 “role”과 “content” 키를 포함합니다.

사용 중인 모델의 설정 파일(generation_config.json)에서 이러한 생성 매개변수를 명시적으로 설정하지 않는 한, 다음 기본값이 사용됩니다:

  • max_new_tokens: 256

예:

>>> from transformers import pipeline

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

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

pipeline 튜토리얼에서 pipeline 사용의 기본 사항에 대해 자세히 알아보세요.

This image-text to text pipeline can currently be loaded from pipeline() using the following task identifier: “image-text-to-text”.

huggingface.co/models에서 사용 가능한 모델 목록을 확인하세요.

__call__

< >

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

매개변수

  • images (str, list[str], PIL.Image, list[PIL.Image], list[dict[str, Union[str, PIL.Image]]]`) — 파이프라인은 다음 세 가지 유형의 이미지를 처리합니다:
    • 이미지를 가리키는 HTTP(s) 링크를 포함하는 문자열
    • 이미지의 로컬 경로를 포함하는 문자열
    • PIL에 직접 로드된 이미지

    pipeline은 단일 이미지 또는 이미지 배치 모두를 입력으로 받을 수 있습니다. 마지막으로, 이 pipeline은 text 인자에 포함된 이미지와 텍스트를 포함한 채팅 형식도 지원합니다.

  • text (str, list[str], list[dict[str, Union[str, PIL.Image]]]) — 생성에 사용할 텍스트입니다. 문자열 리스트를 전달하는 경우, 리스트의 길이는 이미지 수와 동일해야 합니다. 텍스트는 채팅 형식을 따를 수도 있습니다. 채팅 형식은 대화의 각 메시지를 나타내는 딕셔너리의 리스트이며, 각 딕셔너리는 ‘role’과 ‘content’라는 두 개의 키를 가져야 합니다. ‘role’은 ‘user’, ‘system’, ‘assistant’ 중 하나여야 합니다. ‘content’는 메시지의 텍스트와 메시지 유형을 포함하는 딕셔너리의 리스트여야 합니다. 메시지 유형은 ‘text’ 또는 ‘image’일 수 있습니다. 유형이 ‘image’인 경우 텍스트는 필요하지 않습니다.
  • return_tensors (bool, 선택 사항, 기본값 False) — 출력에서 예측 텐서(토큰 인덱스 형태)를 반환합니다. True로 설정하면 디코딩된 텍스트는 반환되지 않습니다.
  • return_text (bool, 선택 사항) — 출력에서 디코딩된 텍스트를 반환합니다.
  • return_full_text (bool, 선택 사항, 기본값 True) — False로 설정하면 추가된 텍스트만 반환되고, 그렇지 않으면 전체 텍스트가 반환됩니다. return_text와 동시에 지정할 수 없습니다.
  • clean_up_tokenization_spaces (bool, 선택) — 텍스트 출력에 포함된 잠재적인 추가 공백을 정리할지 여부입니다. 기본값은 토크나이저의 clean_up_tokenization_spaces 설정입니다.
  • continue_final_message( bool, optional) — 입력 채팅의 마지막 메시지를 새로운 메시지로 시작하는 대신 계속하도록 모델을 설정할지 여부를 나타냅니다. 이를 통해 응답을 “prefill”할 수 있습니다. 기본적으로 입력 채팅의 마지막 메시지가 assistant 역할을 가지는 경우 True, 그렇지 않은 경우 False로 설정되지만, 이 플래그를 설정하여 해당 동작을 수동으로 오버라이드할 수 있습니다.

반환값

dict의 리스트 또는 dict 리스트의 리스트

각 결과는 다음 키를 가진 사전으로 반환됩니다(generated_text와 generated_token_ids를 동시에 반환할 수 없음):

  • generated_text (str, return_text=True인 경우 존재) — 생성된 텍스트.
  • generated_token_ids (torch.Tensor, return_tensors=True일 때 존재) — 생성된 텍스트의 토큰 ID입니다.
  • input_text (str) — 입력 텍스트.

입력으로 전달된 텍스트와 이미지(들)를 기반으로 텍스트를 생성합니다.

AnyToAnyPipeline

class transformers.AnyToAnyPipeline

< >

( *args**kwargs )

매개변수

  • model (PreTrainedModel) — 파이프라인이 예측을 수행하는 데 사용할 모델입니다. PreTrainedModel을 상속하는 모델이어야 합니다.
  • processor (ProcessorMixin) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 프로세서입니다. 이 객체는 ProcessorMixin을 상속합니다. Processor는 tokenizer, feature_extractor, image_processor를 포함할 수 있는 복합 객체입니다.
  • task (str, 기본값 "") — pipeline의 작업 식별자입니다.
  • num_workers (int, 선택, 기본값 8) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우) 사용할 워커 수입니다.
  • batch_size (int, 선택 사항, 기본값 1) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우)에 사용할 배치 크기입니다. 추론에서는 항상 이롭지 않을 수 있으므로 파이프라인을 사용한 배치 처리를 읽어보십시오.
  • args_parser (ArgumentHandler, 선택 사항) — 공급된 파이프라인 매개변수를 파싱하는 책임을 지는 객체에 대한 참조입니다.
  • device (int 또는 str 또는 torch.device, 선택 사항) — 파이프라인이 할당되는 디바이스입니다. 설정하지 않으면 파이프라인은 첫 번째 사용 가능한 가속기(CUDA, MPS, XPU, …)에 배치되고, 사용 가능한 가속기가 없으면 CPU로 폴백됩니다. 모델은 자동으로 해당 디바이스로 이동합니다. CPU를 강제하려면 device="cpu"(또는 -1)을 전달하고, 특정 가속기를 선택하려면 양의 순번 또는 "cuda:1"을 전달하며, 네이티브 torch.device/str도 사용할 수 있습니다. 이 인수는 accelerate를 통해 이미 로드된 모델(즉, hf_device_map이 있는 모델)과 함께 사용할 수 없습니다.
  • dtype (str 또는 torch.dtype, 선택 사항, 기본값 "auto") — 모델이 로드되는 정밀도로, from_pretrained로 전달됩니다. 기본값은 "auto"이며, 모델이 저장된 dtype로 로드합니다(체크포인트의 config.dtype에서 읽거나, 그렇지 않으면 가중치에서 추론). 명시적으로 torch.float16, torch.bfloat16, torch.float32, ...를 전달하여 이를 재정의할 수 있습니다.
  • binary_output (bool, 선택 사항, 기본값 False) — 파이프라인의 출력이 직렬화 형식(예: pickle)으로 생성되어야 하는지, 아니면 텍스트와 같은 원시 출력 데이터로 생성되어야 하는지를 나타내는 플래그입니다.

AutoModelForMultimodalLM을 사용하는 멀티모달 생성 파이프라인입니다. 이 파이프라인은 멀티모달 데이터와 텍스트의 어떤 조합이든 입력으로 받아 텍스트를 생성합니다. 기반 모델이 대화형 모델인 경우, 하나 이상의 채팅을 입력으로 받을 수 있으며, 이 경우 파이프라인은 채팅 모드로 동작하여 응답을 추가함으로써 채팅을 계속합니다. 각 채팅은 딕셔너리의 리스트 형태를 가지며, 각 딕셔너리는 “role”과 “content” 키를 포함합니다.

사용 중인 모델의 설정 파일(generation_config.json)에서 이러한 생성 매개변수를 명시적으로 설정하지 않는 한, 다음 기본값이 사용됩니다:

  • max_new_tokens: 256

예:

>>> from transformers import pipeline

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

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

pipeline 튜토리얼에서 pipeline 사용의 기본 사항에 대해 자세히 알아보세요.

이 멀티모달 파이프라인은 현재 pipeline()에서 다음 작업 식별자를 사용하여 로드할 수 있습니다: “any-to-any”.

huggingface.co/models에서 사용 가능한 모델 목록을 확인하세요.

__call__

< >

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

매개변수

  • text (str, list[str], list[dict]) — 생성에 사용할 텍스트입니다. 문자열 리스트를 전달하는 경우, 리스트의 길이는 이미지 수와 동일해야 합니다. 텍스트는 채팅 형식을 따를 수도 있습니다. 채팅 형식은 대화의 각 메시지를 나타내는 딕셔너리의 리스트이며, 각 딕셔너리는 ‘role’과 ‘content’라는 두 개의 키를 가져야 합니다. ‘role’은 ‘user’, ‘system’, ‘assistant’ 중 하나여야 하며, ‘content’는 메시지의 텍스트와 메시지 유형을 포함하는 딕셔너리의 리스트여야 합니다.
  • images (str, list[str], ImageInput) — 파이프라인은 다음 세 가지 유형의 이미지를 처리합니다:
    • 이미지를 가리키는 HTTP(s) 링크를 포함하는 문자열
    • 이미지의 로컬 경로를 포함하는 문자열
    • PIL에 직접 로드된 이미지

    pipeline은 단일 이미지 또는 이미지 배치 모두를 입력으로 받을 수 있습니다. 마지막으로, 이 pipeline은 text 인자에 포함된 이미지와 텍스트를 포함한 채팅 형식도 지원합니다.

  • videos (str, list[str], VideoInput) — 파이프라인은 다음 세 가지 유형의 비디오를 처리합니다:
    • 비디오를 가리키는 HTTP(s) 링크를 포함하는 문자열
    • 비디오의 로컬 경로를 포함하는 문자열
    • 배열 형식으로 로드 및 디코딩된 비디오

    pipeline은 단일 비디오 또는 비디오 배치 모두를 입력으로 받을 수 있습니다. 마지막으로, 이 pipeline은 text 인자에 포함된 비디오와 텍스트를 처리하는 채팅 형식도 지원합니다.

  • audio (str, list[str], AudioInput) — 파이프라인은 다음 세 가지 유형의 오디오를 처리합니다:
    • 오디오를 가리키는 HTTP(s) 링크를 포함하는 문자열
    • 오디오에 대한 로컬 경로를 포함하는 문자열
    • PIL에 직접 로드된 오디오

    pipeline은 단일 audios 또는 audios 배치(batch)를 모두 받아들입니다. 마지막으로, 이 pipeline은 이 인자에 포함된 audios와 text를 가진 chat 형식(자세한 내용은 text 참조)도 지원합니다.

  • return_tensors (bool, 선택 사항, 기본값 False) — 출력에서 예측 텐서(토큰 인덱스 형태)를 반환합니다. True로 설정하면 디코딩된 텍스트는 반환되지 않습니다.
  • return_text (bool, 선택 사항) — 출력에서 디코딩된 텍스트를 반환합니다.
  • return_full_text (bool, 선택 사항, 기본값 True) — False로 설정하면 추가된 텍스트만 반환되고, 그렇지 않으면 전체 텍스트가 반환됩니다. return_text와 동시에 지정할 수 없습니다.
  • clean_up_tokenization_spaces (bool, 선택) — 텍스트 출력에 포함된 잠재적인 추가 공백을 정리할지 여부입니다. 기본값은 토크나이저의 clean_up_tokenization_spaces 설정입니다.
  • continue_final_message( bool, optional) — 입력 채팅의 마지막 메시지를 새로운 메시지로 시작하는 대신 계속하도록 모델을 설정할지 여부를 나타냅니다. 이를 통해 응답을 “prefill”할 수 있습니다. 기본적으로 입력 채팅의 마지막 메시지가 assistant 역할을 가지는 경우 True, 그렇지 않은 경우 False로 설정되지만, 이 플래그를 설정하여 해당 동작을 수동으로 오버라이드할 수 있습니다.

반환값

dict의 리스트 또는 dict 리스트의 리스트

각 결과는 다음 키를 가진 사전으로 반환됩니다(generated_text와 generated_token_ids를 동시에 반환할 수 없음):

  • generated_text (str, return_text=True이고 generation_mode="text"인 경우 존재) — 생성된 텍스트입니다.
  • generated_audio (np.ndarray, generation_mode="audio"일 때 존재) — 생성된 오디오입니다.
  • generated_image (PIL.Image.Image, generation_mode="image"일 때 존재) — 생성된 이미지.
  • generated_token_ids (torch.Tensor, return_tensors=True이고 generation_mode="text"인 경우 존재) — 생성된 텍스트의 토큰 ID입니다.
  • input_text (str) — 입력 텍스트.

입력으로 텍스트를, 선택적으로 멀티모달 데이터를 전달하여 텍스트를 생성합니다.

MaskGenerationPipeline

class transformers.MaskGenerationPipeline

< >

( **kwargs )

매개변수

  • model (PreTrainedModel) — 파이프라인이 예측을 수행하는 데 사용할 모델입니다. PreTrainedModel을 상속하는 모델이어야 합니다.
  • image_processor (BaseImageProcessor) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 이미지 프로세서입니다. 이 객체는 BaseImageProcessor를 상속합니다.
  • task (str, 기본값 "") — pipeline의 작업 식별자입니다.
  • num_workers (int, 선택, 기본값 8) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우) 사용할 워커 수입니다.
  • batch_size (int, 선택 사항, 기본값 1) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우)에 사용할 배치 크기입니다. 추론에서는 항상 이롭지 않을 수 있으므로 파이프라인을 사용한 배치 처리를 읽어보십시오.
  • args_parser (ArgumentHandler, 선택 사항) — 공급된 파이프라인 매개변수를 파싱하는 책임을 지는 객체에 대한 참조입니다.
  • device (int 또는 str 또는 torch.device, 선택 사항) — 파이프라인이 할당되는 디바이스입니다. 설정하지 않으면 파이프라인은 첫 번째 사용 가능한 가속기(CUDA, MPS, XPU, …)에 배치되고, 사용 가능한 가속기가 없으면 CPU로 폴백됩니다. 모델은 자동으로 해당 디바이스로 이동합니다. CPU를 강제하려면 device="cpu"(또는 -1)을 전달하고, 특정 가속기를 선택하려면 양의 순번 또는 "cuda:1"을 전달하며, 네이티브 torch.device/str도 사용할 수 있습니다. 이 인수는 accelerate를 통해 이미 로드된 모델(즉, hf_device_map이 있는 모델)과 함께 사용할 수 없습니다.
  • dtype (str 또는 torch.dtype, 선택 사항, 기본값 "auto") — 모델이 로드되는 정밀도로, from_pretrained로 전달됩니다. 기본값은 "auto"이며, 모델이 저장된 dtype로 로드합니다(체크포인트의 config.dtype에서 읽거나, 그렇지 않으면 가중치에서 추론). 명시적으로 torch.float16, torch.bfloat16, torch.float32, ...를 전달하여 이를 재정의할 수 있습니다.
  • binary_output (bool, 선택 사항, 기본값 False) — 파이프라인의 출력이 직렬화 형식(예: pickle)으로 생성되어야 하는지, 아니면 텍스트와 같은 원시 출력 데이터로 생성되어야 하는지를 나타내는 플래그입니다.
  • points_per_batch (선택, int, 기본값 64) — 모델이 동시에 처리할 포인트 수를 설정합니다. 값이 클수록 속도가 빨라질 수 있지만 GPU 메모리 사용량이 증가합니다.
  • output_bboxes_mask (bool, 선택 사항, 기본값 False) — 바운딩 박스 예측을 출력할지 여부입니다.
  • output_rle_masks (bool, 선택 사항, 기본값 False) — 마스크를 RLE 형식으로 출력할지 여부

SamForMaskGeneration을 사용하여 이미지에서 마스크를 자동으로 생성합니다. 이 파이프라인은 이미지를 입력으로 받아 해당 이미지에 대한 바이너리 마스크를 예측합니다. 미니 배치 내에서 포인트를 분리하여 OOM 문제를 방지할 수 있으므로 ChunkPipeline입니다. 동시에 처리할 포인트의 수를 제어하려면 points_per_batch 인수를 사용하세요. 기본값은 64입니다.

파이프라인은 3단계로 작동합니다:

  1. preprocess: 1024개의 점이 균등한 간격으로 배치된 그리드와 바운딩 박스, 점 라벨이 생성됩니다. 점과 바운딩 박스가 생성되는 방식에 대한 자세한 내용은 _generate_crop_boxes 함수를 확인하세요. 이미지는 image_processor를 사용하여 전처리됩니다. 이 함수는 points_per_batch 크기의 미니배치를 yields합니다.

  2. forward: preprocess의 출력을 모델에 전달합니다. 이미지 임베딩은 한 번만 계산됩니다. self.model.get_image_embeddings를 호출하고, 그래디언트가 계산되지 않도록 하며, 텐서와 모델이 동일한 디바이스에 있는지 확인합니다.

  3. postprocess: 자동 마스크 생성에서 가장 중요한 부분이 여기서 수행됩니다. 세 단계가 유도됩니다:

    • image_processor.postprocess_masks (각 미니배치 루프에서 실행): 원시 출력 마스크를 입력받아 이미지 크기에 맞게 리사이즈하고, 이를 바이너리 마스크로 변환합니다.
    • image_processor.filter_masks (각 미니배치 루프에서): pred_iou_thresh와 stability_scores를 모두 사용합니다. 또한 비최대억제(NMS)에 기반한 다양한 필터를 적용하여 품질이 낮은 마스크를 제거합니다.
    • image_processor.postprocess_masks_for_amg는 NSM을 마스크에 적용하여 관련 있는 것만 유지합니다.

예:

>>> from transformers import pipeline

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

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

pipeline 튜토리얼에서 pipeline 사용의 기본 사항에 대해 자세히 알아보세요.

이 분할 파이프라인은 현재 pipeline()에서 다음 작업 식별자를 사용하여 로드할 수 있습니다: "mask-generation".

huggingface.co/models에서 사용 가능한 모델 목록을 확인하세요.

__call__

< >

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

매개변수

  • image (str, List[str], PIL.Image 또는 List[PIL.Image]) — 이미지 또는 이미지 목록입니다.
  • mask_threshold (float, 선택 사항, 기본값 0.0) — 예측된 마스크를 이진 값으로 변환할 때 사용할 임계값입니다.
  • pred_iou_thresh (float, 선택 사항, 기본값 0.88) — 모델이 예측한 마스크 품질에 적용되는 [0,1] 범위의 필터링 임계값입니다.
  • stability_score_thresh (float, 선택 사항, 기본값 0.95) — 모델의 mask 예측을 이진화하는 데 사용되는 cutoff의 변화에 따른 mask의 안정성을 사용하여 [0,1] 범위에서 필터링하는 임계값입니다.
  • stability_score_offset (int, 선택 사항, 기본값 1) — 안정성 점수를 계산할 때 임계값을 이동할 양.
  • crops_nms_thresh (float, 선택 사항, 기본값 0.7) — 중복 마스크를 필터링하기 위해 non-maximal suppression에서 사용하는 박스 IoU 임계값입니다.
  • crops_n_layers (int, 선택 사항, 기본값 0) — crops_n_layers>0인 경우, 이미지 크롭에 대해 마스크 예측을 다시 실행합니다. 실행할 레이어 수를 설정하며, 각 레이어에는 2**i_layer개의 이미지 크롭이 포함됩니다.
  • crop_overlap_ratio (float, 선택 사항, 기본값 512 / 1500) — 크롭이 겹치는 정도를 설정합니다. 첫 번째 크롭 레이어에서는 크롭이 이미지 길이의 해당 비율만큼 겹칩니다. 크롭 수가 더 많은 후속 레이어에서는 이 겹침 정도가 축소됩니다.
  • crop_n_points_downscale_factor (int, 선택 사항, 기본값 1) — n번째 레이어에서 한 변당 샘플링되는 점의 수는 crop_n_points_downscale_factor**n으로 축소됩니다.
  • timeout (float, 선택, 기본값 None) — 웹에서 이미지를 가져오는 데 대기할 최대 시간(초). None인 경우 타임아웃이 설정되지 않으며, 호출이 영원히 차단될 수 있습니다.

반환값

Dict

다음 키를 가진 사전:

  • mask (PIL.Image) — 원본 이미지의 (width, height) 크기를 가진 PIL Image 형식의 감지된 객체의 바이너리 마스크입니다. 객체가 감지되지 않으면 0으로 채워진 마스크를 반환합니다.
  • score (선택 float) — 모델이 라벨과 마스크로 설명되는 “object”의 신뢰도를 추정할 수 있는 경우, 선택적으로 지정할 수 있습니다.

이진 분할 마스크를 생성합니다

부모 클래스: Pipeline

class transformers.Pipeline

< >

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

매개변수

  • model (PreTrainedModel) — 파이프라인이 예측을 수행하는 데 사용할 모델입니다. PreTrainedModel을 상속하는 모델이어야 합니다.
  • tokenizer (PreTrainedTokenizer) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 토크나이저입니다. 이 객체는 PreTrainedTokenizer를 상속합니다.
  • feature_extractor (SequenceFeatureExtractor) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 피처 추출기입니다. 이 객체는 SequenceFeatureExtractor를 상속합니다.
  • image_processor (BaseImageProcessor) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 이미지 프로세서입니다. 이 객체는 BaseImageProcessor를 상속합니다.
  • processor (ProcessorMixin) — 파이프라인이 모델을 위해 데이터를 인코딩하는 데 사용할 프로세서입니다. 이 객체는 ProcessorMixin을 상속합니다. Processor는 tokenizer, feature_extractor, image_processor를 포함할 수 있는 복합 객체입니다.
  • task (str, 기본값 "") — pipeline의 작업 식별자입니다.
  • num_workers (int, 선택, 기본값 8) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우) 사용할 워커 수입니다.
  • batch_size (int, 선택 사항, 기본값 1) — 파이프라인이 DataLoader를 사용하는 경우(데이터셋을 전달하거나 Pytorch 모델에서 GPU를 사용하는 경우)에 사용할 배치 크기입니다. 추론에서는 항상 이롭지 않을 수 있으므로 파이프라인을 사용한 배치 처리를 읽어보십시오.
  • args_parser (ArgumentHandler, 선택 사항) — 공급된 파이프라인 매개변수를 파싱하는 책임을 지는 객체에 대한 참조입니다.
  • device (int 또는 str 또는 torch.device, 선택 사항) — 파이프라인이 할당되는 디바이스입니다. 설정하지 않으면 파이프라인은 첫 번째 사용 가능한 가속기(CUDA, MPS, XPU, …)에 배치되고, 사용 가능한 가속기가 없으면 CPU로 폴백됩니다. 모델은 자동으로 해당 디바이스로 이동합니다. CPU를 강제하려면 device="cpu"(또는 -1)을 전달하고, 특정 가속기를 선택하려면 양의 순번 또는 "cuda:1"을 전달하며, 네이티브 torch.device/str도 사용할 수 있습니다. 이 인수는 accelerate를 통해 이미 로드된 모델(즉, hf_device_map이 있는 모델)과 함께 사용할 수 없습니다.
  • dtype (str 또는 torch.dtype, 선택 사항, 기본값 "auto") — 모델이 로드되는 정밀도로, from_pretrained로 전달됩니다. 기본값은 "auto"이며, 모델이 저장된 dtype로 로드합니다(체크포인트의 config.dtype에서 읽거나, 그렇지 않으면 가중치에서 추론). 명시적으로 torch.float16, torch.bfloat16, torch.float32, ...를 전달하여 이를 재정의할 수 있습니다.
  • binary_output (bool, 선택 사항, 기본값 False) — 파이프라인의 출력이 직렬화 형식(예: pickle)으로 생성되어야 하는지, 아니면 텍스트와 같은 원시 출력 데이터로 생성되어야 하는지를 나타내는 플래그입니다.

Pipeline 클래스는 모든 파이프라인이 상속하는 클래스입니다. 서로 다른 파이프라인에서 공유되는 메서드에 대해서는 이 클래스를 참조하세요.

파이프라인 작업을 구현하는 베이스 클래스입니다. 파이프라인 워크플로우는 다음 작업들의 시퀀스로 정의됩니다:

입력 -> Tokenization -> 모델 추론 -> 후처리(작업에 따라 다름) -> 출력

Pipeline은 device 인수를 통해 CPU 또는 GPU에서 실행하는 것을 지원합니다(아래 참조).

FeatureExtractionPipeline ('feature-extraction')와 같은 일부 pipeline은 큰 tensor 객체를 중첩 리스트 형태로 출력합니다. 이러한 큰 구조를 텍스트 데이터로 덤프하는 것을 방지하기 위해 binary_output 생성자 인수를 제공합니다. True로 설정하면 출력은 pickle 형식으로 저장됩니다.

check_model_type

< >

( supported_models: list[str] | dict )

매개변수

  • supported_models (list[str] 또는 dict) — pipeline이 지원하는 모델 목록 또는 모델 클래스 값을 가지는 사전입니다.

모델 클래스가 pipeline에 의해 지원되는지 확인합니다.

device_placement

< >

( )

사용자가 지정한 디바이스에서 텐서 할당을 허용하는 Context Manager입니다.

예:

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

ensure_tensor_on_device

< >

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

매개변수

  • inputs (torch.Tensor가 되어야 하는 키워드 인수로, 나머지는 무시됨) — self.device에 배치할 텐서입니다.
  • Recursive는 리스트에만 적용됩니다. —

반환값

dict[str, torch.Tensor]

inputs와 동일하지만, 올바른 장치에 배치된 상태입니다.

PyTorch 텐서가 지정된 device에 있는지 확인합니다.

postprocess

< >

( model_outputs: ModelOutput**postprocess_parameters: dict )

Postprocess는 _forward 메서드의 원시 출력, 일반적으로 텐서를 받아 더 사용하기 쉬운 형태로 재포맷합니다. 일반적으로 문자열과 숫자만 포함된 결과의 리스트나 딕셔너리를 출력합니다.

predict

< >

( X )

Transformers의 pipelines에 대한 Scikit / Keras 인터페이스입니다. 이 메서드는 call()로 전달됩니다.

preprocess

< >

( input_: Any**preprocess_parameters: dict )

Preprocess는 특정 파이프라인의 input_를 받아 _forward가 정상적으로 실행되는 데 필요한 모든 항목을 딕셔너리로 반환합니다. 최소한 하나의 텐서를 포함해야 하지만, 임의의 기타 항목을 포함할 수도 있습니다.

push_to_hub

< >

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

매개변수

  • repo_id (str) — pipe를 push하려는 저장소의 이름입니다. 특정 조직에 push하는 경우 해당 조직 이름을 포함해야 합니다.
  • commit_message (str, 선택) — 푸시할 때 커밋할 메시지입니다. 기본값은 "Upload pipe"입니다.
  • commit_description (str, 선택 사항) — 생성될 커밋의 설명
  • private (bool, 선택 사항) — 리포지토리를 비공개로 만들지 여부를 지정합니다. None(기본값)인 경우, 조직의 기본 설정이 비공개가 아닌 한 리포지토리는 공개됩니다. 리포지토리가 이미 존재하면 이 값은 무시됩니다.
  • token (bool 또는 str, 선택 사항) — 원격 파일에 대한 HTTP bearer 인증으로 사용할 토큰입니다. True(기본값)인 경우, hf auth login 실행 시 생성된 토큰(~/.huggingface에 저장됨)을 사용합니다.
  • revision (str, 선택 사항) — 업로드된 파일을 푸시할 브랜치.
  • create_pr (bool, 선택 사항, 기본값 False) — 업로드된 파일로 PR을 생성할지 아니면 직접 커밋할지 여부.
  • max_shard_size (int 또는 str, 선택 사항, 기본값 "50GB") — 모델에만 적용됩니다. 샤딩되기 전 체크포인트의 최대 크기입니다. 샤딩된 각 체크포인트의 크기는 이 크기보다 작아집니다. 문자열로 표현하는 경우, 숫자 뒤에 단위(예: "5MB")가 따라와야 합니다.
  • tags (list[str], 선택) — Hub에 push할 태그 목록.

🤗 Model Hub에 파이프라인 파일을 업로드합니다.

예:

from transformers import pipeline

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

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

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

save_pretrained

< >

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

매개변수

  • save_directory (str 또는 os.PathLike) — 저장할 디렉터리의 경로입니다. 존재하지 않으면 생성됩니다.
  • kwargs (dict[str, Any], 선택) — push_to_hub() 메서드에 함께 전달되는 추가 키워드 인자입니다.

pipeline의 모델과 토크나이저를 저장합니다.

transform

< >

( X )

Transformers의 pipelines에 대한 Scikit / Keras 인터페이스입니다. 이 메서드는 call()로 전달됩니다.

Update on GitHub

←PEFT 프로세서→