# Pipelines Os pipelines são uma maneira excelente e simples de usar modelos para inferência. Esses pipelines são objetos que abstrai a maior parte do código complexo da biblioteca, oferecendo uma API simples dedicada a várias tarefas, incluindo Named Entity Recognition, Masked Language Modeling, Sentiment Analysis, Feature Extraction e Question Answering. Consulte a [lista de tarefas](https://huggingface.co/tasks) para exemplos de uso. Há duas categorias de abstrações de pipeline sobre as quais é importante estar ciente: - O [pipeline()](/docs/transformers/main/pt/main_classes/pipelines#transformers.pipeline), que é o objeto mais poderoso, encapsulando todos os outros pipelines. - Pipelines específicos para tarefas estão disponíveis para tarefas de [áudio](#audio), [visão computacional](#computer-vision), [processamento de linguagem natural](#natural-language-processing) e [multimodais](#multimodal). ## A abstração de pipeline[[transformers.pipeline]] A abstração *pipeline* é um wrapper em torno de todos os outros pipelines disponíveis. Ela é instanciada como qualquer outro pipeline, mas pode oferecer melhorias adicionais de usabilidade. Chamada simples em um item: ```python >>> pipe = pipeline("text-classification") >>> pipe("This restaurant is awesome") [{'label': 'POSITIVE', 'score': 0.9998743534088135}] ``` Se você deseja usar um modelo específico do [hub](https://huggingface.co), pode ignorar a tarefa se o modelo no hub já a define: ```python >>> pipe = pipeline(model="FacebookAI/roberta-large-mnli") >>> pipe("This restaurant is awesome") [{'label': 'NEUTRAL', 'score': 0.7313136458396912}] ``` Para chamar um pipeline em muitos itens, você pode chamá-lo com uma *list*. ```python >>> pipe = pipeline("text-classification") >>> pipe(["This restaurant is awesome", "This restaurant is awful"]) [{'label': 'POSITIVE', 'score': 0.9998743534088135}, {'label': 'NEGATIVE', 'score': 0.9996669292449951}] ``` Para iterar sobre conjuntos de dados completos, recomenda-se usar um `dataset` diretamente. Isso significa que você não precisa alocar o conjunto de dados inteiro de uma vez, nem precisa fazer o loteamento (batching) por conta própria. Isso deve funcionar tão rápido quanto loops personalizados em GPU. Se não for o caso, não hesite em abrir uma issue. ```python import datasets from transformers import pipeline from transformers.pipelines.pt_utils import KeyDataset from tqdm.auto import tqdm pipe = pipeline("automatic-speech-recognition", model="facebook/wav2vec2-base-960h", device=0) dataset = datasets.load_dataset("s3prl/superb", name="asr", split="test") # KeyDataset (only *pt*) will simply return the item in the dict returned by the dataset item # as we're not interested in the *target* part of the dataset. For sentence pair use KeyPairDataset for out in tqdm(pipe(KeyDataset(dataset, "file"))): print(out) # {"text": "NUMBER TEN FRESH NELLY IS WAITING ON YOU GOOD NIGHT HUSBAND"} # {"text": ....} # .... ``` Para facilitar o uso, também é possível utilizar um gerador: ```python from transformers import pipeline pipe = pipeline("text-classification") def data(): while True: # This could come from a dataset, a database, a queue or HTTP request # in a server # Caveat: because this is iterative, you cannot use `num_workers > 1` variable # to use multiple threads to preprocess data. You can still have 1 thread that # does the preprocessing while the main runs the big inference yield "This is a test" for out in pipe(data()): print(out) # {"text": "NUMBER TEN FRESH NELLY IS WAITING ON YOU GOOD NIGHT HUSBAND"} # {"text": ....} # .... ``` #### transformers.pipeline[[transformers.pipeline]] ```python transformers.pipeline(task: str | None = None, model: str | PreTrainedModel | None = None, config: str | PreTrainedConfig | None = None, tokenizer: str | PreTrainedTokenizer | PreTrainedTokenizerFast | None = None, feature_extractor: str | FeatureExtractionMixin | None = None, image_processor: str | BaseImageProcessor | None = None, video_processor: str | BaseVideoProcessor | None = None, processor: str | ProcessorMixin | None = None, revision: str | None = None, use_fast: bool = True, token: str | bool | None = None, device: int | str | torch.device | None = None, device_map: str | dict[str, int | str] | None = None, dtype: str | torch.dtype | None = 'auto', trust_remote_code: bool | None = None, model_kwargs: dict[str, Any] | None = None, pipeline_class: Any | None = None, **kwargs: Any) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/__init__.py#L745) **Parâmetros:** task (`str`) : A tarefa que define qual pipeline será retornado. As tarefas atualmente aceitas são: - `"audio-classification"`: retornará um [AudioClassificationPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.AudioClassificationPipeline). - `"automatic-speech-recognition"`: retornará um [AutomaticSpeechRecognitionPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.AutomaticSpeechRecognitionPipeline). - `"depth-estimation"`: retornará um [DepthEstimationPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.DepthEstimationPipeline). - `"document-question-answering"`: retornará um [DocumentQuestionAnsweringPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.DocumentQuestionAnsweringPipeline). - `"feature-extraction"`: retornará um [FeatureExtractionPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.FeatureExtractionPipeline). - `"fill-mask"`: retornará um [FillMaskPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.FillMaskPipeline):. - `"image-classification"`: retornará um [ImageClassificationPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.ImageClassificationPipeline). - `"image-feature-extraction"`: retornará um [ImageFeatureExtractionPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.ImageFeatureExtractionPipeline). - `"image-segmentation"`: retornará um [ImageSegmentationPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.ImageSegmentationPipeline). - `"image-text-to-text"`: retornará um [ImageTextToTextPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.ImageTextToTextPipeline). - `"keypoint-matching"`: retornará um [KeypointMatchingPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.KeypointMatchingPipeline). - `"mask-generation"`: retornará um [MaskGenerationPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.MaskGenerationPipeline). - `"object-detection"`: retornará um [ObjectDetectionPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.ObjectDetectionPipeline). - `"table-question-answering"`: retornará um [TableQuestionAnsweringPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.TableQuestionAnsweringPipeline). - `"text-classification"` (alias `"sentiment-analysis"` disponível): retornará um [TextClassificationPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.TextClassificationPipeline). - `"text-generation"`: retornará um [TextGenerationPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.TextGenerationPipeline):. - `"text-to-audio"` (alias `"text-to-speech"` disponível): retornará um [TextToAudioPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.TextToAudioPipeline):. - `"token-classification"` (alias `"ner"` disponível): retornará um [TokenClassificationPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.TokenClassificationPipeline). - `"video-classification"`: retornará um [VideoClassificationPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.VideoClassificationPipeline). - `"zero-shot-classification"`: retornará um [ZeroShotClassificationPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.ZeroShotClassificationPipeline). - `"zero-shot-image-classification"`: retornará um [ZeroShotImageClassificationPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.ZeroShotImageClassificationPipeline). - `"zero-shot-audio-classification"`: retornará um [ZeroShotAudioClassificationPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.ZeroShotAudioClassificationPipeline). - `"zero-shot-object-detection"`: retornará um [ZeroShotObjectDetectionPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.ZeroShotObjectDetectionPipeline). model (`str` ou [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel), *opcional*) : O modelo que será utilizado pelo pipeline para fazer previsões. Pode ser um identificador de modelo ou uma instância real de um modelo pré-treinado que herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Se não for fornecido, o padrão para o `task` será carregado. config (`str` ou [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig), *opcional*) : A configuração que será usada pelo pipeline para instanciar o modelo. Isso pode ser um identificador de modelo ou uma configuração de modelo pré-treinado real que herda de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig). Se não for fornecida, o arquivo de configuração padrão para o modelo solicitado será usado. Isso significa que, se `model` for fornecido, sua configuração padrão será usada. No entanto, se `model` não for fornecido, a configuração do modelo padrão deste `task` será usada em vez disso. tokenizer (`str` ou [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend), *opcional*) : O tokenizer que será usado pelo pipeline para codificar os dados para o modelo. Isso pode ser um identificador de modelo ou um tokenizer pré-treinado real que herda de [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend). Se não for fornecido, o tokenizer padrão para o `model` dado será carregado (se for uma string). Se `model` não for especificado ou não for uma string, então o tokenizer padrão para `config` será carregado (se for uma string). No entanto, se `config` também não for fornecido ou não for uma string, então o tokenizer padrão para o `task` dado será carregado. feature_extractor (`str` ou [FeatureExtractionMixin](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.FeatureExtractionMixin), *opcional*) : O extrator de recursos que será usado pelo pipeline para codificar os dados para o modelo. Isso pode ser um identificador de modelo ou um extrator de recursos pré-treinado real que herda de [FeatureExtractionMixin](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.FeatureExtractionMixin). Os extratores de recursos são usados para modelos não-NLP, como modelos de Fala ou Visão, bem como modelos multimodais. Modelos multimodais também exigirão que um tokenizer seja passado. Se não for fornecido, o extrator de recursos padrão para o `model` dado será carregado (se for uma string). Se `model` não for especificado ou não for uma string, então o extrator de recursos padrão para `config` será carregado (se for uma string). No entanto, se `config` também não for fornecido ou não for uma string, então o extrator de recursos padrão para o `task` dado será carregado. image_processor (`str` ou [BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor), *opcional*) : O processador de imagens que será usado pelo pipeline para pré-processar as imagens para o modelo. Isso pode ser um identificador de modelo ou um processador de imagens real que herda de [BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor). Processadores de imagens são usados para modelos de Visão e modelos multi-modais que exigem entradas de imagem. Modelos multi-modais também exigirão que um tokenizer seja passado. Se não for fornecido, o processador de imagens padrão para o `model` dado será carregado (se for uma string). Se `model` não for especificado ou não for uma string, então o processador de imagens padrão para `config` será carregado (se for uma string). processor (`str` ou [ProcessorMixin](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin), *opcional*) : O processador que será usado pelo pipeline para pré-processar os dados para o modelo. Isso pode ser um identificador de modelo ou um processador real que herda de [ProcessorMixin](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin). Processadores são usados para modelos multimodais que exigem entradas multimodais, por exemplo, um modelo que requer entradas de texto e de imagem. Se não for fornecido, o processador padrão para o `model` dado será carregado (se for uma string). Se `model` não for especificado ou não for uma string, então o processador padrão para `config` será carregado (se for uma string). revision (`str`, *opcional*, padrão `"main"`) : Ao passar um nome de tarefa ou um identificador de modelo em formato de string: a versão específica do modelo a ser usada. Pode ser o nome de um branch, o nome de uma tag ou um id de commit, pois utilizamos um sistema baseado em git para armazenar modelos e outros artefatos no huggingface.co, portanto `revision` pode ser qualquer identificador permitido pelo git. use_fast (`bool`, *opcional*, padrão `True`) : Se deve ou não usar um Fast tokenizer, quando possível (um [PreTrainedTokenizerFast](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend)). token (`str` ou *bool*, *opcional*) : O token a ser usado como autorização HTTP bearer para arquivos remotos. Se `True`, usará o token gerado ao executar `hf auth login`. device (`int` ou `str` ou `torch.device`, *opcional*) : Define o dispositivo (*por exemplo*, `"cpu"`, `"cuda:1"`, `"mps"` ou um rank ordinal de GPU como `1`) no qual este pipeline será alocado. Quando não definido, o pipeline é colocado automaticamente no primeiro acelerador disponível (CUDA, MPS, XPU, ...) e só recorre à CPU quando nenhum estiver disponível; o modelo é movido para lá automaticamente. Passe `device="cpu"` (ou `-1`) para forçar o uso da CPU. Não pode ser usado em conjunto com `device_map`. device_map (`str` ou `dict[str, Union[int, str, torch.device]`, *opcional*) : Enviado diretamente como `model_kwargs` (apenas um atalho mais simples). Quando a biblioteca `accelerate` está presente, defina `device_map="auto"` para calcular automaticamente o `device_map` mais otimizado (veja [aqui](https://huggingface.co/docs/accelerate/main/en/package_reference/big_modeling#accelerate.cpu_offload) para mais informações). Não use `device_map` e `device` ao mesmo tempo, pois eles entrarão em conflito dtype (`str` ou `torch.dtype`, *opcional*, padrão `"auto"`) : A precisão na qual o modelo é carregado, encaminhada para `from_pretrained`. O padrão é `"auto"`, que carrega o modelo no dtype em que ele foi salvo. Passe um `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescrever. trust_remote_code (`bool`, *opcional*, padrão `False`) : Se deve ou não permitir o uso de código personalizado definido no Hub em seus próprios arquivos de modelagem, configuração, tokenização ou até mesmo de pipeline. Essa opção deve ser definida como `True` apenas para repositórios nos quais você confia e cujo código você já leu, pois ela executará o código presente no Hub na sua máquina local. model_kwargs (`dict[str, Any]`, *opcional*) : Dicionário adicional de argumentos de palavra-chave passados para a função `from_pretrained(..., **model_kwargs)` do modelo. kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palavra-chave adicionais passados para a inicialização do pipeline específico (consulte a documentação da classe de pipeline correspondente para os valores possíveis). **Retorna:** [Pipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.Pipeline) Um pipeline adequado para a tarefa. Método de fábrica utilitário para construir um [Pipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.Pipeline). Um pipeline consiste em: - Um ou mais componentes para pré-processamento das entradas do modelo, como um [tokenizer](tokenizer), [image_processor](image_processor), [feature_extractor](feature_extractor) ou [processor](processors). - Um [modelo](model) que gera previsões a partir das entradas. - Etapas opcionais de pós-processamento para refinar a saída do modelo, que também podem ser tratadas por processadores. Embora existam argumentos opcionais como `tokenizer`, `feature_extractor`, `image_processor` e `processor`, eles não devem ser especificados todos ao mesmo tempo. Se esses componentes não forem fornecidos, o `pipeline` tentará carregar automaticamente os necessários. Caso você queira fornecer esses componentes explicitamente, consulte o pipeline específico para obter mais detalhes sobre quais componentes são obrigatórios. Exemplos: ```python >>> from transformers import pipeline, AutoModelForTokenClassification, AutoTokenizer >>> # Sentiment analysis pipeline >>> analyzer = pipeline("sentiment-analysis") >>> # Named entity recognition pipeline, passing in a specific model and tokenizer >>> model = AutoModelForTokenClassification.from_pretrained("dbmdz/bert-large-cased-finetuned-conll03-english") >>> tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-cased") >>> recognizer = pipeline("ner", model=model, tokenizer=tokenizer) ``` ## Lote de pipelines Todos os pipelines podem usar loteamento (batching). Isso funcionará sempre que o pipeline utilizar sua capacidade de streaming (ou seja, ao passar listas, `Dataset` ou `generator`). ```python from transformers import pipeline from transformers.pipelines.pt_utils import KeyDataset import datasets dataset = datasets.load_dataset("stanfordnlp/imdb", name="plain_text", split="unsupervised") pipe = pipeline("text-classification", device=0) for out in pipe(KeyDataset(dataset, "text"), batch_size=8, truncation="only_first"): print(out) # [{'label': 'POSITIVE', 'score': 0.9998743534088135}] # Exactly the same output as before, but the content are passed # as batches to the model ``` No entanto, isso não é automaticamente uma vantagem de desempenho. Pode resultar em uma aceleração de 10x ou em uma lentidão de 5x, dependendo do hardware, dos dados e do modelo específico utilizado. Exemplo em que há principalmente um ganho de velocidade: ```python from transformers import pipeline from torch.utils.data import Dataset from tqdm.auto import tqdm pipe = pipeline("text-classification", device=0) class MyDataset(Dataset): def __len__(self): return 5000 def __getitem__(self, i): return "This is a test" dataset = MyDataset() for batch_size in [1, 8, 64, 256]: print("-" * 30) print(f"Streaming batch_size={batch_size}") for out in tqdm(pipe(dataset, batch_size=batch_size), total=len(dataset)): pass ``` ```text # On GTX 970 ------------------------------ Streaming no batching 100%|██████████████████████████████████████████████████████████████████████| 5000/5000 [00:26<00:00, 187.52it/s] ------------------------------ Streaming batch_size=8 100%|█████████████████████████████████████████████████████████████████████| 5000/5000 [00:04<00:00, 1205.95it/s] ------------------------------ Streaming batch_size=64 100%|█████████████████████████████████████████████████████████████████████| 5000/5000 [00:02<00:00, 2478.24it/s] ------------------------------ Streaming batch_size=256 100%|█████████████████████████████████████████████████████████████████████| 5000/5000 [00:01<00:00, 2554.43it/s] (diminishing returns, saturated the GPU) ``` Exemplo em que há principalmente uma redução de desempenho: ```python class MyDataset(Dataset): def __len__(self): return 5000 def __getitem__(self, i): if i % 64 == 0: n = 100 else: n = 1 return "This is a test" * n ``` Esta é uma frase ocasionalmente muito longa em comparação com as outras. Nesse caso, o **lote inteiro** precisará ter 400 tokens de comprimento, de modo que o lote inteiro será [64, 400] em vez de [64, 4], resultando em um grande atraso. Pior ainda, em lotes maiores, o programa simplesmente trava. ```text ------------------------------ Streaming no batching 100%|█████████████████████████████████████████████████████████████████████| 1000/1000 [00:05<00:00, 183.69it/s] ------------------------------ Streaming batch_size=8 100%|█████████████████████████████████████████████████████████████████████| 1000/1000 [00:03<00:00, 265.74it/s] ------------------------------ Streaming batch_size=64 100%|██████████████████████████████████████████████████████████████████████| 1000/1000 [00:26<00:00, 37.80it/s] ------------------------------ Streaming batch_size=256 0%| | 0/1000 [00:00 for out in tqdm(pipe(dataset, batch_size=256), total=len(dataset)): .... q = q / math.sqrt(dim_per_head) # (bs, n_heads, q_length, dim_per_head) RuntimeError: CUDA out of memory. Tried to allocate 376.00 MiB (GPU 0; 3.95 GiB total capacity; 1.72 GiB already allocated; 354.88 MiB free; 2.46 GiB reserved in total by PyTorch) ``` Não existem boas soluções (gerais) para esse problema, e os resultados podem variar dependendo dos seus casos de uso. Regra geral: Para os usuários, uma regra geral é: - **Meça o desempenho na sua carga de trabalho, com o seu hardware. Meça, meça e continue medindo. Números reais são o único caminho a seguir.** - Se você estiver limitado por latência (produto em produção executando inferência), não use lote. - Se você estiver usando CPU, não use lotes. - Se você está usando throughput (quer dizer, deseja executar seu modelo em um conjunto de dados estáticos), em GPU, então: - Se você não tem ideia do tamanho do sequence_length (dados "naturais"), por padrão, não faça lote, meça e tente adicioná-lo de forma tentativa, adicione verificações de OOM para se recuperar quando falhar (e ele falhará em algum ponto se você não controlar o sequence_length). - Se o seu sequence_length for muito regular, o batching tem mais chances de ser MUITO interessante; meça e aumente até obter OOMs. - Quanto maior a GPU, mais provável é que o batching se torne mais interessante - Assim que você ativar o batching, certifique-se de que consegue lidar com OOMs de forma adequada. ## Lote de blocos do Pipeline `zero-shot-classification` e `question-answering` são um pouco específicos no sentido de que uma única entrada pode gerar múltiplas passadas de inferência de um modelo. Em circunstâncias normais, isso causaria problemas com o argumento `batch_size`. Para contornar esse problema, ambos esses pipelines são um pouco específicos: eles são `ChunkPipeline` em vez do `Pipeline` regular. Em resumo: ```python preprocessed = pipe.preprocess(inputs) model_outputs = pipe.forward(preprocessed) outputs = pipe.postprocess(model_outputs) ``` Agora se torna: ```python all_model_outputs = [] for preprocessed in pipe.preprocess(inputs): model_outputs = pipe.forward(preprocessed) all_model_outputs.append(model_outputs) outputs = pipe.postprocess(all_model_outputs) ``` Isso deve ser muito transparente para o seu código, pois os pipelines são usados da mesma forma. Esta é uma visão simplificada, pois o pipeline pode lidar automaticamente com o lote para você! Isso significa que você não precisa se preocupar com quantas passadas de propagação para frente suas entradas realmente vão acionar; você pode otimizar o `batch_size` de forma independente das entradas. As ressalvas da seção anterior ainda se aplicam. ## Pipeline Inferência FP16 Os modelos podem ser executados em FP16, o que pode ser significativamente mais rápido em GPU, ao mesmo tempo em que economiza memória. A maioria dos modelos não sofrerá perda de desempenho perceptível com isso. Quanto maior o modelo, menor a probabilidade de isso ocorrer. Para habilitar a inferência em FP16, basta passar `dtype=torch.float16` ou `dtype='float16'` para o construtor do pipeline. Observe que isso só funciona para modelos com backend PyTorch. Suas entradas serão convertidas para FP16 internamente. ## Código personalizado do Pipeline Se você deseja substituir um pipeline específico. Não hesite em criar uma issue para a sua tarefa, pois o objetivo do pipeline é ser fácil de usar e suportar a maioria dos casos, de modo que o `transformers` talvez possa suportar o seu caso de uso. Se você quiser apenas experimentar, pode: - Subclasseie o pipeline de sua escolha ```python class MyPipeline(TextClassificationPipeline): def postprocess(): # Your code goes here scores = scores * 100 # And here my_pipeline = MyPipeline(model=model, tokenizer=tokenizer, ...) # or if you use *pipeline* function, then: my_pipeline = pipeline(model="xxxx", pipeline_class=MyPipeline) ``` Isso deve permitir que você execute todo o código personalizado que desejar. ## Implementando um pipeline [Implementando um novo pipeline](../add_new_pipeline) ## Áudio Os pipelines disponíveis para tarefas de áudio incluem os seguintes. ### AudioClassificationPipeline[[transformers.AudioClassificationPipeline]] #### transformers.AudioClassificationPipeline[[transformers.AudioClassificationPipeline]] ```python transformers.AudioClassificationPipeline(*args, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/audio_classification.py#L68) **Parâmetros:** model ([PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel)): o modelo que será usado pelo pipeline para fazer previsões. Ele precisa ser um modelo que herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). feature_extractor ([SequenceFeatureExtractor](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor)) : O extrator de recursos que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [SequenceFeatureExtractor](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor). task (`str`, padrão `""`) : Um identificador de tarefa para o pipeline. num_workers (`int`, *opcional*, padrão 8) : Quando o pipeline utilizar *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o número de workers a serem usados. batch_size (`int`, *opcional*, padrão 1) : Quando o pipeline usará *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o tamanho do lote a ser usado. Para inferência, isso nem sempre é vantajoso; leia [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/pt/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referência ao objeto responsável por analisar os parâmetros fornecidos do pipeline. device (`int` ou `str` ou `torch.device`, *opcional*) : Dispositivo no qual o pipeline é alocado. Se não for definido, o pipeline é colocado no primeiro acelerador disponível (CUDA, MPS, XPU, ...) e recorre para a CPU apenas quando nenhum estiver disponível; o modelo é movido para lá automaticamente. Passe `device="cpu"` (ou `-1`) para forçar o uso da CPU, um ordinal positivo ou `"cuda:1"` para selecionar um acelerador específico, ou um `torch.device`/`str` nativo. Este argumento não pode ser combinado com um modelo já carregado via `accelerate` (ou seja, um com `hf_device_map`). dtype (`str` ou `torch.dtype`, *opcional*, padrão `"auto"`) : A precisão na qual o modelo é carregado, encaminhada para `from_pretrained`. O padrão é `"auto"`, que carrega o modelo no dtype em que ele foi salvo (lido do `config.dtype` do checkpoint, ou inferido a partir dos pesos). Passe um `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescrever. binary_output (`bool`, *opcional*, padrão `False`) : Indica se a saída do pipeline deve ocorrer em um formato serializado (ou seja, pickle) ou como os dados de saída brutos, por exemplo, texto. Pipeline de classificação de áudio usando qualquer `AutoModelForAudioClassification`. Este pipeline prevê a classe de uma forma de onda bruta ou de um arquivo de áudio. No caso de um arquivo de áudio, o ffmpeg deve estar instalado para suportar múltiplos formatos de áudio. Exemplo: ```python >>> from transformers import pipeline >>> classifier = pipeline(model="superb/wav2vec2-base-superb-ks") >>> classifier("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/1.flac") [{'score': 0.997, 'label': '_unknown_'}, {'score': 0.002, 'label': 'left'}, {'score': 0.0, 'label': 'yes'}, {'score': 0.0, 'label': 'down'}, {'score': 0.0, 'label': 'stop'}] ``` Saiba mais sobre os fundamentos do uso de um pipeline no [tutorial de pipeline](../pipeline_tutorial) Este pipeline pode ser carregado atualmente a partir de [pipeline()](/docs/transformers/main/pt/main_classes/pipelines#transformers.pipeline) usando o seguinte identificador de tarefa: `"audio-classification"`. Veja a lista de modelos disponíveis em [huggingface.co/models](https://huggingface.co/models?filter=audio-classification). #### __call__[[transformers.AudioClassificationPipeline.__call__]] ```python __call__(inputs: numpy.ndarray | bytes | str | dict, **kwargs: Any) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/audio_classification.py#L110) **Parâmetros:** inputs (`np.ndarray` ou `bytes` ou `str` ou `dict`) : A entrada é uma das seguintes opções: - `str` que é o nome do arquivo de áudio; o arquivo será lido na taxa de amostragem correta para obter a forma de onda usando *ffmpeg*. Isso requer que o *ffmpeg* esteja instalado no sistema. - `bytes` deve ser o conteúdo de um arquivo de áudio e é interpretado pelo *ffmpeg* da mesma forma. - (`np.ndarray` de forma (n, ) do tipo `np.float32` ou `np.float64`) Áudio bruto na taxa de amostragem correta (nenhuma verificação adicional será feita) - A forma `dict` pode ser usada para passar áudio bruto amostrado em uma `sampling_rate` arbitrária e deixar que este pipeline faça a reamostragem. O dict deve estar no formato `{"sampling_rate": int, "raw": np.array}` ou `{"sampling_rate": int, "array": np.array}`, onde a chave `"raw"` ou `"array"` é usada para denotar a forma de onda do áudio bruto. top_k (`int`, *opcional*, padrão None) : O número de rótulos principais que serão retornados pelo pipeline. Se o número fornecido for `None` ou maior que o número de rótulos disponíveis na configuração do modelo, o padrão será o número de rótulos. function_to_apply (`str`, *opcional*, padrão "softmax") : A função a ser aplicada à saída do modelo. Por padrão, o pipeline aplicará a função softmax à saída do modelo. Opções válidas: ["softmax", "sigmoid", "none"]. Observe que passar o `None` embutido do Python resultará em "softmax" por padrão, portanto, é necessário passar a string "none" para desativar qualquer pós-processamento. **Retorna:** Uma lista de `dict` com as seguintes chaves - **label** (`str`) -- O rótulo previsto. - **score** (`float`) -- A probabilidade correspondente. Classifique a(s) sequência(s) fornecida(s) como entrada. Consulte a documentação do [AutomaticSpeechRecognitionPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.AutomaticSpeechRecognitionPipeline) para mais informações. ### AutomaticSpeechRecognitionPipeline[[transformers.AutomaticSpeechRecognitionPipeline]] #### transformers.AutomaticSpeechRecognitionPipeline[[transformers.AutomaticSpeechRecognitionPipeline]] ```python transformers.AutomaticSpeechRecognitionPipeline(model: PreTrainedModel, feature_extractor: typing.Union[ForwardRef('SequenceFeatureExtractor'), str, NoneType] = None, tokenizer: transformers.tokenization_python.PythonBackend | None = None, decoder: typing.Union[ForwardRef('BeamSearchDecoderCTC'), str, NoneType] = None, device: typing.Union[int, ForwardRef('torch.device'), NoneType] = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/automatic_speech_recognition.py#L147) **Parâmetros:** model ([PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel)): o modelo que será usado pelo pipeline para fazer previsões. Ele precisa ser um modelo que herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). feature_extractor ([SequenceFeatureExtractor](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), *opcional*) : O extrator de recursos que será usado pelo pipeline para codificar a forma de onda para o modelo. tokenizer ([PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend), *opcional*) : O tokenizer que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend). decoder (`pyctcdecode.BeamSearchDecoderCTC`, *opcional*) : [PyCTCDecode's BeamSearchDecoderCTC](https://github.com/kensho-technologies/pyctcdecode/blob/2fd33dc37c4111417e08d89ccd23d28e9b308d19/pyctcdecode/decoder.py#L180) pode ser passado para decodificação com reforço de modelo de linguagem. Consulte [Wav2Vec2ProcessorWithLM](/docs/transformers/main/pt/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM) para mais informações. device (Union[`int`, `torch.device`], *opcional*) : Ordinal do dispositivo para suporte a CPU/GPU. Definir isso como `None` utilizará a CPU, enquanto um valor positivo executará o modelo no id do dispositivo CUDA associado. Pipeline que visa extrair o texto falado contido em algum áudio. A entrada pode ser uma forma de onda bruta ou um arquivo de áudio. No caso de um arquivo de áudio, o ffmpeg deve estar instalado para suportar múltiplos formatos de áudio A menos que o modelo que você está usando defina explicitamente esses parâmetros de geração em seus arquivos de configuração (`generation_config.json`), os seguintes valores padrão serão usados: - max_new_tokens: 256 - num_beams: 5 Exemplo: ```python >>> from transformers import pipeline >>> transcriber = pipeline(model="openai/whisper-base") >>> transcriber("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/1.flac") {'text': ' He hoped there would be stew for dinner, turnips and carrots and bruised potatoes and fat mutton pieces to be ladled out in thick, peppered flour-fatten sauce.'} ``` Saiba mais sobre os fundamentos do uso de um pipeline no [tutorial de pipeline](../pipeline_tutorial) #### __call__[[transformers.AutomaticSpeechRecognitionPipeline.__call__]] ```python __call__(inputs: numpy.ndarray | bytes | str | dict, **kwargs: Any) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/automatic_speech_recognition.py#L232) **Parâmetros:** inputs (`np.ndarray` ou `bytes` ou `str` ou `dict`) : A entrada é uma das seguintes opções: - `str` que é o nome de um arquivo de áudio local ou um endereço de URL público para baixar o arquivo de áudio. O arquivo será lido na taxa de amostragem correta para obter a forma de onda usando *ffmpeg*. Isso requer que o *ffmpeg* esteja instalado no sistema. - `bytes` deve ser o conteúdo de um arquivo de áudio e é interpretado pelo *ffmpeg* da mesma forma. - (`np.ndarray` de forma (n, ) do tipo `np.float32` ou `np.float64`) Áudio bruto na taxa de amostragem correta (nenhuma verificação adicional será feita) - A forma `dict` pode ser usada para passar áudio bruto amostrado em uma `sampling_rate` arbitrária e deixar que este pipeline faça a reamostragem. O dict deve estar no formato `{"sampling_rate": int, "raw": np.array}` com, opcionalmente, um `"stride": (left: int, right: int)` que pode pedir ao pipeline para tratar os primeiros `left` amostras e os últimos `right` amostras para serem ignorados na decodificação (mas usados na inferência para fornecer mais contexto ao modelo). Use `stride` apenas com modelos CTC. return_timestamps (*opcional*, `str` ou `bool`) : Disponível apenas para modelos puros de CTC (Wav2Vec2, HuBERT, etc.) e para o modelo Whisper. Não está disponível para outros modelos de sequência-para-sequência. Para modelos de CTC, os timestamps podem ter um de dois formatos: - `"char"`: o pipeline retornará timestamps ao longo do texto para cada caractere do texto. Por exemplo, se você obtiver `[{"text": "h", "timestamp": (0.5, 0.6)}, {"text": "i", "timestamp": (0.7, 0.9)}]`, isso significa que o modelo prevê que a letra "h" foi falada após `0.5` e antes de `0.6` segundos. - `"word"`: o pipeline retornará timestamps ao longo do texto para cada palavra do texto. Por exemplo, se você obtiver `[{"text": "hi ", "timestamp": (0.5, 0.9)}, {"text": "there", "timestamp": (1.0, 1.5)}]`, isso significa que o modelo prevê que a palavra "hi" foi falada após `0.5` e antes de `0.9` segundos. Para o modelo Whisper, os timestamps podem ter um de dois formatos: - `"word"`: o mesmo que acima para timestamps de CTC em nível de palavra. Os timestamps em nível de palavra são previstos por meio do algoritmo *dynamic-time warping (DTW)*, uma aproximação para timestamps em nível de palavra ao inspecionar os pesos de atenção cruzada. - `True`: o pipeline retornará timestamps ao longo do texto para *segmentos* de palavras no texto. Por exemplo, se você obtiver `[{"text": " Hi there!", "timestamp": (0.5, 1.5)}]`, isso significa que o modelo prevê que o segmento "Hi there!" foi falado após `0.5` e antes de `1.5` segundos. Observe que um segmento de texto se refere a uma sequência de uma ou mais palavras, em vez de palavras individuais, como nos timestamps em nível de palavra. generate_kwargs (`dict`, *opcional*) : O dicionário de parametrização ad-hoc de `generate_config` a ser usado na chamada de geração. Para uma visão completa do generate, consulte o [guia a seguir](https://huggingface.co/docs/transformers/en/main_classes/text_generation). **Retorna:** `Dict` Um dicionário com as seguintes chaves: - **text** (`str`): O texto reconhecido. - **chunks** (*opcional(, `list[Dict]`) Ao usar `return_timestamps`, `chunks` se tornará uma lista contendo todos os diversos trechos de texto identificados pelo modelo, *por exemplo* `[{"text": "hi ", "timestamp": (0.5, 0.9)}, {"text": "there", "timestamp": (1.0, 1.5)}]`. O texto completo original pode ser recuperado aproximadamente executando `"".join(chunk["text"] for chunk in output["chunks"])`. Transcreva as sequências de áudio fornecidas como entradas para texto. Consulte a documentação do [AutomaticSpeechRecognitionPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.AutomaticSpeechRecognitionPipeline) para mais informações. ### TextToAudioPipeline[[transformers.TextToAudioPipeline]] #### transformers.TextToAudioPipeline[[transformers.TextToAudioPipeline]] ```python transformers.TextToAudioPipeline(*args, vocoder = None, sampling_rate = None, noise_scheduler = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/text_to_audio.py#L46) Pipeline de geração de áudio a partir de texto usando qualquer `AutoModelForTextToWaveform` ou `AutoModelForTextToSpectrogram`. Este pipeline gera um arquivo de áudio a partir de um texto de entrada e de outros inputs condicionais opcionais. A menos que o modelo que você está usando defina explicitamente os parâmetros de geração em `generation_config.json`, os valores padrão de `generation.configuration_utils.py._get_default_generation_params()` serão utilizados. - max_new_tokens: 256 Exemplo: ```python >>> from transformers import pipeline >>> pipe = pipeline(model="suno/bark-small") >>> output = pipe("Hey it's HuggingFace on the phone!") >>> audio = output["audio"] >>> sampling_rate = output["sampling_rate"] ``` Saiba mais sobre os fundamentos do uso de um pipeline no [tutorial de pipeline](../pipeline_tutorial) Você pode especificar os parâmetros passados ao modelo usando `TextToAudioPipeline.__call__.forward_params` ou `TextToAudioPipeline.__call__.generate_kwargs`. Exemplo: ```python >>> from transformers import pipeline >>> music_generator = pipeline(task="text-to-audio", model="facebook/musicgen-small") >>> # diversify the music generation by adding randomness with a high temperature and set a maximum music length >>> generate_kwargs = { ... "do_sample": True, ... "temperature": 0.7, ... "max_new_tokens": 35, ... } >>> outputs = music_generator("Techno music with high melodic riffs", generate_kwargs=generate_kwargs) ``` Este pipeline pode ser carregado atualmente a partir de [pipeline()](/docs/transformers/main/pt/main_classes/pipelines#transformers.pipeline) usando os seguintes identificadores de tarefa: `"text-to-speech"` ou `"text-to-audio"`. Veja a lista de modelos disponíveis em [huggingface.co/models](https://huggingface.co/models?filter=text-to-speech). #### __call__[[transformers.TextToAudioPipeline.__call__]] ```python __call__(text_inputs, **forward_params) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/text_to_audio.py#L260) **Parâmetros:** text_inputs (`str`, `list[str]`, `ChatType` ou `list[ChatType]`) : Um ou vários textos para gerar. Se strings ou uma lista de strings forem passadas, este pipeline gerará o texto correspondente. Alternativamente, um "chat", na forma de uma lista de dicts com as chaves "role" e "content", pode ser passado, ou uma lista de tais chats. Quando chats são passados, o modelo de chat do modelo será usado para formatá-los antes de passá-los ao modelo. forward_params (`dict`, *opcional*) : Parâmetros passados para o método de geração/forward do modelo. `forward_params` são sempre passados para o modelo subjacente. generate_kwargs (`dict`, *opcional*) : O dicionário de parametrização ad hoc de `generate_config` a ser usado na chamada de geração. Para uma visão completa do generate, consulte o [guia a seguir](https://huggingface.co/docs/transformers/en/main_classes/text_generation). `generate_kwargs` são passados apenas para o modelo subjacente se este for um modelo generativo, e têm precedência sobre `forward_params`. **Retorna:** `AudioOutput` ou uma lista de `AudioOutput`, que é um `TypedDict` com duas chaves - **audio** (`np.ndarray` de forma `(nb_channels, audio_length)`) -- A forma de onda de áudio gerada. - **sampling_rate** (`int`) -- A taxa de amostragem da forma de onda de áudio gerada. Gera fala/áudio a partir das entradas. Consulte a documentação do [TextToAudioPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.TextToAudioPipeline) para mais informações. ### ZeroShotAudioClassificationPipeline[[transformers.ZeroShotAudioClassificationPipeline]] #### transformers.ZeroShotAudioClassificationPipeline[[transformers.ZeroShotAudioClassificationPipeline]] ```python transformers.ZeroShotAudioClassificationPipeline(**kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/zero_shot_audio_classification.py#L32) **Parâmetros:** model ([PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel)): o modelo que será usado pelo pipeline para fazer previsões. Ele precisa ser um modelo que herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend)) : O tokenizer que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend). feature_extractor ([SequenceFeatureExtractor](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor)) : O extrator de recursos que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [SequenceFeatureExtractor](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor). task (`str`, padrão `""`) : Um identificador de tarefa para o pipeline. num_workers (`int`, *opcional*, padrão 8) : Quando o pipeline utilizar *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o número de workers a serem usados. batch_size (`int`, *opcional*, padrão 1) : Quando o pipeline usará *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o tamanho do lote a ser usado. Para inferência, isso nem sempre é vantajoso; leia [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/pt/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referência ao objeto responsável por analisar os parâmetros fornecidos do pipeline. device (`int` ou `str` ou `torch.device`, *opcional*) : Dispositivo no qual o pipeline é alocado. Se não for definido, o pipeline é colocado no primeiro acelerador disponível (CUDA, MPS, XPU, ...) e recorre para a CPU apenas quando nenhum estiver disponível; o modelo é movido para lá automaticamente. Passe `device="cpu"` (ou `-1`) para forçar o uso da CPU, um ordinal positivo ou `"cuda:1"` para selecionar um acelerador específico, ou um `torch.device`/`str` nativo. Este argumento não pode ser combinado com um modelo já carregado via `accelerate` (ou seja, um com `hf_device_map`). dtype (`str` ou `torch.dtype`, *opcional*, padrão `"auto"`) : A precisão na qual o modelo é carregado, encaminhada para `from_pretrained`. O padrão é `"auto"`, que carrega o modelo no dtype em que ele foi salvo (lido do `config.dtype` do checkpoint, ou inferido a partir dos pesos). Passe um `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescrever. binary_output (`bool`, *opcional*, padrão `False`) : Indica se a saída do pipeline deve ocorrer em um formato serializado (ou seja, pickle) ou como os dados de saída brutos, por exemplo, texto. Pipeline de classificação de áudio zero shot usando `ClapModel`. Este pipeline prevê a classe de um áudio quando você fornece um áudio e um conjunto de `candidate_labels`. O `hypothesis_template` padrão é: `"This is a sound of {}."`. Certifique-se de atualizá-lo para o seu uso. Exemplo: ```python >>> from transformers import pipeline >>> from datasets import load_dataset >>> dataset = load_dataset("ashraq/esc50") >>> audio = next(iter(dataset["train"]["audio"]))["array"] >>> classifier = pipeline(task="zero-shot-audio-classification", model="laion/clap-htsat-unfused") >>> classifier(audio, candidate_labels=["Sound of a dog", "Sound of vacuum cleaner"]) [{'score': 0.9996, 'label': 'Sound of a dog'}, {'score': 0.0004, 'label': 'Sound of vacuum cleaner'}] ``` Saiba mais sobre os fundamentos do uso de um pipeline no [tutorial de pipeline](../pipeline_tutorial). Este pipeline de classificação de áudio pode ser carregado atualmente a partir de [pipeline()](/docs/transformers/main/pt/main_classes/pipelines#transformers.pipeline) usando o seguinte identificador de tarefa: `"zero-shot-audio-classification"`. Consulte a lista de modelos disponíveis em [huggingface.co/models](https://huggingface.co/models?filter=zero-shot-audio-classification). #### __call__[[transformers.ZeroShotAudioClassificationPipeline.__call__]] ```python __call__(audios: numpy.ndarray | bytes | str | dict, **kwargs: Any) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/zero_shot_audio_classification.py#L70) **Parâmetros:** audios (`str`, `list[str]`, `np.array` ou `list[np.array]`) : O pipeline trata três tipos de entradas: - Uma string contendo um link http apontando para um áudio - Uma string contendo um caminho local para um áudio - Um áudio carregado em numpy candidate_labels (`list[str]`) : Os rótulos candidatos para este áudio. Eles serão formatados usando *hypothesis_template*. hypothesis_template (`str`, *opcional*, padrão `"This is a sound of {}"`) : O formato usado em conjunto com *candidate_labels* para tentar a classificação de áudio substituindo o placeholder pelos candidate_labels. Passe "{}" se *candidate_labels* já estiverem formatados. **Retorna:** Uma lista de dicionários contendo uma entrada por rótulo proposto. Cada dicionário contém as seguintes chaves: - **label** (`str`) -- Um dos *candidate_labels* sugeridos. - **score** (`float`) -- A pontuação atribuída pelo modelo a esse rótulo. É um valor entre 0 e 1, calculado como o `softmax` de `logits_per_audio`. Atribua rótulos aos áudios passados como entradas. ## Visão computacional Os pipelines disponíveis para tarefas de visão computacional incluem os seguintes. ### DepthEstimationPipeline[[transformers.DepthEstimationPipeline]] #### transformers.DepthEstimationPipeline[[transformers.DepthEstimationPipeline]] ```python transformers.DepthEstimationPipeline(*args, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/depth_estimation.py#L25) **Parâmetros:** model ([PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel)): o modelo que será usado pelo pipeline para fazer previsões. Ele precisa ser um modelo que herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor)): o processador de imagens que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, padrão `""`) : Um identificador de tarefa para o pipeline. num_workers (`int`, *opcional*, padrão 8) : Quando o pipeline utilizar *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o número de workers a serem usados. batch_size (`int`, *opcional*, padrão 1) : Quando o pipeline usará *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o tamanho do lote a ser usado. Para inferência, isso nem sempre é vantajoso; leia [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/pt/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referência ao objeto responsável por analisar os parâmetros fornecidos do pipeline. device (`int` ou `str` ou `torch.device`, *opcional*) : Dispositivo no qual o pipeline é alocado. Se não for definido, o pipeline é colocado no primeiro acelerador disponível (CUDA, MPS, XPU, ...) e recorre para a CPU apenas quando nenhum estiver disponível; o modelo é movido para lá automaticamente. Passe `device="cpu"` (ou `-1`) para forçar o uso da CPU, um ordinal positivo ou `"cuda:1"` para selecionar um acelerador específico, ou um `torch.device`/`str` nativo. Este argumento não pode ser combinado com um modelo já carregado via `accelerate` (ou seja, um com `hf_device_map`). dtype (`str` ou `torch.dtype`, *opcional*, padrão `"auto"`) : A precisão na qual o modelo é carregado, encaminhada para `from_pretrained`. O padrão é `"auto"`, que carrega o modelo no dtype em que ele foi salvo (lido do `config.dtype` do checkpoint, ou inferido a partir dos pesos). Passe um `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescrever. binary_output (`bool`, *opcional*, padrão `False`) : Indica se a saída do pipeline deve ocorrer em um formato serializado (ou seja, pickle) ou como os dados de saída brutos, por exemplo, texto. Pipeline de estimativa de profundidade usando qualquer `AutoModelForDepthEstimation`. Este pipeline prevê a profundidade de uma imagem. Exemplo: ```python >>> from transformers import pipeline >>> depth_estimator = pipeline(task="depth-estimation", model="LiheYoung/depth-anything-base-hf") >>> output = depth_estimator("http://images.cocodataset.org/val2017/000000039769.jpg") >>> # This is a tensor with the values being the depth expressed in meters for each pixel >>> output["predicted_depth"].shape torch.Size([1, 384, 384]) ``` Saiba mais sobre os fundamentos do uso de um pipeline no [tutorial de pipeline](../pipeline_tutorial) Este pipeline de estimativa de profundidade pode ser carregado atualmente a partir de [pipeline()](/docs/transformers/main/pt/main_classes/pipelines#transformers.pipeline) usando o seguinte identificador de tarefa: `"depth-estimation"`. Veja a lista de modelos disponíveis em [huggingface.co/models](https://huggingface.co/models?filter=depth-estimation). #### __call__[[transformers.DepthEstimationPipeline.__call__]] ```python __call__(inputs: typing.Union[str, list[str], ForwardRef('Image.Image'), list['Image.Image']], **kwargs: Any) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/depth_estimation.py#L66) **Parâmetros:** inputs (`str`, `list[str]`, `PIL.Image` ou `list[PIL.Image]`) : O pipeline lida com três tipos de imagens: - Uma string contendo um link http que aponta para uma imagem - Uma string contendo um caminho local para uma imagem - Uma imagem carregada diretamente em PIL O pipeline aceita uma única imagem ou um lote de imagens, que deve ser passado como uma string. As imagens em um lote devem estar todas no mesmo formato: todas como links http, todas como caminhos locais ou todas como imagens PIL. parameters (`Dict`, *opcional*) : Um dicionário de nomes de argumentos para valores de parâmetros, para controlar o comportamento do pipeline. O único parâmetro disponível no momento é `timeout`, que é o tempo, em segundos, que o pipeline deve aguardar antes de desistir de tentar baixar uma imagem. timeout (`float`, *opcional*, padrão None) : O tempo máximo, em segundos, para aguardar a busca de imagens da web. Se for None, nenhum tempo limite é definido e a chamada pode bloquear indefinidamente. **Retorna:** Um dicionário ou uma lista de dicionários contendo o resultado. Se a entrada for uma única imagem, será retornado um dicionário; se a entrada for uma lista de várias imagens, será retornada uma lista de dicionários correspondentes às imagens. Os dicionários contêm as seguintes chaves: - **predicted_depth** (`torch.Tensor`) -- A profundidade prevista pelo modelo como um `torch.Tensor`. - **depth** (`PIL.Image`) -- A profundidade prevista pelo modelo como uma `PIL.Image`. Preveja a(s) profundidade(s) da(s) imagem(ns) passada(s) como entrada(s). ### ImageClassificationPipeline[[transformers.ImageClassificationPipeline]] #### transformers.ImageClassificationPipeline[[transformers.ImageClassificationPipeline]] ```python transformers.ImageClassificationPipeline(*args, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/image_classification.py#L73) **Parâmetros:** model ([PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel)): o modelo que será usado pelo pipeline para fazer previsões. Ele precisa ser um modelo que herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor)): o processador de imagens que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, padrão `""`) : Um identificador de tarefa para o pipeline. num_workers (`int`, *opcional*, padrão 8) : Quando o pipeline utilizar *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o número de workers a serem usados. batch_size (`int`, *opcional*, padrão 1) : Quando o pipeline usará *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o tamanho do lote a ser usado. Para inferência, isso nem sempre é vantajoso; leia [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/pt/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referência ao objeto responsável por analisar os parâmetros fornecidos do pipeline. device (`int` ou `str` ou `torch.device`, *opcional*) : Dispositivo no qual o pipeline é alocado. Se não for definido, o pipeline é colocado no primeiro acelerador disponível (CUDA, MPS, XPU, ...) e recorre para a CPU apenas quando nenhum estiver disponível; o modelo é movido para lá automaticamente. Passe `device="cpu"` (ou `-1`) para forçar o uso da CPU, um ordinal positivo ou `"cuda:1"` para selecionar um acelerador específico, ou um `torch.device`/`str` nativo. Este argumento não pode ser combinado com um modelo já carregado via `accelerate` (ou seja, um com `hf_device_map`). dtype (`str` ou `torch.dtype`, *opcional*, padrão `"auto"`) : A precisão na qual o modelo é carregado, encaminhada para `from_pretrained`. O padrão é `"auto"`, que carrega o modelo no dtype em que ele foi salvo (lido do `config.dtype` do checkpoint, ou inferido a partir dos pesos). Passe um `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescrever. binary_output (`bool`, *opcional*, padrão `False`) : Indica se a saída do pipeline deve ocorrer em um formato serializado (ou seja, pickle) ou como os dados de saída brutos, por exemplo, texto. function_to_apply (`str`, *opcional*, padrão `"default"`) : A função a ser aplicada às saídas do modelo para recuperar as pontuações. Aceita quatro valores diferentes: - `"default"`: se o modelo tiver um único rótulo, aplicará a função sigmoid na saída. Se o modelo tiver vários rótulos, aplicará a função softmax na saída. - `"sigmoid"`: Aplica a função sigmoid na saída. - `"softmax"`: Aplica a função softmax na saída. - `"none"`: Não aplica nenhuma função na saída. Pipeline de classificação de imagens usando qualquer `AutoModelForImageClassification`. Este pipeline prevê a classe de uma imagem. Exemplo: ```python >>> from transformers import pipeline >>> classifier = pipeline(model="microsoft/beit-base-patch16-224-pt22k-ft22k") >>> classifier("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png") [{'score': 0.442, 'label': 'macaw'}, {'score': 0.088, 'label': 'popinjay'}, {'score': 0.075, 'label': 'parrot'}, {'score': 0.073, 'label': 'parodist, lampooner'}, {'score': 0.046, 'label': 'poll, poll_parrot'}] ``` Saiba mais sobre os fundamentos do uso de um pipeline no [tutorial de pipeline](../pipeline_tutorial) Este pipeline de classificação de imagens pode ser carregado atualmente a partir de [pipeline()](/docs/transformers/main/pt/main_classes/pipelines#transformers.pipeline) usando o seguinte identificador de tarefa: `"image-classification"`. Veja a lista de modelos disponíveis em [huggingface.co/models](https://huggingface.co/models?filter=image-classification). #### __call__[[transformers.ImageClassificationPipeline.__call__]] ```python __call__(inputs: typing.Union[str, list[str], ForwardRef('Image.Image'), list['Image.Image']], **kwargs: Any) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/image_classification.py#L127) **Parâmetros:** inputs (`str`, `list[str]`, `PIL.Image` ou `list[PIL.Image]`) : O pipeline lida com três tipos de imagens: - Uma string contendo um link http que aponta para uma imagem - Uma string contendo um caminho local para uma imagem - Uma imagem carregada diretamente em PIL O pipeline aceita uma única imagem ou um lote de imagens, que deve ser passado como uma string. As imagens em um lote devem estar todas no mesmo formato: todas como links http, todas como caminhos locais ou todas como imagens PIL. function_to_apply (`str`, *opcional*, padrão `"default"`) : A função a ser aplicada às saídas do modelo para recuperar as pontuações. Aceita quatro valores diferentes: Se esse argumento não for especificado, as seguintes funções serão aplicadas de acordo com o número de rótulos: - Se o modelo tiver um único rótulo, a função sigmoid será aplicada à saída. - Se o modelo tiver vários rótulos, a função softmax será aplicada à saída. Os valores possíveis são: - `"sigmoid"`: Aplica a função sigmoid à saída. - `"softmax"`: Aplica a função softmax à saída. - `"none"`: Não aplica nenhuma função à saída. top_k (`int`, *opcional*, padrão 5) : O número de rótulos principais que serão retornados pelo pipeline. Se o número fornecido for maior que o número de rótulos disponíveis na configuração do modelo, ele será definido como o número de rótulos. timeout (`float`, *opcional*, padrão None) : O tempo máximo, em segundos, para aguardar a busca de imagens da web. Se for None, nenhum tempo limite é definido e a chamada pode bloquear indefinidamente. **Retorna:** Um dicionário ou uma lista de dicionários contendo o resultado. Se a entrada for uma única imagem, será retornado um dicionário; se a entrada for uma lista de várias imagens, será retornada uma lista de dicionários correspondentes às imagens. Os dicionários contêm as seguintes chaves: - **label** (`str`) -- O rótulo identificado pelo modelo. - **score** (`int`) -- A pontuação atribuída pelo modelo para esse rótulo. Atribua rótulos às imagens passadas como entradas. ### ImageSegmentationPipeline[[transformers.ImageSegmentationPipeline]] #### transformers.ImageSegmentationPipeline[[transformers.ImageSegmentationPipeline]] ```python transformers.ImageSegmentationPipeline(*args, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/image_segmentation.py#L27) **Parâmetros:** model ([PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel)): o modelo que será usado pelo pipeline para fazer previsões. Ele precisa ser um modelo que herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor)): o processador de imagens que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, padrão `""`) : Um identificador de tarefa para o pipeline. num_workers (`int`, *opcional*, padrão 8) : Quando o pipeline utilizar *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o número de workers a serem usados. batch_size (`int`, *opcional*, padrão 1) : Quando o pipeline usará *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o tamanho do lote a ser usado. Para inferência, isso nem sempre é vantajoso; leia [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/pt/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referência ao objeto responsável por analisar os parâmetros fornecidos do pipeline. device (`int` ou `str` ou `torch.device`, *opcional*) : Dispositivo no qual o pipeline é alocado. Se não for definido, o pipeline é colocado no primeiro acelerador disponível (CUDA, MPS, XPU, ...) e recorre para a CPU apenas quando nenhum estiver disponível; o modelo é movido para lá automaticamente. Passe `device="cpu"` (ou `-1`) para forçar o uso da CPU, um ordinal positivo ou `"cuda:1"` para selecionar um acelerador específico, ou um `torch.device`/`str` nativo. Este argumento não pode ser combinado com um modelo já carregado via `accelerate` (ou seja, um com `hf_device_map`). dtype (`str` ou `torch.dtype`, *opcional*, padrão `"auto"`) : A precisão na qual o modelo é carregado, encaminhada para `from_pretrained`. O padrão é `"auto"`, que carrega o modelo no dtype em que ele foi salvo (lido do `config.dtype` do checkpoint, ou inferido a partir dos pesos). Passe um `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescrever. binary_output (`bool`, *opcional*, padrão `False`) : Indica se a saída do pipeline deve ocorrer em um formato serializado (ou seja, pickle) ou como os dados de saída brutos, por exemplo, texto. Pipeline de segmentação de imagem usando qualquer `AutoModelForXXXSegmentation`. Este pipeline prevê máscaras de objetos e suas classes. Exemplo: ```python >>> from transformers import pipeline >>> segmenter = pipeline(model="facebook/detr-resnet-50-panoptic") >>> segments = segmenter("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png") >>> len(segments) 2 >>> segments[0]["label"] 'bird' >>> segments[1]["label"] 'bird' >>> type(segments[0]["mask"]) # This is a black and white mask showing where is the bird on the original image. >>> segments[0]["mask"].size (768, 512) ``` Este pipeline de segmentação de imagem pode ser carregado atualmente a partir de [pipeline()](/docs/transformers/main/pt/main_classes/pipelines#transformers.pipeline) usando o seguinte identificador de tarefa: `"image-segmentation"`. Veja a lista de modelos disponíveis em [huggingface.co/models](https://huggingface.co/models?filter=image-segmentation). #### __call__[[transformers.ImageSegmentationPipeline.__call__]] ```python __call__(inputs: typing.Union[str, ForwardRef('Image.Image'), list[str], list['Image.Image']], **kwargs: Any) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/image_segmentation.py#L101) **Parâmetros:** inputs (`str`, `list[str]`, `PIL.Image` ou `list[PIL.Image]`) : O pipeline processa três tipos de imagens: - Uma string contendo um link HTTP(S) que aponta para uma imagem - Uma string contendo um caminho local para uma imagem - Uma imagem carregada diretamente em PIL O pipeline aceita uma única imagem ou um lote de imagens. As imagens em um lote devem estar todas no mesmo formato: todas como links HTTP(S), todas como caminhos locais ou todas como imagens PIL. subtask (`str`, *opcional*) : Tarefa de segmentação a ser executada, escolha entre [`semantic`, `instance` e `panoptic`] de acordo com as capacidades do modelo. Se não for definido, o pipeline tentará resolver na seguinte ordem: `panoptic`, `instance`, `semantic`. threshold (`float`, *opcional*, padrão 0.9) : Limiar de probabilidade para filtrar máscaras previstas. mask_threshold (`float`, *opcional*, padrão 0.5) : Limiar a ser utilizado ao converter as máscaras previstas em valores binários. overlap_mask_area_threshold (`float`, *opcional*, padrão 0.5) : Limiar de sobreposição da máscara para eliminar segmentos pequenos e desconectados. timeout (`float`, *opcional*, padrão None) : O tempo máximo, em segundos, para aguardar a busca de imagens da web. Se for None, nenhum tempo limite é definido e a chamada pode bloquear indefinidamente. **Retorna:** Se a entrada for uma única imagem, retornará uma lista de dicionários; se a entrada for uma lista de várias imagens, retornará uma lista de listas de dicionários correspondentes a cada imagem. Os dicionários contêm a máscara, o rótulo e a pontuação (quando aplicável) de cada objeto detectado e possuem as seguintes chaves: - **label** (`str`) -- O rótulo da classe identificado pelo modelo. - **mask** (`PIL.Image`) -- Uma máscara binária do objeto detectado, na forma de uma imagem PIL com as dimensões (largura, altura) da imagem original. Retorna uma máscara preenchida com zeros se nenhum objeto for encontrado. - **score** (*opcional* `float`) -- Opcionalmente, quando o modelo é capaz de estimar a confiança do "objeto" descrito pelo rótulo e pela máscara. Realize a segmentação (detectar máscaras & classes) na(s) imagem(ns) passada(s) como entrada(s). ### KeypointMatchingPipeline[[transformers.KeypointMatchingPipeline]] #### transformers.KeypointMatchingPipeline[[transformers.KeypointMatchingPipeline]] ```python transformers.KeypointMatchingPipeline(*args, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/keypoint_matching.py#L67) Pipeline de correspondência de pontos-chave usando qualquer `AutoModelForKeypointMatching`. Este pipeline corresponde pontos-chave entre duas imagens. #### __call__[[transformers.KeypointMatchingPipeline.__call__]] ```python __call__(inputs: list[collections.abc.Sequence[typing.Union[ForwardRef('Image.Image'), str]]] | collections.abc.Sequence[typing.Union[ForwardRef('Image.Image'), str]], threshold: float = 0.0, **kwargs: Any) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/keypoint_matching.py#L96) **Parâmetros:** inputs (`str`, `list[str]`, `PIL.Image` ou `list[PIL.Image]`) : O pipeline lida com três tipos de imagens: - Uma string contendo um link http que aponta para uma imagem - Uma string contendo um caminho local para uma imagem - Uma imagem carregada diretamente em PIL O pipeline aceita um único par de imagens ou um lote de pares de imagens, que deve ser passado como uma string. As imagens em um lote devem estar todas no mesmo formato: todas como links http, todas como caminhos locais ou todas como imagens PIL. threshold (`float`, *opcional*, padrão 0.0) : O limiar a ser usado para o casamento de pontos-chave. Pontos-chave casados com uma pontuação de casamento menor serão filtrados. Um valor de 0 significa que todos os pontos-chave casados serão retornados. kwargs : `timeout (`float`, *optional*, defaults to None)` O tempo máximo, em segundos, para aguardar a busca de imagens da web. Se for None, nenhum tempo limite é definido e a chamada pode bloquear indefinidamente. **Retorna:** Union[list[Match], list[list[Match]]] Uma lista de correspondências ou uma lista se um único par de imagens for fornecido, ou uma lista de listas de correspondências se um lote de pares de imagens for fornecido. Cada correspondência é um dicionário contendo as seguintes chaves: - **keypoint_image_0** (`Keypoint`): O ponto-chave na primeira imagem (coordenadas x, y). - **keypoint_image_1** (`Keypoint`): O ponto-chave na segunda imagem (coordenadas x, y). - **score** (`float`): A pontuação de correspondência entre os dois pontos-chave. Encontre correspondências entre pontos-chave em duas imagens. ### ObjectDetectionPipeline[[transformers.ObjectDetectionPipeline]] #### transformers.ObjectDetectionPipeline[[transformers.ObjectDetectionPipeline]] ```python transformers.ObjectDetectionPipeline(*args, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/object_detection.py#L26) **Parâmetros:** model ([PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel)): o modelo que será usado pelo pipeline para fazer previsões. Ele precisa ser um modelo que herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor)): o processador de imagens que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, padrão `""`) : Um identificador de tarefa para o pipeline. num_workers (`int`, *opcional*, padrão 8) : Quando o pipeline utilizar *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o número de workers a serem usados. batch_size (`int`, *opcional*, padrão 1) : Quando o pipeline usará *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o tamanho do lote a ser usado. Para inferência, isso nem sempre é vantajoso; leia [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/pt/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referência ao objeto responsável por analisar os parâmetros fornecidos do pipeline. device (`int` ou `str` ou `torch.device`, *opcional*) : Dispositivo no qual o pipeline é alocado. Se não for definido, o pipeline é colocado no primeiro acelerador disponível (CUDA, MPS, XPU, ...) e recorre para a CPU apenas quando nenhum estiver disponível; o modelo é movido para lá automaticamente. Passe `device="cpu"` (ou `-1`) para forçar o uso da CPU, um ordinal positivo ou `"cuda:1"` para selecionar um acelerador específico, ou um `torch.device`/`str` nativo. Este argumento não pode ser combinado com um modelo já carregado via `accelerate` (ou seja, um com `hf_device_map`). dtype (`str` ou `torch.dtype`, *opcional*, padrão `"auto"`) : A precisão na qual o modelo é carregado, encaminhada para `from_pretrained`. O padrão é `"auto"`, que carrega o modelo no dtype em que ele foi salvo (lido do `config.dtype` do checkpoint, ou inferido a partir dos pesos). Passe um `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescrever. binary_output (`bool`, *opcional*, padrão `False`) : Indica se a saída do pipeline deve ocorrer em um formato serializado (ou seja, pickle) ou como os dados de saída brutos, por exemplo, texto. Pipeline de detecção de objetos usando qualquer `AutoModelForObjectDetection`. Este pipeline prevê as caixas delimitadoras dos objetos e suas classes. Exemplo: ```python >>> from transformers import pipeline >>> detector = pipeline(model="facebook/detr-resnet-50") >>> detector("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png") [{'score': 0.997, 'label': 'bird', 'box': {'xmin': 69, 'ymin': 171, 'xmax': 396, 'ymax': 507}}, {'score': 0.999, 'label': 'bird', 'box': {'xmin': 398, 'ymin': 105, 'xmax': 767, 'ymax': 507}}] >>> # x, y are expressed relative to the top left hand corner. ``` Saiba mais sobre os fundamentos do uso de um pipeline no [tutorial de pipeline](../pipeline_tutorial) Este pipeline de detecção de objetos pode ser carregado atualmente a partir de [pipeline()](/docs/transformers/main/pt/main_classes/pipelines#transformers.pipeline) usando o seguinte identificador de tarefa: `"object-detection"`. Veja a lista de modelos disponíveis em [huggingface.co/models](https://huggingface.co/models?filter=object-detection). #### __call__[[transformers.ObjectDetectionPipeline.__call__]] ```python __call__(*args, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/object_detection.py#L81) **Parâmetros:** inputs (`str`, `list[str]`, `PIL.Image` ou `list[PIL.Image]`) : O pipeline processa três tipos de imagens: - Uma string contendo um link HTTP(S) que aponta para uma imagem - Uma string contendo um caminho local para uma imagem - Uma imagem carregada diretamente em PIL O pipeline aceita uma única imagem ou um lote de imagens. As imagens em um lote devem estar todas no mesmo formato: todas como links HTTP(S), todas como caminhos locais ou todas como imagens PIL. threshold (`float`, *opcional*, padrão 0.5) : A probabilidade necessária para fazer uma previsão. timeout (`float`, *opcional*, padrão None) : O tempo máximo, em segundos, para aguardar a busca de imagens da web. Se for None, nenhum tempo limite é definido e a chamada pode bloquear indefinidamente. **Retorna:** Uma lista de dicionários ou uma lista de listas de dicionários contendo o resultado. Se a entrada for uma única imagem, será retornada uma lista de dicionários; se a entrada for uma lista de várias imagens, será retornada uma lista de listas de dicionários correspondentes a cada imagem. Os dicionários contêm as seguintes chaves: - **label** (`str`) -- O rótulo da classe identificado pelo modelo. - **score** (`float`) -- A pontuação atribuída pelo modelo para esse rótulo. - **box** (`list[dict[str, int]]`) -- A caixa delimitadora do objeto detectado no tamanho original da imagem. Detecte objetos (caixas delimitadoras & classes) nas imagens passadas como entradas. ### VideoClassificationPipeline[[transformers.VideoClassificationPipeline]] #### transformers.VideoClassificationPipeline[[transformers.VideoClassificationPipeline]] ```python transformers.VideoClassificationPipeline(*args, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/video_classification.py#L41) **Parâmetros:** model ([PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel)): o modelo que será usado pelo pipeline para fazer previsões. Ele precisa ser um modelo que herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor)): o processador de imagens que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor). video_processor ([BaseVideoProcessor](/docs/transformers/main/pt/main_classes/video_processor#transformers.BaseVideoProcessor)) : o processador de vídeo que será usado pelo pipeline para codificar os dados de vídeo para o modelo. Este objeto herda de [BaseVideoProcessor](/docs/transformers/main/pt/main_classes/video_processor#transformers.BaseVideoProcessor). task (`str`, padrão `""`) : Um identificador de tarefa para o pipeline. num_workers (`int`, *opcional*, padrão 8) : Quando o pipeline utilizar *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o número de workers a serem usados. batch_size (`int`, *opcional*, padrão 1) : Quando o pipeline usará *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o tamanho do lote a ser usado. Para inferência, isso nem sempre é vantajoso; leia [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/pt/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referência ao objeto responsável por analisar os parâmetros fornecidos do pipeline. device (`int` ou `str` ou `torch.device`, *opcional*) : Dispositivo no qual o pipeline é alocado. Se não for definido, o pipeline é colocado no primeiro acelerador disponível (CUDA, MPS, XPU, ...) e recorre para a CPU apenas quando nenhum estiver disponível; o modelo é movido para lá automaticamente. Passe `device="cpu"` (ou `-1`) para forçar o uso da CPU, um ordinal positivo ou `"cuda:1"` para selecionar um acelerador específico, ou um `torch.device`/`str` nativo. Este argumento não pode ser combinado com um modelo já carregado via `accelerate` (ou seja, um com `hf_device_map`). dtype (`str` ou `torch.dtype`, *opcional*, padrão `"auto"`) : A precisão na qual o modelo é carregado, encaminhada para `from_pretrained`. O padrão é `"auto"`, que carrega o modelo no dtype em que ele foi salvo (lido do `config.dtype` do checkpoint, ou inferido a partir dos pesos). Passe um `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescrever. binary_output (`bool`, *opcional*, padrão `False`) : Indica se a saída do pipeline deve ocorrer em um formato serializado (ou seja, pickle) ou como os dados de saída brutos, por exemplo, texto. Pipeline de classificação de vídeo usando qualquer `AutoModelForVideoClassification`. Este pipeline prevê a classe de um vídeo. Este pipeline de classificação de vídeo pode ser carregado atualmente a partir de [pipeline()](/docs/transformers/main/pt/main_classes/pipelines#transformers.pipeline) usando o seguinte identificador de tarefa: `"video-classification"`. Veja a lista de modelos disponíveis em [huggingface.co/models](https://huggingface.co/models?filter=video-classification). O pipeline suporta modelos que utilizam um processador de imagem (modelos de vídeo legados, como VideoMAE, ViViT e TimeSformer) ou um processador de vídeo (modelos mais recentes, como VJEPA2). Quando ambos estão presentes, o processador de vídeo tem prioridade; quando nenhum é encontrado, o pipeline lançará um erro. #### __call__[[transformers.VideoClassificationPipeline.__call__]] ```python __call__(inputs: str | list[str] | None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/video_classification.py#L105) **Parâmetros:** inputs (`str`, `list[str]`) : O pipeline trata três tipos de vídeos: - Uma string contendo um link http que aponta para um vídeo - Uma string contendo um caminho local para um vídeo O pipeline aceita um único vídeo ou um lote de vídeos, que deve ser passado como uma string. Os vídeos em um lote devem estar todos no mesmo formato: todos como links http ou todos como caminhos locais. top_k (`int`, *opcional*, padrão 5) : O número de rótulos principais que serão retornados pelo pipeline. Se o número fornecido for maior que o número de rótulos disponíveis na configuração do modelo, ele será definido como o número de rótulos. num_frames (`int`, *opcional*, padrão `self.model.config.num_frames`) : O número de quadros amostrados do vídeo para executar a classificação. Se não for fornecido, o padrão será o número de quadros especificado na configuração do modelo. frame_sampling_rate (`int`, *opcional*, padrão 1) : A taxa de amostragem usada para selecionar quadros do vídeo. Se não for fornecida, o padrão será 1, ou seja, todos os quadros serão usados. function_to_apply(`str`, *opcional*, padrão "softmax") : A função a ser aplicada à saída do modelo. Por padrão, o pipeline aplicará a função softmax à saída do modelo. Opções válidas: ["softmax", "sigmoid", "none"]. Observe que passar o valor `None` nativo do Python resultará em "softmax" por padrão, portanto, é necessário passar a string "none" para desativar qualquer pós-processamento. **Retorna:** Uma lista de dicionários ou uma lista de listas de dicionários contendo o resultado. Se a entrada for um único vídeo, será retornada uma lista de `top_k` dicionários; se a entrada for uma lista de vários vídeos, será retornada uma lista de listas de `top_k` dicionários correspondentes aos vídeos. Os dicionários contêm as seguintes chaves: - **label** (`str`) -- O rótulo identificado pelo modelo. - **score** (`int`) -- A pontuação atribuída pelo modelo para esse rótulo. Atribua rótulos ao(s) vídeo(s) passado(s) como entrada(s). ### ZeroShotImageClassificationPipeline[[transformers.ZeroShotImageClassificationPipeline]] #### transformers.ZeroShotImageClassificationPipeline[[transformers.ZeroShotImageClassificationPipeline]] ```python transformers.ZeroShotImageClassificationPipeline(**kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/zero_shot_image_classification.py#L29) **Parâmetros:** model ([PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel)): o modelo que será usado pelo pipeline para fazer previsões. Ele precisa ser um modelo que herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor)): o processador de imagens que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, padrão `""`) : Um identificador de tarefa para o pipeline. num_workers (`int`, *opcional*, padrão 8) : Quando o pipeline utilizar *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o número de workers a serem usados. batch_size (`int`, *opcional*, padrão 1) : Quando o pipeline usará *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o tamanho do lote a ser usado. Para inferência, isso nem sempre é vantajoso; leia [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/pt/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referência ao objeto responsável por analisar os parâmetros fornecidos do pipeline. device (`int` ou `str` ou `torch.device`, *opcional*) : Dispositivo no qual o pipeline é alocado. Se não for definido, o pipeline é colocado no primeiro acelerador disponível (CUDA, MPS, XPU, ...) e recorre para a CPU apenas quando nenhum estiver disponível; o modelo é movido para lá automaticamente. Passe `device="cpu"` (ou `-1`) para forçar o uso da CPU, um ordinal positivo ou `"cuda:1"` para selecionar um acelerador específico, ou um `torch.device`/`str` nativo. Este argumento não pode ser combinado com um modelo já carregado via `accelerate` (ou seja, um com `hf_device_map`). dtype (`str` ou `torch.dtype`, *opcional*, padrão `"auto"`) : A precisão na qual o modelo é carregado, encaminhada para `from_pretrained`. O padrão é `"auto"`, que carrega o modelo no dtype em que ele foi salvo (lido do `config.dtype` do checkpoint, ou inferido a partir dos pesos). Passe um `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescrever. binary_output (`bool`, *opcional*, padrão `False`) : Indica se a saída do pipeline deve ocorrer em um formato serializado (ou seja, pickle) ou como os dados de saída brutos, por exemplo, texto. Pipeline de classificação de imagem zero shot usando `CLIPModel`. Este pipeline prevê a classe de uma imagem quando você fornece uma imagem e um conjunto de `candidate_labels`. Exemplo: ```python >>> from transformers import pipeline >>> classifier = pipeline(model="google/siglip-so400m-patch14-384") >>> classifier( ... "https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png", ... candidate_labels=["animals", "humans", "landscape"], ... ) [{'score': 0.965, 'label': 'animals'}, {'score': 0.03, 'label': 'humans'}, {'score': 0.005, 'label': 'landscape'}] >>> classifier( ... "https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png", ... candidate_labels=["black and white", "photorealist", "painting"], ... ) [{'score': 0.996, 'label': 'black and white'}, {'score': 0.003, 'label': 'photorealist'}, {'score': 0.0, 'label': 'painting'}] ``` Saiba mais sobre os fundamentos do uso de um pipeline no [tutorial de pipeline](../pipeline_tutorial) Este pipeline de classificação de imagens pode ser carregado atualmente a partir de [pipeline()](/docs/transformers/main/pt/main_classes/pipelines#transformers.pipeline) usando o seguinte identificador de tarefa: `"zero-shot-image-classification"`. Veja a lista de modelos disponíveis em [huggingface.co/models](https://huggingface.co/models?filter=zero-shot-image-classification). #### __call__[[transformers.ZeroShotImageClassificationPipeline.__call__]] ```python __call__(image: typing.Union[str, list[str], ForwardRef('Image.Image'), list['Image.Image']], candidate_labels: list, **kwargs: Any) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/zero_shot_image_classification.py#L83) **Parâmetros:** image (`str`, `list[str]`, `PIL.Image` ou `list[PIL.Image]`) : O pipeline trata três tipos de imagens: - Uma string contendo um link http que aponta para uma imagem - Uma string contendo um caminho local para uma imagem - Uma imagem carregada diretamente em PIL candidate_labels (`list[str]`) : Os rótulos candidatos para esta imagem. Eles serão formatados usando *hypothesis_template*. hypothesis_template (`str`, *opcional*, padrão `"This is a photo of {}"`) : O formato usado em conjunto com *candidate_labels* para tentar a classificação de imagem substituindo o marcador de posição pelos candidate_labels. Passe "{}" se *candidate_labels* já estiverem formatados. timeout (`float`, *opcional*, padrão None) : O tempo máximo, em segundos, para aguardar a busca de imagens da web. Se for None, nenhum tempo limite é definido e a chamada pode bloquear indefinidamente. **Retorna:** Uma lista de dicionários contendo uma entrada por rótulo proposto. Cada dicionário contém as seguintes chaves: - **label** (`str`) -- Um dos *candidate_labels* sugeridos. - **score** (`float`) -- A pontuação atribuída pelo modelo a esse rótulo. É um valor entre 0 e 1, calculado como o `softmax` de `logits_per_image`. Atribua rótulos às imagens passadas como entradas. ### ZeroShotObjectDetectionPipeline[[transformers.ZeroShotObjectDetectionPipeline]] #### transformers.ZeroShotObjectDetectionPipeline[[transformers.ZeroShotObjectDetectionPipeline]] ```python transformers.ZeroShotObjectDetectionPipeline(**kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/zero_shot_object_detection.py#L23) **Parâmetros:** model ([PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel)): o modelo que será usado pelo pipeline para fazer previsões. Ele precisa ser um modelo que herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor)): o processador de imagens que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, padrão `""`) : Um identificador de tarefa para o pipeline. num_workers (`int`, *opcional*, padrão 8) : Quando o pipeline utilizar *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o número de workers a serem usados. batch_size (`int`, *opcional*, padrão 1) : Quando o pipeline usará *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o tamanho do lote a ser usado. Para inferência, isso nem sempre é vantajoso; leia [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/pt/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referência ao objeto responsável por analisar os parâmetros fornecidos do pipeline. device (`int` ou `str` ou `torch.device`, *opcional*) : Dispositivo no qual o pipeline é alocado. Se não for definido, o pipeline é colocado no primeiro acelerador disponível (CUDA, MPS, XPU, ...) e recorre para a CPU apenas quando nenhum estiver disponível; o modelo é movido para lá automaticamente. Passe `device="cpu"` (ou `-1`) para forçar o uso da CPU, um ordinal positivo ou `"cuda:1"` para selecionar um acelerador específico, ou um `torch.device`/`str` nativo. Este argumento não pode ser combinado com um modelo já carregado via `accelerate` (ou seja, um com `hf_device_map`). dtype (`str` ou `torch.dtype`, *opcional*, padrão `"auto"`) : A precisão na qual o modelo é carregado, encaminhada para `from_pretrained`. O padrão é `"auto"`, que carrega o modelo no dtype em que ele foi salvo (lido do `config.dtype` do checkpoint, ou inferido a partir dos pesos). Passe um `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescrever. binary_output (`bool`, *opcional*, padrão `False`) : Indica se a saída do pipeline deve ocorrer em um formato serializado (ou seja, pickle) ou como os dados de saída brutos, por exemplo, texto. Pipeline de detecção de objetos zero shot usando `OwlViTForObjectDetection`. Este pipeline prevê as caixas delimitadoras dos objetos quando você fornece uma imagem e um conjunto de `candidate_labels`. Exemplo: ```python >>> from transformers import pipeline >>> detector = pipeline(model="google/owlvit-base-patch32", task="zero-shot-object-detection") >>> detector( ... "http://images.cocodataset.org/val2017/000000039769.jpg", ... candidate_labels=["cat", "couch"], ... ) [{'score': 0.287, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}}, {'score': 0.254, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}}, {'score': 0.121, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}}] >>> detector( ... "https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png", ... candidate_labels=["head", "bird"], ... ) [{'score': 0.119, 'label': 'bird', 'box': {'xmin': 71, 'ymin': 170, 'xmax': 410, 'ymax': 508}}] ``` Saiba mais sobre os fundamentos do uso de um pipeline no [tutorial de pipeline](../pipeline_tutorial) Este pipeline de detecção de objetos pode ser carregado atualmente a partir de [pipeline()](/docs/transformers/main/pt/main_classes/pipelines#transformers.pipeline) usando o seguinte identificador de tarefa: `"zero-shot-object-detection"`. Veja a lista de modelos disponíveis em [huggingface.co/models](https://huggingface.co/models?filter=zero-shot-object-detection). #### __call__[[transformers.ZeroShotObjectDetectionPipeline.__call__]] ```python __call__(image: typing.Union[str, ForwardRef('Image.Image'), list[dict[str, typing.Any]]], candidate_labels: str | list[str] | None = None, **kwargs: Any) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/zero_shot_object_detection.py#L75) **Parâmetros:** image (`str`, `PIL.Image` or `list[dict[str, Any]]`) : O pipeline processa três tipos de imagens: - Uma string contendo uma URL http que aponta para uma imagem - Uma string contendo um caminho local para uma imagem - Uma imagem carregada diretamente no PIL Você pode usar este parâmetro para enviar diretamente uma lista de imagens, ou um dataset ou um gerador, como mostrado a seguir: ```python >>> from transformers import pipeline >>> detector = pipeline(model="google/owlvit-base-patch32", task="zero-shot-object-detection") >>> detector( ... [ ... { ... "image": "http://images.cocodataset.org/val2017/000000039769.jpg", ... "candidate_labels": ["cat", "couch"], ... }, ... { ... "image": "http://images.cocodataset.org/val2017/000000039769.jpg", ... "candidate_labels": ["cat", "couch"], ... }, ... ] ... ) [[{'score': 0.287, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}}, {'score': 0.25, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}}, {'score': 0.121, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}}], [{'score': 0.287, 'label': 'cat', 'box': {'xmin': 324, 'ymin': 20, 'xmax': 640, 'ymax': 373}}, {'score': 0.254, 'label': 'cat', 'box': {'xmin': 1, 'ymin': 55, 'xmax': 315, 'ymax': 472}}, {'score': 0.121, 'label': 'couch', 'box': {'xmin': 4, 'ymin': 0, 'xmax': 642, 'ymax': 476}}]] ``` candidate_labels (`str` ou `list[str]` ou `list[list[str]]`) : O que o modelo deve reconhecer na imagem. threshold (`float`, *opcional*, padrão 0.1) : A probabilidade necessária para fazer uma previsão. top_k (`int`, *opcional*, padrão None) : O número de principais previsões que serão retornadas pelo pipeline. Se o número fornecido for `None` ou maior que o número de previsões disponíveis, o valor padrão será o número de previsões. timeout (`float`, *opcional*, padrão None) : O tempo máximo, em segundos, para aguardar a busca de imagens da web. Se for None, nenhum tempo limite é definido e a chamada pode bloquear indefinidamente. **Retorna:** Uma lista de listas contendo os resultados das previsões, com uma lista para cada imagem de entrada. Cada lista contém dicionários com as seguintes chaves: - **label** (`str`) -- Consulta de texto correspondente ao objeto encontrado. - **score** (`float`) -- Pontuação correspondente ao objeto (entre 0 e 1). - **box** (`dict[str,int]`) -- Caixa delimitadora do objeto detectado no tamanho original da imagem. É um dicionário com as chaves `x_min`, `x_max`, `y_min`, `y_max`. Detecte objetos (caixas delimitadoras & classes) nas imagens passadas como entradas. ## Processamento de Linguagem Natural Os pipelines disponíveis para tarefas de processamento de linguagem natural incluem os seguintes. ### FillMaskPipeline[[transformers.FillMaskPipeline]] #### transformers.FillMaskPipeline[[transformers.FillMaskPipeline]] ```python transformers.FillMaskPipeline(model: PreTrainedModel, tokenizer: PreTrainedTokenizer | None = None, feature_extractor: PreTrainedFeatureExtractor | None = None, image_processor: BaseImageProcessor | None = None, video_processor: BaseVideoProcessor | None = None, processor: ProcessorMixin | None = None, task: str = '', device: int | torch.device | None = None, binary_output: bool = False, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/fill_mask.py#L28) **Parâmetros:** model ([PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel)): o modelo que será usado pelo pipeline para fazer previsões. Ele precisa ser um modelo que herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend)) : O tokenizer que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend). task (`str`, padrão `""`) : Um identificador de tarefa para o pipeline. num_workers (`int`, *opcional*, padrão 8) : Quando o pipeline utilizar *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o número de workers a serem usados. batch_size (`int`, *opcional*, padrão 1) : Quando o pipeline usará *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o tamanho do lote a ser usado. Para inferência, isso nem sempre é vantajoso; leia [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/pt/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referência ao objeto responsável por analisar os parâmetros fornecidos do pipeline. device (`int` ou `str` ou `torch.device`, *opcional*) : Dispositivo no qual o pipeline é alocado. Se não for definido, o pipeline é colocado no primeiro acelerador disponível (CUDA, MPS, XPU, ...) e recorre para a CPU apenas quando nenhum estiver disponível; o modelo é movido para lá automaticamente. Passe `device="cpu"` (ou `-1`) para forçar o uso da CPU, um ordinal positivo ou `"cuda:1"` para selecionar um acelerador específico, ou um `torch.device`/`str` nativo. Este argumento não pode ser combinado com um modelo já carregado via `accelerate` (ou seja, um com `hf_device_map`). dtype (`str` ou `torch.dtype`, *opcional*, padrão `"auto"`) : A precisão na qual o modelo é carregado, encaminhada para `from_pretrained`. O padrão é `"auto"`, que carrega o modelo no dtype em que ele foi salvo (lido do `config.dtype` do checkpoint, ou inferido a partir dos pesos). Passe um `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescrever. binary_output (`bool`, *opcional*, padrão `False`) : Indica se a saída do pipeline deve ocorrer em um formato serializado (ou seja, pickle) ou como os dados de saída brutos, por exemplo, texto. top_k (`int`, *opcional*, padrão 5) : O número de previsões a serem retornadas. targets (`str` ou `list[str]`, *opcional*) : Quando fornecido, o modelo limitará as pontuações aos alvos passados, em vez de procurar em todo o vocabulário. Se os alvos fornecidos não estiverem no vocabulário do modelo, eles serão tokenizados e o primeiro token resultante será usado (com um aviso, e isso pode ser mais lento). tokenizer_kwargs (`dict`, *opcional*) : Dicionário adicional de argumentos de palavra-chave passados ao tokenizer. #### __call__[[transformers.FillMaskPipeline.__call__]] ```python __call__(inputs: str | list[str], **kwargs: Any) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/fill_mask.py#L234) **Parâmetros:** inputs (`str` ou `list[str]`) : Um ou vários textos (ou uma lista de prompts) com tokens mascarados. targets (`str` ou `list[str]`, *opcional*) : Quando fornecido, o modelo limitará as pontuações aos alvos passados, em vez de procurar em todo o vocabulário. Se os alvos fornecidos não estiverem no vocabulário do modelo, eles serão tokenizados e o primeiro token resultante será usado (com um aviso, e isso pode ser mais lento). top_k (`int`, *opcional*) : Quando fornecido, substitui o número de previsões a serem retornadas. **Retorna:** Uma lista ou uma lista de listas de `dict` Cada resultado vem como uma lista de dicionários com as seguintes chaves: - **sequence** (`str`) -- A entrada correspondente com a previsão do token de máscara. - **score** (`float`) -- A probabilidade correspondente. - **token** (`int`) -- O id do token previsto (para substituir o token mascarado). - **token_str** (`str`) -- O token previsto (para substituir o token mascarado). Preencha o token mascarado no(s) texto(s) fornecido(s) como entradas. ### TableQuestionAnsweringPipeline[[transformers.TableQuestionAnsweringPipeline]] #### transformers.TableQuestionAnsweringPipeline[[transformers.TableQuestionAnsweringPipeline]] ```python transformers.TableQuestionAnsweringPipeline(args_parser = , **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/table_question_answering.py#L78) **Parâmetros:** model ([PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel)): o modelo que será usado pelo pipeline para fazer previsões. Ele precisa ser um modelo que herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend)) : O tokenizer que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend). task (`str`, padrão `""`) : Um identificador de tarefa para o pipeline. num_workers (`int`, *opcional*, padrão 8) : Quando o pipeline utilizar *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o número de workers a serem usados. batch_size (`int`, *opcional*, padrão 1) : Quando o pipeline usará *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o tamanho do lote a ser usado. Para inferência, isso nem sempre é vantajoso; leia [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/pt/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referência ao objeto responsável por analisar os parâmetros fornecidos do pipeline. device (`int` ou `str` ou `torch.device`, *opcional*) : Dispositivo no qual o pipeline é alocado. Se não for definido, o pipeline é colocado no primeiro acelerador disponível (CUDA, MPS, XPU, ...) e recorre para a CPU apenas quando nenhum estiver disponível; o modelo é movido para lá automaticamente. Passe `device="cpu"` (ou `-1`) para forçar o uso da CPU, um ordinal positivo ou `"cuda:1"` para selecionar um acelerador específico, ou um `torch.device`/`str` nativo. Este argumento não pode ser combinado com um modelo já carregado via `accelerate` (ou seja, um com `hf_device_map`). dtype (`str` ou `torch.dtype`, *opcional*, padrão `"auto"`) : A precisão na qual o modelo é carregado, encaminhada para `from_pretrained`. O padrão é `"auto"`, que carrega o modelo no dtype em que ele foi salvo (lido do `config.dtype` do checkpoint, ou inferido a partir dos pesos). Passe um `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescrever. binary_output (`bool`, *opcional*, padrão `False`) : Indica se a saída do pipeline deve ocorrer em um formato serializado (ou seja, pickle) ou como os dados de saída brutos, por exemplo, texto. Pipeline de Question Answering em Tabelas usando um `ModelForTableQuestionAnswering`. Este pipeline está disponível apenas no PyTorch. A menos que o modelo que você está usando defina explicitamente esses parâmetros de geração em seus arquivos de configuração (`generation_config.json`), os seguintes valores padrão serão usados: - max_new_tokens: 256 Exemplo: ```python >>> from transformers import pipeline >>> oracle = pipeline(model="google/tapas-base-finetuned-wtq") >>> table = { ... "Repository": ["Transformers", "Datasets", "Tokenizers"], ... "Stars": ["36542", "4512", "3934"], ... "Contributors": ["651", "77", "34"], ... "Programming language": ["Python", "Python", "Rust, Python and NodeJS"], ... } >>> oracle(query="How many stars does the transformers repository have?", table=table) {'answer': 'AVERAGE > 36542', 'coordinates': [(0, 1)], 'cells': ['36542'], 'aggregator': 'AVERAGE'} ``` Saiba mais sobre os fundamentos do uso de um pipeline no [tutorial de pipeline](../pipeline_tutorial) Este pipeline de resposta a perguntas tabulares pode ser carregado atualmente a partir de [pipeline()](/docs/transformers/main/pt/main_classes/pipelines#transformers.pipeline) usando o seguinte identificador de tarefa: `"table-question-answering"`. Os modelos que este pipeline pode utilizar são aqueles que foram ajustados em uma tarefa de resposta a perguntas tabulares. Consulte a lista atualizada de modelos disponíveis em [huggingface.co/models](https://huggingface.co/models?filter=table-question-answering). #### __call__[[transformers.TableQuestionAnsweringPipeline.__call__]] ```python __call__(*args, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/table_question_answering.py#L208) **Parâmetros:** table (`pd.DataFrame` ou `Dict`) : DataFrame do Pandas ou dicionário que será convertido em um DataFrame contendo todos os valores da tabela. Veja acima um exemplo de dicionário. query (`str` ou `list[str]`) : Consulta ou lista de consultas que serão enviadas ao modelo junto com a tabela. sequential (`bool`, *opcional*, padrão `False`) : Se a inferência deve ser feita sequencialmente ou em lote. O processamento em lote é mais rápido, mas modelos como SQA exigem que a inferência seja realizada sequencialmente para extrair relações dentro das sequências, devido à sua natureza conversacional. padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, padrão `False`) : Ativa e controla o padding. Aceita os seguintes valores: - `True` ou `'longest'`: Preenche até a sequência mais longa do lote (ou não aplica padding se apenas uma sequência for fornecida). - `'max_length'`: Preenche até o comprimento máximo especificado com o argumento `max_length` ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. - `False` ou `'do_not_pad'` (padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes). truncation (`bool`, `str` ou `TapasTruncationStrategy`, *opcional*, padrão `False`) : Ativa e controla a truncagem. Aceita os seguintes valores: - `True` ou `'drop_rows_to_fit'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca linha por linha, removendo linhas da tabela. - `False` ou `'do_not_truncate'` (padrão): Sem truncagem (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada admissível do modelo). **Retorna:** `A dictionary or a list of dictionaries containing results` Cada resultado é um dicionário com as seguintes chaves: - **answer** (`str`) -- A resposta da consulta com base na tabela. Se houver um agregador, a resposta será precedida por `AGGREGATOR >`. - **coordenadas** (`list[tuple[int, int]]`) -- Coordenadas das células das respostas. - **células** (`list[str]`) -- Lista de strings composta pelos valores das células de resposta. - **aggregator** (`str`) -- Se o modelo tiver um agregador, isso retorna o agregador. Responde consultas de acordo com uma tabela. O pipeline aceita vários tipos de entrada, detalhados abaixo: - `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}])` O argumento `table` deve ser um dict ou um DataFrame construído a partir desse dict, contendo a tabela inteira: Exemplo: ```python data = { "actors": ["brad pitt", "leonardo di caprio", "george clooney"], "age": ["56", "45", "59"], "number of movies": ["87", "53", "69"], "date of birth": ["7 february 1967", "10 june 1996", "28 november 1967"], } ``` Este dicionário pode ser passado como está, ou pode ser convertido em um DataFrame do pandas: Exemplo: ```python import pandas as pd table = pd.DataFrame.from_dict(data) ``` ### TextClassificationPipeline[[transformers.TextClassificationPipeline]] #### transformers.TextClassificationPipeline[[transformers.TextClassificationPipeline]] ```python transformers.TextClassificationPipeline(**kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/text_classification.py#L43) **Parâmetros:** model ([PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel)): o modelo que será usado pelo pipeline para fazer previsões. Ele precisa ser um modelo que herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend)) : O tokenizer que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend). task (`str`, padrão `""`) : Um identificador de tarefa para o pipeline. num_workers (`int`, *opcional*, padrão 8) : Quando o pipeline utilizar *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o número de workers a serem usados. batch_size (`int`, *opcional*, padrão 1) : Quando o pipeline usará *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o tamanho do lote a ser usado. Para inferência, isso nem sempre é vantajoso; leia [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/pt/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referência ao objeto responsável por analisar os parâmetros fornecidos do pipeline. device (`int` ou `str` ou `torch.device`, *opcional*) : Dispositivo no qual o pipeline é alocado. Se não for definido, o pipeline é colocado no primeiro acelerador disponível (CUDA, MPS, XPU, ...) e recorre para a CPU apenas quando nenhum estiver disponível; o modelo é movido para lá automaticamente. Passe `device="cpu"` (ou `-1`) para forçar o uso da CPU, um ordinal positivo ou `"cuda:1"` para selecionar um acelerador específico, ou um `torch.device`/`str` nativo. Este argumento não pode ser combinado com um modelo já carregado via `accelerate` (ou seja, um com `hf_device_map`). dtype (`str` ou `torch.dtype`, *opcional*, padrão `"auto"`) : A precisão na qual o modelo é carregado, encaminhada para `from_pretrained`. O padrão é `"auto"`, que carrega o modelo no dtype em que ele foi salvo (lido do `config.dtype` do checkpoint, ou inferido a partir dos pesos). Passe um `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescrever. binary_output (`bool`, *opcional*, padrão `False`) : Indica se a saída do pipeline deve ocorrer em um formato serializado (ou seja, pickle) ou como os dados de saída brutos, por exemplo, texto. function_to_apply (`str`, *opcional*, padrão `"default"`) : A função a ser aplicada às saídas do modelo para recuperar as pontuações. Aceita quatro valores diferentes: - `"default"`: se o modelo tiver um único rótulo, aplicará a função sigmoid na saída. Se o modelo tiver vários rótulos, aplicará a função softmax na saída. No caso de tarefas de regressão, não aplicará nenhuma função na saída. - `"sigmoid"`: Aplica a função sigmoid na saída. - `"softmax"`: Aplica a função softmax na saída. - `"none"`: Não aplica nenhuma função na saída. Pipeline de classificação de texto usando qualquer `ModelForSequenceClassification`. Consulte os [exemplos de classificação de sequência](../task_summary#sequence-classification) para mais informações. Exemplo: ```python >>> from transformers import pipeline >>> classifier = pipeline(model="distilbert/distilbert-base-uncased-finetuned-sst-2-english") >>> classifier("This movie is disgustingly good !") [{'label': 'POSITIVE', 'score': 1.0}] >>> classifier("Director tried too much.") [{'label': 'NEGATIVE', 'score': 0.996}] ``` Saiba mais sobre os fundamentos do uso de um pipeline no [tutorial de pipeline](../pipeline_tutorial) Este pipeline de classificação de texto pode ser carregado atualmente a partir de [pipeline()](/docs/transformers/main/pt/main_classes/pipelines#transformers.pipeline) usando o seguinte identificador de tarefa: `"sentiment-analysis"` (para classificar sequências de acordo com sentimentos positivos ou negativos). Se múltiplos rótulos de classificação estiverem disponíveis (`model.config.num_labels >= 2`), o pipeline executará um softmax sobre os resultados. Se houver um único rótulo, o pipeline executará um sigmoid sobre o resultado. No caso de tarefas de regressão (`model.config.problem_type == "regression"`), nenhuma função será aplicada à saída. Os modelos que este pipeline pode utilizar são aqueles que foram ajustados em uma tarefa de classificação de sequência. Consulte a lista atualizada de modelos disponíveis em [huggingface.co/models](https://huggingface.co/models?filter=text-classification). #### __call__[[transformers.TextClassificationPipeline.__call__]] ```python __call__(inputs: str | list[str] | dict[str, str] | list[dict[str, str]], **kwargs: Any) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/text_classification.py#L105) **Parâmetros:** inputs (`str` ou `list[str]` ou `dict[str]`, ou `list[dict[str]]`) : Um ou vários textos para classificar. Para usar pares de texto na sua classificação, você pode enviar um dicionário contendo as chaves `{"text", "text_pair"}`, ou uma lista desses. top_k (`int`, *opcional*, padrão `1`) : Quantos resultados retornar. function_to_apply (`str`, *opcional*, padrão `"default"`) : A função a ser aplicada às saídas do modelo para recuperar as pontuações. Aceita quatro valores diferentes: Se esse argumento não for especificado, as seguintes funções serão aplicadas de acordo com o número de rótulos: - Se o tipo de problema for regressão, nenhuma função será aplicada à saída. - Se o modelo tiver um único rótulo, a função sigmoid será aplicada à saída. - Se o modelo tiver vários rótulos, a função softmax será aplicada à saída. Os valores possíveis são: - `"sigmoid"`: Aplica a função sigmoid à saída. - `"softmax"`: Aplica a função softmax à saída. - `"none"`: Não aplica nenhuma função à saída. **Retorna:** Uma lista de `dict` Cada resultado vem como uma lista de dicionários com as seguintes chaves: - **label** (`str`) -- O rótulo previsto. - **score** (`float`) -- A probabilidade correspondente. Se `top_k` for usado, um dicionário desses é retornado por rótulo. Classifique o(s) texto(s) fornecido(s) como entradas. ### TextGenerationPipeline[[transformers.TextGenerationPipeline]] #### transformers.TextGenerationPipeline[[transformers.TextGenerationPipeline]] ```python transformers.TextGenerationPipeline(*args, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/text_generation.py#L23) **Parâmetros:** model ([PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel)): o modelo que será usado pelo pipeline para fazer previsões. Ele precisa ser um modelo que herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend)) : O tokenizer que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend). task (`str`, padrão `""`) : Um identificador de tarefa para o pipeline. num_workers (`int`, *opcional*, padrão 8) : Quando o pipeline utilizar *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o número de workers a serem usados. batch_size (`int`, *opcional*, padrão 1) : Quando o pipeline usará *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o tamanho do lote a ser usado. Para inferência, isso nem sempre é vantajoso; leia [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/pt/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referência ao objeto responsável por analisar os parâmetros fornecidos do pipeline. device (`int` ou `str` ou `torch.device`, *opcional*) : Dispositivo no qual o pipeline é alocado. Se não for definido, o pipeline é colocado no primeiro acelerador disponível (CUDA, MPS, XPU, ...) e recorre para a CPU apenas quando nenhum estiver disponível; o modelo é movido para lá automaticamente. Passe `device="cpu"` (ou `-1`) para forçar o uso da CPU, um ordinal positivo ou `"cuda:1"` para selecionar um acelerador específico, ou um `torch.device`/`str` nativo. Este argumento não pode ser combinado com um modelo já carregado via `accelerate` (ou seja, um com `hf_device_map`). dtype (`str` ou `torch.dtype`, *opcional*, padrão `"auto"`) : A precisão na qual o modelo é carregado, encaminhada para `from_pretrained`. O padrão é `"auto"`, que carrega o modelo no dtype em que ele foi salvo (lido do `config.dtype` do checkpoint, ou inferido a partir dos pesos). Passe um `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescrever. binary_output (`bool`, *opcional*, padrão `False`) : Indica se a saída do pipeline deve ocorrer em um formato serializado (ou seja, pickle) ou como os dados de saída brutos, por exemplo, texto. Pipeline de geração de linguagem usando qualquer `ModelWithLMHead` ou `ModelForCausalLM`. Este pipeline prevê as palavras que seguirão um prompt de texto especificado. Quando o modelo subjacente é um modelo conversacional, ele também pode aceitar um ou mais chats, caso em que o pipeline operará em modo de chat e continuará o(s) chat(s) adicionando sua(s) resposta(s). Cada chat tem a forma de uma lista de dicts, em que cada dict contém as chaves "role" e "content". A menos que o modelo que você está usando defina explicitamente esses parâmetros de geração em seus arquivos de configuração (`generation_config.json`), os seguintes valores padrão serão usados: - max_new_tokens: 256 - do_sample: True - temperature: 0.7 Exemplos: ```python >>> from transformers import pipeline >>> generator = pipeline(model="openai-community/gpt2") >>> generator("I can't believe you did such a ", do_sample=False) [{'generated_text': "I can't believe you did such a icky thing to me. I'm so sorry. I'm so sorry. I'm so sorry. I'm so sorry. I'm so sorry. I'm so sorry. I'm so sorry. I"}] >>> # These parameters will return suggestions, and only the newly created text making it easier for prompting suggestions. >>> outputs = generator("My tart needs some", num_return_sequences=4, return_full_text=False) ``` ```python >>> from transformers import pipeline >>> generator = pipeline(model="HuggingFaceH4/zephyr-7b-beta") >>> # Zephyr-beta is a conversational model, so let's pass it a chat instead of a single string >>> generator([{"role": "user", "content": "What is the capital of France? Answer in one word."}], do_sample=False, max_new_tokens=2) [{'generated_text': [{'role': 'user', 'content': 'What is the capital of France? Answer in one word.'}, {'role': 'assistant', 'content': 'Paris'}]}] ``` Saiba mais sobre os fundamentos do uso de um pipeline no [tutorial de pipeline](../pipeline_tutorial). Você pode passar parâmetros de geração de texto para este pipeline para controlar os critérios de parada, a estratégia de decodificação e muito mais. Saiba mais sobre os parâmetros de geração de texto em [Estratégias de geração de texto](../generation_strategies) e [Geração de texto](text_generation). Este pipeline de geração de linguagem pode ser carregado atualmente a partir de [pipeline()](/docs/transformers/main/pt/main_classes/pipelines#transformers.pipeline) usando o seguinte identificador de tarefa: `"text-generation"`. Os modelos que este pipeline pode utilizar são aqueles treinados com um objetivo de modelagem de linguagem autoregressiva. Consulte a lista de [modelos de conclusão de texto](https://huggingface.co/models?filter=text-generation) e a lista de [modelos conversacionais](https://huggingface.co/models?other=conversational) em [huggingface.co/models]. #### __call__[[transformers.TextGenerationPipeline.__call__]] ```python __call__(text_inputs, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/text_generation.py#L251) **Parâmetros:** text_inputs (`str`, `list[str]`, `ChatType` ou `list[ChatType]`) : Um ou vários prompts (ou uma lista de prompts) para completar. Se strings ou uma lista de strings forem passadas, este pipeline continuará cada prompt. Alternativamente, um "chat", na forma de uma lista de dicts com as chaves "role" e "content", pode ser passado, ou uma lista de tais chats. Quando chats são passados, o template de chat do modelo será usado para formatá-los antes de passá-los ao modelo. return_tensors (`bool`, *opcional*, padrão `False`) : Retorna os tensores de previsões (como índices de tokens) nas saídas. Se definido como `True`, o texto decodificado não é retornado. return_text (`bool`, *opcional*) : Retorna os textos decodificados nas saídas. return_full_text (`bool`, *opcional*, padrão `True`) : Se definido como `False`, apenas o texto adicionado é retornado; caso contrário, o texto completo é retornado. Não pode ser especificado ao mesmo tempo que `return_text`. clean_up_tokenization_spaces (`bool`, *opcional*) : Indica se os espaços extras potenciais na saída de texto devem ser removidos. O valor padrão é a configuração `clean_up_tokenization_spaces` do tokenizer. continue_final_message( `bool`, *opcional*) : Indica que você deseja que o modelo continue a última mensagem no chat de entrada, em vez de iniciar uma nova, permitindo "preencher" sua resposta. Por padrão, isso é `True` quando a última mensagem no chat de entrada tem o papel `assistant` e `False` caso contrário, mas você pode sobrescrever manualmente esse comportamento definindo essa flag. prefix (`str`, *opcional*) : Prefixo adicionado ao prompt. stop_sequence (`str` ou `list[str]`, *opcional*) : Uma ou mais strings que interrompem a geração assim que forem geradas. A string de parada é incluída na saída. handle_long_generation (`str`, *opcional*) : Por padrão, este pipeline não lida com gerações longas (aquelas que excedem, de alguma forma, o comprimento máximo do modelo). Não existe uma maneira perfeita de resolver isso (mais informações: https://github.com/huggingface/transformers/issues/14033#issuecomment-948385227). Isso fornece estratégias comuns para contornar esse problema, dependendo do seu caso de uso. - `None` : estratégia padrão, na qual nada em particular acontece - `"hole"`: Trunca a parte esquerda da entrada e deixa um espaço amplo o suficiente para permitir que a geração aconteça (pode truncar grande parte do prompt e não é adequado quando a geração excede a capacidade do modelo) tokenizer_encode_kwargs (`dict`, *opcional*) : Argumentos de palavra-chave adicionais para passar à etapa de codificação do tokenizer. Se a entrada de texto for um chat, ele é passado para `apply_chat_template`. Caso contrário, é passado para `__call__`. generate_kwargs (`dict`, *opcional*) : Argumentos de palavra-chave adicionais para passar ao método generate do modelo (veja o método generate [aqui](./text_generation)). **Retorna:** Uma lista ou uma lista de listas de `dict` Retorna um dos seguintes dicionários (não é possível retornar uma combinação de `generated_text` e `generated_token_ids`): - **generated_text** (`str`, presente quando `return_text=True`) -- O texto gerado. - **generated_token_ids** (`torch.Tensor`, presente quando `return_tensors=True`) -- Os ids dos tokens do texto gerado. Complete o(s) prompt(s) fornecido(s) como entradas. ### TokenClassificationPipeline[[transformers.TokenClassificationPipeline]] #### transformers.TokenClassificationPipeline[[transformers.TokenClassificationPipeline]] ```python transformers.TokenClassificationPipeline(args_parser = , **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/token_classification.py#L91) **Parâmetros:** model ([PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel)): o modelo que será usado pelo pipeline para fazer previsões. Ele precisa ser um modelo que herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend)) : O tokenizer que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend). task (`str`, padrão `""`) : Um identificador de tarefa para o pipeline. num_workers (`int`, *opcional*, padrão 8) : Quando o pipeline utilizar *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o número de workers a serem usados. batch_size (`int`, *opcional*, padrão 1) : Quando o pipeline usará *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o tamanho do lote a ser usado. Para inferência, isso nem sempre é vantajoso; leia [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/pt/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referência ao objeto responsável por analisar os parâmetros fornecidos do pipeline. device (`int` ou `str` ou `torch.device`, *opcional*) : Dispositivo no qual o pipeline é alocado. Se não for definido, o pipeline é colocado no primeiro acelerador disponível (CUDA, MPS, XPU, ...) e recorre para a CPU apenas quando nenhum estiver disponível; o modelo é movido para lá automaticamente. Passe `device="cpu"` (ou `-1`) para forçar o uso da CPU, um ordinal positivo ou `"cuda:1"` para selecionar um acelerador específico, ou um `torch.device`/`str` nativo. Este argumento não pode ser combinado com um modelo já carregado via `accelerate` (ou seja, um com `hf_device_map`). dtype (`str` ou `torch.dtype`, *opcional*, padrão `"auto"`) : A precisão na qual o modelo é carregado, encaminhada para `from_pretrained`. O padrão é `"auto"`, que carrega o modelo no dtype em que ele foi salvo (lido do `config.dtype` do checkpoint, ou inferido a partir dos pesos). Passe um `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescrever. binary_output (`bool`, *opcional*, padrão `False`) : Indica se a saída do pipeline deve ocorrer em um formato serializado (ou seja, pickle) ou como os dados de saída brutos, por exemplo, texto. ignore_labels (`list[str]`, padrão `["O"]`) : Uma lista de rótulos a serem ignorados. stride (`int`, *opcional*) : Se stride for fornecido, o pipeline é aplicado em todo o texto. O texto é dividido em blocos de tamanho model_max_length. Funciona apenas com tokenizers rápidos e `aggregation_strategy` diferente de `NONE`. O valor deste argumento define o número de tokens sobrepostos entre os blocos. Em outras palavras, o modelo avança `tokenizer.model_max_length - stride` tokens a cada etapa. aggregation_strategy (`str`, *opcional*, padrão `"none"`) : A estratégia para fundir (ou não) tokens com base na previsão do modelo. - "none" : Simplesmente não realiza nenhuma agregação e retorna os resultados brutos do modelo - "simple" : Tentará agrupar entidades seguindo o esquema padrão. (A, B-TAG), (B, I-TAG), (C, I-TAG), (D, B-TAG2) (E, B-TAG2) resultarão em [{"word": ABC, "entity": "TAG"}, {"word": "D", "entity": "TAG2"}, {"word": "E", "entity": "TAG2"}] Observe que duas tags B consecutivas resultarão em entidades diferentes. Em idiomas baseados em palavras, podemos acabar dividindo palavras de forma indesejada : Imagine "Microsoft" sendo etiquetado como [{"word": "Micro", "entity": "ENTERPRISE"}, {"word": "soft", "entity": "NAME"}]. Procure por FIRST, MAX, AVERAGE para formas de mitigar isso e desambiguar palavras (em idiomas que suportam esse significado, que basicamente são tokens separados por um espaço). Essas mitigações funcionarão apenas em palavras reais, "New york" ainda pode ser etiquetado com duas entidades diferentes. - "first" : (funciona apenas em modelos baseados em palavras) Usará a estratégia `SIMPLE`, exceto que as palavras não podem terminar com tags diferentes. As palavras simplesmente usarão a tag do primeiro token da palavra quando houver ambiguidade. - "average" : (funciona apenas em modelos baseados em palavras) Usará a estratégia `SIMPLE`, exceto que as palavras não podem terminar com tags diferentes. As pontuações serão primeiro médias entre os tokens e, em seguida, o rótulo máximo será aplicado. - "max" : (funciona apenas em modelos baseados em palavras) Usará a estratégia `SIMPLE`, exceto que as palavras não podem terminar com tags diferentes. A entidade da palavra será simplesmente o token com a pontuação máxima. Pipeline de Reconhecimento de Entidades Nomeadas usando qualquer `ModelForTokenClassification`. Veja os [exemplos de reconhecimento de entidades nomeadas](../task_summary#named-entity-recognition) para mais informações. Exemplo: ```python >>> from transformers import pipeline >>> token_classifier = pipeline(model="Jean-Baptiste/camembert-ner", aggregation_strategy="simple") >>> sentence = "Je m'appelle jean-baptiste et je vis à montréal" >>> tokens = token_classifier(sentence) >>> tokens [{'entity_group': 'PER', 'score': 0.9931, 'word': 'jean-baptiste', 'start': 12, 'end': 26}, {'entity_group': 'LOC', 'score': 0.998, 'word': 'montréal', 'start': 38, 'end': 47}] >>> token = tokens[0] >>> # Start and end provide an easy way to highlight words in the original text. >>> sentence[token["start"] : token["end"]] ' jean-baptiste' >>> # Some models use the same idea to do part of speech. >>> syntaxer = pipeline(model="vblagoje/bert-english-uncased-finetuned-pos", aggregation_strategy="simple") >>> syntaxer("My name is Sarah and I live in London") [{'entity_group': 'PRON', 'score': 0.999, 'word': 'my', 'start': 0, 'end': 2}, {'entity_group': 'NOUN', 'score': 0.997, 'word': 'name', 'start': 3, 'end': 7}, {'entity_group': 'AUX', 'score': 0.994, 'word': 'is', 'start': 8, 'end': 10}, {'entity_group': 'PROPN', 'score': 0.999, 'word': 'sarah', 'start': 11, 'end': 16}, {'entity_group': 'CCONJ', 'score': 0.999, 'word': 'and', 'start': 17, 'end': 20}, {'entity_group': 'PRON', 'score': 0.999, 'word': 'i', 'start': 21, 'end': 22}, {'entity_group': 'VERB', 'score': 0.998, 'word': 'live', 'start': 23, 'end': 27}, {'entity_group': 'ADP', 'score': 0.999, 'word': 'in', 'start': 28, 'end': 30}, {'entity_group': 'PROPN', 'score': 0.999, 'word': 'london', 'start': 31, 'end': 37}] ``` Saiba mais sobre os fundamentos do uso de um pipeline no [tutorial de pipeline](../pipeline_tutorial) Este pipeline de reconhecimento de tokens pode atualmente ser carregado a partir de [pipeline()](/docs/transformers/main/pt/main_classes/pipelines#transformers.pipeline) usando o seguinte identificador de tarefa: `"ner"` (para prever as classes dos tokens em uma sequência: pessoa, organização, local ou diversos). Os modelos que este pipeline pode utilizar são aqueles que foram ajustados em uma tarefa de classificação de tokens. Consulte a lista atualizada de modelos disponíveis em [huggingface.co/models](https://huggingface.co/models?filter=token-classification). #### __call__[[transformers.TokenClassificationPipeline.__call__]] ```python __call__(inputs: str | list[str], **kwargs: Any) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/token_classification.py#L210) **Parâmetros:** inputs (`str` ou `List[str]`) : Um ou vários textos (ou uma lista de textos) para classificação de tokens. Pode ser pré-tokenizado quando `is_split_into_words=True`. **Retorna:** Uma lista ou uma lista de listas de `dict` Cada resultado é retornado como uma lista de dicionários (um para cada token na entrada correspondente, ou para cada entidade, se este pipeline foi instanciado com um aggregation_strategy) com as seguintes chaves: - **word** (`str`) -- O token/palavra classificado. Isso é obtido decodificando os tokens selecionados. Se você deseja obter a string exata na frase original, use `start` e `end`. - **score** (`float`) -- A probabilidade correspondente para `entity`. - **entity** (`str`) -- A entidade prevista para esse token/palavra (é nomeada *entity_group* quando *aggregation_strategy* não é `"none"`. - **index** (`int`, presente apenas quando `aggregation_strategy="none"`) -- O índice do token correspondente na frase. - **start** (`int`, *opcional*) -- O índice do início da entidade correspondente na frase. Existe apenas se os deslocamentos estiverem disponíveis no tokenizer - **end** (`int`, *opcional*) -- O índice do final da entidade correspondente na frase. Existe apenas se os deslocamentos estiverem disponíveis no tokenizer Classifique cada token dos textos fornecidos como entradas. #### aggregate_words[[transformers.TokenClassificationPipeline.aggregate_words]] ```python aggregate_words(entities: list, aggregation_strategy: AggregationStrategy) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/token_classification.py#L522) Substitua os tokens de uma palavra específica que divergem para forçar a concordância nas fronteiras de palavras. Exemplo: micro|soft| com|pany| B-ENT I-NAME I-ENT I-ENT será reescrito com a primeira estratégia como microsoft| company| B-ENT I-ENT #### gather_pre_entities[[transformers.TokenClassificationPipeline.gather_pre_entities]] ```python gather_pre_entities(sentence: str, input_ids: ndarray, scores: ndarray, offset_mapping: list[tuple[int, int]] | None, special_tokens_mask: ndarray, aggregation_strategy: AggregationStrategy, word_ids: list[int | None] | None = None, word_to_chars_map: list[tuple[int, int]] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/token_classification.py#L398) Fusione vários arrays numpy em dicts com todas as informações necessárias para agregação #### group_entities[[transformers.TokenClassificationPipeline.group_entities]] ```python group_entities(entities: list) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/token_classification.py#L585) **Parâmetros:** entities (`dict`) : As entidades previstas pelo pipeline. Encontre e agrupe os tokens adjacentes com a mesma entidade prevista. #### group_sub_entities[[transformers.TokenClassificationPipeline.group_sub_entities]] ```python group_sub_entities(entities: list) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/token_classification.py#L550) **Parâmetros:** entities (`dict`) : As entidades previstas pelo pipeline. Agrupe os tokens adjacentes com a mesma entidade prevista. ### ZeroShotClassificationPipeline[[transformers.ZeroShotClassificationPipeline]] #### transformers.ZeroShotClassificationPipeline[[transformers.ZeroShotClassificationPipeline]] ```python transformers.ZeroShotClassificationPipeline(args_parser = , **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/zero_shot_classification.py#L44) **Parâmetros:** model ([PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel)): o modelo que será usado pelo pipeline para fazer previsões. Ele precisa ser um modelo que herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend)) : O tokenizer que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend). task (`str`, padrão `""`) : Um identificador de tarefa para o pipeline. num_workers (`int`, *opcional*, padrão 8) : Quando o pipeline utilizar *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o número de workers a serem usados. batch_size (`int`, *opcional*, padrão 1) : Quando o pipeline usará *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o tamanho do lote a ser usado. Para inferência, isso nem sempre é vantajoso; leia [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/pt/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referência ao objeto responsável por analisar os parâmetros fornecidos do pipeline. device (`int` ou `str` ou `torch.device`, *opcional*) : Dispositivo no qual o pipeline é alocado. Se não for definido, o pipeline é colocado no primeiro acelerador disponível (CUDA, MPS, XPU, ...) e recorre para a CPU apenas quando nenhum estiver disponível; o modelo é movido para lá automaticamente. Passe `device="cpu"` (ou `-1`) para forçar o uso da CPU, um ordinal positivo ou `"cuda:1"` para selecionar um acelerador específico, ou um `torch.device`/`str` nativo. Este argumento não pode ser combinado com um modelo já carregado via `accelerate` (ou seja, um com `hf_device_map`). dtype (`str` ou `torch.dtype`, *opcional*, padrão `"auto"`) : A precisão na qual o modelo é carregado, encaminhada para `from_pretrained`. O padrão é `"auto"`, que carrega o modelo no dtype em que ele foi salvo (lido do `config.dtype` do checkpoint, ou inferido a partir dos pesos). Passe um `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescrever. binary_output (`bool`, *opcional*, padrão `False`) : Indica se a saída do pipeline deve ocorrer em um formato serializado (ou seja, pickle) ou como os dados de saída brutos, por exemplo, texto. Pipeline de classificação zero-shot baseado em NLI, que utiliza um `ModelForSequenceClassification` treinado em tarefas de NLI (inferência de linguagem natural). Equivalente aos pipelines de `text-classification`, mas esses modelos não exigem um número fixo de classes potenciais; elas podem ser escolhidas em tempo de execução. Isso geralmente significa que o processo é mais lento, porém é **muito** mais flexível. Qualquer combinação de sequências e rótulos pode ser passada, e cada combinação será apresentada como um par premissa/hipótese e enviada ao modelo pré-treinado. Em seguida, o logit de *entailment* é utilizado como o logit de que o rótulo candidato é válido. Qualquer modelo de NLI pode ser usado, mas o id do rótulo *entailment* deve estar incluído em :attr:*~transformers.PreTrainedConfig.label2id* da configuração do modelo. Exemplo: ```python >>> from transformers import pipeline >>> oracle = pipeline(model="facebook/bart-large-mnli") >>> oracle( ... "I have a problem with my iphone that needs to be resolved asap!!", ... candidate_labels=["urgent", "not urgent", "phone", "tablet", "computer"], ... ) {'sequence': 'I have a problem with my iphone that needs to be resolved asap!!', 'labels': ['urgent', 'phone', 'computer', 'not urgent', 'tablet'], 'scores': [0.504, 0.479, 0.013, 0.003, 0.002]} >>> oracle( ... "I have a problem with my iphone that needs to be resolved asap!!", ... candidate_labels=["english", "german"], ... ) {'sequence': 'I have a problem with my iphone that needs to be resolved asap!!', 'labels': ['english', 'german'], 'scores': [0.814, 0.186]} ``` Saiba mais sobre os fundamentos do uso de um pipeline no [tutorial de pipeline](../pipeline_tutorial) Este pipeline de NLI pode ser carregado atualmente a partir de [pipeline()](/docs/transformers/main/pt/main_classes/pipelines#transformers.pipeline) usando o seguinte identificador de tarefa: `"zero-shot-classification"`. Os modelos que este pipeline pode utilizar são aqueles que foram ajustados em uma tarefa de NLI. Consulte a lista atualizada de modelos disponíveis em [huggingface.co/models](https://huggingface.co/models?search=nli). #### __call__[[transformers.ZeroShotClassificationPipeline.__call__]] ```python __call__(sequences: str | list[str], *args, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/zero_shot_classification.py#L159) **Parâmetros:** sequences (`str` ou `list[str]`) : A(s) sequência(s) a serem classificadas; será truncada se a entrada do modelo for grande demais. candidate_labels (`str` ou `list[str]`) : O conjunto de rótulos de classe possíveis para classificar cada sequência. Pode ser um único rótulo, uma string de rótulos separados por vírgula ou uma lista de rótulos. hypothesis_template (`str`, *opcional*, padrão `"This example is {}."`) : O modelo usado para transformar cada rótulo em uma hipótese no estilo NLI. Esse modelo deve incluir a sintaxe {} ou similar para que o rótulo candidato seja inserido no modelo. Por exemplo, o modelo padrão é `"This example is {}."` Com o rótulo candidato `"sports"`, isso seria enviado ao modelo como `" sequence to classify This example is sports . "`. O modelo padrão funciona bem em muitos casos, mas pode valer a pena experimentar modelos diferentes dependendo da configuração da tarefa. multi_label (`bool`, *opcional*, padrão `False`) : Indica se múltiplos rótulos candidatos podem ser verdadeiros. Se `False`, as pontuações são normalizadas de modo que a soma das probabilidades dos rótulos para cada sequência seja 1. Se `True`, os rótulos são considerados independentes e as probabilidades são normalizadas para cada candidato aplicando um softmax à pontuação de entailment em relação à pontuação de contradiction. **Retorna:** Um `dict` ou uma lista de `dict` Cada resultado é retornado como um dicionário com as seguintes chaves: - **sequence** (`str`) -- A sequência para a qual este é a saída. - **labels** (`list[str]`) -- Os rótulos ordenados pela ordem de probabilidade. - **scores** (`list[float]`) -- As probabilidades para cada um dos rótulos. Classifique a(s) sequência(s) fornecida(s) como entrada. Consulte a documentação do [ZeroShotClassificationPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.ZeroShotClassificationPipeline) para mais informações. ## Multimodal Os pipelines disponíveis para tarefas multimodais incluem os seguintes. ### DocumentQuestionAnsweringPipeline[[transformers.DocumentQuestionAnsweringPipeline]] #### transformers.DocumentQuestionAnsweringPipeline[[transformers.DocumentQuestionAnsweringPipeline]] ```python transformers.DocumentQuestionAnsweringPipeline(*args, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/document_question_answering.py#L206) **Parâmetros:** model ([PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel)): o modelo que será usado pelo pipeline para fazer previsões. Ele precisa ser um modelo que herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend)) : O tokenizer que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend). image_processor ([BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor)): o processador de imagens que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, padrão `""`) : Um identificador de tarefa para o pipeline. num_workers (`int`, *opcional*, padrão 8) : Quando o pipeline utilizar *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o número de workers a serem usados. batch_size (`int`, *opcional*, padrão 1) : Quando o pipeline usará *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o tamanho do lote a ser usado. Para inferência, isso nem sempre é vantajoso; leia [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/pt/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referência ao objeto responsável por analisar os parâmetros fornecidos do pipeline. device (`int` ou `str` ou `torch.device`, *opcional*) : Dispositivo no qual o pipeline é alocado. Se não for definido, o pipeline é colocado no primeiro acelerador disponível (CUDA, MPS, XPU, ...) e recorre para a CPU apenas quando nenhum estiver disponível; o modelo é movido para lá automaticamente. Passe `device="cpu"` (ou `-1`) para forçar o uso da CPU, um ordinal positivo ou `"cuda:1"` para selecionar um acelerador específico, ou um `torch.device`/`str` nativo. Este argumento não pode ser combinado com um modelo já carregado via `accelerate` (ou seja, um com `hf_device_map`). dtype (`str` ou `torch.dtype`, *opcional*, padrão `"auto"`) : A precisão na qual o modelo é carregado, encaminhada para `from_pretrained`. O padrão é `"auto"`, que carrega o modelo no dtype em que ele foi salvo (lido do `config.dtype` do checkpoint, ou inferido a partir dos pesos). Passe um `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescrever. binary_output (`bool`, *opcional*, padrão `False`) : Indica se a saída do pipeline deve ocorrer em um formato serializado (ou seja, pickle) ou como os dados de saída brutos, por exemplo, texto. Pipeline de Document Question Answering usando qualquer `AutoModelForDocumentQuestionAnswering`. As entradas/saídas são semelhantes às do pipeline de question answering (extrativo); no entanto, o pipeline recebe uma imagem (e palavras/caixas OCR opcionais) como entrada, em vez de um contexto de texto. A menos que o modelo que você está usando defina explicitamente esses parâmetros de geração em seus arquivos de configuração (`generation_config.json`), os seguintes valores padrão serão usados: - max_new_tokens: 256 Exemplo: ```python >>> from transformers import pipeline >>> document_qa = pipeline(model="impira/layoutlm-document-qa") >>> document_qa( ... image="https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/invoice_docquery_a.png", ... question="What is the invoice number?", ... ) [{'score': 0.425, 'answer': 'us-001', 'start': 16, 'end': 16}] ``` Saiba mais sobre os fundamentos do uso de um pipeline no [tutorial de pipeline](../pipeline_tutorial) Este pipeline de resposta a perguntas sobre documentos pode ser carregado atualmente a partir de [pipeline()](/docs/transformers/main/pt/main_classes/pipelines#transformers.pipeline) usando o seguinte identificador de tarefa: `"document-question-answering"`. Os modelos que este pipeline pode utilizar são aqueles que foram ajustados em uma tarefa de resposta a perguntas em documentos. Consulte a lista atualizada de modelos disponíveis em [huggingface.co/models](https://huggingface.co/models?filter=document-question-answering). #### __call__[[transformers.DocumentQuestionAnsweringPipeline.__call__]] ```python __call__(image: typing.Union[ForwardRef('Image.Image'), str, list[dict[str, typing.Any]]], question: str | None = None, word_boxes: tuple[str, list[float]] | None = None, **kwargs: Any) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/document_question_answering.py#L338) **Parâmetros:** image (`str` ou `PIL.Image`) : O pipeline lida com três tipos de imagens: - Uma string contendo um link http que aponta para uma imagem - Uma string contendo um caminho local para uma imagem - Uma imagem carregada diretamente em PIL O pipeline aceita uma única imagem ou um lote de imagens. Se for fornecida uma única imagem, ela pode ser transmitida para várias perguntas. question (`str`) : Uma pergunta a ser feita ao documento. word_boxes (`list[str, tuple[float, float, float, float]]`, *opcional*) : Uma lista de palavras e caixas delimitadoras (normalizadas de 0->1000). Se você fornecer esta entrada opcional, o pipeline usará essas palavras e caixas em vez de executar OCR na imagem para derivá-las, para modelos que as necessitam (por exemplo, LayoutLM). Isso permite reutilizar resultados de OCR em muitas chamadas do pipeline sem precisar executá-lo novamente a cada vez. top_k (`int`, *opcional*, padrão 1) : O número de respostas a serem retornadas (serão escolhidas pela ordem de probabilidade). Observe que retornamos menos respostas do que top_k se não houver opções suficientes disponíveis no contexto. doc_stride (`int`, *opcional*, padrão 128) : Se as palavras do documento forem longas demais para caber junto com a pergunta para o modelo, o texto será dividido em vários blocos com alguma sobreposição. Este argumento controla o tamanho dessa sobreposição. max_answer_len (`int`, *opcional*, padrão 15) : O comprimento máximo das respostas previstas (por exemplo, apenas respostas com comprimento menor são consideradas). max_seq_len (`int`, *opcional*, padrão 384) : O comprimento máximo da frase total (contexto + pergunta) em tokens de cada chunk passado ao modelo. O contexto será dividido em vários chunks (usando `doc_stride` como sobreposição), se necessário. max_question_len (`int`, *opcional*, padrão 64) : O comprimento máximo da pergunta após a tokenização. Será truncada, se necessário. handle_impossible_answer (`bool`, *opcional*, padrão `False`) : Se aceitamos ou não "impossível" como resposta. lang (`str`, *opcional*) : Idioma a ser usado durante a execução do OCR. O padrão é inglês. tesseract_config (`str`, *opcional*) : Sinalizadores adicionais para passar ao tesseract durante a execução do OCR. timeout (`float`, *opcional*, padrão None) : O tempo máximo, em segundos, para aguardar a busca de imagens da web. Se for None, nenhum tempo limite é definido e a chamada pode bloquear indefinidamente. **Retorna:** Um `dict` ou uma lista de `dict` Cada resultado é retornado como um dicionário com as seguintes chaves: - **score** (`float`) -- A probabilidade associada à resposta. - **start** (`int`) -- O índice da palavra inicial da resposta (na versão OCR da entrada ou nos `word_boxes` fornecidos). - **end** (`int`) -- O índice da palavra final da resposta (na versão OCR da entrada ou nos `word_boxes` fornecidos). - **answer** (`str`) -- A resposta à pergunta. - **words** (`list[int]`) -- O índice de cada par palavra/caixa que está na resposta Responda à(s) pergunta(s) fornecida(s) como entrada(s) utilizando o(s) documento(s). Um documento é definido como uma imagem e uma lista opcional de tuplas (palavra, caixa) que representam o texto no documento. Se as `word_boxes` não forem fornecidas, o mecanismo de OCR Tesseract (se disponível) será usado para extrair automaticamente as palavras e as caixas para modelos semelhantes ao LayoutLM, que as exigem como entrada. Para o Donut, nenhum OCR é executado. Você pode invocar o pipeline de várias maneiras: - `pipeline(image=image, question=question)` - `pipeline(image=image, question=question, word_boxes=word_boxes)` - `pipeline([{"image": image, "question": question}])` - `pipeline([{"image": image, "question": question, "word_boxes": word_boxes}])` ### FeatureExtractionPipeline[[transformers.FeatureExtractionPipeline]] #### transformers.FeatureExtractionPipeline[[transformers.FeatureExtractionPipeline]] ```python transformers.FeatureExtractionPipeline(model: PreTrainedModel, tokenizer: PreTrainedTokenizer | None = None, feature_extractor: PreTrainedFeatureExtractor | None = None, image_processor: BaseImageProcessor | None = None, video_processor: BaseVideoProcessor | None = None, processor: ProcessorMixin | None = None, task: str = '', device: int | torch.device | None = None, binary_output: bool = False, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/feature_extraction.py#L15) **Parâmetros:** model ([PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel)): o modelo que será usado pelo pipeline para fazer previsões. Ele precisa ser um modelo que herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend)) : O tokenizer que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend). task (`str`, padrão `""`) : Um identificador de tarefa para o pipeline. num_workers (`int`, *opcional*, padrão 8) : Quando o pipeline utilizar *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o número de workers a serem usados. batch_size (`int`, *opcional*, padrão 1) : Quando o pipeline usará *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o tamanho do lote a ser usado. Para inferência, isso nem sempre é vantajoso; leia [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/pt/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referência ao objeto responsável por analisar os parâmetros fornecidos do pipeline. device (`int` ou `str` ou `torch.device`, *opcional*) : Dispositivo no qual o pipeline é alocado. Se não for definido, o pipeline é colocado no primeiro acelerador disponível (CUDA, MPS, XPU, ...) e recorre para a CPU apenas quando nenhum estiver disponível; o modelo é movido para lá automaticamente. Passe `device="cpu"` (ou `-1`) para forçar o uso da CPU, um ordinal positivo ou `"cuda:1"` para selecionar um acelerador específico, ou um `torch.device`/`str` nativo. Este argumento não pode ser combinado com um modelo já carregado via `accelerate` (ou seja, um com `hf_device_map`). dtype (`str` ou `torch.dtype`, *opcional*, padrão `"auto"`) : A precisão na qual o modelo é carregado, encaminhada para `from_pretrained`. O padrão é `"auto"`, que carrega o modelo no dtype em que ele foi salvo (lido do `config.dtype` do checkpoint, ou inferido a partir dos pesos). Passe um `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescrever. tokenize_kwargs (`dict`, *opcional*) : Dicionário adicional de argumentos de palavra-chave passados ao tokenizer. return_tensors (`bool`, *opcional*) : Se `True`, retorna um tensor de acordo com o framework especificado; caso contrário, retorna uma lista. O pipeline de extração de recursos não utiliza nenhuma cabeça de modelo. Este pipeline extrai os estados ocultos do transformer base, que podem ser usados como recursos em tarefas subsequentes. Exemplo: ```python >>> from transformers import pipeline >>> extractor = pipeline(model="google-bert/bert-base-uncased", task="feature-extraction") >>> result = extractor("This is a simple test.", return_tensors=True) >>> result.shape # This is a tensor of shape [1, sequence_length, hidden_dimension] representing the input string. torch.Size([1, 8, 768]) ``` Saiba mais sobre os fundamentos do uso de um pipeline no [tutorial de pipeline](../pipeline_tutorial) Este pipeline de extração de características pode atualmente ser carregado a partir de [pipeline()](/docs/transformers/main/pt/main_classes/pipelines#transformers.pipeline) usando o identificador de tarefa: `"feature-extraction"`. Todos os modelos podem ser usados para este pipeline. Consulte a lista de todos os modelos, incluindo modelos contribuídos pela comunidade em [huggingface.co/models](https://huggingface.co/models). #### __call__[[transformers.FeatureExtractionPipeline.__call__]] ```python __call__(*args: str | list[str], **kwargs: Any) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/feature_extraction.py#L78) **Parâmetros:** args (`str` ou `list[str]`) : Um ou vários textos (ou uma lista de textos) para obter os recursos. **Retorna:** Uma lista aninhada de `float` Os recursos calculados pelo modelo. Extraia os recursos do(s) texto(s) de entrada. ### ImageFeatureExtractionPipeline[[transformers.ImageFeatureExtractionPipeline]] #### transformers.ImageFeatureExtractionPipeline[[transformers.ImageFeatureExtractionPipeline]] ```python transformers.ImageFeatureExtractionPipeline(model: PreTrainedModel, tokenizer: PreTrainedTokenizer | None = None, feature_extractor: PreTrainedFeatureExtractor | None = None, image_processor: BaseImageProcessor | None = None, video_processor: BaseVideoProcessor | None = None, processor: ProcessorMixin | None = None, task: str = '', device: int | torch.device | None = None, binary_output: bool = False, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/image_feature_extraction.py#L23) **Parâmetros:** model ([PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel)): o modelo que será usado pelo pipeline para fazer previsões. Ele precisa ser um modelo que herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor)): o processador de imagens que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, padrão `""`) : Um identificador de tarefa para o pipeline. num_workers (`int`, *opcional*, padrão 8) : Quando o pipeline utilizar *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o número de workers a serem usados. batch_size (`int`, *opcional*, padrão 1) : Quando o pipeline usará *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o tamanho do lote a ser usado. Para inferência, isso nem sempre é vantajoso; leia [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/pt/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referência ao objeto responsável por analisar os parâmetros fornecidos do pipeline. device (`int` ou `str` ou `torch.device`, *opcional*) : Dispositivo no qual o pipeline é alocado. Se não for definido, o pipeline é colocado no primeiro acelerador disponível (CUDA, MPS, XPU, ...) e recorre para a CPU apenas quando nenhum estiver disponível; o modelo é movido para lá automaticamente. Passe `device="cpu"` (ou `-1`) para forçar o uso da CPU, um ordinal positivo ou `"cuda:1"` para selecionar um acelerador específico, ou um `torch.device`/`str` nativo. Este argumento não pode ser combinado com um modelo já carregado via `accelerate` (ou seja, um com `hf_device_map`). dtype (`str` ou `torch.dtype`, *opcional*, padrão `"auto"`) : A precisão na qual o modelo é carregado, encaminhada para `from_pretrained`. O padrão é `"auto"`, que carrega o modelo no dtype em que ele foi salvo (lido do `config.dtype` do checkpoint, ou inferido a partir dos pesos). Passe um `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescrever. binary_output (`bool`, *opcional*, padrão `False`) : Indica se a saída do pipeline deve ocorrer em um formato serializado (ou seja, pickle) ou como os dados de saída brutos, por exemplo, texto. image_processor_kwargs (`dict`, *opcional*) : Dicionário adicional de argumentos de palavra-chave passados ao processador de imagens, por exemplo, {"size": {"height": 100, "width": 100}} pool (`bool`, *opcional*, padrão `False`) : Indica se a saída agregada (pooled output) deve ser retornada. Se `False`, o modelo retornará os estados ocultos brutos (raw hidden states). O pipeline de extração de características de imagem não utiliza nenhuma cabeça de modelo. Este pipeline extrai os estados ocultos do transformer base, que podem ser usados como características em tarefas subsequentes. Exemplo: ```python >>> from transformers import pipeline >>> extractor = pipeline(model="google/vit-base-patch16-224", task="image-feature-extraction") >>> result = extractor("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png", return_tensors=True) >>> result.shape # This is a tensor of shape [1, sequence_length, hidden_dimension] representing the input image. torch.Size([1, 197, 768]) ``` Saiba mais sobre os fundamentos do uso de um pipeline no [tutorial de pipeline](../pipeline_tutorial) Este pipeline de extração de características de imagem pode ser carregado atualmente a partir de [pipeline()](/docs/transformers/main/pt/main_classes/pipelines#transformers.pipeline) usando o identificador de tarefa: `"image-feature-extraction"`. Todos os modelos de visão podem ser usados neste pipeline. Consulte a lista de todos os modelos, incluindo modelos contribuídos pela comunidade, em [huggingface.co/models](https://huggingface.co/models). #### __call__[[transformers.ImageFeatureExtractionPipeline.__call__]] ```python __call__(*args: typing.Union[str, ForwardRef('Image.Image'), list['Image.Image'], list[str]], **kwargs: Any) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/image_feature_extraction.py#L94) **Parâmetros:** images (`str`, `list[str]`, `PIL.Image` ou `list[PIL.Image]`) : O pipeline lida com três tipos de imagens: - Uma string contendo um link http que aponta para uma imagem - Uma string contendo um caminho local para uma imagem - Uma imagem carregada diretamente em PIL O pipeline aceita uma única imagem ou um lote de imagens, que deve ser passado como uma string. As imagens em um lote devem estar todas no mesmo formato: todas como links http, todas como caminhos locais ou todas como imagens PIL. timeout (`float`, *opcional*, padrão None) : O tempo máximo, em segundos, para aguardar a busca de imagens da web. Se for None, nenhum tempo limite é usado e a chamada pode bloquear indefinidamente. **Retorna:** Uma lista aninhada de `float` Os recursos calculados pelo modelo. Extraia os recursos das entradas. ### ImageTextToTextPipeline[[transformers.ImageTextToTextPipeline]] #### transformers.ImageTextToTextPipeline[[transformers.ImageTextToTextPipeline]] ```python transformers.ImageTextToTextPipeline(*args, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/image_text_to_text.py#L53) **Parâmetros:** model ([PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel)): o modelo que será usado pelo pipeline para fazer previsões. Ele precisa ser um modelo que herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). processor ([ProcessorMixin](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin)) : O processador que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [ProcessorMixin](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin). O Processor é um objeto composto que pode conter `tokenizer`, `feature_extractor` e `image_processor`. task (`str`, padrão `""`) : Um identificador de tarefa para o pipeline. num_workers (`int`, *opcional*, padrão 8) : Quando o pipeline utilizar *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o número de workers a serem usados. batch_size (`int`, *opcional*, padrão 1) : Quando o pipeline usará *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o tamanho do lote a ser usado. Para inferência, isso nem sempre é vantajoso; leia [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/pt/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referência ao objeto responsável por analisar os parâmetros fornecidos do pipeline. device (`int` ou `str` ou `torch.device`, *opcional*) : Dispositivo no qual o pipeline é alocado. Se não for definido, o pipeline é colocado no primeiro acelerador disponível (CUDA, MPS, XPU, ...) e recorre para a CPU apenas quando nenhum estiver disponível; o modelo é movido para lá automaticamente. Passe `device="cpu"` (ou `-1`) para forçar o uso da CPU, um ordinal positivo ou `"cuda:1"` para selecionar um acelerador específico, ou um `torch.device`/`str` nativo. Este argumento não pode ser combinado com um modelo já carregado via `accelerate` (ou seja, um com `hf_device_map`). dtype (`str` ou `torch.dtype`, *opcional*, padrão `"auto"`) : A precisão na qual o modelo é carregado, encaminhada para `from_pretrained`. O padrão é `"auto"`, que carrega o modelo no dtype em que ele foi salvo (lido do `config.dtype` do checkpoint, ou inferido a partir dos pesos). Passe um `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescrever. binary_output (`bool`, *opcional*, padrão `False`) : Indica se a saída do pipeline deve ocorrer em um formato serializado (ou seja, pickle) ou como os dados de saída brutos, por exemplo, texto. Pipeline de imagem-texto-para-texto usando um `AutoModelForImageTextToText`. Este pipeline gera texto a partir de uma imagem e de um texto. Quando o modelo subjacente é um modelo conversacional, ele também pode aceitar uma ou mais conversas, caso em que o pipeline operará em modo de chat e continuará a(s) conversa(s) adicionando sua(s) resposta(s). Cada conversa tem a forma de uma lista de dicts, em que cada dict contém as chaves "role" e "content". A menos que o modelo que você está usando defina explicitamente esses parâmetros de geração em seus arquivos de configuração (`generation_config.json`), os seguintes valores padrão serão usados: - max_new_tokens: 256 Exemplo: ```python >>> from transformers import pipeline >>> pipe = pipeline(task="image-text-to-text", model="Salesforce/blip-image-captioning-base") >>> pipe("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png", text="A photo of") [{'generated_text': 'a photo of two birds'}] ``` ```python >>> from transformers import pipeline >>> pipe = pipeline("image-text-to-text", model="llava-hf/llava-interleave-qwen-0.5b-hf") >>> messages = [ >>> { >>> "role": "user", >>> "content": [ >>> { >>> "type": "image", >>> "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/qwen_vl_demo.jpeg", >>> }, >>> {"type": "text", "text": "Describe this image."}, >>> ], >>> }, >>> { >>> "role": "assistant", >>> "content": [ >>> {"type": "text", "text": "There is a dog and"}, >>> ], >>> }, >>> ] >>> pipe(text=messages, max_new_tokens=20, return_full_text=False) [{'input_text': [{'role': 'user', 'content': [{'type': 'image', 'url': 'https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/qwen_vl_demo.jpeg'}, {'type': 'text', 'text': 'Describe this image.'}]}, {'role': 'assistant', 'content': [{'type': 'text', 'text': 'There is a dog and'}]}], 'generated_text': ' a person in the image. The dog is sitting on the sand, and the person is sitting on'}] ``` Saiba mais sobre os fundamentos do uso de um pipeline no [tutorial de pipeline](../pipeline_tutorial) Este pipeline de imagem e texto para texto pode ser carregado atualmente a partir de pipeline() usando o seguinte identificador de tarefa: "image-text-to-text". Veja a lista de modelos disponíveis em [huggingface.co/models](https://huggingface.co/models?pipeline_tag=image-text-to-text). #### __call__[[transformers.ImageTextToTextPipeline.__call__]] ```python __call__(images: typing.Union[str, list[str], list[list[str]], ForwardRef('Image.Image'), list['Image.Image'], list[list['Image.Image']], list[dict], NoneType] = None, text: str | list[str] | list[dict] | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/image_text_to_text.py#L215) **Parâmetros:** images (`str`, `list[str]`, `PIL.Image, `list[PIL.Image]`, `list[dict[str, Union[str, PIL.Image]]]`) : The pipeline handles three types of images: - A string containing a HTTP(s) link pointing to an image - A string containing a local path to an image - An image loaded in PIL directly The pipeline accepts either a single image or a batch of images. Finally, this pipeline also supports the chat format (see `text`) containing images and text in this argument. text (str, list[str], `list[dict[str, Union[str, PIL.Image]]]`) : O texto a ser usado para a geração. Se uma lista de strings for passada, o comprimento da lista deve ser o mesmo que o número de imagens. O texto também pode seguir o formato de chat: uma lista de dicionários em que cada dicionário representa uma mensagem em uma conversa. Cada dicionário deve ter duas chaves: 'role' e 'content'. 'role' deve ser um dos valores 'user', 'system' ou 'assistant'. 'content' deve ser uma lista de dicionários contendo o texto da mensagem e o tipo da mensagem. O tipo da mensagem pode ser 'text' ou 'image'. Se o tipo for 'image', nenhum texto é necessário. return_tensors (`bool`, *opcional*, padrão `False`) : Retorna os tensores de previsões (como índices de tokens) nas saídas. Se definido como `True`, o texto decodificado não é retornado. return_text (`bool`, *opcional*) : Retorna os textos decodificados nas saídas. return_full_text (`bool`, *opcional*, padrão `True`) : Se definido como `False`, apenas o texto adicionado é retornado; caso contrário, o texto completo é retornado. Não pode ser especificado ao mesmo tempo que `return_text`. clean_up_tokenization_spaces (`bool`, *opcional*) : Indica se os espaços extras potenciais na saída de texto devem ser removidos. O valor padrão é a configuração `clean_up_tokenization_spaces` do tokenizer. continue_final_message( `bool`, *opcional*) : Indica que você deseja que o modelo continue a última mensagem no chat de entrada, em vez de iniciar uma nova, permitindo "preencher" sua resposta. Por padrão, isso é `True` quando a última mensagem no chat de entrada tem o papel `assistant` e `False` caso contrário, mas você pode sobrescrever manualmente esse comportamento definindo essa flag. **Retorna:** Uma lista ou uma lista de listas de `dict` Cada resultado é retornado como um dicionário com a seguinte chave (não é possível retornar uma combinação de `generated_text` e `generated_token_ids`): - **generated_text** (`str`, presente quando `return_text=True`) -- O texto gerado. - **generated_token_ids** (`torch.Tensor`, presente quando `return_tensors=True`) -- Os ids dos tokens do texto gerado. - **input_text** (`str`) -- O texto de entrada. Gere um texto com base no texto e nas imagens passadas como entradas. ### AnyToAnyPipeline[[transformers.AnyToAnyPipeline]] #### transformers.AnyToAnyPipeline[[transformers.AnyToAnyPipeline]] ```python transformers.AnyToAnyPipeline(*args, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/any_to_any.py#L67) **Parâmetros:** model ([PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel)): o modelo que será usado pelo pipeline para fazer previsões. Ele precisa ser um modelo que herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). processor ([ProcessorMixin](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin)) : O processador que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [ProcessorMixin](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin). O Processor é um objeto composto que pode conter `tokenizer`, `feature_extractor` e `image_processor`. task (`str`, padrão `""`) : Um identificador de tarefa para o pipeline. num_workers (`int`, *opcional*, padrão 8) : Quando o pipeline utilizar *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o número de workers a serem usados. batch_size (`int`, *opcional*, padrão 1) : Quando o pipeline usará *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o tamanho do lote a ser usado. Para inferência, isso nem sempre é vantajoso; leia [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/pt/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referência ao objeto responsável por analisar os parâmetros fornecidos do pipeline. device (`int` ou `str` ou `torch.device`, *opcional*) : Dispositivo no qual o pipeline é alocado. Se não for definido, o pipeline é colocado no primeiro acelerador disponível (CUDA, MPS, XPU, ...) e recorre para a CPU apenas quando nenhum estiver disponível; o modelo é movido para lá automaticamente. Passe `device="cpu"` (ou `-1`) para forçar o uso da CPU, um ordinal positivo ou `"cuda:1"` para selecionar um acelerador específico, ou um `torch.device`/`str` nativo. Este argumento não pode ser combinado com um modelo já carregado via `accelerate` (ou seja, um com `hf_device_map`). dtype (`str` ou `torch.dtype`, *opcional*, padrão `"auto"`) : A precisão na qual o modelo é carregado, encaminhada para `from_pretrained`. O padrão é `"auto"`, que carrega o modelo no dtype em que ele foi salvo (lido do `config.dtype` do checkpoint, ou inferido a partir dos pesos). Passe um `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescrever. binary_output (`bool`, *opcional*, padrão `False`) : Indica se a saída do pipeline deve ocorrer em um formato serializado (ou seja, pickle) ou como os dados de saída brutos, por exemplo, texto. Pipeline de Geração Multimodal que utiliza um `AutoModelForMultimodalLM`. Este pipeline gera texto a partir de qualquer combinação de dados multimodais e texto. Quando o modelo subjacente é um modelo conversacional, ele também pode aceitar um ou mais chats, caso em que o pipeline operará em modo de chat e continuará o(s) chat(s) adicionando sua(s) resposta(s). Cada chat tem a forma de uma lista de dicts, em que cada dict contém as chaves "role" e "content". A menos que o modelo que você está usando defina explicitamente esses parâmetros de geração em seus arquivos de configuração (`generation_config.json`), os seguintes valores padrão serão usados: - max_new_tokens: 256 Exemplo: ```python >>> from transformers import pipeline >>> pipe = pipeline(task="any-to-any", model="google/gemma-3n-E4B-it") >>> pipe("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png", text="A photo of") [{'generated_text': 'a photo of two birds'}] ``` ```python >>> from transformers import pipeline >>> pipe = pipeline("any-to-any", model="google/gemma-3n-E4B-it") >>> messages = [ >>> { >>> "role": "user", >>> "content": [ >>> { >>> "type": "image", >>> "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/qwen_vl_demo.jpeg", >>> }, >>> {"type": "text", "text": "Describe this image."}, >>> ], >>> }, >>> { >>> "role": "assistant", >>> "content": [ >>> {"type": "text", "text": "There is a dog and"}, >>> ], >>> }, >>> ] >>> pipe(text=messages, max_new_tokens=20, return_full_text=False) [{'input_text': [{'role': 'user', 'content': [{'type': 'image', 'url': 'https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/qwen_vl_demo.jpeg'}, {'type': 'text', 'text': 'Describe this image.'}]}, {'role': 'assistant', 'content': [{'type': 'text', 'text': 'There is a dog and'}]}], 'generated_text': ' a person in the image. The dog is sitting on the sand, and the person is sitting on'}] ``` Saiba mais sobre os fundamentos do uso de um pipeline no [tutorial de pipeline](../pipeline_tutorial) Este pipeline multimodal pode atualmente ser carregado a partir de pipeline() usando o seguinte identificador de tarefa: "any-to-any". Veja a lista de modelos disponíveis em [huggingface.co/models](https://huggingface.co/models?pipeline_tag=any-to-any). #### __call__[[transformers.AnyToAnyPipeline.__call__]] ```python __call__(text: str | list[str] | list[dict], images: typing.Union[str, list[str], list[list[str]], ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, videos: typing.Union[str, list[str], list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, audio: typing.Union[str, list[str], numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/any_to_any.py#L258) **Parâmetros:** text (`str`, `list[str]`, `list[dict]`) : O texto a ser usado para a geração. Se uma lista de strings for passada, o comprimento da lista deve ser igual ao número de imagens. O texto também pode seguir o formato de chat: uma lista de dicionários em que cada dicionário representa uma mensagem em uma conversa. Cada dicionário deve ter duas chaves: 'role' e 'content'. 'role' deve ser um dos valores 'user', 'system' ou 'assistant'. 'content' deve ser uma lista de dicionários contendo o texto da mensagem e o tipo da mensagem. images (`str`, `list[str]`, `ImageInput`) : O pipeline processa três tipos de imagens: - Uma string contendo um link HTTP(s) que aponta para uma imagem - Uma string contendo um caminho local para uma imagem - Uma imagem carregada diretamente em PIL O pipeline aceita uma única imagem ou um lote de imagens. Por fim, este pipeline também suporta o formato de chat (veja `text`) contendo imagens e texto neste argumento. videos (`str`, `list[str]`, `VideoInput`) : O pipeline processa três tipos de vídeos: - Uma string contendo um link HTTP(s) que aponta para um vídeo - Uma string contendo um caminho local para um vídeo - Um vídeo carregado e decodificado para o formato de array O pipeline aceita um único vídeo ou um lote de vídeos. Por fim, este pipeline também suporta o formato de chat (veja `text`) contendo vídeos e texto neste argumento. audio (`str`, `list[str]`, `AudioInput`) : O pipeline processa três tipos de áudio: - Uma string contendo um link HTTP(s) para um áudio - Uma string contendo um caminho local para um áudio - Um áudio carregado diretamente em PIL O pipeline aceita um único áudio ou um lote de áudios. Por fim, este pipeline também suporta o formato de chat (veja `text`) contendo áudios e texto neste argumento. return_tensors (`bool`, *opcional*, padrão `False`) : Retorna os tensores de previsões (como índices de tokens) nas saídas. Se definido como `True`, o texto decodificado não é retornado. return_text (`bool`, *opcional*) : Retorna os textos decodificados nas saídas. return_full_text (`bool`, *opcional*, padrão `True`) : Se definido como `False`, apenas o texto adicionado é retornado; caso contrário, o texto completo é retornado. Não pode ser especificado ao mesmo tempo que `return_text`. clean_up_tokenization_spaces (`bool`, *opcional*) : Indica se os espaços extras potenciais na saída de texto devem ser removidos. O valor padrão é a configuração `clean_up_tokenization_spaces` do tokenizer. continue_final_message( `bool`, *opcional*) : Indica que você deseja que o modelo continue a última mensagem no chat de entrada, em vez de iniciar uma nova, permitindo "preencher" sua resposta. Por padrão, isso é `True` quando a última mensagem no chat de entrada tem o papel `assistant` e `False` caso contrário, mas você pode sobrescrever manualmente esse comportamento definindo essa flag. **Retorna:** Uma lista ou uma lista de listas de `dict` Cada resultado é retornado como um dicionário com a seguinte chave (não é possível retornar uma combinação de `generated_text` e `generated_token_ids`): - **generated_text** (`str`, presente quando `return_text=True` e `generation_mode="text"`) -- O texto gerado. - **generated_audio** (`np.ndarray`, presente quando `generation_mode="audio"`) -- O áudio gerado. - **generated_image** (`PIL.Image.Image`, presente quando `generation_mode="image"`) -- A imagem gerada. - **generated_token_ids** (`torch.Tensor`, presente quando `return_tensors=True` e `generation_mode="text"`) -- Os ids dos tokens do texto gerado. - **input_text** (`str`) -- O texto de entrada. Gere um texto a partir de um texto e, opcionalmente, de dados multimodais passados como entradas. ### MaskGenerationPipeline[[transformers.MaskGenerationPipeline]] #### transformers.MaskGenerationPipeline[[transformers.MaskGenerationPipeline]] ```python transformers.MaskGenerationPipeline(**kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/mask_generation.py#L36) **Parâmetros:** model ([PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel)): o modelo que será usado pelo pipeline para fazer previsões. Ele precisa ser um modelo que herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). image_processor ([BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor)): o processador de imagens que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor). task (`str`, padrão `""`) : Um identificador de tarefa para o pipeline. num_workers (`int`, *opcional*, padrão 8) : Quando o pipeline utilizar *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o número de workers a serem usados. batch_size (`int`, *opcional*, padrão 1) : Quando o pipeline usará *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o tamanho do lote a ser usado. Para inferência, isso nem sempre é vantajoso; leia [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/pt/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referência ao objeto responsável por analisar os parâmetros fornecidos do pipeline. device (`int` ou `str` ou `torch.device`, *opcional*) : Dispositivo no qual o pipeline é alocado. Se não for definido, o pipeline é colocado no primeiro acelerador disponível (CUDA, MPS, XPU, ...) e recorre para a CPU apenas quando nenhum estiver disponível; o modelo é movido para lá automaticamente. Passe `device="cpu"` (ou `-1`) para forçar o uso da CPU, um ordinal positivo ou `"cuda:1"` para selecionar um acelerador específico, ou um `torch.device`/`str` nativo. Este argumento não pode ser combinado com um modelo já carregado via `accelerate` (ou seja, um com `hf_device_map`). dtype (`str` ou `torch.dtype`, *opcional*, padrão `"auto"`) : A precisão na qual o modelo é carregado, encaminhada para `from_pretrained`. O padrão é `"auto"`, que carrega o modelo no dtype em que ele foi salvo (lido do `config.dtype` do checkpoint, ou inferido a partir dos pesos). Passe um `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescrever. binary_output (`bool`, *opcional*, padrão `False`) : Indica se a saída do pipeline deve ocorrer em um formato serializado (ou seja, pickle) ou como os dados de saída brutos, por exemplo, texto. points_per_batch (*opcional*, int, padrão 64) : Define o número de pontos executados simultaneamente pelo modelo. Números maiores podem ser mais rápidos, mas usam mais memória de GPU. output_bboxes_mask (`bool`, *opcional*, padrão `False`) : Se as previsões de caixas delimitadoras devem ser exibidas ou não. output_rle_masks (`bool`, *opcional*, padrão `False`) : Se as máscaras devem ser ou não exibidas no formato `RLE` Geração automática de máscaras para imagens usando `SamForMaskGeneration`. Este pipeline prevê máscaras binárias para uma imagem, dado uma imagem. É um `ChunkPipeline` porque você pode separar os pontos em um mini-lote para evitar problemas de OOM. Use o argumento `points_per_batch` para controlar o número de pontos que serão processados ao mesmo tempo. O padrão é `64`. O pipeline funciona em 3 etapas: 1. `preprocess`: Uma grade de 1024 pontos separados uniformemente é gerada, juntamente com caixas delimitadoras e rótulos de pontos. Para mais detalhes sobre como os pontos e as caixas delimitadoras são criados, consulte a função `_generate_crop_boxes`. A imagem também é pré-processada usando o `image_processor`. Esta função `yields` um minibatch de `points_per_batch`. 2. `forward`: fornece as saídas de `preprocess` ao modelo. O embedding da imagem é calculado apenas uma vez. Chama `self.model.get_image_embeddings` e garante que os gradientes não sejam calculados e que os tensores e modelos estejam no mesmo dispositivo. 3. `postprocess`: A parte mais importante da geração automática de máscaras acontece aqui. Três etapas são induzidas: - image_processor.postprocess_masks (executado em cada iteração do laço de minibatch): recebe as máscaras de saída brutas, redimensiona-as de acordo com o tamanho da imagem e as converte em máscaras binárias. - image_processor.filter_masks (em cada iteração do laço de minibatch): utiliza tanto `pred_iou_thresh` quanto `stability_scores`. Também aplica uma variedade de filtros com base em supressão de máximos não máximos para remover máscaras ruins. - image_processor.postprocess_masks_for_amg aplica o NSM na máscara para reter apenas as relevantes. Exemplo: ```python >>> from transformers import pipeline >>> generator = pipeline(model="facebook/sam-vit-base", task="mask-generation") >>> outputs = generator( ... "http://images.cocodataset.org/val2017/000000039769.jpg", ... ) >>> outputs = generator( ... "https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png", points_per_batch=128 ... ) ``` Saiba mais sobre os fundamentos do uso de um pipeline no [tutorial de pipeline](../pipeline_tutorial) Este pipeline de segmentação pode ser carregado atualmente a partir de [pipeline()](/docs/transformers/main/pt/main_classes/pipelines#transformers.pipeline) usando o seguinte identificador de tarefa: `"mask-generation"`. Veja a lista de modelos disponíveis em [huggingface.co/models](https://huggingface.co/models?filter=mask-generation). #### __call__[[transformers.MaskGenerationPipeline.__call__]] ```python __call__(image: typing.Union[str, ForwardRef('Image.Image'), list[str], list['Image.Image']], *args: Any, **kwargs: Any) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/mask_generation.py#L143) **Parâmetros:** image (`str`, `List[str]`, `PIL.Image` ou `List[PIL.Image]`) : Imagem ou lista de imagens. mask_threshold (`float`, *opcional*, padrão 0.0) : Limiar a ser utilizado ao converter as máscaras previstas em valores binários. pred_iou_thresh (`float`, *opcional*, padrão 0.88) : Um limiar de filtragem em `[0,1]` aplicado à qualidade da máscara prevista pelo modelo. stability_score_thresh (`float`, *opcional*, padrão 0.95) : Um limiar de filtragem em `[0,1]`, que utiliza a estabilidade da máscara sob alterações no corte usado para binarizar as previsões de máscara do modelo. stability_score_offset (`int`, *opcional*, padrão 1) : A quantidade a ser deslocada no cutoff ao calcular a pontuação de estabilidade. crops_nms_thresh (`float`, *opcional*, padrão 0.7) : O limite de IoU de caixa usado pela supressão não máxima para filtrar máscaras duplicadas. crops_n_layers (`int`, *opcional*, padrão 0) : Se `crops_n_layers>0`, a previsão de máscara será executada novamente em recortes da imagem. Define o número de camadas a serem executadas, em que cada camada possui 2**i_layer recortes da imagem. crop_overlap_ratio (`float`, *opcional*, padrão `512 / 1500`) : Define o grau de sobreposição entre os recortes. Na primeira camada de recortes, os recortes se sobrepõem por essa fração do comprimento da imagem. Camadas posteriores, com mais recortes, reduzem essa sobreposição. crop_n_points_downscale_factor (`int`, *opcional*, padrão `1`) : O número de pontos por lado amostrados na camada n é reduzido pelo fator crop_n_points_downscale_factor**n. timeout (`float`, *opcional*, padrão None) : O tempo máximo, em segundos, para aguardar a busca de imagens da web. Se for None, nenhum tempo limite é definido e a chamada pode bloquear indefinidamente. **Retorna:** `Dict` Um dicionário com as seguintes chaves: - **mask** (`PIL.Image`) -- Uma máscara binária do objeto detectado, como uma imagem PIL com a forma `(width, height)` da imagem original. Retorna uma máscara preenchida com zeros se nenhum objeto for encontrado. - **score** (*opcional* `float`) -- Opcionalmente, quando o modelo é capaz de estimar a confiança do "objeto" descrito pelo rótulo e pela máscara. Gera máscaras de segmentação binária ## Classe pai: `Pipeline`[[transformers.Pipeline]] #### transformers.Pipeline[[transformers.Pipeline]] ```python transformers.Pipeline(model: PreTrainedModel, tokenizer: PreTrainedTokenizer | None = None, feature_extractor: PreTrainedFeatureExtractor | None = None, image_processor: BaseImageProcessor | None = None, video_processor: BaseVideoProcessor | None = None, processor: ProcessorMixin | None = None, task: str = '', device: int | torch.device | None = None, binary_output: bool = False, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L763) **Parâmetros:** model ([PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel)): o modelo que será usado pelo pipeline para fazer previsões. Ele precisa ser um modelo que herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). tokenizer ([PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend)) : O tokenizer que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [PreTrainedTokenizer](/docs/transformers/main/pt/main_classes/tokenizer#transformers.PythonBackend). feature_extractor ([SequenceFeatureExtractor](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor)) : O extrator de recursos que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [SequenceFeatureExtractor](/docs/transformers/main/pt/main_classes/feature_extractor#transformers.SequenceFeatureExtractor). image_processor ([BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor)): o processador de imagens que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [BaseImageProcessor](/docs/transformers/main/pt/main_classes/image_processor#transformers.BaseImageProcessor). processor ([ProcessorMixin](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin)) : O processador que será usado pelo pipeline para codificar os dados para o modelo. Este objeto herda de [ProcessorMixin](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin). O Processor é um objeto composto que pode conter `tokenizer`, `feature_extractor` e `image_processor`. task (`str`, padrão `""`) : Um identificador de tarefa para o pipeline. num_workers (`int`, *opcional*, padrão 8) : Quando o pipeline utilizar *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o número de workers a serem usados. batch_size (`int`, *opcional*, padrão 1) : Quando o pipeline usará *DataLoader* (ao passar um dataset, em GPU para um modelo Pytorch), o tamanho do lote a ser usado. Para inferência, isso nem sempre é vantajoso; leia [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) . args_parser ([ArgumentHandler](/docs/transformers/main/pt/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referência ao objeto responsável por analisar os parâmetros fornecidos do pipeline. device (`int` ou `str` ou `torch.device`, *opcional*) : Dispositivo no qual o pipeline é alocado. Se não for definido, o pipeline é colocado no primeiro acelerador disponível (CUDA, MPS, XPU, ...) e recorre para a CPU apenas quando nenhum estiver disponível; o modelo é movido para lá automaticamente. Passe `device="cpu"` (ou `-1`) para forçar o uso da CPU, um ordinal positivo ou `"cuda:1"` para selecionar um acelerador específico, ou um `torch.device`/`str` nativo. Este argumento não pode ser combinado com um modelo já carregado via `accelerate` (ou seja, um com `hf_device_map`). dtype (`str` ou `torch.dtype`, *opcional*, padrão `"auto"`) : A precisão na qual o modelo é carregado, encaminhada para `from_pretrained`. O padrão é `"auto"`, que carrega o modelo no dtype em que ele foi salvo (lido do `config.dtype` do checkpoint, ou inferido a partir dos pesos). Passe um `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescrever. binary_output (`bool`, *opcional*, padrão `False`) : Indica se a saída do pipeline deve ocorrer em um formato serializado (ou seja, pickle) ou como os dados de saída brutos, por exemplo, texto. A classe Pipeline é a classe da qual todos os pipelines herdam. Consulte esta classe para os métodos compartilhados entre diferentes pipelines. Classe base que implementa operações em pipeline. O fluxo de trabalho do pipeline é definido como uma sequência das seguintes operações: Entrada -> Tokenização -> Inferência do Modelo -> Pós-processamento (dependente da tarefa) -> Saída O Pipeline suporta execução em CPU ou GPU por meio do argumento device (veja abaixo). Algumas pipelines, como por exemplo a [FeatureExtractionPipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.FeatureExtractionPipeline) (`'feature-extraction'`), produzem objetos de tensor grandes como listas aninhadas. Para evitar a gravação de estruturas tão grandes como dados textuais, fornecemos o argumento de construtor `binary_output`. Se definido como `True`, a saída será armazenada no formato pickle. #### check_model_type[[transformers.Pipeline.check_model_type]] ```python check_model_type(supported_models: list[str] | dict) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L1126) **Parâmetros:** supported_models (`list[str]` ou `dict`) : A lista de modelos suportados pelo pipeline, ou um dicionário com valores de classes de modelo. Verifique se a classe do modelo é suportada pelo pipeline. #### device_placement[[transformers.Pipeline.device_placement]] ```python device_placement() ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L1012) **Retorna:** Gerenciador de contexto Context Manager que permite a alocação de tensores no dispositivo especificado pelo usuário. Exemplos: ```python # Explicitly ask for tensor allocation on CUDA device :0 pipe = pipeline(..., device=0) with pipe.device_placement(): # Every tensor allocation will be done on the request device output = pipe(...) ``` #### ensure_tensor_on_device[[transformers.Pipeline.ensure_tensor_on_device]] ```python ensure_tensor_on_device(**inputs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L1094) **Parâmetros:** inputs (argumentos de palavra-chave que devem ser `torch.Tensor`, o restante é ignorado) : Os tensores a serem colocados em `self.device`. Recursivo em listas **apenas**. -- **Retorna:** `dict[str, torch.Tensor]` O mesmo que `inputs`, mas no dispositivo adequado. Garanta que os tensores do PyTorch estejam no dispositivo especificado. #### postprocess[[transformers.Pipeline.postprocess]] ```python postprocess(model_outputs: ModelOutput, **postprocess_parameters: dict) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L1193) O Postprocess receberá as saídas brutas do método `_forward`, geralmente tensores, e as reformatará em algo mais amigável. Geralmente, ele produzirá uma lista ou um dicionário de resultados (contendo apenas strings e números). #### predict[[transformers.Pipeline.predict]] ```python predict(X) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L991) Interface Scikit / Keras para os pipelines do Transformers. Este método encaminhará para __call__(). #### preprocess[[transformers.Pipeline.preprocess]] ```python preprocess(input_: Any, **preprocess_parameters: dict) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L1172) O método `input_` de um pipeline específico será processado pelo Preprocess, que retorna um dicionário com tudo o que é necessário para que o `_forward` seja executado corretamente. Ele deve conter pelo menos um tensor, mas pode incluir outros itens arbitrários. #### push_to_hub[[transformers.Pipeline.push_to_hub]] ```python push_to_hub(repo_id: str, commit_message: str | None = None, commit_description: str | None = None, private: bool | None = None, token: bool | str | None = None, revision: str | None = None, create_pr: bool = False, max_shard_size: int | str | None = '50GB', tags: list[str] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/hub.py#L822) **Parâmetros:** repo_id (`str`) : O nome do repositório para o qual você deseja enviar seu pipe. Deve conter o nome da sua organização ao enviar para uma organização específica. commit_message (`str`, *opcional*) : Mensagem a ser commitada durante o push. O valor padrão será `"Upload pipe"`. commit_description (`str`, *opcional*) : A descrição do commit que será criado private (`bool`, *opcional*) : Se deve tornar o repositório privado. Se `None` (padrão), o repositório será público, a menos que o padrão da organização seja privado. Este valor é ignorado se o repositório já existir. token (`bool` ou `str`, *opcional*) : O token a ser usado como autorização bearer HTTP para arquivos remotos. Se `True` (padrão), usará o token gerado ao executar `hf auth login` (armazenado em `~/.huggingface`). revision (`str`, *opcional*) : Branch para a qual os arquivos enviados serão enviados. create_pr (`bool`, *opcional*, padrão `False`) : Se deve ou não criar um PR com os arquivos enviados ou fazer o commit diretamente. max_shard_size (`int` ou `str`, *opcional*, padrão `"50GB"`) : Aplicável apenas a modelos. O tamanho máximo de um checkpoint antes de ser fragmentado. Os fragmentos do checkpoint terão, então, cada um um tamanho menor que esse valor. Se expresso como string, deve conter dígitos seguidos de uma unidade (como `"5MB"`). tags (`list[str]`, *opcional*) : Lista de tags para enviar no Hub. Envie o arquivo de pipeline para o 🤗 Model Hub. Exemplos: ```python from transformers import pipeline pipe = pipeline("google-bert/bert-base-cased") # Push the pipe to your namespace with the name "my-finetuned-bert". pipe.push_to_hub("my-finetuned-bert") # Push the pipe to an organization with the name "my-finetuned-bert". pipe.push_to_hub("huggingface/my-finetuned-bert") ``` #### save_pretrained[[transformers.Pipeline.save_pretrained]] ```python save_pretrained(save_directory: str | os.PathLike, **kwargs: Any) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L939) **Parâmetros:** save_directory (`str` ou `os.PathLike`) : Um caminho para o diretório onde será salvo. Ele será criado se não existir. kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palavra-chave adicionais passados ao método [push_to_hub()](/docs/transformers/main/pt/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub). Salve o modelo e o tokenizer do pipeline. #### transform[[transformers.Pipeline.transform]] ```python transform(X) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/pipelines/base.py#L985) Interface Scikit / Keras para os pipelines do Transformers. Este método encaminhará para __call__().