# Pipelines

Los pipelines son una forma excelente y sencilla de usar modelos para inferencia. Estos pipelines son objetos que abstraen la mayor parte del código complejo de la biblioteca, ofreciendo una API simple dedicada a varias tareas, entre ellas el reconocimiento de entidades nombradas, el modelado de lenguaje enmascarado, el análisis de sentimiento, la extracción de características y la respuesta a preguntas. Consulte la [lista de tareas](https://huggingface.co/tasks) para ver ejemplos de uso.

Hay dos categorías de abstracciones de pipeline de las que conviene estar al tanto:

- El [pipeline()](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.pipeline), que es el objeto más potente y encapsula todos los demás pipelines.
- Hay pipelines específicos para tareas disponibles para [audio](#audio), [visión por computadora](#computer-vision), [procesamiento de lenguaje natural](#natural-language-processing) y tareas [multimodales](#multimodal).

## La abstracción de pipeline[[transformers.pipeline]]

La abstracción *pipeline* es un envoltorio alrededor de todos los demás pipelines disponibles. Se instancia como cualquier otro pipeline, pero puede ofrecer una mayor comodidad de uso.

Llamada simple en un elemento:

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

Si deseas usar un modelo específico del [hub](https://huggingface.co), puedes ignorar la tarea si el modelo en el hub ya la define:

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

Para llamar a un pipeline con muchos elementos, puedes llamarlo con una *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 datos completos, se recomienda usar un `dataset` directamente. Esto significa que no es necesario asignar el conjunto de datos completo de una sola vez, ni realizar el agrupamiento (batching) manualmente. Debería funcionar igual de rápido que los bucles personalizados en GPU. Si no es así, no dude en crear un problema (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 su uso, también es posible utilizar un generador:

```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)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/__init__.py#L759)

**Parámetros:**

task (`str`) : La tarea que define qué pipeline se devolverá. Las tareas aceptadas actualmente son:  - `"audio-classification"`: devolverá un [AudioClassificationPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.AudioClassificationPipeline). - `"automatic-speech-recognition"`: devolverá un [AutomaticSpeechRecognitionPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.AutomaticSpeechRecognitionPipeline). - `"decision"`: devolverá un [DecisionPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.DecisionPipeline). - `"depth-estimation"`: devolverá un [DepthEstimationPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.DepthEstimationPipeline). - `"document-question-answering"`: devolverá un [DocumentQuestionAnsweringPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.DocumentQuestionAnsweringPipeline). - `"feature-extraction"`: devolverá un [FeatureExtractionPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.FeatureExtractionPipeline). - `"fill-mask"`: devolverá un [FillMaskPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.FillMaskPipeline):. - `"image-classification"`: devolverá un [ImageClassificationPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.ImageClassificationPipeline). - `"image-feature-extraction"`: devolverá un [ImageFeatureExtractionPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.ImageFeatureExtractionPipeline). - `"image-segmentation"`: devolverá un [ImageSegmentationPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.ImageSegmentationPipeline). - `"image-text-to-text"`: devolverá un [ImageTextToTextPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.ImageTextToTextPipeline). - `"keypoint-matching"`: devolverá un [KeypointMatchingPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.KeypointMatchingPipeline). - `"mask-generation"`: devolverá un [MaskGenerationPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.MaskGenerationPipeline). - `"object-detection"`: devolverá un [ObjectDetectionPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.ObjectDetectionPipeline). - `"table-question-answering"`: devolverá un [TableQuestionAnsweringPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.TableQuestionAnsweringPipeline). - `"text-classification"` (alias `"sentiment-analysis"` disponible): devolverá un [TextClassificationPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.TextClassificationPipeline). - `"text-generation"`: devolverá un [TextGenerationPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.TextGenerationPipeline):. - `"text-to-audio"` (alias `"text-to-speech"` disponible): devolverá un [TextToAudioPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.TextToAudioPipeline):. - `"token-classification"` (alias `"ner"` disponible): devolverá un [TokenClassificationPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.TokenClassificationPipeline). - `"video-classification"`: devolverá un [VideoClassificationPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.VideoClassificationPipeline). - `"zero-shot-classification"`: devolverá un [ZeroShotClassificationPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.ZeroShotClassificationPipeline). - `"zero-shot-image-classification"`: devolverá un [ZeroShotImageClassificationPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.ZeroShotImageClassificationPipeline). - `"zero-shot-audio-classification"`: devolverá un [ZeroShotAudioClassificationPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.ZeroShotAudioClassificationPipeline). - `"zero-shot-object-detection"`: devolverá un [ZeroShotObjectDetectionPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.ZeroShotObjectDetectionPipeline).

model (`str` o [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel), *opcional*) : El modelo que se utilizará en el pipeline para realizar predicciones. Puede ser un identificador de modelo o una instancia real de un modelo preentrenado que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel). Si no se proporciona, se cargará el valor predeterminado para la `task`.

config (`str` o [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig), *opcional*) : La configuración que se utilizará en el pipeline para instanciar el modelo. Puede ser un identificador de modelo o una configuración de modelo preentrenado que herede de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig). Si no se proporciona, se utilizará el archivo de configuración predeterminado del modelo solicitado. Esto significa que si se especifica `model`, se usará su configuración predeterminada. Sin embargo, si no se proporciona `model`, se usará en su lugar la configuración del modelo predeterminado de esta `task`.

tokenizer (`str` o [PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend), *opcional*) : El tokenizador que se utilizará en el pipeline para codificar los datos para el modelo. Puede ser un identificador de modelo o un tokenizador preentrenado real que herede de [PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend). Si no se proporciona, se cargará el tokenizador predeterminado para el `model` dado (si es una cadena). Si `model` no se especifica o no es una cadena, se cargará el tokenizador predeterminado para `config` (si es una cadena). Sin embargo, si `config` tampoco se proporciona o no es una cadena, se cargará el tokenizador predeterminado para la `task` dada.

feature_extractor (`str` o [FeatureExtractionMixin](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.FeatureExtractionMixin), *opcional*) : El extractor de características que se utilizará en el pipeline para codificar los datos para el modelo. Puede ser un identificador de modelo o un extractor de características preentrenado que herede de [FeatureExtractionMixin](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.FeatureExtractionMixin). Los extractores de características se utilizan para modelos no basados en NLP, como modelos de audio o visión, así como para modelos multimodales. Los modelos multimodales también requerirán pasar un tokenizador. Si no se proporciona, se cargará el extractor de características predeterminado para el `model` dado (si es una cadena). Si `model` no se especifica o no es una cadena, se cargará el extractor de características predeterminado para `config` (si es una cadena). Sin embargo, si `config` tampoco se proporciona o no es una cadena, se cargará el extractor de características predeterminado para la `task` dada.

image_processor (`str` o [BaseImageProcessor](/docs/transformers/v5.23.0/es/main_classes/image_processor#transformers.BaseImageProcessor), *opcional*) : El procesador de imágenes que se utilizará en el pipeline para preprocesar las imágenes para el modelo. Puede ser un identificador de modelo o un procesador de imágenes real que herede de [BaseImageProcessor](/docs/transformers/v5.23.0/es/main_classes/image_processor#transformers.BaseImageProcessor).  Los procesadores de imágenes se utilizan en modelos de visión y modelos multimodales que requieren entradas de imagen. Los modelos multimodales también requerirán pasar un tokenizador.  Si no se proporciona, se cargará el procesador de imágenes predeterminado para el `model` dado (si es una cadena). Si `model` no se especifica o no es una cadena, se cargará el procesador de imágenes predeterminado para `config` (si es una cadena).

processor (`str` o [ProcessorMixin](/docs/transformers/v5.23.0/es/main_classes/processors#transformers.ProcessorMixin), *opcional*) : El procesador que se utilizará en el pipeline para preprocesar los datos para el modelo. Puede ser un identificador de modelo o un procesador real que herede de [ProcessorMixin](/docs/transformers/v5.23.0/es/main_classes/processors#transformers.ProcessorMixin).  Los procesadores se utilizan para modelos multimodales que requieren entradas multimodales, por ejemplo, un modelo que requiere tanto entradas de texto como de imagen.  Si no se proporciona, se cargará el procesador predeterminado para el `model` dado (si es una cadena). Si `model` no se especifica o no es una cadena, se cargará el procesador predeterminado para `config` (si es una cadena).

revision (`str`, *opcional*, valor predeterminado `"main"`) : Al pasar un nombre de tarea o un identificador de modelo en formato de cadena: la versión específica del modelo que se utilizará. Puede ser el nombre de una rama, el nombre de una etiqueta o un id de commit, ya que utilizamos un sistema basado en git para almacenar modelos y otros artefactos en huggingface.co, por lo que `revision` puede ser cualquier identificador permitido por git.

use_fast (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe utilizar un tokenizador Fast si es posible (un [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.TokenizersBackend)).

token (`str` o *bool*, *opcional*) : El token que se usará como autorización HTTP bearer para archivos remotos. Si es `True`, se usará el token generado al ejecutar `hf auth login`.

device (`int` o `str` o `torch.device`, *opcional*) : Define el dispositivo (*p. ej.*, `"cpu"`, `"cuda:1"`, `"mps"` o un rango ordinal de GPU como `1`) en el que se asignará este pipeline. Si se deja sin establecer, el pipeline se coloca automáticamente en el primer acelerador disponible (CUDA, MPS, XPU, ...) y solo recurre a la CPU si no hay ninguno disponible; el modelo se mueve allí por ti. Pasa `device="cpu"` (o `-1`) para forzar la CPU. No se puede usar junto con `device_map`.

device_map (`str` o `dict[str, Union[int, str, torch.device]`, *opcional*) : Se envía directamente como `model_kwargs` (simplemente un atajo más sencillo). Cuando la biblioteca `accelerate` está presente, establezca `device_map="auto"` para calcular automáticamente el `device_map` más optimizado (consulte [aquí](https://huggingface.co/docs/accelerate/main/en/package_reference/big_modeling#accelerate.cpu_offload) para obtener más información).    No utilice `device_map` y `device` al mismo tiempo, ya que entrarán en conflicto

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Precisión en la que se carga el modelo, se reenvía a `from_pretrained`. El valor predeterminado es `"auto"`, que carga el modelo en el dtype en el que se guardó. Pase un `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescribirlo.

trust_remote_code (`bool`, *opcional*, valor predeterminado `False`) : Indica si se permite o no el uso de código personalizado definido en el Hub en sus propios archivos de modelado, configuración, tokenización o incluso de pipeline. Esta opción solo debe establecerse en `True` para repositorios de confianza en los que hayas leído el código, ya que ejecutará el código presente en el Hub en tu máquina local.

model_kwargs (`dict[str, Any]`, *opcional*) : Diccionario adicional de argumentos por nombre que se pasa a la función `from_pretrained(..., **model_kwargs)` del modelo.

kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palabra clave adicionales que se pasan a la inicialización de la pipeline específica (consulte la documentación de la clase de pipeline correspondiente para ver los valores posibles).

**Devuelve:** [Pipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.Pipeline)

Un pipeline adecuado para la tarea.

Método de fábrica de utilidad para construir un [Pipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.Pipeline).

Un pipeline consiste en:

- Uno o más componentes para el preprocesamiento de las entradas del modelo, como un [tokenizer](tokenizer),
[image_processor](image_processor), [feature_extractor](feature_extractor) o [processor](processors).
- Un [modelo](model) que genera predicciones a partir de las entradas.
- Pasos de posprocesamiento opcionales para refinar la salida del modelo, que también pueden ser gestionados por los procesadores.

Aunque existen argumentos opcionales como `tokenizer`, `feature_extractor`, `image_processor` y `processor`, no deben especificarse todos a la vez. Si no se proporcionan estos componentes, `pipeline` intentará cargar automáticamente los necesarios. Si deseas proporcionar estos componentes de forma explícita, consulta la documentación de la pipeline específica para obtener más detalles sobre qué componentes son requeridos.

Ejemplos:

```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)
```

## Loteo de pipelines

Todas las pipelines pueden usar batching. Esto funcionará siempre que la pipeline utilice su capacidad de streaming (es decir, al pasar listas o `Dataset` o `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
```

Sin embargo, esto no supone automáticamente una mejora en el rendimiento. Puede suponer una aceleración de 10x o una ralentización de 5x, dependiendo del hardware, los datos y el modelo real que se esté utilizando.

Ejemplo en el que se produce principalmente una aceleración:

```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)
```

Ejemplo en el que se produce principalmente una ralentización:

```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 es una oración ocasionalmente muy larga en comparación con las demás. En ese caso, el **lote completo** deberá tener 400 tokens de longitud, por lo que el lote completo será [64, 400] en lugar de [64, 4], lo que provoca un gran aumento en el tiempo de ejecución. Aún peor, en lotes más grandes, el programa simplemente se bloquea.

```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<?, ?it/s]
Traceback (most recent call last):
  File "/home/nicolas/src/transformers/test.py", line 42, in <module>
    for out in tqdm(pipe(dataset, batch_size=256), total=len(dataset)):
....
    q = q / math.sqrt(dim_per_head)  # (bs, n_heads, q_length, dim_per_head)
RuntimeError: CUDA out of memory. Tried to allocate 376.00 MiB (GPU 0; 3.95 GiB total capacity; 1.72 GiB already allocated; 354.88 MiB free; 2.46 GiB reserved in total by PyTorch)
```

No existen buenas soluciones (generales) para este problema, y los resultados pueden variar según sus casos de uso. Regla general:

Para los usuarios, una regla general es:

- **Mide el rendimiento con tu carga de trabajo y tu hardware. Mide, mide y sigue midiendo. Los datos reales son la única vía a seguir.**
- Si tiene restricciones de latencia (un producto en vivo que realiza inferencia), no use lotes.
- Si estás usando CPU, no uses lotes.
- Si estás usando throughput (quieres ejecutar tu modelo en un conjunto de datos estáticos), en GPU, entonces:

  - Si no tienes idea sobre el tamaño de sequence_length (datos "naturales"), por defecto no uses lotes, mide y prueba tentativamente a añadirlo, y añade comprobaciones de OOM para recuperarte cuando falle (y fallará en algún momento si no controlas sequence_length).
  - Si tu sequence_length es muy regular, es más probable que el batching sea MUY interesante; médelo y aumenta el tamaño hasta que obtengas errores OOM.
  - A mayor GPU, más probable es que el batching resulte más interesante
- En cuanto actives el agrupamiento, asegúrate de poder manejar los errores de memoria insuficiente (OOM) de manera adecuada.

## Loteo por fragmentos en Pipeline

`zero-shot-classification` y `question-answering` son ligeramente específicos en el sentido de que una sola entrada puede generar múltiples pases hacia adelante de un modelo. En circunstancias normales, esto causaría problemas con el argumento `batch_size`.

Para evitar este problema, ambos pipelines son un poco específicos: son `ChunkPipeline` en lugar de `Pipeline` regulares. En resumen:

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

Ahora se convierte en:

```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)
```

Esto debería ser muy transparente para tu código, ya que las pipelines se utilizan de la misma manera.

Esta es una vista simplificada, ya que el pipeline puede gestionar automáticamente el lote para ti. Es decir, no tienes que preocuparte por cuántas pasadas hacia adelante van a provocar realmente tus entradas; puedes optimizar el `batch_size` de forma independiente a las entradas. Las advertencias de la sección anterior siguen siendo aplicables.

## Inferencia FP16 de Pipeline

Los modelos se pueden ejecutar en FP16, lo que puede ser significativamente más rápido en GPU y ahorrar memoria. La mayoría de los modelos no sufrirán una pérdida de rendimiento notable por ello. A mayor tamaño del modelo, menos probable es que esto ocurra.

Para habilitar la inferencia en FP16, simplemente puede pasar `dtype=torch.float16` o `dtype='float16'` al constructor de la pipeline. Tenga en cuenta que esto solo funciona para modelos con un backend de PyTorch. Sus entradas se convertirán a FP16 internamente.

## Código personalizado de Pipeline

Si desea sobrescribir una pipeline específica.

No dudele en crear un issue para la tarea que tiene entre manos, el objetivo del pipeline es ser fácil de usar y soportar la mayoría de los casos, por lo que `transformers` podría tal vez soportar su caso de uso.

Si quieres probarlo, simplemente puedes:

- Subclasea el pipeline de tu elección

```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)
```

Eso debería permitirte escribir todo el código personalizado que desees.

## Implementar un pipeline

[Implementar un nuevo pipeline](../add_new_pipeline)

## Audio

Los pipelines disponibles para tareas de audio incluyen los siguientes.

### AudioClassificationPipeline[[transformers.AudioClassificationPipeline]]

#### transformers.AudioClassificationPipeline[[transformers.AudioClassificationPipeline]]

```python
transformers.AudioClassificationPipeline(*args, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/audio_classification.py#L68)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel)): el modelo que se utilizará en el pipeline para realizar predicciones. Debe ser un modelo que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).

feature_extractor ([SequenceFeatureExtractor](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.SequenceFeatureExtractor)) : El extractor de características que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [SequenceFeatureExtractor](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.SequenceFeatureExtractor).

task (`str`, por defecto `""`) : Un identificador de tarea para el pipeline.

num_workers (`int`, *opcional*, valor predeterminado: 8) : Cuando la pipeline utilizará *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el número de workers que se usarán.

batch_size (`int`, *opcional*, valor predeterminado 1) : Cuando la pipeline utilice *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del batch a utilizar; para inferencia, esto no siempre es beneficioso, por favor lea [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) .

args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/es/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.

device (`int` o `str` o `torch.device`, *opcional*) : Dispositivo en el que se asigna el pipeline. Si se deja sin establecer, el pipeline se coloca en el primer acelerador disponible (CUDA, MPS, XPU, ...) y solo recurre a la CPU si no hay ninguno disponible; el modelo se mueve allí automáticamente. Pasa `device="cpu"` (o `-1`) para forzar la CPU, un ordinal positivo o `"cuda:1"` para seleccionar un acelerador específico, o un `torch.device`/`str` nativo. Este argumento no puede combinarse con un modelo ya cargado mediante `accelerate` (es decir, uno con un `hf_device_map`).

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Precisión en la que se carga el modelo, se reenvía a `from_pretrained`. El valor predeterminado es `"auto"`, que carga el modelo en el dtype en el que se guardó (leído de `config.dtype` del checkpoint, o inferido de los pesos si no está disponible). Pasa un `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescribirlo.

binary_output (`bool`, *opcional*, valor predeterminado `False`) : Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida sin procesar, por ejemplo, texto.

Pipeline de clasificación de audio que utiliza cualquier `AutoModelForAudioClassification`. Este pipeline predice la clase de una forma de onda cruda o de un archivo de audio. En el caso de un archivo de audio, debe estar instalado ffmpeg para admitir múltiples formatos de audio.

Ejemplo:

```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'}]
```

Obtenga más información sobre los fundamentos del uso de un pipeline en el [tutorial de pipeline](../pipeline_tutorial)

Este pipeline se puede cargar actualmente desde [pipeline()](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.pipeline) utilizando el siguiente identificador de tarea: `"audio-classification"`.

Vea la lista de modelos disponibles en [huggingface.co/models](https://huggingface.co/models?filter=audio-classification).

#### __llamada__[[transformers.AudioClassificationPipeline.__call__]]

```python
__call__(inputs: numpy.ndarray | bytes | str | dict, **kwargs: Any)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/audio_classification.py#L110)

**Parámetros:**

inputs (`np.ndarray` o `bytes` o `str` o `dict`) : La entrada es una de las siguientes: - `str` que es el nombre del archivo de audio; el archivo se leerá a la tasa de muestreo correcta para obtener la forma de onda usando *ffmpeg*. Esto requiere que *ffmpeg* esté instalado en el sistema. - `bytes` se supone que es el contenido de un archivo de audio y se interpreta con *ffmpeg* de la misma manera. - (`np.ndarray` de forma (n, ) de tipo `np.float32` o `np.float64`) Audio sin procesar a la tasa de muestreo correcta (no se realizará ninguna comprobación adicional) - Se puede usar la forma `dict` para pasar audio sin procesar muestreado a una `sampling_rate` arbitraria y dejar que esta pipeline realice el remuestreo. El diccionario debe estar en el formato `{"sampling_rate": int, "raw": np.array}`, o `{"sampling_rate": int, "array": np.array}`, donde la clave `"raw"` o `"array"` se usa para denotar la forma de onda del audio sin procesar.

top_k (`int`, *opcional*, valor predeterminado None) : El número de etiquetas principales que devolverá el pipeline. Si el número proporcionado es `None` o es mayor que el número de etiquetas disponibles en la configuración del modelo, se usará el número de etiquetas como valor predeterminado.

function_to_apply (`str`, *opcional*) : La función que se aplica a la salida del modelo. Por defecto es "none" para regresión, "sigmoid" para clasificación multietiqueta y "softmax" en cualquier otro caso. Opciones válidas: ["softmax", "sigmoid", "none"]. Los valores explícitos proporcionados en la inicialización o en el momento de la llamada reemplazan estos valores predeterminados. Pasa la cadena "none" para deshabilitar el posprocesamiento.

**Devuelve:** una lista de `dict` con las siguientes claves

- **label** (`str`) -- La etiqueta predicha.
- **score** (`float`) -- La probabilidad correspondiente.

Clasifica la(s) secuencia(s) dadas como entradas. Consulte la documentación de [AutomaticSpeechRecognitionPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.AutomaticSpeechRecognitionPipeline) para obtener más información.

### 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)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/automatic_speech_recognition.py#L147)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel)): el modelo que se utilizará en el pipeline para realizar predicciones. Debe ser un modelo que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).

feature_extractor ([SequenceFeatureExtractor](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), *opcional*) : El extractor de características que se utilizará en el pipeline para codificar la forma de onda para el modelo.

tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend), *opcional*) : El tokenizador que se utilizará en el pipeline para codificar los datos del modelo. Este objeto hereda de [PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend).

decoder (`pyctcdecode.BeamSearchDecoderCTC`, *opcional*) : [BeamSearchDecoderCTC de PyCTCDecode](https://github.com/kensho-technologies/pyctcdecode/blob/2fd33dc37c4111417e08d89ccd23d28e9b308d19/pyctcdecode/decoder.py#L180) se puede pasar para decodificación potenciada por modelo de lenguaje. Consulte [Wav2Vec2ProcessorWithLM](/docs/transformers/v5.23.0/es/model_doc/wav2vec2#transformers.Wav2Vec2ProcessorWithLM) para obtener más información. Obsoleto, se eliminará en Transformers v6.

device (Union[`int`, `torch.device`], *opcional*) : Ordinal del dispositivo para la compatibilidad con CPU/GPU. Establecerlo en `None` utilizará la CPU, mientras que un valor positivo ejecutará el modelo en el id del dispositivo CUDA asociado.

Pipeline que tiene como objetivo extraer el texto hablado contenido en algún audio.

La entrada puede ser una forma de onda cruda o un archivo de audio. En el caso de un archivo de audio, se debe instalar ffmpeg para admitir múltiples formatos de audio.

A menos que el modelo que esté usando establezca explícitamente estos parámetros de generación en sus archivos de configuración (`generation_config.json`), se usarán los siguientes valores predeterminados:
- max_new_tokens: 256
- num_beams: 5

Ejemplo:

```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.'}
```

Obtenga más información sobre los fundamentos del uso de un pipeline en el [tutorial de pipeline](../pipeline_tutorial)

#### __llamada__[[transformers.AutomaticSpeechRecognitionPipeline.__call__]]

```python
__call__(inputs: numpy.ndarray | bytes | str | dict, **kwargs: Any)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/automatic_speech_recognition.py#L238)

**Parámetros:**

inputs (`np.ndarray` o `bytes` o `str` o `dict`) : La entrada es una de las siguientes: - `str` que es el nombre de un archivo de audio local o una URL pública para descargar el archivo de audio. El archivo se leerá a la tasa de muestreo correcta para obtener la forma de onda usando *ffmpeg*. Esto requiere que *ffmpeg* esté instalado en el sistema. - `bytes` se supone que es el contenido de un archivo de audio y se interpreta con *ffmpeg* de la misma manera. - (`np.ndarray` de forma (n, ) de tipo `np.float32` o `np.float64`) Audio sin procesar a la tasa de muestreo correcta (no se realizará ninguna comprobación adicional) - Se puede usar la forma `dict` para pasar audio sin procesar muestreado a una `sampling_rate` arbitraria y dejar que esta pipeline realice el remuestreo. El diccionario debe estar en el formato `{"sampling_rate": int, "raw": np.array}` con opcionalmente un `"stride": (left: int, right: int)` que puede pedir a la pipeline que ignore las primeras `left` muestras y las últimas `right` muestras en la decodificación (pero se usan en la inferencia para proporcionar más contexto al modelo). Solo use `stride` con modelos CTC.

return_timestamps (*opcional*, `str` o `bool`) : Solo disponible para modelos puros de CTC (Wav2Vec2, HuBERT, etc.) y el modelo Whisper. No disponible para otros modelos de secuencia a secuencia. Para los modelos de CTC, los timestamps pueden adoptar uno de dos formatos: - `"char"`: el pipeline devolverá timestamps a lo largo del texto para cada carácter del texto. Por ejemplo, si obtienes `[{"text": "h", "timestamp": (0.5, 0.6)}, {"text": "i", "timestamp": (0.7, 0.9)}]`, significa que el modelo predice que la letra "h" fue pronunciada después de `0.5` y antes de `0.6` segundos. - `"word"`: el pipeline devolverá timestamps a lo largo del texto para cada palabra del texto. Por ejemplo, si obtienes `[{"text": "hi ", "timestamp": (0.5, 0.9)}, {"text": "there", "timestamp": (1.0, 1.5)}]`, significa que el modelo predice que la palabra "hi" fue pronunciada después de `0.5` y antes de `0.9` segundos. Para el modelo Whisper, los timestamps pueden adoptar uno de dos formatos: - `"word"`: igual que arriba para los timestamps de CTC a nivel de palabra. Los timestamps a nivel de palabra se predicen mediante el algoritmo de *dynamic-time warping (DTW)*, una aproximación a los timestamps a nivel de palabra al inspeccionar los pesos de cross-attention. - `True`: el pipeline devolverá timestamps a lo largo del texto para *segmentos* de palabras en el texto. Por ejemplo, si obtienes `[{"text": " Hi there!", "timestamp": (0.5, 1.5)}]`, significa que el modelo predice que el segmento "Hi there!" fue pronunciado después de `0.5` y antes de `1.5` segundos. Ten en cuenta que un segmento de texto se refiere a una secuencia de una o más palabras, en lugar de palabras individuales como en los timestamps a nivel de palabra.

generate_kwargs (`dict`, *opcional*) : El diccionario de parametrización ad hoc de `generate_config` que se utilizará para la llamada de generación. Para una visión completa de generate, consulte la [siguiente guía](https://huggingface.co/docs/transformers/en/main_classes/text_generation).

**Devuelve:** `Dict`

Un diccionario con las siguientes claves:
- **text** (`str`): El texto reconocido.
- **chunks** (*opcional(, `list[Dict]`) Al usar `return_timestamps`, `chunks` se convierte en una lista que contiene todos los fragmentos de texto identificados por el modelo, *por ejemplo* `[{"text": "hi ", "timestamp": (0.5, 0.9)}, {"text": "there", "timestamp": (1.0, 1.5)}]`. El texto completo original se puede recuperar aproximadamente mediante `"".join(chunk["text"] for chunk in output["chunks"])`.

Transcribe las secuencias de audio dadas como entradas a texto. Consulte la documentación de [AutomaticSpeechRecognitionPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.AutomaticSpeechRecognitionPipeline) para obtener más información.

### TextToAudioPipeline[[transformers.TextToAudioPipeline]]

#### transformers.TextToAudioPipeline[[transformers.TextToAudioPipeline]]

```python
transformers.TextToAudioPipeline(*args, vocoder = None, sampling_rate = None, noise_scheduler = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/text_to_audio.py#L46)

Pipeline de generación de audio a partir de texto que utiliza cualquier `AutoModelForTextToWaveform` o `AutoModelForTextToSpectrogram`. Este pipeline genera un archivo de audio a partir de un texto de entrada y otros posibles inputs condicionales opcionales.

A menos que el modelo que estás usando establezca explícitamente los parámetros de generación en `generation_config.json`, se utilizarán los valores predeterminados de `generation.configuration_utils.py._get_default_generation_params()`.
- max_new_tokens: 256

Ejemplo:

```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"]
```

Obtenga más información sobre los fundamentos del uso de un pipeline en el [tutorial de pipeline](../pipeline_tutorial)

Puede especificar los parámetros que se pasan al modelo mediante `TextToAudioPipeline.__call__.forward_params` o `TextToAudioPipeline.__call__.generate_kwargs`.

Ejemplo:

```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 se puede cargar actualmente desde [pipeline()](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.pipeline) utilizando los siguientes identificadores de tarea: `"text-to-speech"` o `"text-to-audio"`.

Vea la lista de modelos disponibles en [huggingface.co/models](https://huggingface.co/models?filter=text-to-speech).

#### __llamada__[[transformers.TextToAudioPipeline.__call__]]

```python
__call__(text_inputs, **forward_params)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/text_to_audio.py#L260)

**Parámetros:**

text_inputs (`str`, `list[str]`, `ChatType` o `list[ChatType]`) : Uno o varios textos para generar. Si se pasan cadenas de caracteres o una lista de cadenas, esta pipeline generará el texto correspondiente. Alternativamente, se puede pasar un "chat", en forma de una lista de diccionarios con las claves "role" y "content", o una lista de dichos chats. Cuando se pasan chats, se utilizará la plantilla de chat del modelo para formatearlos antes de pasarlos al modelo.

forward_params (`dict`, *opcional*) : Parámetros pasados al método de generación/forward del modelo. `forward_params` se pasan siempre al modelo subyacente.

generate_kwargs (`dict`, *opcional*) : El diccionario de parametrización ad hoc de `generate_config` que se usará para la llamada de generación. Para una visión completa de generate, consulte la [siguiente guía](https://huggingface.co/docs/transformers/en/main_classes/text_generation). `generate_kwargs` solo se pasan al modelo subyacente si este es un modelo generativo, y tienen prioridad sobre `forward_params`.

**Devuelve:** `AudioOutput` o una lista de `AudioOutput`, que es un `TypedDict` con dos claves

- **audio** (`np.ndarray` de forma `(nb_channels, audio_length)`) -- La forma de onda de audio generada.
- **sampling_rate** (`int`) -- La tasa de muestreo de la forma de onda de audio generada.

Genera voz/audios a partir de las entradas. Consulte la documentación de [TextToAudioPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.TextToAudioPipeline) para obtener más información.

### ZeroShotAudioClassificationPipeline[[transformers.ZeroShotAudioClassificationPipeline]]

#### transformers.ZeroShotAudioClassificationPipeline[[transformers.ZeroShotAudioClassificationPipeline]]

```python
transformers.ZeroShotAudioClassificationPipeline(**kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/zero_shot_audio_classification.py#L32)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel)): el modelo que se utilizará en el pipeline para realizar predicciones. Debe ser un modelo que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).

tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend)) : El tokenizador que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend).

feature_extractor ([SequenceFeatureExtractor](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.SequenceFeatureExtractor)) : El extractor de características que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [SequenceFeatureExtractor](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.SequenceFeatureExtractor).

task (`str`, por defecto `""`) : Un identificador de tarea para el pipeline.

num_workers (`int`, *opcional*, valor predeterminado: 8) : Cuando la pipeline utilizará *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el número de workers que se usarán.

batch_size (`int`, *opcional*, valor predeterminado 1) : Cuando la pipeline utilice *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del batch a utilizar; para inferencia, esto no siempre es beneficioso, por favor lea [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) .

args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/es/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.

device (`int` o `str` o `torch.device`, *opcional*) : Dispositivo en el que se asigna el pipeline. Si se deja sin establecer, el pipeline se coloca en el primer acelerador disponible (CUDA, MPS, XPU, ...) y solo recurre a la CPU si no hay ninguno disponible; el modelo se mueve allí automáticamente. Pasa `device="cpu"` (o `-1`) para forzar la CPU, un ordinal positivo o `"cuda:1"` para seleccionar un acelerador específico, o un `torch.device`/`str` nativo. Este argumento no puede combinarse con un modelo ya cargado mediante `accelerate` (es decir, uno con un `hf_device_map`).

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Precisión en la que se carga el modelo, se reenvía a `from_pretrained`. El valor predeterminado es `"auto"`, que carga el modelo en el dtype en el que se guardó (leído de `config.dtype` del checkpoint, o inferido de los pesos si no está disponible). Pasa un `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescribirlo.

binary_output (`bool`, *opcional*, valor predeterminado `False`) : Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida sin procesar, por ejemplo, texto.

Pipeline de clasificación de audio sin ejemplos de entrenamiento que utiliza `ClapModel`. Este pipeline predice la clase de un audio cuando se proporciona un audio y un conjunto de `candidate_labels`.

La plantilla `hypothesis_template` predeterminada es: `"This is a sound of {}."`. Asegúrate de actualizarla para tu uso.

Ejemplo:
```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'}]
```

Puede obtener más información sobre los fundamentos del uso de un pipeline en el [tutorial de pipeline](../pipeline_tutorial). Este pipeline de clasificación de audio se puede cargar actualmente desde [pipeline()](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.pipeline) utilizando el siguiente identificador de tarea: `"zero-shot-audio-classification"`. Consulte la lista de modelos disponibles en [huggingface.co/models](https://huggingface.co/models?filter=zero-shot-audio-classification).

#### __llamada__[[transformers.ZeroShotAudioClassificationPipeline.__call__]]

```python
__call__(audios: numpy.ndarray | bytes | str | dict, **kwargs: Any)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/zero_shot_audio_classification.py#L70)

**Parámetros:**

audios (`str`, `list[str]`, `np.array` o `list[np.array]`) : El pipeline maneja tres tipos de entradas: - Una cadena de texto que contiene un enlace http que apunta a un audio - Una cadena de texto que contiene una ruta local a un audio - Un audio cargado en numpy

candidate_labels (`list[str]`) : Las etiquetas candidatas para este audio. Se formatearán usando *hypothesis_template*.

hypothesis_template (`str`, *opcional*, valor predeterminado `"This is a sound of {}"`) : El formato utilizado junto con *candidate_labels* para intentar la clasificación de audio reemplazando el marcador de posición con candidate_labels. Pasa "{}" si *candidate_labels* ya están formateados.

**Devuelve:**

Una lista de diccionarios que contiene una entrada por cada etiqueta propuesta. Cada diccionario contiene las siguientes claves:
- **label** (`str`) -- Uno de los *candidate_labels* sugeridos.
- **score** (`float`) -- La puntuación que el modelo asigna a esa etiqueta. Es un valor entre 0 y 1, calculado como el `softmax` de `logits_per_audio`.

Asigna etiquetas a las entradas de audio.

## Visión por computadora

Los pipelines disponibles para tareas de visión por computadora incluyen los siguientes.

### DepthEstimationPipeline[[transformers.DepthEstimationPipeline]]

#### transformers.DepthEstimationPipeline[[transformers.DepthEstimationPipeline]]

```python
transformers.DepthEstimationPipeline(*args, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/depth_estimation.py#L25)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel)): el modelo que se utilizará en el pipeline para realizar predicciones. Debe ser un modelo que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).

image_processor ([BaseImageProcessor](/docs/transformers/v5.23.0/es/main_classes/image_processor#transformers.BaseImageProcessor)): el procesador de imágenes que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [BaseImageProcessor](/docs/transformers/v5.23.0/es/main_classes/image_processor#transformers.BaseImageProcessor).

task (`str`, por defecto `""`) : Un identificador de tarea para el pipeline.

num_workers (`int`, *opcional*, valor predeterminado: 8) : Cuando la pipeline utilizará *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el número de workers que se usarán.

batch_size (`int`, *opcional*, valor predeterminado 1) : Cuando la pipeline utilice *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del batch a utilizar; para inferencia, esto no siempre es beneficioso, por favor lea [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) .

args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/es/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.

device (`int` o `str` o `torch.device`, *opcional*) : Dispositivo en el que se asigna el pipeline. Si se deja sin establecer, el pipeline se coloca en el primer acelerador disponible (CUDA, MPS, XPU, ...) y solo recurre a la CPU si no hay ninguno disponible; el modelo se mueve allí automáticamente. Pasa `device="cpu"` (o `-1`) para forzar la CPU, un ordinal positivo o `"cuda:1"` para seleccionar un acelerador específico, o un `torch.device`/`str` nativo. Este argumento no puede combinarse con un modelo ya cargado mediante `accelerate` (es decir, uno con un `hf_device_map`).

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Precisión en la que se carga el modelo, se reenvía a `from_pretrained`. El valor predeterminado es `"auto"`, que carga el modelo en el dtype en el que se guardó (leído de `config.dtype` del checkpoint, o inferido de los pesos si no está disponible). Pasa un `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescribirlo.

binary_output (`bool`, *opcional*, valor predeterminado `False`) : Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida sin procesar, por ejemplo, texto.

Pipeline de estimación de profundidad que utiliza cualquier `AutoModelForDepthEstimation`. Este pipeline predice la profundidad de una imagen.

Ejemplo:

```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])
```

Obtenga más información sobre los fundamentos del uso de un pipeline en el [tutorial de pipeline](../pipeline_tutorial)

Este pipeline de estimación de profundidad se puede cargar actualmente desde [pipeline()](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.pipeline) utilizando el siguiente identificador de tarea: `"depth-estimation"`.

Vea la lista de modelos disponibles en [huggingface.co/models](https://huggingface.co/models?filter=depth-estimation).

#### __llamada__[[transformers.DepthEstimationPipeline.__call__]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/depth_estimation.py#L66)

**Parámetros:**

inputs (`str`, `list[str]`, `PIL.Image` o `list[PIL.Image]`) : El pipeline maneja tres tipos de imágenes: - Una cadena de texto que contiene un enlace http que apunta a una imagen - Una cadena de texto que contiene una ruta local a una imagen - Una imagen cargada directamente en PIL  El pipeline acepta una sola imagen o un lote de imágenes, que en ese caso debe pasarse como una cadena de texto. Las imágenes de un lote deben estar todas en el mismo formato: todas como enlaces http, todas como rutas locales o todas como imágenes PIL.

parameters (`Dict`, *opcional*) : Un diccionario de nombres de argumentos a valores de parámetros, para controlar el comportamiento de la pipeline. El único parámetro disponible actualmente es `timeout`, que es la duración, en segundos, que la pipeline debe esperar antes de dejar de intentar descargar una imagen.

timeout (`float`, *opcional*, valor predeterminado None) : Tiempo máximo en segundos para esperar la obtención de imágenes de la web. Si es None, no se establece un tiempo de espera y la llamada puede bloquearse indefinidamente.

**Devuelve:**

Un diccionario o una lista de diccionarios que contienen el resultado. Si la entrada es una sola imagen, se devolverá un diccionario; si la entrada es una lista de varias imágenes, se devolverá una lista de diccionarios correspondientes a las imágenes.

Los diccionarios contienen las siguientes claves:

- **predicted_depth** (`torch.Tensor`) -- La profundidad predicha por el modelo como un `torch.Tensor`.
- **depth** (`PIL.Image`) -- La profundidad predicha por el modelo como una `PIL.Image`.

Predice la profundidad de las imágenes pasadas como entradas.

### ImageClassificationPipeline[[transformers.ImageClassificationPipeline]]

#### transformers.ImageClassificationPipeline[[transformers.ImageClassificationPipeline]]

```python
transformers.ImageClassificationPipeline(*args, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/image_classification.py#L74)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel)): el modelo que se utilizará en el pipeline para realizar predicciones. Debe ser un modelo que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).

image_processor ([BaseImageProcessor](/docs/transformers/v5.23.0/es/main_classes/image_processor#transformers.BaseImageProcessor)): el procesador de imágenes que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [BaseImageProcessor](/docs/transformers/v5.23.0/es/main_classes/image_processor#transformers.BaseImageProcessor).

task (`str`, por defecto `""`) : Un identificador de tarea para el pipeline.

num_workers (`int`, *opcional*, valor predeterminado: 8) : Cuando la pipeline utilizará *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el número de workers que se usarán.

batch_size (`int`, *opcional*, valor predeterminado 1) : Cuando la pipeline utilice *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del batch a utilizar; para inferencia, esto no siempre es beneficioso, por favor lea [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) .

args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/es/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.

device (`int` o `str` o `torch.device`, *opcional*) : Dispositivo en el que se asigna el pipeline. Si se deja sin establecer, el pipeline se coloca en el primer acelerador disponible (CUDA, MPS, XPU, ...) y solo recurre a la CPU si no hay ninguno disponible; el modelo se mueve allí automáticamente. Pasa `device="cpu"` (o `-1`) para forzar la CPU, un ordinal positivo o `"cuda:1"` para seleccionar un acelerador específico, o un `torch.device`/`str` nativo. Este argumento no puede combinarse con un modelo ya cargado mediante `accelerate` (es decir, uno con un `hf_device_map`).

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Precisión en la que se carga el modelo, se reenvía a `from_pretrained`. El valor predeterminado es `"auto"`, que carga el modelo en el dtype en el que se guardó (leído de `config.dtype` del checkpoint, o inferido de los pesos si no está disponible). Pasa un `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescribirlo.

binary_output (`bool`, *opcional*, valor predeterminado `False`) : Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida sin procesar, por ejemplo, texto.

function_to_apply (`str`, *opcional*, valor predeterminado `"default"`) : La función que se aplica a las salidas del modelo para obtener las puntuaciones. Acepta cuatro valores diferentes:  - `"default"`: si el modelo tiene una única etiqueta, se aplicará la función sigmoide a la salida. Si el modelo tiene varias etiquetas, se aplicará la función softmax a la salida. En el caso de tareas de regresión, no se aplicará ninguna función a la salida. - `"sigmoid"`: Aplica la función sigmoide a la salida. - `"softmax"`: Aplica la función softmax a la salida. - `"none"`: No aplica ninguna función a la salida.

Pipeline de clasificación de imágenes que utiliza cualquier `AutoModelForImageClassification`. Este pipeline predice la clase de una imagen.

Ejemplo:

```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'}]
```

Obtenga más información sobre los fundamentos del uso de un pipeline en el [tutorial de pipeline](../pipeline_tutorial)

Este pipeline de clasificación de imágenes se puede cargar actualmente desde [pipeline()](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.pipeline) utilizando el siguiente identificador de tarea: `"image-classification"`.

Vea la lista de modelos disponibles en [huggingface.co/models](https://huggingface.co/models?filter=image-classification).

#### __llamada__[[transformers.ImageClassificationPipeline.__call__]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/image_classification.py#L128)

**Parámetros:**

inputs (`str`, `list[str]`, `PIL.Image` o `list[PIL.Image]`) : El pipeline maneja tres tipos de imágenes: - Una cadena de texto que contiene un enlace http que apunta a una imagen - Una cadena de texto que contiene una ruta local a una imagen - Una imagen cargada directamente en PIL  El pipeline acepta una sola imagen o un lote de imágenes, que en ese caso debe pasarse como una cadena de texto. Las imágenes de un lote deben estar todas en el mismo formato: todas como enlaces http, todas como rutas locales o todas como imágenes PIL.

function_to_apply (`str`, *opcional*, valor predeterminado `"default"`) : La función que se aplica a las salidas del modelo para obtener las puntuaciones. Acepta cuatro valores diferentes:  Si no se especifica este argumento, se aplicarán las siguientes funciones según el número de etiquetas:  - Si el tipo de problema es regresión, no se aplicará ninguna función a la salida. - Si el modelo tiene una única etiqueta, se aplicará la función sigmoide a la salida. - Si el modelo tiene varias etiquetas, se aplicará la función softmax a la salida.  Los valores posibles son:  - `"sigmoid"`: Aplica la función sigmoide a la salida. - `"softmax"`: Aplica la función softmax a la salida. - `"none"`: No aplica ninguna función a la salida.

top_k (`int`, *opcional*, valor predeterminado: 5) : El número de etiquetas principales que devolverá el pipeline. Si el número proporcionado es mayor que el número de etiquetas disponibles en la configuración del modelo, se usará el número de etiquetas disponible.

timeout (`float`, *opcional*, valor predeterminado None) : Tiempo máximo en segundos para esperar la obtención de imágenes de la web. Si es None, no se establece un tiempo de espera y la llamada puede bloquearse indefinidamente.

**Devuelve:**

Un diccionario o una lista de diccionarios que contienen el resultado. Si la entrada es una sola imagen, se devolverá un diccionario; si la entrada es una lista de varias imágenes, se devolverá una lista de diccionarios correspondientes a las imágenes.

Los diccionarios contienen las siguientes claves:

- **label** (`str`) -- La etiqueta identificada por el modelo.
- **score** (`int`) -- La puntuación que el modelo asigna a esa etiqueta.

Asigna etiquetas a la(s) imagen(es) pasadas como entradas.

### ImageSegmentationPipeline[[transformers.ImageSegmentationPipeline]]

#### transformers.ImageSegmentationPipeline[[transformers.ImageSegmentationPipeline]]

```python
transformers.ImageSegmentationPipeline(*args, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/image_segmentation.py#L27)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel)): el modelo que se utilizará en el pipeline para realizar predicciones. Debe ser un modelo que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).

image_processor ([BaseImageProcessor](/docs/transformers/v5.23.0/es/main_classes/image_processor#transformers.BaseImageProcessor)): el procesador de imágenes que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [BaseImageProcessor](/docs/transformers/v5.23.0/es/main_classes/image_processor#transformers.BaseImageProcessor).

task (`str`, por defecto `""`) : Un identificador de tarea para el pipeline.

num_workers (`int`, *opcional*, valor predeterminado: 8) : Cuando la pipeline utilizará *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el número de workers que se usarán.

batch_size (`int`, *opcional*, valor predeterminado 1) : Cuando la pipeline utilice *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del batch a utilizar; para inferencia, esto no siempre es beneficioso, por favor lea [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) .

args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/es/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.

device (`int` o `str` o `torch.device`, *opcional*) : Dispositivo en el que se asigna el pipeline. Si se deja sin establecer, el pipeline se coloca en el primer acelerador disponible (CUDA, MPS, XPU, ...) y solo recurre a la CPU si no hay ninguno disponible; el modelo se mueve allí automáticamente. Pasa `device="cpu"` (o `-1`) para forzar la CPU, un ordinal positivo o `"cuda:1"` para seleccionar un acelerador específico, o un `torch.device`/`str` nativo. Este argumento no puede combinarse con un modelo ya cargado mediante `accelerate` (es decir, uno con un `hf_device_map`).

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Precisión en la que se carga el modelo, se reenvía a `from_pretrained`. El valor predeterminado es `"auto"`, que carga el modelo en el dtype en el que se guardó (leído de `config.dtype` del checkpoint, o inferido de los pesos si no está disponible). Pasa un `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescribirlo.

binary_output (`bool`, *opcional*, valor predeterminado `False`) : Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida sin procesar, por ejemplo, texto.

Pipeline de segmentación de imágenes que utiliza cualquier `AutoModelForXXXSegmentation`. Este pipeline predice las máscaras de los objetos y sus clases.

Ejemplo:

```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.
<class 'PIL.Image.Image'>

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

Este pipeline de segmentación de imágenes se puede cargar actualmente desde [pipeline()](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.pipeline) utilizando el siguiente identificador de tarea: `"image-segmentation"`.

Vea la lista de modelos disponibles en [huggingface.co/models](https://huggingface.co/models?filter=image-segmentation).

#### __llamada__[[transformers.ImageSegmentationPipeline.__call__]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/image_segmentation.py#L101)

**Parámetros:**

inputs (`str`, `list[str]`, `PIL.Image` o `list[PIL.Image]`) : El pipeline maneja tres tipos de imágenes:  - Una cadena que contiene un enlace HTTP(S) que apunta a una imagen - Una cadena que contiene una ruta local a una imagen - Una imagen cargada directamente en PIL  El pipeline acepta una sola imagen o un lote de imágenes. Las imágenes de un lote deben estar todas en el mismo formato: todas como enlaces HTTP(S), todas como rutas locales o todas como imágenes de PIL.

subtask (`str`, *opcional*) : Tarea de segmentación a realizar, elija entre [`semantic`, `instance` y `panoptic`] según las capacidades del modelo. Si no se establece, el pipeline intentará resolverla en el siguiente orden: `panoptic`, `instance`, `semantic`.

threshold (`float`, *opcional*, valor predeterminado 0.9) : Umbral de probabilidad para filtrar las máscaras predichas.

mask_threshold (`float`, *opcional*, valor predeterminado 0.5) : Umbral a utilizar al convertir las máscaras predichas en valores binarios.

overlap_mask_area_threshold (`float`, *opcional*, valor predeterminado 0.5) : Umbral de solapamiento de la máscara para eliminar segmentos pequeños y desconectados.

timeout (`float`, *opcional*, valor predeterminado None) : Tiempo máximo en segundos para esperar la obtención de imágenes de la web. Si es None, no se establece un tiempo de espera y la llamada puede bloquearse indefinidamente.

**Devuelve:**

Si la entrada es una sola imagen, se devolverá una lista de diccionarios; si la entrada es una lista de varias imágenes, se devolverá una lista de listas de diccionarios correspondientes a cada imagen.

Los diccionarios contienen la máscara, la etiqueta y la puntuación (cuando sea aplicable) de cada objeto detectado y contienen las siguientes claves:

- **label** (`str`) -- La etiqueta de clase identificada por el modelo.
- **mask** (`PIL.Image`) -- Una máscara binaria del objeto detectado como una imagen PIL de forma (width, height) de la imagen original. Devuelve una máscara rellena con ceros si no se encuentra ningún objeto.
- **score** (*opcional* `float`) -- Opcionalmente, cuando el modelo es capaz de estimar la confianza del "object" descrito por la etiqueta y la máscara.

Realiza segmentación (detecta máscaras y clases) en la(s) imagen(es) pasadas como entradas.

### KeypointMatchingPipeline[[transformers.KeypointMatchingPipeline]]

#### transformers.KeypointMatchingPipeline[[transformers.KeypointMatchingPipeline]]

```python
transformers.KeypointMatchingPipeline(*args, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/keypoint_matching.py#L67)

Pipeline de correspondencia de puntos clave que utiliza cualquier `AutoModelForKeypointMatching`. Este pipeline corresponde puntos clave entre dos imágenes.

#### __llamada__[[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)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/keypoint_matching.py#L96)

**Parámetros:**

inputs (`str`, `list[str]`, `PIL.Image` o `list[PIL.Image]`) : El pipeline maneja tres tipos de imágenes:  - Una cadena que contiene un enlace http que apunta a una imagen - Una cadena que contiene una ruta local a una imagen - Una imagen cargada directamente en PIL  El pipeline acepta un solo par de imágenes o un lote de pares de imágenes, que en ese caso debe pasarse como una cadena. Las imágenes de un lote deben estar todas en el mismo formato: todas como enlaces http, todas como rutas locales o todas como imágenes PIL.

threshold (`float`, *opcional*, valor predeterminado 0.0) : Umbral a utilizar para el emparejamiento de puntos clave. Se filtrarán los puntos clave emparejados con una puntuación de coincidencia inferior. Un valor de 0 significa que se devolverán todos los puntos clave emparejados.

kwargs : `timeout (`float`, *optional*, defaults to None)` El tiempo máximo en segundos para esperar la obtención de imágenes de la web. Si es None, no se establece un tiempo de espera y la llamada puede bloquearse indefinidamente.

**Devuelve:** Union[list[Match], list[list[Match]]]

Una lista de coincidencias o una lista si se proporciona un solo par de imágenes, o una lista de listas de coincidencias si se proporciona un lote de pares de imágenes. Cada coincidencia es un diccionario que contiene las siguientes claves:

- **keypoint_image_0** (`Keypoint`): El punto clave en la primera imagen (coordenadas x, y).
- **keypoint_image_1** (`Keypoint`): El punto clave en la segunda imagen (coordenadas x, y).
- **score** (`float`): La puntuación de coincidencia entre los dos puntos clave.

Encuentra coincidencias entre puntos clave en dos imágenes.

### ObjectDetectionPipeline[[transformers.ObjectDetectionPipeline]]

#### transformers.ObjectDetectionPipeline[[transformers.ObjectDetectionPipeline]]

```python
transformers.ObjectDetectionPipeline(*args, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/object_detection.py#L26)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel)): el modelo que se utilizará en el pipeline para realizar predicciones. Debe ser un modelo que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).

image_processor ([BaseImageProcessor](/docs/transformers/v5.23.0/es/main_classes/image_processor#transformers.BaseImageProcessor)): el procesador de imágenes que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [BaseImageProcessor](/docs/transformers/v5.23.0/es/main_classes/image_processor#transformers.BaseImageProcessor).

task (`str`, por defecto `""`) : Un identificador de tarea para el pipeline.

num_workers (`int`, *opcional*, valor predeterminado: 8) : Cuando la pipeline utilizará *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el número de workers que se usarán.

batch_size (`int`, *opcional*, valor predeterminado 1) : Cuando la pipeline utilice *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del batch a utilizar; para inferencia, esto no siempre es beneficioso, por favor lea [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) .

args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/es/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.

device (`int` o `str` o `torch.device`, *opcional*) : Dispositivo en el que se asigna el pipeline. Si se deja sin establecer, el pipeline se coloca en el primer acelerador disponible (CUDA, MPS, XPU, ...) y solo recurre a la CPU si no hay ninguno disponible; el modelo se mueve allí automáticamente. Pasa `device="cpu"` (o `-1`) para forzar la CPU, un ordinal positivo o `"cuda:1"` para seleccionar un acelerador específico, o un `torch.device`/`str` nativo. Este argumento no puede combinarse con un modelo ya cargado mediante `accelerate` (es decir, uno con un `hf_device_map`).

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Precisión en la que se carga el modelo, se reenvía a `from_pretrained`. El valor predeterminado es `"auto"`, que carga el modelo en el dtype en el que se guardó (leído de `config.dtype` del checkpoint, o inferido de los pesos si no está disponible). Pasa un `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescribirlo.

binary_output (`bool`, *opcional*, valor predeterminado `False`) : Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida sin procesar, por ejemplo, texto.

Pipeline de detección de objetos que utiliza cualquier `AutoModelForObjectDetection`. Este pipeline predice las cajas delimitadoras de los objetos y sus clases.

Ejemplo:

```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.
```

Obtenga más información sobre los fundamentos del uso de un pipeline en el [tutorial de pipeline](../pipeline_tutorial)

Este pipeline de detección de objetos se puede cargar actualmente desde [pipeline()](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.pipeline) utilizando el siguiente identificador de tarea: `"object-detection"`.

Vea la lista de modelos disponibles en [huggingface.co/models](https://huggingface.co/models?filter=object-detection).

#### __llamada__[[transformers.ObjectDetectionPipeline.__call__]]

```python
__call__(*args, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/object_detection.py#L81)

**Parámetros:**

inputs (`str`, `list[str]`, `PIL.Image` o `list[PIL.Image]`) : El pipeline maneja tres tipos de imágenes:  - Una cadena que contiene un enlace HTTP(S) que apunta a una imagen - Una cadena que contiene una ruta local a una imagen - Una imagen cargada directamente en PIL  El pipeline acepta una sola imagen o un lote de imágenes. Las imágenes de un lote deben estar todas en el mismo formato: todas como enlaces HTTP(S), todas como rutas locales o todas como imágenes de PIL.

threshold (`float`, *opcional*, valor predeterminado 0.5) : La probabilidad necesaria para realizar una predicción.

timeout (`float`, *opcional*, valor predeterminado None) : Tiempo máximo en segundos para esperar la obtención de imágenes de la web. Si es None, no se establece un tiempo de espera y la llamada puede bloquearse indefinidamente.

**Devuelve:**

Una lista de diccionarios o una lista de listas de diccionarios que contiene el resultado. Si la entrada es una sola imagen, se devuelve una lista de diccionarios; si la entrada es una lista de varias imágenes, se devuelve una lista de listas de diccionarios correspondiente a cada imagen.

Los diccionarios contienen las siguientes claves:

- **label** (`str`) -- La etiqueta de clase identificada por el modelo.
- **score** (`float`) -- La puntuación que el modelo asigna a esa etiqueta.
- **box** (`list[dict[str, int]]`) -- La caja delimitadora del objeto detectado en el tamaño original de la imagen.

Detecta objetos (cajas delimitadoras y clases) en la(s) imagen(es) pasadas como entradas.

### VideoClassificationPipeline[[transformers.VideoClassificationPipeline]]

#### transformers.VideoClassificationPipeline[[transformers.VideoClassificationPipeline]]

```python
transformers.VideoClassificationPipeline(*args, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/video_classification.py#L41)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel)): el modelo que se utilizará en el pipeline para realizar predicciones. Debe ser un modelo que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).

image_processor ([BaseImageProcessor](/docs/transformers/v5.23.0/es/main_classes/image_processor#transformers.BaseImageProcessor)): el procesador de imágenes que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [BaseImageProcessor](/docs/transformers/v5.23.0/es/main_classes/image_processor#transformers.BaseImageProcessor).

video_processor ([BaseVideoProcessor](/docs/transformers/v5.23.0/es/main_classes/video_processor#transformers.BaseVideoProcessor)) : el procesador de video que se utilizará en el pipeline para codificar los datos de video para el modelo. Este objeto hereda de [BaseVideoProcessor](/docs/transformers/v5.23.0/es/main_classes/video_processor#transformers.BaseVideoProcessor).

task (`str`, por defecto `""`) : Un identificador de tarea para el pipeline.

num_workers (`int`, *opcional*, valor predeterminado: 8) : Cuando la pipeline utilizará *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el número de workers que se usarán.

batch_size (`int`, *opcional*, valor predeterminado 1) : Cuando la pipeline utilice *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del batch a utilizar; para inferencia, esto no siempre es beneficioso, por favor lea [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) .

args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/es/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.

device (`int` o `str` o `torch.device`, *opcional*) : Dispositivo en el que se asigna el pipeline. Si se deja sin establecer, el pipeline se coloca en el primer acelerador disponible (CUDA, MPS, XPU, ...) y solo recurre a la CPU si no hay ninguno disponible; el modelo se mueve allí automáticamente. Pasa `device="cpu"` (o `-1`) para forzar la CPU, un ordinal positivo o `"cuda:1"` para seleccionar un acelerador específico, o un `torch.device`/`str` nativo. Este argumento no puede combinarse con un modelo ya cargado mediante `accelerate` (es decir, uno con un `hf_device_map`).

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Precisión en la que se carga el modelo, se reenvía a `from_pretrained`. El valor predeterminado es `"auto"`, que carga el modelo en el dtype en el que se guardó (leído de `config.dtype` del checkpoint, o inferido de los pesos si no está disponible). Pasa un `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescribirlo.

binary_output (`bool`, *opcional*, valor predeterminado `False`) : Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida sin procesar, por ejemplo, texto.

Pipeline de clasificación de video que utiliza cualquier `AutoModelForVideoClassification`. Este pipeline predice la clase de un video.

Este pipeline de clasificación de vídeo se puede cargar actualmente desde [pipeline()](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.pipeline) utilizando el siguiente identificador de tarea: `"video-classification"`.

Vea la lista de modelos disponibles en [huggingface.co/models](https://huggingface.co/models?filter=video-classification).

El pipeline admite modelos que utilizan un procesador de imágenes (modelos de video legados como VideoMAE, ViViT y TimeSformer) o un procesador de video (modelos más recientes como VJEPA2). Cuando están presentes ambos, el procesador de video tiene prioridad; si no se encuentra ninguno, el pipeline generará un error.

#### __llamada__[[transformers.VideoClassificationPipeline.__call__]]

```python
__call__(inputs: str | list[str] | None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/video_classification.py#L103)

**Parámetros:**

inputs (`str`, `list[str]`) : El pipeline maneja tres tipos de videos:  - Una cadena que contiene un enlace http que apunta a un video - Una cadena que contiene una ruta local a un video  El pipeline acepta un solo video o un lote de videos, que en ese caso debe pasarse como una cadena. Los videos de un lote deben estar todos en el mismo formato: todos como enlaces http o todos como rutas locales.

top_k (`int`, *opcional*, valor predeterminado: 5) : El número de etiquetas principales que devolverá el pipeline. Si el número proporcionado es mayor que el número de etiquetas disponibles en la configuración del modelo, se usará el número de etiquetas disponible.

num_frames (`int`, *opcional*, valor predeterminado `self.model.config.num_frames`) : El número de fotogramas muestreados del video para ejecutar la clasificación. Si no se proporciona, se utilizará el número de fotogramas especificado en la configuración del modelo.

frame_sampling_rate (`int`, *opcional*, valor predeterminado 1) : La tasa de muestreo utilizada para seleccionar fotogramas del video. Si no se proporciona, se usará 1 por defecto, es decir, se utilizará cada fotograma.

function_to_apply (`str`, *opcional*) : La función que se aplica a la salida del modelo. Por defecto es "none" para regresión, "sigmoid" para clasificación multietiqueta y "softmax" en cualquier otro caso. Opciones válidas: ["softmax", "sigmoid", "none"]. Los valores explícitos proporcionados en la inicialización o en el momento de la llamada reemplazan estos valores predeterminados. Pasa la cadena "none" para deshabilitar el posprocesamiento.

**Devuelve:**

Una lista de diccionarios o una lista de listas de diccionarios que contienen el resultado. Si la entrada es un único video, se devolverá una lista de `top_k` diccionarios; si la entrada es una lista de varios videos, se devolverá una lista de listas de `top_k` diccionarios correspondientes a los videos.

Los diccionarios contienen las siguientes claves:

- **label** (`str`) -- La etiqueta identificada por el modelo.
- **score** (`int`) -- La puntuación que el modelo asigna a esa etiqueta.

Asigna etiquetas a los vídeos pasados como entradas.

### ZeroShotImageClassificationPipeline[[transformers.ZeroShotImageClassificationPipeline]]

#### transformers.ZeroShotImageClassificationPipeline[[transformers.ZeroShotImageClassificationPipeline]]

```python
transformers.ZeroShotImageClassificationPipeline(**kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/zero_shot_image_classification.py#L29)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel)): el modelo que se utilizará en el pipeline para realizar predicciones. Debe ser un modelo que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).

image_processor ([BaseImageProcessor](/docs/transformers/v5.23.0/es/main_classes/image_processor#transformers.BaseImageProcessor)): el procesador de imágenes que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [BaseImageProcessor](/docs/transformers/v5.23.0/es/main_classes/image_processor#transformers.BaseImageProcessor).

task (`str`, por defecto `""`) : Un identificador de tarea para el pipeline.

num_workers (`int`, *opcional*, valor predeterminado: 8) : Cuando la pipeline utilizará *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el número de workers que se usarán.

batch_size (`int`, *opcional*, valor predeterminado 1) : Cuando la pipeline utilice *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del batch a utilizar; para inferencia, esto no siempre es beneficioso, por favor lea [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) .

args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/es/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.

device (`int` o `str` o `torch.device`, *opcional*) : Dispositivo en el que se asigna el pipeline. Si se deja sin establecer, el pipeline se coloca en el primer acelerador disponible (CUDA, MPS, XPU, ...) y solo recurre a la CPU si no hay ninguno disponible; el modelo se mueve allí automáticamente. Pasa `device="cpu"` (o `-1`) para forzar la CPU, un ordinal positivo o `"cuda:1"` para seleccionar un acelerador específico, o un `torch.device`/`str` nativo. Este argumento no puede combinarse con un modelo ya cargado mediante `accelerate` (es decir, uno con un `hf_device_map`).

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Precisión en la que se carga el modelo, se reenvía a `from_pretrained`. El valor predeterminado es `"auto"`, que carga el modelo en el dtype en el que se guardó (leído de `config.dtype` del checkpoint, o inferido de los pesos si no está disponible). Pasa un `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescribirlo.

binary_output (`bool`, *opcional*, valor predeterminado `False`) : Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida sin procesar, por ejemplo, texto.

Pipeline de clasificación de imágenes sin ejemplos de entrenamiento que utiliza `CLIPModel`. Este pipeline predice la clase de una imagen cuando se proporciona una imagen y un conjunto de `candidate_labels`.

Ejemplo:

```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'}]
```

Obtenga más información sobre los fundamentos del uso de un pipeline en el [tutorial de pipeline](../pipeline_tutorial)

Este pipeline de clasificación de imágenes se puede cargar actualmente desde [pipeline()](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.pipeline) utilizando el siguiente identificador de tarea: `"zero-shot-image-classification"`.

Vea la lista de modelos disponibles en [huggingface.co/models](https://huggingface.co/models?filter=zero-shot-image-classification).

#### __llamada__[[transformers.ZeroShotImageClassificationPipeline.__call__]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/zero_shot_image_classification.py#L83)

**Parámetros:**

image (`str`, `list[str]`, `PIL.Image` o `list[PIL.Image]`) : El pipeline maneja tres tipos de imágenes:  - Una cadena de texto que contiene un enlace http que apunta a una imagen - Una cadena de texto que contiene una ruta local a una imagen - Una imagen cargada directamente en PIL

candidate_labels (`list[str]`) : Las etiquetas candidatas para esta imagen. Se formatearán usando *hypothesis_template*.

hypothesis_template (`str`, *opcional*, valor predeterminado `"This is a photo of {}"`) : El formato utilizado junto con *candidate_labels* para intentar la clasificación de la imagen reemplazando el marcador de posición con candidate_labels. Pasa "{}" si *candidate_labels* ya están formateados.

timeout (`float`, *opcional*, valor predeterminado None) : Tiempo máximo en segundos para esperar la obtención de imágenes de la web. Si es None, no se establece un tiempo de espera y la llamada puede bloquearse indefinidamente.

**Devuelve:**

Una lista de diccionarios que contiene una entrada por cada etiqueta propuesta. Cada diccionario contiene las siguientes claves:
- **label** (`str`) -- Uno de los *candidate_labels* sugeridos.
- **score** (`float`) -- La puntuación que el modelo asigna a esa etiqueta. Es un valor entre 0 y 1, calculado como el `softmax` de `logits_per_image`.

Asigna etiquetas a la(s) imagen(es) pasadas como entradas.

### ZeroShotObjectDetectionPipeline[[transformers.ZeroShotObjectDetectionPipeline]]

#### transformers.ZeroShotObjectDetectionPipeline[[transformers.ZeroShotObjectDetectionPipeline]]

```python
transformers.ZeroShotObjectDetectionPipeline(**kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/zero_shot_object_detection.py#L23)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel)): el modelo que se utilizará en el pipeline para realizar predicciones. Debe ser un modelo que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).

image_processor ([BaseImageProcessor](/docs/transformers/v5.23.0/es/main_classes/image_processor#transformers.BaseImageProcessor)): el procesador de imágenes que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [BaseImageProcessor](/docs/transformers/v5.23.0/es/main_classes/image_processor#transformers.BaseImageProcessor).

task (`str`, por defecto `""`) : Un identificador de tarea para el pipeline.

num_workers (`int`, *opcional*, valor predeterminado: 8) : Cuando la pipeline utilizará *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el número de workers que se usarán.

batch_size (`int`, *opcional*, valor predeterminado 1) : Cuando la pipeline utilice *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del batch a utilizar; para inferencia, esto no siempre es beneficioso, por favor lea [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) .

args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/es/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.

device (`int` o `str` o `torch.device`, *opcional*) : Dispositivo en el que se asigna el pipeline. Si se deja sin establecer, el pipeline se coloca en el primer acelerador disponible (CUDA, MPS, XPU, ...) y solo recurre a la CPU si no hay ninguno disponible; el modelo se mueve allí automáticamente. Pasa `device="cpu"` (o `-1`) para forzar la CPU, un ordinal positivo o `"cuda:1"` para seleccionar un acelerador específico, o un `torch.device`/`str` nativo. Este argumento no puede combinarse con un modelo ya cargado mediante `accelerate` (es decir, uno con un `hf_device_map`).

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Precisión en la que se carga el modelo, se reenvía a `from_pretrained`. El valor predeterminado es `"auto"`, que carga el modelo en el dtype en el que se guardó (leído de `config.dtype` del checkpoint, o inferido de los pesos si no está disponible). Pasa un `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescribirlo.

binary_output (`bool`, *opcional*, valor predeterminado `False`) : Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida sin procesar, por ejemplo, texto.

Pipeline de detección de objetos sin ejemplos (zero shot) que utiliza `OwlViTForObjectDetection`. Este pipeline predice las cajas delimitadoras de los objetos cuando se proporciona una imagen y un conjunto de `candidate_labels`.

Ejemplo:

```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}}]
```

Obtenga más información sobre los fundamentos del uso de un pipeline en el [tutorial de pipeline](../pipeline_tutorial)

Este pipeline de detección de objetos se puede cargar actualmente desde [pipeline()](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.pipeline) utilizando el siguiente identificador de tarea: `"zero-shot-object-detection"`.

Vea la lista de modelos disponibles en [huggingface.co/models](https://huggingface.co/models?filter=zero-shot-object-detection).

#### __llamada__[[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)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/zero_shot_object_detection.py#L75)

**Parámetros:**

image (`str`, `PIL.Image` or `list[dict[str, Any]]`) : El pipeline maneja tres tipos de imágenes:  - Una cadena que contiene una URL http que apunta a una imagen - Una cadena que contiene una ruta local a una imagen - Una imagen cargada directamente en PIL  Puedes usar este parámetro para enviar directamente una lista de imágenes, o un dataset o un generador, de la siguiente manera:  ```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` o `list[str]` o `list[list[str]]`) : Lo que el modelo debe reconocer en la imagen.

threshold (`float`, *opcional*, valor predeterminado 0.1) : La probabilidad necesaria para realizar una predicción.

top_k (`int`, *opcional*, valor predeterminado None) : El número de predicciones principales que se devolverán por la canalización. Si el número proporcionado es `None` o es mayor que el número de predicciones disponibles, se usará el número de predicciones disponibles.

timeout (`float`, *opcional*, valor predeterminado None) : Tiempo máximo en segundos para esperar la obtención de imágenes de la web. Si es None, no se establece un tiempo de espera y la llamada puede bloquearse indefinidamente.

**Devuelve:**

Una lista de listas que contiene los resultados de predicción, una lista por cada imagen de entrada. Cada lista contiene diccionarios con las siguientes claves:

- **label** (`str`) -- Consulta de texto correspondiente al objeto encontrado.
- **score** (`float`) -- Puntuación correspondiente al objeto (entre 0 y 1).
- **box** (`dict[str,int]`) -- Caja delimitadora del objeto detectado en el tamaño original de la imagen. Es un diccionario con las claves `x_min`, `x_max`, `y_min`, `y_max`.

Detecta objetos (cajas delimitadoras y clases) en la(s) imagen(es) pasadas como entradas.

## Procesamiento del Lenguaje Natural

Los pipelines disponibles para tareas de procesamiento de lenguaje natural incluyen los siguientes.

### DecisionPipeline[[transformers.DecisionPipeline]]

> [!WARNING]
> Los modelos de decisión, el pipeline `decision` y `DecisionConfig` son experimentales: su API puede cambiar en cualquier momento, sin periodo de deprecación.

Cada llamada hace sus preguntas: una solicitud `{"state": ..., "questions": ...}`, o un estado con `questions`:

```python
from transformers import pipeline

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

Las imágenes se proporcionan como `assets`, como en la API de System One: cada marcador de posición en el estado, las instrucciones o los criterios se reemplaza por su imagen. Un asset es `{"type": "image", "format": "png", "data_base64": ...}`, una imagen PIL, una ruta o una URL, y el modelo necesita un procesador que maneje imágenes.

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

#### transformers.DecisionPipeline[[transformers.DecisionPipeline]]

```python
transformers.DecisionPipeline(*args, decision_config: transformers.decision.configuration_utils.DecisionConfig | str | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/decision.py#L15)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel)): el modelo que se utilizará en el pipeline para realizar predicciones. Debe ser un modelo que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).

tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend)) : El tokenizador que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend).

task (`str`, por defecto `""`) : Un identificador de tarea para el pipeline.

num_workers (`int`, *opcional*, valor predeterminado: 8) : Cuando la pipeline utilizará *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el número de workers que se usarán.

batch_size (`int`, *opcional*, valor predeterminado 1) : Cuando la pipeline utilice *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del batch a utilizar; para inferencia, esto no siempre es beneficioso, por favor lea [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) .

args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/es/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.

device (`int` o `str` o `torch.device`, *opcional*) : Dispositivo en el que se asigna el pipeline. Si se deja sin establecer, el pipeline se coloca en el primer acelerador disponible (CUDA, MPS, XPU, ...) y solo recurre a la CPU si no hay ninguno disponible; el modelo se mueve allí automáticamente. Pasa `device="cpu"` (o `-1`) para forzar la CPU, un ordinal positivo o `"cuda:1"` para seleccionar un acelerador específico, o un `torch.device`/`str` nativo. Este argumento no puede combinarse con un modelo ya cargado mediante `accelerate` (es decir, uno con un `hf_device_map`).

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Precisión en la que se carga el modelo, se reenvía a `from_pretrained`. El valor predeterminado es `"auto"`, que carga el modelo en el dtype en el que se guardó (leído de `config.dtype` del checkpoint, o inferido de los pesos si no está disponible). Pasa un `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescribirlo.

binary_output (`bool`, *opcional*, valor predeterminado `False`) : Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida sin procesar, por ejemplo, texto.

Pipeline de decisión: responde preguntas de tipo pregunta (`choice`, `score`, `noul`) sobre un `state` con una probabilidad para cada opción, a partir de una sola pasada por adelante por prompt (la API System One de modelos tipo Jev). La configuración de decisión (ver [DecisionConfig](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.DecisionConfig)) se encuentra junto al modelo o en el repositorio indicado como `decision_config`. Un modelo de decisión (`XxxForDecision`) puntúa las opciones por sí mismo; cualquier otro modelo las puntúa mediante los logits del siguiente token de sus etiquetas, por lo que cualquier modelo de chat puede responder.

Ejemplo:

```python
>>> from transformers import pipeline

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

Argumentos de llamada: inputs (`dict`, `str` o `list`): `{"state": ..., "questions": {name: {"type": ..., "instructions": ..., "criteria": ...}}}` o su JSON, con `type` siendo uno de `choice` (`criteria` asigna opciones a descripciones), `score` (`criteria` lista los niveles, del más bajo al más alto) o `noul` (`criteria` opcional describe `true` y `false`). Las solicitudes pueden incluir `assets`, como en la API de System One. questions (`dict`, *opcional*): Preguntas que hacer a la entrada, como el `state` de una solicitud. assets (`dict`, *opcional*): Imágenes indexadas por un marcador de posición: dondequiera que aparezca el marcador en una cadena del estado, las instrucciones o los criterios, el modelo ve la imagen. Una imagen es un activo de System One (`{"type": "image", "format": "png", "data_base64": ...}`), una imagen PIL, una ruta o una URL. Requiere un modelo con un procesador que maneje imágenes.

Devuelve `dict` (o una lista de `dict`): las respuestas indexadas por el nombre de la pregunta, en el formato System One.

#### __llamada__[[transformers.DecisionPipeline.__call__]]

```python
__call__(inputs, *args, num_workers = None, batch_size = None, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/base.py#L1239)

#### transformers.DecisionConfig[[transformers.DecisionConfig]]

```python
transformers.DecisionConfig(labels: dict[str, list[str]] = <factory>, temperature: dict[str, float | int] = <factory>, chat_template: str | None = None, noul_options: list[str] = <factory>, sanitize_control_tokens: bool = True, adapter: str | None = None)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/decision/configuration_utils.py#L30)

**Parámetros:**

labels (`dict[str, list[str]]`, *opcional*) : Etiquetas de un solo token para las opciones por tipo de pregunta, para las cabezas que las leen de los logits. Por defecto, `Yes`/`No` para `noul` y `A`, `B`, `C`, ... en caso contrario.

temperature (`dict[str, float]`, *opcional*) : Temperatura por tipo de pregunta, aplicada a las puntuaciones de las opciones antes del softmax. El valor predeterminado es 1.

chat_template (`str`, *opcional*) : Plantilla Jinja para renderizar `state` con `question` (un prompt por pregunta) o `questions` (un prompt para todas). Por defecto, se utiliza un prompt genérico en la plantilla de chat del tokenizer.

noul_options (`list[str]`, *opcional*, por defecto `["true", "false"]`) : Orden en el que la plantilla recibe las dos opciones de una pregunta `noul`.

sanitize_control_tokens (`bool`, *opcional*, valor predeterminado `True`) : Si los tokens de control en la solicitud se codifican como texto. Las plantillas que los escapan por sí mismas lo desactivan para mantener los ids de entrada de su código original.

adapter (`str`, *opcional*) : Subcarpeta del LoRA que la pipeline carga en el modelo, para repositorios que no la mantienen en su raíz.

Configuración de un modelo de decisión, guardado como `decision.json` (y su plantilla de chat como `decision_template.jinja`).

#### get_logits_processor[[transformers.DecisionConfig.get_logits_processor]]

```python
get_logits_processor(question_type: str)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/decision/configuration_utils.py#L63)

La [LogitsProcessorList](/docs/transformers/v5.23.0/es/internal/generation_utils#transformers.LogitsProcessorList) aplicada a las puntuaciones de las opciones de una pregunta de tipo `question_type`.

#### prepare_inputs[[transformers.DecisionConfig.prepare_inputs]]

```python
prepare_inputs(request, processor)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/decision/configuration_utils.py#L78)

Los `(inputs, questions)` tokenizados de cada prompt de `request`, ver `prepare_inputs()`.

#### validate[[transformers.DecisionConfig.validate]]

```python
validate()
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/huggingface_hub/dataclasses.py#L247)

Ejecuta los validadores de clase en la instancia.

### 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)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/fill_mask.py#L28)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel)): el modelo que se utilizará en el pipeline para realizar predicciones. Debe ser un modelo que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).

tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend)) : El tokenizador que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend).

task (`str`, por defecto `""`) : Un identificador de tarea para el pipeline.

num_workers (`int`, *opcional*, valor predeterminado: 8) : Cuando la pipeline utilizará *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el número de workers que se usarán.

batch_size (`int`, *opcional*, valor predeterminado 1) : Cuando la pipeline utilice *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del batch a utilizar; para inferencia, esto no siempre es beneficioso, por favor lea [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) .

args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/es/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.

device (`int` o `str` o `torch.device`, *opcional*) : Dispositivo en el que se asigna el pipeline. Si se deja sin establecer, el pipeline se coloca en el primer acelerador disponible (CUDA, MPS, XPU, ...) y solo recurre a la CPU si no hay ninguno disponible; el modelo se mueve allí automáticamente. Pasa `device="cpu"` (o `-1`) para forzar la CPU, un ordinal positivo o `"cuda:1"` para seleccionar un acelerador específico, o un `torch.device`/`str` nativo. Este argumento no puede combinarse con un modelo ya cargado mediante `accelerate` (es decir, uno con un `hf_device_map`).

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Precisión en la que se carga el modelo, se reenvía a `from_pretrained`. El valor predeterminado es `"auto"`, que carga el modelo en el dtype en el que se guardó (leído de `config.dtype` del checkpoint, o inferido de los pesos si no está disponible). Pasa un `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescribirlo.

binary_output (`bool`, *opcional*, valor predeterminado `False`) : Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida sin procesar, por ejemplo, texto.

top_k (`int`, *opcional*, valor predeterminado 5) : El número de predicciones a devolver.

targets (`str` o `list[str]`, *opcional*) : Si se proporciona, el modelo limitará las puntuaciones a los objetivos pasados, en lugar de buscarlos en todo el vocabulario. Si los objetivos proporcionados no están en el vocabulario del modelo, se tokenizarán y se utilizará el primer token resultante (con una advertencia, y esto podría ser más lento).

tokenizer_kwargs (`dict`, *opcional*) : Diccionario adicional de argumentos por nombre que se pasa al tokenizador.

#### __llamada__[[transformers.FillMaskPipeline.__call__]]

```python
__call__(inputs: str | list[str], **kwargs: Any)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/fill_mask.py#L234)

**Parámetros:**

inputs (`str` o `list[str]`) : Uno o varios textos (o una lista de prompts) con tokens enmascarados.

targets (`str` o `list[str]`, *opcional*) : Si se proporciona, el modelo limitará las puntuaciones a los objetivos pasados, en lugar de buscarlos en todo el vocabulario. Si los objetivos proporcionados no están en el vocabulario del modelo, se tokenizarán y se utilizará el primer token resultante (con una advertencia, y esto podría ser más lento).

top_k (`int`, *opcional*) : Si se especifica, reemplaza el número de predicciones a devolver.

**Devuelve:** una lista o una lista de listas de `dict`

Cada resultado se presenta como una lista de diccionarios con las siguientes claves:

- **sequence** (`str`) -- La entrada correspondiente con la predicción del token de máscara.
- **score** (`float`) -- La probabilidad correspondiente.
- **token** (`int`) -- El id del token predicho (para reemplazar al enmascarado).
- **token_str** (`str`) -- El token predicho (para reemplazar al enmascarado).

Rellene el token enmascarado en el o los textos dados como entradas.

### TableQuestionAnsweringPipeline[[transformers.TableQuestionAnsweringPipeline]]

#### transformers.TableQuestionAnsweringPipeline[[transformers.TableQuestionAnsweringPipeline]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/table_question_answering.py#L78)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel)): el modelo que se utilizará en el pipeline para realizar predicciones. Debe ser un modelo que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).

tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend)) : El tokenizador que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend).

task (`str`, por defecto `""`) : Un identificador de tarea para el pipeline.

num_workers (`int`, *opcional*, valor predeterminado: 8) : Cuando la pipeline utilizará *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el número de workers que se usarán.

batch_size (`int`, *opcional*, valor predeterminado 1) : Cuando la pipeline utilice *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del batch a utilizar; para inferencia, esto no siempre es beneficioso, por favor lea [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) .

args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/es/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.

device (`int` o `str` o `torch.device`, *opcional*) : Dispositivo en el que se asigna el pipeline. Si se deja sin establecer, el pipeline se coloca en el primer acelerador disponible (CUDA, MPS, XPU, ...) y solo recurre a la CPU si no hay ninguno disponible; el modelo se mueve allí automáticamente. Pasa `device="cpu"` (o `-1`) para forzar la CPU, un ordinal positivo o `"cuda:1"` para seleccionar un acelerador específico, o un `torch.device`/`str` nativo. Este argumento no puede combinarse con un modelo ya cargado mediante `accelerate` (es decir, uno con un `hf_device_map`).

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Precisión en la que se carga el modelo, se reenvía a `from_pretrained`. El valor predeterminado es `"auto"`, que carga el modelo en el dtype en el que se guardó (leído de `config.dtype` del checkpoint, o inferido de los pesos si no está disponible). Pasa un `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescribirlo.

binary_output (`bool`, *opcional*, valor predeterminado `False`) : Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida sin procesar, por ejemplo, texto.

Pipeline de respuesta a preguntas sobre tablas que utiliza un `ModelForTableQuestionAnswering`. Este pipeline solo está disponible en PyTorch.

A menos que el modelo que esté usando establezca explícitamente estos parámetros de generación en sus archivos de configuración (`generation_config.json`), se usarán los siguientes valores predeterminados:
- max_new_tokens: 256

Ejemplo:

```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'}
```

Obtenga más información sobre los fundamentos del uso de un pipeline en el [tutorial de pipeline](../pipeline_tutorial)

Este pipeline de respuesta a preguntas tabulares se puede cargar actualmente desde [pipeline()](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.pipeline) utilizando el siguiente identificador de tarea: `"table-question-answering"`.

Los modelos que puede utilizar este pipeline son modelos que han sido ajustados finamente en una tarea de respuesta a preguntas tabulares. Consulte la lista actualizada de modelos disponibles en [huggingface.co/models](https://huggingface.co/models?filter=table-question-answering).

#### __llamada__[[transformers.TableQuestionAnsweringPipeline.__call__]]

```python
__call__(*args, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/table_question_answering.py#L208)

**Parámetros:**

table (`pd.DataFrame` o `Dict`) : DataFrame de Pandas o diccionario que se convertirá en un DataFrame que contiene todos los valores de la tabla. Consulte arriba un ejemplo de diccionario.

query (`str` o `list[str]`) : Consulta o lista de consultas que se enviarán al modelo junto con la tabla.

sequential (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe realizar la inferencia de forma secuencial o por lotes. El procesamiento por lotes es más rápido, pero modelos como SQA requieren que la inferencia se realice de forma secuencial para extraer relaciones dentro de las secuencias, debido a su naturaleza conversacional.

padding (`bool`, `str` o [PaddingStrategy](/docs/transformers/v5.23.0/es/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, valor predeterminado `False`) : Activa y controla el relleno. Acepta los siguientes valores:  - `True` o `'longest'`: Rellena hasta la secuencia más larga del lote (o no aplica relleno si solo se proporciona una secuencia). - `'max_length'`: Rellena hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. - `False` o `'do_not_pad'` (predeterminado): Sin relleno (es decir, puede generar un lote con secuencias de longitudes diferentes).

truncation (`bool`, `str` o `TapasTruncationStrategy`, *opcional*, valor predeterminado `False`) : Activa y controla la truncación. Acepta los siguientes valores:  - `True` o `'drop_rows_to_fit'`: Trunca hasta una longitud máxima especificada con el argumento `max_length` o hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento. Esto truncará fila por fila, eliminando filas de la tabla. - `False` o `'do_not_truncate'` (predeterminado): Sin truncación (es decir, puede generar un lote con longitudes de secuencia mayores que el tamaño de entrada máximo admisible del modelo).

**Devuelve:** `A dictionary or a list of dictionaries containing results`

Cada resultado es un diccionario con las siguientes claves:

- **answer** (`str`) -- La respuesta de la consulta dada la tabla. Si hay un agregador, la respuesta irá precedida por `AGGREGATOR >`.
- **coordinates** (`list[tuple[int, int]]`) -- Coordenadas de las celdas de las respuestas.
- **cells** (`list[str]`) -- Lista de cadenas compuesta por los valores de las celdas de respuesta.
- **aggregator** (`str`) -- Si el modelo tiene un agregador, esto devuelve el agregador.

Responde consultas según una tabla. El pipeline acepta varios tipos de entradas, que se detallan a continuación:

- `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}])`

El argumento `table` debe ser un diccionario o un DataFrame construido a partir de ese diccionario, que contenga la tabla completa:

Ejemplo:

```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 diccionario se puede pasar tal cual o convertirse en un DataFrame de pandas:

Ejemplo:

```python
import pandas as pd

table = pd.DataFrame.from_dict(data)
```

### TextClassificationPipeline[[transformers.TextClassificationPipeline]]

#### transformers.TextClassificationPipeline[[transformers.TextClassificationPipeline]]

```python
transformers.TextClassificationPipeline(**kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/text_classification.py#L43)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel)): el modelo que se utilizará en el pipeline para realizar predicciones. Debe ser un modelo que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).

tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend)) : El tokenizador que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend).

task (`str`, por defecto `""`) : Un identificador de tarea para el pipeline.

num_workers (`int`, *opcional*, valor predeterminado: 8) : Cuando la pipeline utilizará *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el número de workers que se usarán.

batch_size (`int`, *opcional*, valor predeterminado 1) : Cuando la pipeline utilice *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del batch a utilizar; para inferencia, esto no siempre es beneficioso, por favor lea [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) .

args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/es/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.

device (`int` o `str` o `torch.device`, *opcional*) : Dispositivo en el que se asigna el pipeline. Si se deja sin establecer, el pipeline se coloca en el primer acelerador disponible (CUDA, MPS, XPU, ...) y solo recurre a la CPU si no hay ninguno disponible; el modelo se mueve allí automáticamente. Pasa `device="cpu"` (o `-1`) para forzar la CPU, un ordinal positivo o `"cuda:1"` para seleccionar un acelerador específico, o un `torch.device`/`str` nativo. Este argumento no puede combinarse con un modelo ya cargado mediante `accelerate` (es decir, uno con un `hf_device_map`).

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Precisión en la que se carga el modelo, se reenvía a `from_pretrained`. El valor predeterminado es `"auto"`, que carga el modelo en el dtype en el que se guardó (leído de `config.dtype` del checkpoint, o inferido de los pesos si no está disponible). Pasa un `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescribirlo.

binary_output (`bool`, *opcional*, valor predeterminado `False`) : Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida sin procesar, por ejemplo, texto.

function_to_apply (`str`, *opcional*, valor predeterminado `"default"`) : La función que se aplica a las salidas del modelo para obtener las puntuaciones. Acepta cuatro valores diferentes:  - `"default"`: si el modelo tiene una única etiqueta, se aplicará la función sigmoide a la salida. Si el modelo tiene varias etiquetas, se aplicará la función softmax a la salida. En el caso de tareas de regresión, no se aplicará ninguna función a la salida. - `"sigmoid"`: Aplica la función sigmoide a la salida. - `"softmax"`: Aplica la función softmax a la salida. - `"none"`: No aplica ninguna función a la salida.

Pipeline de clasificación de texto que utiliza cualquier `ModelForSequenceClassification`. Consulte los [ejemplos de clasificación de secuencias](../task_summary#sequence-classification) para obtener más información.

Ejemplo:

```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}]
```

Obtenga más información sobre los fundamentos del uso de un pipeline en el [tutorial de pipeline](../pipeline_tutorial)

Este pipeline de clasificación de texto se puede cargar actualmente desde [pipeline()](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.pipeline) utilizando el siguiente identificador de tarea: `"sentiment-analysis"` (para clasificar secuencias según sentimientos positivos o negativos).

Si hay disponibles varias etiquetas de clasificación (`model.config.num_labels >= 2`), el pipeline ejecutará un softmax sobre los resultados. Si hay una única etiqueta, el pipeline ejecutará un sigmoid sobre el resultado. En el caso de tareas de regresión (`model.config.problem_type == "regression"`), no se aplicará ninguna función a la salida.

Los modelos que puede utilizar este pipeline son modelos que han sido ajustados finamente en una tarea de clasificación de secuencias. Consulte la lista actualizada de modelos disponibles en [huggingface.co/models](https://huggingface.co/models?filter=text-classification).

#### __llamada__[[transformers.TextClassificationPipeline.__call__]]

```python
__call__(inputs: str | list[str] | dict[str, str] | list[dict[str, str]], **kwargs: Any)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/text_classification.py#L105)

**Parámetros:**

inputs (`str` o `list[str]` o `dict[str]`, o `list[dict[str]]`) : Uno o varios textos para clasificar. Para usar pares de texto en tu clasificación, puedes enviar un diccionario que contenga las claves `{"text", "text_pair"}`, o una lista de esos.

top_k (`int`, *opcional*, valor predeterminado `1`) : Número de resultados a devolver.

function_to_apply (`str`, *opcional*, valor predeterminado `"default"`) : La función que se aplica a las salidas del modelo para obtener las puntuaciones. Acepta cuatro valores diferentes:  Si no se especifica este argumento, se aplicarán las siguientes funciones según el número de etiquetas:  - Si el tipo de problema es regresión, no se aplicará ninguna función a la salida. - Si el modelo tiene una única etiqueta, se aplicará la función sigmoide a la salida. - Si el modelo tiene varias etiquetas, se aplicará la función softmax a la salida.  Los valores posibles son:  - `"sigmoid"`: Aplica la función sigmoide a la salida. - `"softmax"`: Aplica la función softmax a la salida. - `"none"`: No aplica ninguna función a la salida.

**Devuelve:** una lista de `dict`

Cada resultado se presenta como una lista de diccionarios con las siguientes claves:

- **label** (`str`) -- La etiqueta predicha.
- **score** (`float`) -- La probabilidad correspondiente.

Si se usa `top_k`, se devuelve un diccionario de este tipo por cada etiqueta.

Clasifica el o los textos dados como entradas.

### TextGenerationPipeline[[transformers.TextGenerationPipeline]]

#### transformers.TextGenerationPipeline[[transformers.TextGenerationPipeline]]

```python
transformers.TextGenerationPipeline(*args, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/text_generation.py#L23)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel)): el modelo que se utilizará en el pipeline para realizar predicciones. Debe ser un modelo que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).

tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend)) : El tokenizador que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend).

task (`str`, por defecto `""`) : Un identificador de tarea para el pipeline.

num_workers (`int`, *opcional*, valor predeterminado: 8) : Cuando la pipeline utilizará *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el número de workers que se usarán.

batch_size (`int`, *opcional*, valor predeterminado 1) : Cuando la pipeline utilice *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del batch a utilizar; para inferencia, esto no siempre es beneficioso, por favor lea [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) .

args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/es/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.

device (`int` o `str` o `torch.device`, *opcional*) : Dispositivo en el que se asigna el pipeline. Si se deja sin establecer, el pipeline se coloca en el primer acelerador disponible (CUDA, MPS, XPU, ...) y solo recurre a la CPU si no hay ninguno disponible; el modelo se mueve allí automáticamente. Pasa `device="cpu"` (o `-1`) para forzar la CPU, un ordinal positivo o `"cuda:1"` para seleccionar un acelerador específico, o un `torch.device`/`str` nativo. Este argumento no puede combinarse con un modelo ya cargado mediante `accelerate` (es decir, uno con un `hf_device_map`).

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Precisión en la que se carga el modelo, se reenvía a `from_pretrained`. El valor predeterminado es `"auto"`, que carga el modelo en el dtype en el que se guardó (leído de `config.dtype` del checkpoint, o inferido de los pesos si no está disponible). Pasa un `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescribirlo.

binary_output (`bool`, *opcional*, valor predeterminado `False`) : Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida sin procesar, por ejemplo, texto.

Pipeline de generación de lenguaje que utiliza cualquier `ModelWithLMHead` o `ModelForCausalLM`. Este pipeline predice las palabras que seguirán a un texto de entrada especificado. Cuando el modelo subyacente es un modelo conversacional, también puede aceptar uno o más chats, en cuyo caso el pipeline operará en modo de chat y continuará el o los chats añadiendo su(s) respuesta(s). Cada chat tiene la forma de una lista de diccionarios, donde cada diccionario contiene las claves "role" y "content".

A menos que el modelo que esté usando establezca explícitamente estos parámetros de generación en sus archivos de configuración (`generation_config.json`), se usarán los siguientes valores predeterminados:
- max_new_tokens: 256
- do_sample: True
- temperature: 0.7

Ejemplos:

```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'}]}]
```

Puede obtener más información sobre los fundamentos del uso de un pipeline en el [tutorial de pipeline](../pipeline_tutorial). Puede pasar parámetros de generación de texto a este pipeline para controlar los criterios de parada, la estrategia de decodificación y más. Obtenga más información sobre los parámetros de generación de texto en [Estrategias de generación de texto](../generation_strategies) y [Generación de texto](text_generation).

Este pipeline de generación de lenguaje se puede cargar actualmente desde [pipeline()](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.pipeline) utilizando el siguiente identificador de tarea: `"text-generation"`.

Los modelos que puede utilizar este pipeline son aquellos que han sido entrenados con un objetivo de modelado de lenguaje autoregresivo. Consulte la lista de [modelos de completado de texto](https://huggingface.co/models?filter=text-generation) y la lista de [modelos conversacionales](https://huggingface.co/models?other=conversational) en [huggingface.co/models].

#### __llamada__[[transformers.TextGenerationPipeline.__call__]]

```python
__call__(text_inputs, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/text_generation.py#L253)

**Parámetros:**

text_inputs (`str`, `list[str]`, `ChatType` o `list[ChatType]`) : Una o varias indicaciones (o una lista de indicaciones) para completar. Si se pasan cadenas de texto o una lista de cadenas de texto, esta línea de procesamiento continuará cada indicación. Alternativamente, se puede pasar un "chat", en forma de una lista de diccionarios con las claves "role" y "content", o una lista de dichos chats. Cuando se pasan chats, se utilizará la plantilla de chat del modelo para formatearlos antes de pasarlos al modelo.

return_tensors (`bool`, *opcional*, valor predeterminado `False`) : Devuelve los tensores de predicciones (como índices de tokens) en las salidas. Si se establece en `True`, no se devuelve el texto decodificado.

return_text (`bool`, *opcional*) : Devuelve los textos decodificados en las salidas.

return_full_text (`bool`, *opcional*, valor predeterminado `True`) : Si se establece en `False`, solo se devuelve el texto añadido; en caso contrario, se devuelve el texto completo. No se puede especificar al mismo tiempo que `return_text`.

clean_up_tokenization_spaces (`bool`, *opcional*) : Indica si se deben limpiar los espacios adicionales potenciales en la salida de texto. El valor predeterminado es la configuración `clean_up_tokenization_spaces` del tokenizador.

continue_final_message( `bool`, *opcional*) : Indica que deseas que el modelo continúe el último mensaje del chat de entrada en lugar de iniciar uno nuevo, lo que te permite «prellenar» su respuesta. De forma predeterminada, este valor es `True` cuando el último mensaje del chat de entrada tiene el rol `assistant` y `False` en caso contrario, pero puedes anular manualmente ese comportamiento estableciendo esta bandera.

prefix (`str`, *opcional*) : Prefijo añadido al prompt.

stop_sequence (`str` o `list[str]`, *opcional*) : Una o más cadenas que detienen la generación una vez que se han generado. La cadena de parada se incluye en la salida.

handle_long_generation (`str`, *opcional*) : Por defecto, este pipeline no maneja la generación larga (aquella que excede de alguna forma la longitud máxima del modelo). No existe una forma perfecta de abordar esto (más información :https://github.com/huggingface/transformers/issues/14033#issuecomment-948385227). Esto proporciona estrategias comunes para sortear ese problema según su caso de uso.  - `None` : estrategia predeterminada donde no ocurre nada en particular - `"hole"`: Trunca a la izquierda de la entrada y deja un hueco lo suficientemente amplio para permitir que ocurra la generación (podría truncar gran parte del prompt y no es adecuado cuando la generación excede la capacidad del modelo)

tokenizer_encode_kwargs (`dict`, *opcional*) : Argumentos de palabra clave adicionales para pasar a la etapa de codificación del tokenizador. Si la entrada de texto es un chat, se pasa a `apply_chat_template`. En caso contrario, se pasa a `__call__`.

generate_kwargs (`dict`, *opcional*) : Argumentos de palabra clave adicionales para pasar al método generate del modelo (véase el método generate [aquí](./text_generation)).

**Devuelve:** una lista o una lista de listas de `dict`

Devuelve uno de los siguientes diccionarios (no puede devolver una combinación de `generated_text` y `generated_token_ids`):

- **generated_text** (`str`, presente cuando `return_text=True`) -- El texto generado.
- **generated_token_ids** (`torch.Tensor`, presente cuando `return_tensors=True`) -- Los ids de los tokens del texto generado.

Complete los prompts dados como entradas.

### TokenClassificationPipeline[[transformers.TokenClassificationPipeline]]

#### transformers.TokenClassificationPipeline[[transformers.TokenClassificationPipeline]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/token_classification.py#L91)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel)): el modelo que se utilizará en el pipeline para realizar predicciones. Debe ser un modelo que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).

tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend)) : El tokenizador que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend).

task (`str`, por defecto `""`) : Un identificador de tarea para el pipeline.

num_workers (`int`, *opcional*, valor predeterminado: 8) : Cuando la pipeline utilizará *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el número de workers que se usarán.

batch_size (`int`, *opcional*, valor predeterminado 1) : Cuando la pipeline utilice *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del batch a utilizar; para inferencia, esto no siempre es beneficioso, por favor lea [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) .

args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/es/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.

device (`int` o `str` o `torch.device`, *opcional*) : Dispositivo en el que se asigna el pipeline. Si se deja sin establecer, el pipeline se coloca en el primer acelerador disponible (CUDA, MPS, XPU, ...) y solo recurre a la CPU si no hay ninguno disponible; el modelo se mueve allí automáticamente. Pasa `device="cpu"` (o `-1`) para forzar la CPU, un ordinal positivo o `"cuda:1"` para seleccionar un acelerador específico, o un `torch.device`/`str` nativo. Este argumento no puede combinarse con un modelo ya cargado mediante `accelerate` (es decir, uno con un `hf_device_map`).

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Precisión en la que se carga el modelo, se reenvía a `from_pretrained`. El valor predeterminado es `"auto"`, que carga el modelo en el dtype en el que se guardó (leído de `config.dtype` del checkpoint, o inferido de los pesos si no está disponible). Pasa un `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescribirlo.

binary_output (`bool`, *opcional*, valor predeterminado `False`) : Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida sin procesar, por ejemplo, texto.

ignore_labels (`list[str]`, por defecto `["O"]`) : Una lista de etiquetas para ignorar.

stride (`int`, *opcional*) : Si se proporciona stride, la pipeline se aplica a todo el texto. El texto se divide en fragmentos de tamaño model_max_length. Solo funciona con tokenizadores rápidos y con `aggregation_strategy` diferente de `NONE`. El valor de este argumento define el número de tokens superpuestos entre fragmentos. En otras palabras, el modelo avanzará `tokenizer.model_max_length - stride` tokens en cada paso.

aggregation_strategy (`str`, *opcional*, valor predeterminado `"none"`) : La estrategia para fusionar (o no) tokens basándose en la predicción del modelo.  - "none" : Simplemente no realizará ninguna agregación y devolverá los resultados crudos del modelo - "simple" : Intentará agrupar entidades siguiendo el esquema predeterminado. (A, B-TAG), (B, I-TAG), (C, I-TAG), (D, B-TAG2) (E, B-TAG2) terminarán siendo [{"word": ABC, "entity": "TAG"}, {"word": "D", "entity": "TAG2"}, {"word": "E", "entity": "TAG2"}] Observe que dos etiquetas B consecutivas terminarán siendo entidades diferentes. En idiomas basados en palabras, es posible que dividamos palabras de manera no deseada : Imagine que Microsoft se etiqueta como [{"word": "Micro", "entity": "ENTERPRISE"}, {"word": "soft", "entity": "NAME"}]. Busque FIRST, MAX, AVERAGE para formas de mitigar eso y desambiguar palabras (en idiomas que admitan ese significado, que básicamente son tokens separados por un espacio). Estas mitigaciones solo funcionarán con palabras reales, "New york" podría seguir etiquetado con dos entidades diferentes. - "first" : (funciona solo con modelos basados en palabras) Usará la estrategia `SIMPLE` excepto que las palabras no pueden terminar con etiquetas diferentes. Las palabras simplemente usarán la etiqueta del primer token de la palabra cuando haya ambigüedad. - "average" : (funciona solo con modelos basados en palabras) Usará la estrategia `SIMPLE` excepto que las palabras no pueden terminar con etiquetas diferentes. Las puntuaciones se promediarán primero entre los tokens y luego se aplicará la etiqueta máxima. - "max" : (funciona solo con modelos basados en palabras) Usará la estrategia `SIMPLE` excepto que las palabras no pueden terminar con etiquetas diferentes. La entidad de la palabra simplemente será el token con la puntuación máxima.

Pipeline de reconocimiento de entidades nombradas que utiliza cualquier `ModelForTokenClassification`. Consulte los [ejemplos de reconocimiento de entidades nombradas](../task_summary#named-entity-recognition) para obtener más información.

Ejemplo:

```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}]
```

Obtenga más información sobre los fundamentos del uso de un pipeline en el [tutorial de pipeline](../pipeline_tutorial)

Este pipeline de reconocimiento de tokens se puede cargar actualmente desde [pipeline()](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.pipeline) utilizando el siguiente identificador de tarea: `"ner"` (para predecir las clases de los tokens en una secuencia: persona, organización, ubicación o varios).

Los modelos que puede utilizar este pipeline son modelos que han sido afinados en una tarea de clasificación de tokens. Consulte la lista actualizada de modelos disponibles en [huggingface.co/models](https://huggingface.co/models?filter=token-classification).

#### __llamada__[[transformers.TokenClassificationPipeline.__call__]]

```python
__call__(inputs: str | list[str], **kwargs: Any)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/token_classification.py#L210)

**Parámetros:**

inputs (`str` o `List[str]`) : Uno o varios textos (o una lista de textos) para la clasificación de tokens. Pueden estar pretokenizados cuando `is_split_into_words=True`.

**Devuelve:** una lista o una lista de listas de `dict`

Cada resultado se presenta como una lista de diccionarios (uno por cada token de la entrada correspondiente, o por cada entidad si esta pipeline se instanció con un aggregation_strategy) con las siguientes claves:

- **word** (`str`) -- El token/palabra clasificada. Se obtiene decodificando los tokens seleccionados. Si desea obtener la cadena exacta en la oración original, use `start` y `end`.
- **score** (`float`) -- La probabilidad correspondiente para `entity`.
- **entity** (`str`) -- La entidad predicha para ese token/palabra (se denomina *entity_group* cuando *aggregation_strategy* no es `"none"`.
- **index** (`int`, solo presente cuando `aggregation_strategy="none"`) -- El índice del token correspondiente en la oración.
- **start** (`int`, *opcional*) -- El índice del inicio de la entidad correspondiente en la oración. Solo existe si los desplazamientos están disponibles en el tokenizador
- **end** (`int`, *opcional*) -- El índice del final de la entidad correspondiente en la oración. Solo existe si los desplazamientos están disponibles en el tokenizador

Clasifica cada token de los textos dados como entradas.

#### aggregate_words[[transformers.TokenClassificationPipeline.aggregate_words]]

```python
aggregate_words(entities: list[dict], aggregation_strategy: AggregationStrategy)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/token_classification.py#L522)

Sobrescribe los tokens de una palabra dada que no coincidan para forzar la coincidencia en los límites de la palabra.

Ejemplo: micro|soft| com|pany| B-ENT I-NAME I-ENT I-ENT se reescribirá con la primera estrategia 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)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/token_classification.py#L398)

Fusiona varios arrays de numpy en diccionarios con toda la información necesaria para la agregación

#### group_entities[[transformers.TokenClassificationPipeline.group_entities]]

```python
group_entities(entities: list[dict])
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/token_classification.py#L585)

**Parámetros:**

entities (`dict`) : Las entidades predichas por el pipeline.

Encuentra y agrupa los tokens adyacentes con la misma entidad predicha.

#### group_sub_entities[[transformers.TokenClassificationPipeline.group_sub_entities]]

```python
group_sub_entities(entities: list[dict])
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/token_classification.py#L550)

**Parámetros:**

entities (`dict`) : Las entidades predichas por el pipeline.

Agrupe los tokens adyacentes con la misma entidad predicha.

### ZeroShotClassificationPipeline[[transformers.ZeroShotClassificationPipeline]]

#### transformers.ZeroShotClassificationPipeline[[transformers.ZeroShotClassificationPipeline]]

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

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/zero_shot_classification.py#L44)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel)): el modelo que se utilizará en el pipeline para realizar predicciones. Debe ser un modelo que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).

tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend)) : El tokenizador que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend).

task (`str`, por defecto `""`) : Un identificador de tarea para el pipeline.

num_workers (`int`, *opcional*, valor predeterminado: 8) : Cuando la pipeline utilizará *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el número de workers que se usarán.

batch_size (`int`, *opcional*, valor predeterminado 1) : Cuando la pipeline utilice *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del batch a utilizar; para inferencia, esto no siempre es beneficioso, por favor lea [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) .

args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/es/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.

device (`int` o `str` o `torch.device`, *opcional*) : Dispositivo en el que se asigna el pipeline. Si se deja sin establecer, el pipeline se coloca en el primer acelerador disponible (CUDA, MPS, XPU, ...) y solo recurre a la CPU si no hay ninguno disponible; el modelo se mueve allí automáticamente. Pasa `device="cpu"` (o `-1`) para forzar la CPU, un ordinal positivo o `"cuda:1"` para seleccionar un acelerador específico, o un `torch.device`/`str` nativo. Este argumento no puede combinarse con un modelo ya cargado mediante `accelerate` (es decir, uno con un `hf_device_map`).

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Precisión en la que se carga el modelo, se reenvía a `from_pretrained`. El valor predeterminado es `"auto"`, que carga el modelo en el dtype en el que se guardó (leído de `config.dtype` del checkpoint, o inferido de los pesos si no está disponible). Pasa un `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescribirlo.

binary_output (`bool`, *opcional*, valor predeterminado `False`) : Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida sin procesar, por ejemplo, texto.

Pipeline de clasificación zero-shot basado en NLI que utiliza un `ModelForSequenceClassification` entrenado en tareas de NLI (inferencia de lenguaje natural). Equivalente a los pipelines de `text-classification`, pero estos modelos no requieren un número fijo de clases potenciales, ya que pueden elegirse en tiempo de ejecución. Generalmente, esto implica que es más lento, pero es **mucho** más flexible.

Se puede pasar cualquier combinación de secuencias y etiquetas, y cada combinación se presentará como un par premisa/hipótesis y se pasará al modelo preentrenado. A continuación, el logit de *entailment* se toma como el logit de que la etiqueta candidata sea válida. Se puede utilizar cualquier modelo NLI, pero el id de la etiqueta *entailment* debe estar incluido en :attr:*~transformers.PreTrainedConfig.label2id* de la configuración del modelo.

Ejemplo:

```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]}
```

Obtenga más información sobre los fundamentos del uso de un pipeline en el [tutorial de pipeline](../pipeline_tutorial)

Este pipeline de NLI se puede cargar actualmente desde [pipeline()](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.pipeline) utilizando el siguiente identificador de tarea: `"zero-shot-classification"`.

Los modelos que puede utilizar este pipeline son modelos que han sido afinados en una tarea de NLI. Consulte la lista actualizada de modelos disponibles en [huggingface.co/models](https://huggingface.co/models?search=nli).

#### __llamada__[[transformers.ZeroShotClassificationPipeline.__call__]]

```python
__call__(sequences: str | list[str], *args, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/zero_shot_classification.py#L159)

**Parámetros:**

sequences (`str` o `list[str]`) : La secuencia o secuencias a clasificar; se truncarán si la entrada del modelo es demasiado grande.

candidate_labels (`str` o `list[str]`) : El conjunto de etiquetas de clase posibles para clasificar cada secuencia. Puede ser una única etiqueta, una cadena de etiquetas separadas por comas o una lista de etiquetas.

hypothesis_template (`str`, *opcional*, valor predeterminado `"This example is {}."`) : La plantilla utilizada para convertir cada etiqueta en una hipótesis de estilo NLI. Esta plantilla debe incluir una sintaxis de {} o similar para insertar la etiqueta candidata en la plantilla. Por ejemplo, la plantilla predeterminada es `"This example is {}."` Con la etiqueta candidata `"sports"`, esto se enviaría al modelo como `"<cls> sequence to classify <sep> This example is sports . <sep>"`. La plantilla predeterminada funciona bien en muchos casos, pero puede ser útil experimentar con plantillas diferentes según la configuración de la tarea.

multi_label (`bool`, *opcional*, valor predeterminado `False`) : Indica si varias etiquetas candidatas pueden ser verdaderas. Si es `False`, las puntuaciones se normalizan de modo que la suma de las probabilidades de las etiquetas para cada secuencia sea 1. Si es `True`, las etiquetas se consideran independientes y las probabilidades se normalizan para cada candidato aplicando un softmax a la puntuación de implicación frente a la puntuación de contradicción.

**Devuelve:** un `dict` o una lista de `dict`

Cada resultado se presenta como un diccionario con las siguientes claves:

- **sequence** (`str`) -- La secuencia para la cual esta es la salida.
- **labels** (`list[str]`) -- Las etiquetas ordenadas por orden de probabilidad.
- **scores** (`list[float]`) -- Las probabilidades para cada una de las etiquetas.

Clasifica la(s) secuencia(s) dadas como entradas. Consulta la documentación de [ZeroShotClassificationPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.ZeroShotClassificationPipeline) para obtener más información.

## Multimodal

Los pipelines disponibles para tareas multimodales incluyen los siguientes.

### DocumentQuestionAnsweringPipeline[[transformers.DocumentQuestionAnsweringPipeline]]

#### transformers.DocumentQuestionAnsweringPipeline[[transformers.DocumentQuestionAnsweringPipeline]]

```python
transformers.DocumentQuestionAnsweringPipeline(*args, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/document_question_answering.py#L206)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel)): el modelo que se utilizará en el pipeline para realizar predicciones. Debe ser un modelo que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).

tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend)) : El tokenizador que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend).

image_processor ([BaseImageProcessor](/docs/transformers/v5.23.0/es/main_classes/image_processor#transformers.BaseImageProcessor)): el procesador de imágenes que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [BaseImageProcessor](/docs/transformers/v5.23.0/es/main_classes/image_processor#transformers.BaseImageProcessor).

task (`str`, por defecto `""`) : Un identificador de tarea para el pipeline.

num_workers (`int`, *opcional*, valor predeterminado: 8) : Cuando la pipeline utilizará *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el número de workers que se usarán.

batch_size (`int`, *opcional*, valor predeterminado 1) : Cuando la pipeline utilice *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del batch a utilizar; para inferencia, esto no siempre es beneficioso, por favor lea [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) .

args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/es/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.

device (`int` o `str` o `torch.device`, *opcional*) : Dispositivo en el que se asigna el pipeline. Si se deja sin establecer, el pipeline se coloca en el primer acelerador disponible (CUDA, MPS, XPU, ...) y solo recurre a la CPU si no hay ninguno disponible; el modelo se mueve allí automáticamente. Pasa `device="cpu"` (o `-1`) para forzar la CPU, un ordinal positivo o `"cuda:1"` para seleccionar un acelerador específico, o un `torch.device`/`str` nativo. Este argumento no puede combinarse con un modelo ya cargado mediante `accelerate` (es decir, uno con un `hf_device_map`).

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Precisión en la que se carga el modelo, se reenvía a `from_pretrained`. El valor predeterminado es `"auto"`, que carga el modelo en el dtype en el que se guardó (leído de `config.dtype` del checkpoint, o inferido de los pesos si no está disponible). Pasa un `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescribirlo.

binary_output (`bool`, *opcional*, valor predeterminado `False`) : Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida sin procesar, por ejemplo, texto.

Pipeline de Document Question Answering que utiliza cualquier `AutoModelForDocumentQuestionAnswering`. Las entradas/salidas son similares a las del pipeline de question answering (extractivo); sin embargo, este pipeline toma una imagen (y palabras/cajas OCR opcionales) como entrada en lugar de un contexto de texto.

A menos que el modelo que esté usando establezca explícitamente estos parámetros de generación en sus archivos de configuración (`generation_config.json`), se usarán los siguientes valores predeterminados:
- max_new_tokens: 256

Ejemplo:

```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}]
```

Obtenga más información sobre los fundamentos del uso de un pipeline en el [tutorial de pipeline](../pipeline_tutorial)

Este pipeline de respuesta a preguntas sobre documentos se puede cargar actualmente desde [pipeline()](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.pipeline) utilizando el siguiente identificador de tarea: `"document-question-answering"`.

Los modelos que puede utilizar este pipeline son modelos que han sido ajustados finamente en una tarea de respuesta a preguntas sobre documentos. Consulte la lista actualizada de modelos disponibles en [huggingface.co/models](https://huggingface.co/models?filter=document-question-answering).

#### __llamada__[[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)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/document_question_answering.py#L338)

**Parámetros:**

image (`str` o `PIL.Image`) : El pipeline maneja tres tipos de imágenes:  - Una cadena que contiene un enlace http que apunta a una imagen - Una cadena que contiene una ruta local a una imagen - Una imagen cargada directamente en PIL  El pipeline acepta una sola imagen o un lote de imágenes. Si se proporciona una sola imagen, se puede difundir a varias preguntas.

question (`str`) : Una pregunta que se le hará al documento.

word_boxes (`list[str, tuple[float, float, float, float]]`, *opcional*) : Una lista de palabras y cajas delimitadoras (normalizadas de 0 a 1000). Si proporciona esta entrada opcional, el pipeline utilizará estas palabras y cajas en lugar de ejecutar OCR en la imagen para derivarlas, en el caso de los modelos que las necesiten (p. ej., LayoutLM). Esto le permite reutilizar los resultados del OCR en muchas invocaciones del pipeline sin tener que volver a ejecutarlo cada vez.

top_k (`int`, *opcional*, valor predeterminado: 1) : El número de respuestas a devolver (se elegirán por orden de probabilidad). Tenga en cuenta que devolvemos menos de top_k respuestas si no hay suficientes opciones disponibles dentro del contexto.

doc_stride (`int`, *opcional*, valor predeterminado 128) : Si las palabras del documento son demasiado largas para caber junto con la pregunta para el modelo, se dividirá en varios fragmentos con cierto solapamiento. Este argumento controla el tamaño de dicho solapamiento.

max_answer_len (`int`, *opcional*, valor predeterminado 15) : La longitud máxima de las respuestas predichas (p. ej., solo se consideran las respuestas con una longitud menor).

max_seq_len (`int`, *opcional*, valor predeterminado 384) : La longitud máxima de la oración total (contexto + pregunta) en tokens de cada fragmento que se pasa al modelo. El contexto se dividirá en varios fragmentos (utilizando `doc_stride` como solapamiento) si es necesario.

max_question_len (`int`, *opcional*, valor predeterminado 64) : La longitud máxima de la pregunta después de la tokenización. Se truncará si es necesario.

handle_impossible_answer (`bool`, *opcional*, valor predeterminado `False`) : Indica si aceptamos "imposible" como respuesta.

lang (`str`, *opcional*) : Idioma a utilizar durante la ejecución de OCR. El valor predeterminado es english.

tesseract_config (`str`, *opcional*) : Banderas adicionales para pasar a tesseract durante la ejecución de OCR.

timeout (`float`, *opcional*, valor predeterminado None) : Tiempo máximo en segundos para esperar la obtención de imágenes de la web. Si es None, no se establece un tiempo de espera y la llamada puede bloquearse indefinidamente.

**Devuelve:** un `dict` o una lista de `dict`

Cada resultado se presenta como un diccionario con las siguientes claves:

- **score** (`float`) -- La probabilidad asociada a la respuesta.
- **start** (`int`) -- El índice de la palabra inicial de la respuesta (en la versión OCR de la entrada o en los `word_boxes` proporcionados).
- **end** (`int`) -- El índice de la palabra final de la respuesta (en la versión OCR de la entrada o en los `word_boxes` proporcionados).
- **answer** (`str`) -- La respuesta a la pregunta.
- **words** (`list[int]`) -- El índice de cada par palabra/caja que está en la respuesta

Responda la(s) pregunta(s) dadas como entradas utilizando el/los documento(s). Un documento se define como una imagen y una lista opcional de tuplas (palabra, caja) que representan el texto en el documento. Si no se proporcionan `word_boxes`, se utilizará el motor de OCR Tesseract (si está disponible) para extraer automáticamente las palabras y las cajas para los modelos tipo LayoutLM que las requieren como entrada. Para Donut, no se ejecuta OCR.

Puedes invocar el pipeline de varias formas:

- `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)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/feature_extraction.py#L15)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel)): el modelo que se utilizará en el pipeline para realizar predicciones. Debe ser un modelo que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).

tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend)) : El tokenizador que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend).

task (`str`, por defecto `""`) : Un identificador de tarea para el pipeline.

num_workers (`int`, *opcional*, valor predeterminado: 8) : Cuando la pipeline utilizará *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el número de workers que se usarán.

batch_size (`int`, *opcional*, valor predeterminado 1) : Cuando la pipeline utilice *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del batch a utilizar; para inferencia, esto no siempre es beneficioso, por favor lea [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) .

args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/es/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.

device (`int` o `str` o `torch.device`, *opcional*) : Dispositivo en el que se asigna el pipeline. Si se deja sin establecer, el pipeline se coloca en el primer acelerador disponible (CUDA, MPS, XPU, ...) y solo recurre a la CPU si no hay ninguno disponible; el modelo se mueve allí automáticamente. Pasa `device="cpu"` (o `-1`) para forzar la CPU, un ordinal positivo o `"cuda:1"` para seleccionar un acelerador específico, o un `torch.device`/`str` nativo. Este argumento no puede combinarse con un modelo ya cargado mediante `accelerate` (es decir, uno con un `hf_device_map`).

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Precisión en la que se carga el modelo, se reenvía a `from_pretrained`. El valor predeterminado es `"auto"`, que carga el modelo en el dtype en el que se guardó (leído de `config.dtype` del checkpoint, o inferido de los pesos si no está disponible). Pasa un `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescribirlo.

tokenize_kwargs (`dict`, *opcional*) : Diccionario adicional de argumentos por nombre que se pasa al tokenizador.

return_tensors (`bool`, *opcional*) : Si `True`, devuelve un tensor según el framework especificado; en caso contrario, devuelve una lista.

El pipeline de extracción de características no utiliza ninguna cabeza de modelo. Este pipeline extrae los estados ocultos del transformer base, que pueden utilizarse como características en tareas posteriores.

Ejemplo:

```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])
```

Obtenga más información sobre los fundamentos del uso de un pipeline en el [tutorial de pipeline](../pipeline_tutorial)

Este pipeline de extracción de características se puede cargar actualmente desde [pipeline()](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.pipeline) utilizando el identificador de tarea: `"feature-extraction"`.

Todos los modelos pueden utilizarse para este pipeline. Consulte la lista de todos los modelos, incluidos los contribuidos por la comunidad, en [huggingface.co/models](https://huggingface.co/models).

#### __llamada__[[transformers.FeatureExtractionPipeline.__call__]]

```python
__call__(*args: str | list[str], **kwargs: Any)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/feature_extraction.py#L78)

**Parámetros:**

args (`str` o `list[str]`) : Uno o varios textos (o una lista de textos) de los que se deben obtener las características.

**Devuelve:** una lista anidada de `float`

Las características calculadas por el modelo.

Extrae las características del texto 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)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/image_feature_extraction.py#L23)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel)): el modelo que se utilizará en el pipeline para realizar predicciones. Debe ser un modelo que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).

image_processor ([BaseImageProcessor](/docs/transformers/v5.23.0/es/main_classes/image_processor#transformers.BaseImageProcessor)): el procesador de imágenes que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [BaseImageProcessor](/docs/transformers/v5.23.0/es/main_classes/image_processor#transformers.BaseImageProcessor).

task (`str`, por defecto `""`) : Un identificador de tarea para el pipeline.

num_workers (`int`, *opcional*, valor predeterminado: 8) : Cuando la pipeline utilizará *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el número de workers que se usarán.

batch_size (`int`, *opcional*, valor predeterminado 1) : Cuando la pipeline utilice *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del batch a utilizar; para inferencia, esto no siempre es beneficioso, por favor lea [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) .

args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/es/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.

device (`int` o `str` o `torch.device`, *opcional*) : Dispositivo en el que se asigna el pipeline. Si se deja sin establecer, el pipeline se coloca en el primer acelerador disponible (CUDA, MPS, XPU, ...) y solo recurre a la CPU si no hay ninguno disponible; el modelo se mueve allí automáticamente. Pasa `device="cpu"` (o `-1`) para forzar la CPU, un ordinal positivo o `"cuda:1"` para seleccionar un acelerador específico, o un `torch.device`/`str` nativo. Este argumento no puede combinarse con un modelo ya cargado mediante `accelerate` (es decir, uno con un `hf_device_map`).

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Precisión en la que se carga el modelo, se reenvía a `from_pretrained`. El valor predeterminado es `"auto"`, que carga el modelo en el dtype en el que se guardó (leído de `config.dtype` del checkpoint, o inferido de los pesos si no está disponible). Pasa un `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescribirlo.

binary_output (`bool`, *opcional*, valor predeterminado `False`) : Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida sin procesar, por ejemplo, texto.

image_processor_kwargs (`dict`, *opcional*) : Diccionario adicional de argumentos por nombre que se pasa al procesador de imágenes, p. ej. {"size": {"height": 100, "width": 100}}

pool (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe devolver la salida agrupada. Si es `False`, el modelo devolverá los estados ocultos sin procesar.

El pipeline de extracción de características de imagen no utiliza ninguna cabeza de modelo. Este pipeline extrae los estados ocultos del transformer base, que pueden utilizarse como características en tareas posteriores.

Ejemplo:

```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])
```

Obtenga más información sobre los fundamentos del uso de un pipeline en el [tutorial de pipeline](../pipeline_tutorial)

Este pipeline de extracción de características de imágenes se puede cargar actualmente desde [pipeline()](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.pipeline) utilizando el identificador de tarea: `"image-feature-extraction"`.

Todos los modelos de visión pueden utilizarse en este pipeline. Consulte la lista de todos los modelos, incluidos los contribuidos por la comunidad, en [huggingface.co/models](https://huggingface.co/models).

#### __llamada__[[transformers.ImageFeatureExtractionPipeline.__call__]]

```python
__call__(*args: typing.Union[str, ForwardRef('Image.Image'), list['Image.Image'], list[str]], **kwargs: Any)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/image_feature_extraction.py#L94)

**Parámetros:**

images (`str`, `list[str]`, `PIL.Image` o `list[PIL.Image]`) : El pipeline maneja tres tipos de imágenes: - Una cadena de texto que contiene un enlace http que apunta a una imagen - Una cadena de texto que contiene una ruta local a una imagen - Una imagen cargada directamente en PIL  El pipeline acepta una sola imagen o un lote de imágenes, que en ese caso debe pasarse como una cadena de texto. Las imágenes de un lote deben estar todas en el mismo formato: todas como enlaces http, todas como rutas locales o todas como imágenes PIL.

timeout (`float`, *opcional*, valor predeterminado None) : Tiempo máximo en segundos para esperar la obtención de imágenes de la web. Si es None, no se usa tiempo de espera y la llamada puede bloquearse indefinidamente.

**Devuelve:** una lista anidada de `float`

Las características calculadas por el modelo.

Extrae las características de la(s) entrada(s).

### ImageTextToTextPipeline[[transformers.ImageTextToTextPipeline]]

#### transformers.ImageTextToTextPipeline[[transformers.ImageTextToTextPipeline]]

```python
transformers.ImageTextToTextPipeline(*args, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/image_text_to_text.py#L53)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel)): el modelo que se utilizará en el pipeline para realizar predicciones. Debe ser un modelo que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).

processor ([ProcessorMixin](/docs/transformers/v5.23.0/es/main_classes/processors#transformers.ProcessorMixin)) : El procesador que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [ProcessorMixin](/docs/transformers/v5.23.0/es/main_classes/processors#transformers.ProcessorMixin). Processor es un objeto compuesto que puede contener `tokenizer`, `feature_extractor` y `image_processor`.

task (`str`, por defecto `""`) : Un identificador de tarea para el pipeline.

num_workers (`int`, *opcional*, valor predeterminado: 8) : Cuando la pipeline utilizará *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el número de workers que se usarán.

batch_size (`int`, *opcional*, valor predeterminado 1) : Cuando la pipeline utilice *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del batch a utilizar; para inferencia, esto no siempre es beneficioso, por favor lea [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) .

args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/es/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.

device (`int` o `str` o `torch.device`, *opcional*) : Dispositivo en el que se asigna el pipeline. Si se deja sin establecer, el pipeline se coloca en el primer acelerador disponible (CUDA, MPS, XPU, ...) y solo recurre a la CPU si no hay ninguno disponible; el modelo se mueve allí automáticamente. Pasa `device="cpu"` (o `-1`) para forzar la CPU, un ordinal positivo o `"cuda:1"` para seleccionar un acelerador específico, o un `torch.device`/`str` nativo. Este argumento no puede combinarse con un modelo ya cargado mediante `accelerate` (es decir, uno con un `hf_device_map`).

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Precisión en la que se carga el modelo, se reenvía a `from_pretrained`. El valor predeterminado es `"auto"`, que carga el modelo en el dtype en el que se guardó (leído de `config.dtype` del checkpoint, o inferido de los pesos si no está disponible). Pasa un `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescribirlo.

binary_output (`bool`, *opcional*, valor predeterminado `False`) : Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida sin procesar, por ejemplo, texto.

Pipeline de imagen y texto a texto que utiliza un `AutoModelForImageTextToText`. Este pipeline genera texto a partir de una imagen y un texto. Cuando el modelo subyacente es un modelo conversacional, también puede aceptar uno o más chats, en cuyo caso el pipeline operará en modo de chat y continuará el o los chats añadiendo su(s) respuesta(s). Cada chat tiene la forma de una lista de dicts, donde cada dict contiene las claves "role" y "content".

A menos que el modelo que esté usando establezca explícitamente estos parámetros de generación en sus archivos de configuración (`generation_config.json`), se usarán los siguientes valores predeterminados:
- max_new_tokens: 256

Ejemplo:

```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'}]
```

Obtenga más información sobre los fundamentos del uso de un pipeline en el [tutorial de pipeline](../pipeline_tutorial)

Este pipeline de imagen y texto a texto se puede cargar actualmente desde pipeline() utilizando el siguiente identificador de tarea: "image-text-to-text".

Vea la lista de modelos disponibles en [huggingface.co/models](https://huggingface.co/models?pipeline_tag=image-text-to-text).

#### __llamada__[[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)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/image_text_to_text.py#L217)

**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]]]`) : El texto que se utilizará para la generación. Si se pasa una lista de cadenas, la longitud de la lista debe ser igual al número de imágenes. El texto también puede seguir el formato de chat: una lista de diccionarios donde cada diccionario representa un mensaje en una conversación. Cada diccionario debe tener dos claves: 'role' y 'content'. 'role' debe ser uno de 'user', 'system' o 'assistant'. 'content' debe ser una lista de diccionarios que contenga el texto del mensaje y el tipo de mensaje. El tipo de mensaje puede ser 'text' o 'image'. Si el tipo es 'image', no se necesita texto.

return_tensors (`bool`, *opcional*, valor predeterminado `False`) : Devuelve los tensores de predicciones (como índices de tokens) en las salidas. Si se establece en `True`, no se devuelve el texto decodificado.

return_text (`bool`, *opcional*) : Devuelve los textos decodificados en las salidas.

return_full_text (`bool`, *opcional*, valor predeterminado `True`) : Si se establece en `False`, solo se devuelve el texto añadido; en caso contrario, se devuelve el texto completo. No se puede especificar al mismo tiempo que `return_text`.

clean_up_tokenization_spaces (`bool`, *opcional*) : Indica si se deben limpiar los espacios adicionales potenciales en la salida de texto. El valor predeterminado es la configuración `clean_up_tokenization_spaces` del tokenizador.

continue_final_message( `bool`, *opcional*) : Indica que deseas que el modelo continúe el último mensaje del chat de entrada en lugar de iniciar uno nuevo, lo que te permite «prellenar» su respuesta. De forma predeterminada, este valor es `True` cuando el último mensaje del chat de entrada tiene el rol `assistant` y `False` en caso contrario, pero puedes anular manualmente ese comportamiento estableciendo esta bandera.

**Devuelve:** una lista o una lista de listas de `dict`

Cada resultado se devuelve como un diccionario con la siguiente clave (no se puede devolver una combinación de `generated_text` y `generated_token_ids`):

- **generated_text** (`str`, presente cuando `return_text=True`) -- El texto generado.
- **generated_token_ids** (`torch.Tensor`, presente cuando `return_tensors=True`) -- Los ids de los tokens del texto generado.
- **input_text** (`str`) -- El texto de entrada.

Genera un texto a partir del texto y las imágenes pasadas como entradas.

### AnyToAnyPipeline[[transformers.AnyToAnyPipeline]]

#### transformers.AnyToAnyPipeline[[transformers.AnyToAnyPipeline]]

```python
transformers.AnyToAnyPipeline(*args, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/any_to_any.py#L67)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel)): el modelo que se utilizará en el pipeline para realizar predicciones. Debe ser un modelo que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).

processor ([ProcessorMixin](/docs/transformers/v5.23.0/es/main_classes/processors#transformers.ProcessorMixin)) : El procesador que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [ProcessorMixin](/docs/transformers/v5.23.0/es/main_classes/processors#transformers.ProcessorMixin). Processor es un objeto compuesto que puede contener `tokenizer`, `feature_extractor` y `image_processor`.

task (`str`, por defecto `""`) : Un identificador de tarea para el pipeline.

num_workers (`int`, *opcional*, valor predeterminado: 8) : Cuando la pipeline utilizará *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el número de workers que se usarán.

batch_size (`int`, *opcional*, valor predeterminado 1) : Cuando la pipeline utilice *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del batch a utilizar; para inferencia, esto no siempre es beneficioso, por favor lea [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) .

args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/es/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.

device (`int` o `str` o `torch.device`, *opcional*) : Dispositivo en el que se asigna el pipeline. Si se deja sin establecer, el pipeline se coloca en el primer acelerador disponible (CUDA, MPS, XPU, ...) y solo recurre a la CPU si no hay ninguno disponible; el modelo se mueve allí automáticamente. Pasa `device="cpu"` (o `-1`) para forzar la CPU, un ordinal positivo o `"cuda:1"` para seleccionar un acelerador específico, o un `torch.device`/`str` nativo. Este argumento no puede combinarse con un modelo ya cargado mediante `accelerate` (es decir, uno con un `hf_device_map`).

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Precisión en la que se carga el modelo, se reenvía a `from_pretrained`. El valor predeterminado es `"auto"`, que carga el modelo en el dtype en el que se guardó (leído de `config.dtype` del checkpoint, o inferido de los pesos si no está disponible). Pasa un `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescribirlo.

binary_output (`bool`, *opcional*, valor predeterminado `False`) : Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida sin procesar, por ejemplo, texto.

Pipeline de generación multimodal que utiliza un `AutoModelForMultimodalLM`. Este pipeline genera texto a partir de cualquier combinación de datos multimodales y texto. Cuando el modelo subyacente es un modelo conversacional, también puede aceptar uno o más chats, en cuyo caso el pipeline operará en modo de chat y continuará el o los chats añadiendo su(s) respuesta(s). Cada chat tiene la forma de una lista de dicts, donde cada dict contiene las claves "role" y "content".

A menos que el modelo que esté usando establezca explícitamente estos parámetros de generación en sus archivos de configuración (`generation_config.json`), se usarán los siguientes valores predeterminados:
- max_new_tokens: 256

Ejemplo:

```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'}]
```

Obtenga más información sobre los fundamentos del uso de un pipeline en el [tutorial de pipeline](../pipeline_tutorial)

Este pipeline multimodal se puede cargar actualmente desde pipeline() utilizando el siguiente identificador de tarea: "any-to-any".

Vea la lista de modelos disponibles en [huggingface.co/models](https://huggingface.co/models?pipeline_tag=any-to-any).

#### __llamada__[[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)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/any_to_any.py#L258)

**Parámetros:**

text (`str`, `list[str]`, `list[dict]`) : El texto que se utilizará para la generación. Si se pasa una lista de cadenas, la longitud de la lista debe ser igual al número de imágenes. El texto también puede seguir el formato de chat: una lista de diccionarios donde cada diccionario representa un mensaje en una conversación. Cada diccionario debe tener dos claves: 'role' y 'content'. 'role' debe ser uno de 'user', 'system' o 'assistant'. 'content' debe ser una lista de diccionarios que contenga el texto del mensaje y el tipo del mensaje.

images (`str`, `list[str]`, `ImageInput`) : El pipeline maneja tres tipos de imágenes: - Una cadena que contiene un enlace HTTP(s) que apunta a una imagen - Una cadena que contiene una ruta local a una imagen - Una imagen cargada directamente en PIL  El pipeline acepta una sola imagen o un lote de imágenes. Por último, este pipeline también admite el formato de chat (ver `text`) que contiene imágenes y texto en este argumento.

videos (`str`, `list[str]`, `VideoInput`) : El pipeline maneja tres tipos de vídeos:  - Una cadena que contiene un enlace HTTP(s) que apunta a un vídeo - Una cadena que contiene una ruta local a un vídeo - Un vídeo cargado y decodificado a formato de matriz  El pipeline acepta un solo vídeo o un lote de vídeos. Por último, este pipeline también admite el formato de chat (ver `text`) que contiene vídeos y texto en este argumento.

audio (`str`, `list[str]`, `AudioInput`) : El pipeline maneja tres tipos de audios:  - Una cadena que contiene un enlace HTTP(s) que apunta a un audio - Una cadena que contiene una ruta local a un audio - Un audio cargado directamente en PIL  El pipeline acepta un solo audio o un lote de audios. Por último, este pipeline también admite el formato de chat (ver `text`) que contiene audios y texto en este argumento.

return_tensors (`bool`, *opcional*, valor predeterminado `False`) : Devuelve los tensores de predicciones (como índices de tokens) en las salidas. Si se establece en `True`, no se devuelve el texto decodificado.

return_text (`bool`, *opcional*) : Devuelve los textos decodificados en las salidas.

return_full_text (`bool`, *opcional*, valor predeterminado `True`) : Si se establece en `False`, solo se devuelve el texto añadido; en caso contrario, se devuelve el texto completo. No se puede especificar al mismo tiempo que `return_text`.

clean_up_tokenization_spaces (`bool`, *opcional*) : Indica si se deben limpiar los espacios adicionales potenciales en la salida de texto. El valor predeterminado es la configuración `clean_up_tokenization_spaces` del tokenizador.

continue_final_message( `bool`, *opcional*) : Indica que deseas que el modelo continúe el último mensaje del chat de entrada en lugar de iniciar uno nuevo, lo que te permite «prellenar» su respuesta. De forma predeterminada, este valor es `True` cuando el último mensaje del chat de entrada tiene el rol `assistant` y `False` en caso contrario, pero puedes anular manualmente ese comportamiento estableciendo esta bandera.

**Devuelve:** una lista o una lista de listas de `dict`

Cada resultado se devuelve como un diccionario con la siguiente clave (no se puede devolver una combinación de `generated_text` y `generated_token_ids`):

- **generated_text** (`str`, presente cuando `return_text=True` y `generation_mode="text"`) -- El texto generado.
- **generated_audio** (`np.ndarray`, presente cuando `generation_mode="audio"`) -- El audio generado.
- **generated_image** (`PIL.Image.Image`, presente cuando `generation_mode="image"`) -- La imagen generada.
- **generated_token_ids** (`torch.Tensor`, presente cuando `return_tensors=True` y `generation_mode="text"`) -- Los ids de los tokens del texto generado.
- **input_text** (`str`) -- El texto de entrada.

Genera un texto a partir de un texto y, opcionalmente, de datos multimodales pasados como entradas.

### MaskGenerationPipeline[[transformers.MaskGenerationPipeline]]

#### transformers.MaskGenerationPipeline[[transformers.MaskGenerationPipeline]]

```python
transformers.MaskGenerationPipeline(**kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/mask_generation.py#L36)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel)): el modelo que se utilizará en el pipeline para realizar predicciones. Debe ser un modelo que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).

image_processor ([BaseImageProcessor](/docs/transformers/v5.23.0/es/main_classes/image_processor#transformers.BaseImageProcessor)): el procesador de imágenes que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [BaseImageProcessor](/docs/transformers/v5.23.0/es/main_classes/image_processor#transformers.BaseImageProcessor).

task (`str`, por defecto `""`) : Un identificador de tarea para el pipeline.

num_workers (`int`, *opcional*, valor predeterminado: 8) : Cuando la pipeline utilizará *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el número de workers que se usarán.

batch_size (`int`, *opcional*, valor predeterminado 1) : Cuando la pipeline utilice *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del batch a utilizar; para inferencia, esto no siempre es beneficioso, por favor lea [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) .

args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/es/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.

device (`int` o `str` o `torch.device`, *opcional*) : Dispositivo en el que se asigna el pipeline. Si se deja sin establecer, el pipeline se coloca en el primer acelerador disponible (CUDA, MPS, XPU, ...) y solo recurre a la CPU si no hay ninguno disponible; el modelo se mueve allí automáticamente. Pasa `device="cpu"` (o `-1`) para forzar la CPU, un ordinal positivo o `"cuda:1"` para seleccionar un acelerador específico, o un `torch.device`/`str` nativo. Este argumento no puede combinarse con un modelo ya cargado mediante `accelerate` (es decir, uno con un `hf_device_map`).

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Precisión en la que se carga el modelo, se reenvía a `from_pretrained`. El valor predeterminado es `"auto"`, que carga el modelo en el dtype en el que se guardó (leído de `config.dtype` del checkpoint, o inferido de los pesos si no está disponible). Pasa un `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescribirlo.

binary_output (`bool`, *opcional*, valor predeterminado `False`) : Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida sin procesar, por ejemplo, texto.

points_per_batch (*opcional*, int, valor predeterminado 64): Establece el número de puntos que el modelo ejecuta simultáneamente. Números más altos pueden ser más rápidos, pero consumen más memoria de GPU.

output_bboxes_mask (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben o no generar las predicciones de las cajas delimitadoras.

output_rle_masks (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben o no generar las máscaras en formato `RLE`

Generación automática de máscaras para imágenes mediante `SamForMaskGeneration`. Este pipeline predice máscaras binarias para una imagen, a partir de una imagen. Es un `ChunkPipeline` porque se pueden separar los puntos en un mini-lote para evitar problemas de OOM. Utilice el argumento `points_per_batch` para controlar el número de puntos que se procesarán simultáneamente. El valor predeterminado es `64`.

El pipeline funciona en 3 pasos:
1. `preprocess`: Se genera una cuadrícula de 1024 puntos separados uniformemente, junto con cajas delimitadoras y etiquetas de puntos. Para más detalles sobre cómo se crean los puntos y las cajas delimitadoras, consulte la función `_generate_crop_boxes`. La imagen también se preprocesa mediante `image_processor`. Esta función `yields` un minibatch de `points_per_batch`.

2. `forward`: alimenta las salidas de `preprocess` al modelo. El embedding de la imagen se calcula solo una vez. Llama a `self.model.get_image_embeddings` y se asegura de que no se calculen los gradientes, y de que los tensores y los modelos estén en el mismo dispositivo.

3. `postprocess`: Aquí ocurre la parte más importante de la generación automática de máscaras. Se inducen tres pasos:
   - image_processor.postprocess_masks (se ejecuta en cada iteración del bucle de minibatch): recibe las máscaras de salida crudas, las redimensiona según el tamaño de la imagen y las convierte en máscaras binarias.
   - image_processor.filter_masks (en cada iteración del minibatch): utiliza tanto `pred_iou_thresh` como `stability_scores`. También aplica una variedad de filtros basados en la supresión de máximos no máximos para eliminar máscaras de baja calidad.
   - image_processor.postprocess_masks_for_amg aplica el NSM a la máscara para conservar solo las relevantes.

Ejemplo:

```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
... )
```

Obtenga más información sobre los fundamentos del uso de un pipeline en el [tutorial de pipeline](../pipeline_tutorial)

Este pipeline de segmentación se puede cargar actualmente desde [pipeline()](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.pipeline) utilizando el siguiente identificador de tarea: `"mask-generation"`.

Vea la lista de modelos disponibles en [huggingface.co/models](https://huggingface.co/models?filter=mask-generation).

#### __llamada__[[transformers.MaskGenerationPipeline.__call__]]

```python
__call__(image: typing.Union[str, ForwardRef('Image.Image'), list[str], list['Image.Image']], *args: Any, **kwargs: Any)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/mask_generation.py#L143)

**Parámetros:**

image (`str`, `List[str]`, `PIL.Image` o `List[PIL.Image]`) : Imagen o lista de imágenes.

mask_threshold (`float`, *opcional*, valor predeterminado 0.0) : Umbral a utilizar al convertir las máscaras predichas en valores binarios.

pred_iou_thresh (`float`, *opcional*, valor predeterminado 0.88) : Umbral de filtrado en `[0,1]` aplicado a la calidad de la máscara predicha por el modelo.

stability_score_thresh (`float`, *opcional*, valor predeterminado 0.95) : Umbral de filtrado en `[0,1]`, que utiliza la estabilidad de la máscara ante cambios en el corte utilizado para binarizar las predicciones de máscara del modelo.

stability_score_offset (`int`, *opcional*, valor predeterminado: 1) : La cantidad a desplazar el punto de corte al calcular la puntuación de estabilidad.

crops_nms_thresh (`float`, *opcional*, valor predeterminado 0.7) : Umbral de IoU de caja utilizado por la supresión no máxima para filtrar máscaras duplicadas.

crops_n_layers (`int`, *opcional*, valor predeterminado 0) : Si `crops_n_layers>0`, la predicción de la máscara se ejecutará de nuevo en recortes de la imagen. Establece el número de capas a ejecutar, donde cada capa tiene 2**i_layer recortes de imagen.

crop_overlap_ratio (`float`, *opcional*, valor predeterminado `512 / 1500`) : Establece el grado de solapamiento de los recortes. En la primera capa de recortes, estos se solapan en la proporción indicada de la longitud de la imagen. Las capas posteriores, con más recortes, reducen este solapamiento.

crop_n_points_downscale_factor (`int`, *opcional*, valor predeterminado `1`) : El número de puntos por lado muestreados en la capa n se reduce mediante crop_n_points_downscale_factor**n.

timeout (`float`, *opcional*, valor predeterminado None) : Tiempo máximo en segundos para esperar la obtención de imágenes de la web. Si es None, no se establece un tiempo de espera y la llamada puede bloquearse indefinidamente.

**Devuelve:** `Dict`

Un diccionario con las siguientes claves:
- **mask** (`PIL.Image`) -- Una máscara binaria del objeto detectado como una imagen PIL de forma `(width, height)` de la imagen original. Devuelve una máscara rellena con ceros si no se encuentra ningún objeto.
- **score** (*opcional* `float`) -- Opcionalmente, cuando el modelo es capaz de estimar la confianza del "object" descrito por la etiqueta y la máscara.

Genera máscaras de segmentación binaria

## Clase padre: `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)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/base.py#L763)

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel)): el modelo que se utilizará en el pipeline para realizar predicciones. Debe ser un modelo que herede de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).

tokenizer ([PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend)) : El tokenizador que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [PreTrainedTokenizer](/docs/transformers/v5.23.0/es/main_classes/tokenizer#transformers.PythonBackend).

feature_extractor ([SequenceFeatureExtractor](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.SequenceFeatureExtractor)) : El extractor de características que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [SequenceFeatureExtractor](/docs/transformers/v5.23.0/es/main_classes/feature_extractor#transformers.SequenceFeatureExtractor).

image_processor ([BaseImageProcessor](/docs/transformers/v5.23.0/es/main_classes/image_processor#transformers.BaseImageProcessor)): el procesador de imágenes que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [BaseImageProcessor](/docs/transformers/v5.23.0/es/main_classes/image_processor#transformers.BaseImageProcessor).

processor ([ProcessorMixin](/docs/transformers/v5.23.0/es/main_classes/processors#transformers.ProcessorMixin)) : El procesador que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de [ProcessorMixin](/docs/transformers/v5.23.0/es/main_classes/processors#transformers.ProcessorMixin). Processor es un objeto compuesto que puede contener `tokenizer`, `feature_extractor` y `image_processor`.

task (`str`, por defecto `""`) : Un identificador de tarea para el pipeline.

num_workers (`int`, *opcional*, valor predeterminado: 8) : Cuando la pipeline utilizará *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el número de workers que se usarán.

batch_size (`int`, *opcional*, valor predeterminado 1) : Cuando la pipeline utilice *DataLoader* (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del batch a utilizar; para inferencia, esto no siempre es beneficioso, por favor lea [Batching with pipelines](https://huggingface.co/transformers/main_classes/pipelines.html#pipeline-batching) .

args_parser ([ArgumentHandler](/docs/transformers/v5.23.0/es/internal/pipelines_utils#transformers.pipelines.ArgumentHandler), *opcional*) : Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.

device (`int` o `str` o `torch.device`, *opcional*) : Dispositivo en el que se asigna el pipeline. Si se deja sin establecer, el pipeline se coloca en el primer acelerador disponible (CUDA, MPS, XPU, ...) y solo recurre a la CPU si no hay ninguno disponible; el modelo se mueve allí automáticamente. Pasa `device="cpu"` (o `-1`) para forzar la CPU, un ordinal positivo o `"cuda:1"` para seleccionar un acelerador específico, o un `torch.device`/`str` nativo. Este argumento no puede combinarse con un modelo ya cargado mediante `accelerate` (es decir, uno con un `hf_device_map`).

dtype (`str` o `torch.dtype`, *opcional*, valor predeterminado `"auto"`) : Precisión en la que se carga el modelo, se reenvía a `from_pretrained`. El valor predeterminado es `"auto"`, que carga el modelo en el dtype en el que se guardó (leído de `config.dtype` del checkpoint, o inferido de los pesos si no está disponible). Pasa un `torch.float16`, `torch.bfloat16`, `torch.float32`, ... explícito para sobrescribirlo.

binary_output (`bool`, *opcional*, valor predeterminado `False`) : Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida sin procesar, por ejemplo, texto.

La clase Pipeline es la clase de la que heredan todas las pipelines. Consulte esta clase para conocer los métodos compartidos entre las distintas pipelines.

Clase base que implementa operaciones en pipeline. El flujo de trabajo del pipeline se define como una secuencia de las siguientes operaciones:

Entrada -> Tokenización -> Inferencia del modelo -> Post-procesamiento (dependiente de la tarea) -> Salida

Pipeline permite ejecutarse en CPU o GPU a través del argumento device (ver más abajo).

Algunos pipelines, como por ejemplo [FeatureExtractionPipeline](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.FeatureExtractionPipeline) (`'feature-extraction'`), devuelven objetos de tensor grandes como listas anidadas. Para evitar volcar dicha estructura tan grande como datos de texto, proporcionamos el argumento del constructor `binary_output`. Si se establece en `True`, la salida se almacenará en formato pickle.

#### check_model_type[[transformers.Pipeline.check_model_type]]

```python
check_model_type(supported_models: list[str] | dict)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/base.py#L1126)

**Parámetros:**

supported_models (`list[str]` o `dict`) : La lista de modelos admitidos por el pipeline, o un diccionario con valores de clases de modelo.

Comprueba si la clase del modelo está soportada por la pipeline.

#### device_placement[[transformers.Pipeline.device_placement]]

```python
device_placement()
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/base.py#L1012)

**Devuelve:**

Gestor de contexto

Context Manager que permite la asignación de tensores en el dispositivo especificado por el usuario.

Ejemplos:

```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)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/base.py#L1094)

**Parámetros:**

inputs (argumentos por nombre que deben ser `torch.Tensor`, el resto se ignora) : Los tensores que se colocarán en `self.device`.

Recursivo en listas **solo**. --

**Devuelve:** `dict[str, torch.Tensor]`

Lo mismo que `inputs` pero en el dispositivo adecuado.

Asegúrate de que los tensores de PyTorch estén en el dispositivo especificado.

#### postprocess[[transformers.Pipeline.postprocess]]

```python
postprocess(model_outputs: ModelOutput, **postprocess_parameters: dict)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/base.py#L1193)

Postprocess recibirá las salidas crudas del método `_forward`, generalmente tensores, y las reformateará en un formato más manejable. Por lo general, producirá una lista o un diccionario de resultados (que contienen solo cadenas de texto y números).

#### predict[[transformers.Pipeline.predict]]

```python
predict(X)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/base.py#L991)

Interfaz de Scikit / Keras para las pipelines de transformers. Este método reenviará a __call__().

#### preprocess[[transformers.Pipeline.preprocess]]

```python
preprocess(input_: Any, **preprocess_parameters: dict)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/base.py#L1172)

Preprocess tomará el `input_` de un pipeline específico y devolverá un diccionario con todo lo necesario para que `_forward` se ejecute correctamente. Debe contener al menos un tensor, pero puede tener otros elementos arbitrarios.

#### 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)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/utils/hub.py#L822)

**Parámetros:**

repo_id (`str`) : El nombre del repositorio al que deseas enviar tu pipe. Debe incluir el nombre de tu organización cuando se envía a una organización determinada.

commit_message (`str`, *opcional*) : Mensaje a confirmar al hacer push. El valor predeterminado es `"Upload pipe"`.

commit_description (`str`, *opcional*) : La descripción del commit que se creará

private (`bool`, *opcional*) : Si se debe hacer el repositorio privado. Si es `None` (valor predeterminado), el repositorio será público a menos que el valor predeterminado de la organización sea privado. Este valor se ignora si el repositorio ya existe.

token (`bool` o `str`, *opcional*) : El token que se usará como autorización HTTP bearer para archivos remotos. Si es `True` (valor predeterminado), se usará el token generado al ejecutar `hf auth login` (guardado en `~/.huggingface`).

revision (`str`, *opcional*) : Rama a la que se enviarán los archivos subidos.

create_pr (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe crear una PR con los archivos subidos o realizar el commit directamente.

max_shard_size (`int` o `str`, *opcional*, valor predeterminado `"50GB"`) : Solo aplicable a modelos. El tamaño máximo de un checkpoint antes de que se divida en fragmentos. Los fragmentos del checkpoint tendrán cada uno un tamaño inferior a este valor. Si se expresa como una cadena, debe consistir en dígitos seguidos de una unidad (como `"5MB"`).

tags (`list[str]`, *opcional*) : Lista de etiquetas para publicar en el Hub.

Sube el archivo de pipeline al 🤗 Model Hub.

Ejemplos:

```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)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/base.py#L939)

**Parámetros:**

save_directory (`str` o `os.PathLike`) : Ruta al directorio donde se guardará. Se creará si no existe.

kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palabra clave adicionales que se pasan al método [push_to_hub()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

Guarde el modelo y el tokenizador de la pipeline.

#### transform[[transformers.Pipeline.transform]]

```python
transform(X)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/pipelines/base.py#L985)

Interfaz de Scikit / Keras para las pipelines de transformers. Este método reenviará a __call__().

