Transformers documentation
Pipelines
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, incluyendo 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. Consulta la lista de tareas para ver ejemplos de uso.
Hay dos categorías de abstracciones de pipeline de las que conviene estar al tanto:
- El pipeline(), que es el objeto más potente y encapsula todos los demás pipelines.
- Hay pipelines específicos para tareas disponibles para audio, visión por computadora, procesamiento de lenguaje natural y tareas multimodales.
La abstracción de 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:
>>> pipe = pipeline("text-classification")
>>> pipe("This restaurant is awesome")
[{'label': 'POSITIVE', 'score': 0.9998743534088135}]Si deseas usar un modelo específico del hub, puedes ignorar la tarea si el modelo del hub ya la define:
>>> 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.
>>> 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 es necesario realizar el agrupamiento (batching) manualmente. Esto debería funcionar igual de rápido que los bucles personalizados en GPU. Si no es así, no dude en crear un problema (issue).
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:
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
< source >( task: str | None = Nonemodel: str | PreTrainedModel | None = Noneconfig: str | PreTrainedConfig | None = Nonetokenizer: str | PreTrainedTokenizer | PreTrainedTokenizerFast | None = Nonefeature_extractor: str | FeatureExtractionMixin | None = Noneimage_processor: str | BaseImageProcessor | None = Nonevideo_processor: str | BaseVideoProcessor | None = Noneprocessor: str | ProcessorMixin | None = Nonerevision: str | None = Noneuse_fast: bool = Truetoken: str | bool | None = Nonedevice: int | str | torch.device | None = Nonedevice_map: str | dict[str, int | str] | None = Nonedtype: str | torch.dtype | None = 'auto'trust_remote_code: bool | None = Nonemodel_kwargs: dict[str, Any] | None = Nonepipeline_class: Any | None = None**kwargs: Any ) → Pipeline
Parámetros
- task (
str) — La tarea que define qué pipeline se devolverá. Las tareas aceptadas actualmente son:"audio-classification": devolverá un AudioClassificationPipeline."automatic-speech-recognition": devolverá un AutomaticSpeechRecognitionPipeline."depth-estimation": devolverá un DepthEstimationPipeline."document-question-answering": devolverá un DocumentQuestionAnsweringPipeline."feature-extraction": devolverá un FeatureExtractionPipeline."fill-mask": devolverá un FillMaskPipeline:."image-classification": devolverá un ImageClassificationPipeline."image-feature-extraction": devolverá un ImageFeatureExtractionPipeline."image-segmentation": devolverá un ImageSegmentationPipeline."image-text-to-text": devolverá un ImageTextToTextPipeline."keypoint-matching": devolverá un KeypointMatchingPipeline."mask-generation": devolverá una MaskGenerationPipeline."object-detection": devolverá un ObjectDetectionPipeline."table-question-answering": devolverá un TableQuestionAnsweringPipeline."text-classification"(alias"sentiment-analysis"disponible): devolverá un TextClassificationPipeline."text-generation": devolverá un TextGenerationPipeline:."text-to-audio"(alias"text-to-speech"disponible): devolverá un TextToAudioPipeline:."token-classification"(alias"ner"disponible): devolverá un TokenClassificationPipeline."video-classification": devolverá un VideoClassificationPipeline."zero-shot-classification": devolverá un ZeroShotClassificationPipeline."zero-shot-image-classification": devolverá un ZeroShotImageClassificationPipeline."zero-shot-audio-classification": devolverá un ZeroShotAudioClassificationPipeline."zero-shot-object-detection": devolverá un ZeroShotObjectDetectionPipeline.
- model (
stro 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.Si no se proporciona, se cargará el valor predeterminado para
task. - config (
stro PreTrainedConfig, opcional) — La configuración que se utilizará para instanciar el modelo en el pipeline. Puede ser un identificador de modelo o una configuración de modelo preentrenado que herede de PreTrainedConfig.Si no se proporciona, se utilizará el archivo de configuración predeterminado del modelo solicitado. Esto significa que si se indica
model, se usará su configuración predeterminada. Sin embargo, si no se suministramodel, se utilizará en su lugar la configuración del modelo predeterminado de estatask. - tokenizer (
stro PreTrainedTokenizer, opcional) — El tokenizer que se utilizará en el pipeline para codificar los datos para el modelo. Puede ser un identificador de modelo o un tokenizer preentrenado que herede de PreTrainedTokenizer.Si no se proporciona, se cargará el tokenizador predeterminado para el
modeldado (si es una cadena). Simodelno se especifica o no es una cadena, se cargará el tokenizador predeterminado paraconfig(si es una cadena). Sin embargo, siconfigtampoco se proporciona o no es una cadena, se cargará el tokenizador predeterminado para lataskdada. - feature_extractor (
stro 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.Los extractores de características se utilizan para modelos que no son de PLN, como modelos de voz o de 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
modeldado (si es una cadena). Simodelno se especifica o no es una cadena, se cargará el extractor de características predeterminado paraconfig(si es una cadena). Sin embargo, siconfigtampoco se proporciona o no es una cadena, se cargará el extractor de características predeterminado para lataskdada. - image_processor (
stro 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. Los procesadores de imágenes se utilizan para modelos de visión y modelos multimodales que requieren entradas de imagen. Los modelos multimodales también requerirán que se pase un tokenizador. Si no se proporciona, se cargará el procesador de imágenes predeterminado para el modelo dado (si es una cadena). Si el modelo no se especifica o no es una cadena, se cargará el procesador de imágenes predeterminado para config (si es una cadena)..Los procesadores de imágenes se utilizan para 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
modeldado (si es una cadena). Simodelno se especifica o no es una cadena, se cargará el procesador de imágenes predeterminado paraconfig(si es una cadena). - processor (
stro ProcessorMixin, opcional) — El procesador que se utilizará en la pipeline para preprocesar los datos para el modelo. Puede ser un identificador de modelo o un procesador real que herede de 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 modelo 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)..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
modeldado (si es una cadena). Simodelno se especifica o no es una cadena, se cargará el procesador predeterminado paraconfig(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 va a 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 querevisionpuede ser cualquier identificador permitido por git. - use_fast (
bool, opcional, valor predeterminadoTrue) — Si se debe utilizar un tokenizador Fast si es posible (un PreTrainedTokenizerFast). - token (
stro bool, opcional) — El token que se usará como autorización HTTP bearer para los archivos remotos. Si esTrue, se utilizará el token generado al ejecutarhf auth login. - device (
intostrotorch.device, opcional) — Define el dispositivo (p. ej.,"cpu","cuda:1","mps"o un rango ordinal de GPU como1) 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 ahí por ti. Pasadevice="cpu"(o-1) para forzar la CPU. No se puede usar junto condevice_map. - device_map (
strodict[str, Union[int, str, torch.device], opcional) — Se envía directamente comomodel_kwargs(solo un atajo más simple). Cuando la libreríaaccelerateestá presente, establecedevice_map="auto"para calcular eldevice_mapmás optimizado automáticamente (ver aquí para obtener más información).No utilice
device_mapydeviceal mismo tiempo, ya que entrarán en conflicto. - dtype (
strotorch.dtype, opcional, valor predeterminado"auto") — Precisión en la que se carga el modelo, se reenvía afrom_pretrained. El valor predeterminado es"auto", que carga el modelo en el dtype en el que se guardó. Pase untorch.float16,torch.bfloat16,torch.float32explícito, … para sobrescribirlo. - trust_remote_code (
bool, opcional, valor predeterminadoFalse) — Indica si se permite el uso de código personalizado definido en el Hub en sus propios archivos de modelado, configuración, tokenización o incluso pipeline. Esta opción solo debe establecerse enTruepara repositorios de confianza y 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 de palabra clave que se pasan a la funciónfrom_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 los valores posibles).
Devuelve
Un pipeline adecuado para la tarea.
Método de fábrica de utilidad para construir un Pipeline.
Un pipeline consiste en:
- Uno o más componentes para el preprocesamiento de las entradas del modelo, como un tokenizer, image_processor, feature_extractor o processor.
- Un modelo que genera predicciones a partir de las entradas.
- Pasos opcionales de posprocesamiento para refinar la salida del modelo, que también pueden ser gestionados por los procesadores.
While there are such optional arguments as `tokenizer`, `feature_extractor`, `image_processor`, and `processor`, they shouldn't be specified all at once. If these components are not provided, `pipeline` will try to load required ones automatically. In case you want to provide these components explicitly, please refer to a specific pipeline in order to get more details regarding what components are required.
Ejemplos:
>>> 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 tuberías pueden usar lotes. Esto funcionará siempre que la tubería utilice su capacidad de transmisión (es decir, al pasar listas o Dataset o generator).
from transformers import pipeline
from transformers.pipelines.pt_utils import KeyDataset
import datasets
dataset = datasets.load_dataset("stanfordnlp/imdb", name="plain_text", split="unsupervised")
pipe = pipeline("text-classification", device=0)
for out in pipe(KeyDataset(dataset, "text"), batch_size=8, truncation="only_first"):
print(out)
# [{'label': 'POSITIVE', 'score': 0.9998743534088135}]
# Exactly the same output as before, but the content are passed
# as batches to the modelSin 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 donde se trata principalmente de una aceleración:
from transformers import pipeline
from torch.utils.data import Dataset
from tqdm.auto import tqdm
pipe = pipeline("text-classification", device=0)
class MyDataset(Dataset):
def __len__(self):
return 5000
def __getitem__(self, i):
return "This is a test"
dataset = MyDataset()
for batch_size in [1, 8, 64, 256]:
print("-" * 30)
print(f"Streaming batch_size={batch_size}")
for out in tqdm(pipe(dataset, batch_size=batch_size), total=len(dataset)):
pass# On GTX 970 ------------------------------ Streaming no batching 100%|██████████████████████████████████████████████████████████████████████| 5000/5000 [00:26<00:00, 187.52it/s] ------------------------------ Streaming batch_size=8 100%|█████████████████████████████████████████████████████████████████████| 5000/5000 [00:04<00:00, 1205.95it/s] ------------------------------ Streaming batch_size=64 100%|█████████████████████████████████████████████████████████████████████| 5000/5000 [00:02<00:00, 2478.24it/s] ------------------------------ Streaming batch_size=256 100%|█████████████████████████████████████████████████████████████████████| 5000/5000 [00:01<00:00, 2554.43it/s] (diminishing returns, saturated the GPU)
Ejemplo donde se produce principalmente una ralentización:
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" * nEsta 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 detiene.
------------------------------
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 números reales son la única forma de avanzar.
Si tienes restricciones de latencia (un producto en vivo que realiza inferencia), no uses 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 del tamaño de sequence_length (datos “naturales”), por defecto no hagas lotes, mide y prueba tentativamente a añadirlo, y añade comprobaciones de OOM para recuperarte cuando falle (y fallará en algún punto 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 de 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 un Pipeline regular. En resumen:
preprocessed = pipe.preprocess(inputs) model_outputs = pipe.forward(preprocessed) outputs = pipe.postprocess(model_outputs)
Ahora se convierte en:
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 los pipelines se utilizan de la misma manera.
Esta es una vista simplificada, ya que el pipeline puede gestionar automáticamente el lote para ti. Esto significa que 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
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
Audio
Los pipelines disponibles para tareas de audio incluyen los siguientes.
AudioClassificationPipeline
clase transformers.AudioClassificationPipeline
< source >( *args**kwargs )
Parámetros
- model (PreTrainedModel) — El modelo que se utilizará en la pipeline para realizar predicciones. Debe ser un modelo que herede de PreTrainedModel.
- feature_extractor (SequenceFeatureExtractor) — El extractor de características que se utilizará en la pipeline para codificar los datos para el modelo. Este objeto hereda de 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 utilizará DataLoader (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del lote a utilizar; para la inferencia, esto no siempre es beneficioso, lea Batching with pipelines . - args_parser (ArgumentHandler, opcional) — Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.
- device (
intostrotorch.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. Pasadevice="cpu"(o-1) para forzar la CPU, un ordinal positivo o"cuda:1"para seleccionar un acelerador específico, o untorch.device/strnativo. Este argumento no se puede combinar con un modelo ya cargado medianteaccelerate(es decir, uno con unhf_device_map). - dtype (
strotorch.dtype, opcional, valor predeterminado"auto") — Precisión en la que se carga el modelo, se reenvía afrom_pretrained. El valor predeterminado es"auto", que carga el modelo en el dtype en el que se guardó (leído deconfig.dtypedel checkpoint, o inferido de los pesos si no está disponible). Pase untorch.float16,torch.bfloat16,torch.float32, … explícito para sobrescribirlo. - binary_output (
bool, opcional, valor predeterminadoFalse) — Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida crudos, 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:
>>> 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
Este pipeline se puede cargar actualmente desde pipeline() utilizando el siguiente identificador de tarea: "audio-classification".
Vea la lista de modelos disponibles en huggingface.co/models.
__call__
< source >( inputs: numpy.ndarray | bytes | str | dict**kwargs: Any ) → A list of dict with the following keys
Parámetros
- inputs (
np.ndarrayobytesostrodict) — Los inputs son uno de los siguientes:strque 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.bytesse supone que es el contenido de un archivo de audio y es interpretado por ffmpeg de la misma manera.- (
np.ndarrayde forma (n, ) de tiponp.float32onp.float64) Audio sin procesar a la tasa de muestreo correcta (no se realizará ninguna comprobación adicional) - La forma
dictse puede usar para pasar audio sin procesar muestreado a unasampling_ratearbitraria 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 de 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 esNoneo 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, valor predeterminado “softmax”) — La función que se aplica a la salida del modelo. De forma predeterminada, el pipeline aplicará la función softmax a la salida del modelo. Opciones válidas: [“softmax”, “sigmoid”, “none”]. Tenga en cuenta que pasar el valorNonede Python predeterminará “softmax”, por lo que debe pasar la cadena “none” para deshabilitar cualquier posprocesamiento.
Devuelve
Una lista de dict con las siguientes claves
- label (
str) — La etiqueta predicha. - score (
float) — La probabilidad correspondiente.
Clasifica las secuencias dadas como entradas. Consulta la documentación de AutomaticSpeechRecognitionPipeline para obtener más información.
AutomaticSpeechRecognitionPipeline
clase transformers.AutomaticSpeechRecognitionPipeline
< source >( model: PreTrainedModelfeature_extractor: typing.Union[ForwardRef('SequenceFeatureExtractor'), str, NoneType] = Nonetokenizer: transformers.tokenization_python.PythonBackend | None = Nonedecoder: typing.Union[ForwardRef('BeamSearchDecoderCTC'), str, NoneType] = Nonedevice: typing.Union[int, ForwardRef('torch.device'), NoneType] = None**kwargs )
Parámetros
- model (PreTrainedModel) — El modelo que se utilizará en la pipeline para realizar predicciones. Debe ser un modelo que herede de PreTrainedModel.
- feature_extractor (SequenceFeatureExtractor, opcional) — El extractor de características que se utilizará en la pipeline para codificar la forma de onda para el modelo.
- tokenizer (PreTrainedTokenizer, opcional) — El tokenizador que se utilizará en la pipeline para codificar los datos para el modelo. Este objeto hereda de PreTrainedTokenizer.
- decoder (
pyctcdecode.BeamSearchDecoderCTC, opcional) — BeamSearchDecoderCTC de PyCTCDecode puede pasarse para decodificación potenciada por modelo de lenguaje. Consulte Wav2Vec2ProcessorWithLM para obtener más información. - device (Union[
int,torch.device], opcional) — Ordinal del dispositivo para CPU/GPU. Establecerlo enNoneutilizará 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, debe estar instalado 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:
>>> 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
__call__
< source >( inputs: numpy.ndarray | bytes | str | dict**kwargs: Any ) → Dict
Parámetros
- inputs (
np.ndarrayobytesostrodict) — Los inputs son uno de los siguientes:strque 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.bytesse supone que es el contenido de un archivo de audio y es interpretado por ffmpeg de la misma manera.- (
np.ndarrayde forma (n, ) de tiponp.float32onp.float64) Audio sin procesar a la tasa de muestreo correcta (no se realizará ninguna comprobación adicional) - Se puede usar la forma
dictpara pasar audio sin procesar muestreado a unasampling_ratearbitraria 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 trate las primerasleftmuestras y las últimasrightmuestras para ignorarlas en la decodificación (pero usarlas en la inferencia para proporcionar más contexto al modelo). Solo usestridecon modelos CTC.
- return_timestamps (opcional,
strobool) — Solo disponible para modelos puros de CTC (Wav2Vec2, HuBERT, etc.) y el modelo Whisper. No está disponible para otros modelos de secuencia a secuencia.Para los modelos CTC, los timestamps pueden adoptar uno de dos formatos:
"char": el pipeline devolverá marcas de tiempo junto con el 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” se pronunció después de0.5y antes de0.6segundos."word": el pipeline devolverá marcas de tiempo junto con el 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” se pronunció después de0.5y antes de0.9segundos.
Para el modelo Whisper, los timestamps pueden adoptar uno de dos formatos:
"word": igual que lo anterior para marcas de tiempo de CTC a nivel de palabra. Las marcas de tiempo a nivel de palabra se predicen mediante el algoritmo alineación dinámica por tiempo (DTW), una aproximación a las marcas de tiempo a nivel de palabra al inspeccionar los pesos de atención cruzada.True: el pipeline devolverá marcas de tiempo junto con el 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!” se pronunció después de0.5y antes de1.5segundos. 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 ocurre con las marcas de tiempo a nivel de palabra.
- generate_kwargs (
dict, opcional) — El diccionario de parametrización ad hoc degenerate_configque se utilizará para la llamada de generación. Para una visión completa de generate, consulte la siguiente guía.
Devuelve
Dict
Un diccionario con las siguientes claves:
- text (
str): El texto reconocido. - chunks (opcional(,
list[Dict]) Al usarreturn_timestamps,chunksse convertirá 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 ejecutando"".join(chunk["text"] for chunk in output["chunks"]).
Transcribe las secuencias de audio dadas como entradas a texto. Consulte la documentación de AutomaticSpeechRecognitionPipeline para obtener más información.
TextToAudioPipeline
clase transformers.TextToAudioPipeline
< source >( *argsvocoder = Nonesampling_rate = Nonenoise_scheduler = None**kwargs )
Pipeline de generación de texto a audio 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:
>>> 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
Puede especificar los parámetros que se pasan al modelo mediante
TextToAudioPipeline.__call__.forward_paramsoTextToAudioPipeline.__call__.generate_kwargs.Ejemplo:
>>> 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() utilizando los siguientes identificadores de tarea: "text-to-speech" o "text-to-audio".
Vea la lista de modelos disponibles en huggingface.co/models.
__call__
< source >( text_inputs**forward_params ) → AudioOutput or a list of AudioOutput, which is a TypedDict with two keys
Parámetros
- text_inputs (
str,list[str],ChatTypeolist[ChatType]) — Uno o varios textos para generar. Si se pasan cadenas 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 que se pasan al método de generación/forward del modelo.forward_paramssiempre se pasan al modelo subyacente. - generate_kwargs (
dict, opcional) — El diccionario de parametrización ad hoc degenerate_configque se usará para la llamada de generación. Para una visión completa de generate, consulta la siguiente guía.generate_kwargssolo se transmiten al modelo subyacente si este es un modelo generativo, y tienen prioridad sobreforward_params.
Devuelve
AudioOutput o una lista de AudioOutput, que es un TypedDict con dos claves
- audio (
np.ndarrayde 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 para obtener más información.
ZeroShotAudioClassificationPipeline
clase transformers.ZeroShotAudioClassificationPipeline
< source >( **kwargs )
Parámetros
- model (PreTrainedModel) — El modelo que se utilizará en la pipeline para realizar predicciones. Debe ser un modelo que herede de PreTrainedModel.
- tokenizer (PreTrainedTokenizer) — El tokenizador que se utilizará en la pipeline para codificar los datos para el modelo. Este objeto hereda de PreTrainedTokenizer.
- feature_extractor (SequenceFeatureExtractor) — El extractor de características que se utilizará en la pipeline para codificar los datos para el modelo. Este objeto hereda de 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 utilizará DataLoader (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del lote a utilizar; para la inferencia, esto no siempre es beneficioso, lea Batching with pipelines . - args_parser (ArgumentHandler, opcional) — Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.
- device (
intostrotorch.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. Pasadevice="cpu"(o-1) para forzar la CPU, un ordinal positivo o"cuda:1"para seleccionar un acelerador específico, o untorch.device/strnativo. Este argumento no se puede combinar con un modelo ya cargado medianteaccelerate(es decir, uno con unhf_device_map). - dtype (
strotorch.dtype, opcional, valor predeterminado"auto") — Precisión en la que se carga el modelo, se reenvía afrom_pretrained. El valor predeterminado es"auto", que carga el modelo en el dtype en el que se guardó (leído deconfig.dtypedel checkpoint, o inferido de los pesos si no está disponible). Pase untorch.float16,torch.bfloat16,torch.float32, … explícito para sobrescribirlo. - binary_output (
bool, opcional, valor predeterminadoFalse) — Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida crudos, por ejemplo, texto.
Pipeline de clasificación de audio sin ejemplos (zero shot) 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_templatepredeterminada es:"This is a sound of {}.". Asegúrate de actualizarla para tu uso.
Ejemplo:
>>> 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'}]Obtenga más información sobre los fundamentos del uso de un pipeline en el tutorial de pipeline. Este pipeline de clasificación de audio se puede cargar actualmente desde pipeline() utilizando el siguiente identificador de tarea: "zero-shot-audio-classification". Consulte la lista de modelos disponibles en huggingface.co/models.
__call__
< source >( audios: numpy.ndarray | bytes | str | dict**kwargs: Any )
Parámetros
- audios (
str,list[str],np.arrayolist[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 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 sustituyendo el marcador de posición por candidate_labels. Pasa ”{}” si candidate_labels ya están formateados.
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
clase transformers.DepthEstimationPipeline
< source >( *args**kwargs )
Parámetros
- model (PreTrainedModel) — El modelo que se utilizará en la pipeline para realizar predicciones. Debe ser un modelo que herede de PreTrainedModel.
- image_processor (BaseImageProcessor) — El procesador de imágenes que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de 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 utilizará DataLoader (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del lote a utilizar; para la inferencia, esto no siempre es beneficioso, lea Batching with pipelines . - args_parser (ArgumentHandler, opcional) — Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.
- device (
intostrotorch.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. Pasadevice="cpu"(o-1) para forzar la CPU, un ordinal positivo o"cuda:1"para seleccionar un acelerador específico, o untorch.device/strnativo. Este argumento no se puede combinar con un modelo ya cargado medianteaccelerate(es decir, uno con unhf_device_map). - dtype (
strotorch.dtype, opcional, valor predeterminado"auto") — Precisión en la que se carga el modelo, se reenvía afrom_pretrained. El valor predeterminado es"auto", que carga el modelo en el dtype en el que se guardó (leído deconfig.dtypedel checkpoint, o inferido de los pesos si no está disponible). Pase untorch.float16,torch.bfloat16,torch.float32, … explícito para sobrescribirlo. - binary_output (
bool, opcional, valor predeterminadoFalse) — Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida crudos, por ejemplo, texto.
Pipeline de estimación de profundidad que utiliza cualquier AutoModelForDepthEstimation. Este pipeline predice la profundidad de una imagen.
Ejemplo:
>>> 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
Este pipeline de estimación de profundidad se puede cargar actualmente desde pipeline() utilizando el siguiente identificador de tarea: "depth-estimation".
Vea la lista de modelos disponibles en huggingface.co/models.
__call__
< source >( inputs: typing.Union[str, list[str], ForwardRef('Image.Image'), list['Image.Image']]**kwargs: Any )
Parámetros
- inputs (
str,list[str],PIL.Imageolist[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 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 luego deben pasarse como una cadena de caracteres. 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 estimeout, que es la duración, en segundos, que la pipeline debe esperar antes de abandonar el intento de descargar una imagen. - timeout (
float, opcional, valor predeterminado None) — El tiempo máximo en segundos para esperar la descarga de imágenes de la web. Si es None, no se establece un tiempo de espera y la llamada puede bloquearse indefinidamente.
Predice la profundidad de las imágenes pasadas como entradas.
ImageClassificationPipeline
clase transformers.ImageClassificationPipeline
< source >( *args**kwargs )
Parámetros
- model (PreTrainedModel) — El modelo que se utilizará en la pipeline para realizar predicciones. Debe ser un modelo que herede de PreTrainedModel.
- image_processor (BaseImageProcessor) — El procesador de imágenes que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de 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 utilizará DataLoader (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del lote a utilizar; para la inferencia, esto no siempre es beneficioso, lea Batching with pipelines . - args_parser (ArgumentHandler, opcional) — Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.
- device (
intostrotorch.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. Pasadevice="cpu"(o-1) para forzar la CPU, un ordinal positivo o"cuda:1"para seleccionar un acelerador específico, o untorch.device/strnativo. Este argumento no se puede combinar con un modelo ya cargado medianteaccelerate(es decir, uno con unhf_device_map). - dtype (
strotorch.dtype, opcional, valor predeterminado"auto") — Precisión en la que se carga el modelo, se reenvía afrom_pretrained. El valor predeterminado es"auto", que carga el modelo en el dtype en el que se guardó (leído deconfig.dtypedel checkpoint, o inferido de los pesos si no está disponible). Pase untorch.float16,torch.bfloat16,torch.float32, … explícito para sobrescribirlo. - binary_output (
bool, opcional, valor predeterminadoFalse) — Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida crudos, por ejemplo, texto. - function_to_apply (
str, opcional, por defecto"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 sola etiqueta, se aplicará la función sigmoid a la salida. Si el modelo tiene varias etiquetas, se aplicará la función softmax 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:
>>> 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
Este pipeline de clasificación de imágenes se puede cargar actualmente desde pipeline() utilizando el siguiente identificador de tarea: "image-classification".
Vea la lista de modelos disponibles en huggingface.co/models.
__call__
< source >( inputs: typing.Union[str, list[str], ForwardRef('Image.Image'), list['Image.Image']]**kwargs: Any )
Parámetros
- inputs (
str,list[str],PIL.Imageolist[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 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 luego deben pasarse como una cadena de caracteres. 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, por defecto"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 modelo tiene una sola etiqueta, se aplicará la función sigmoidal 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) — El tiempo máximo en segundos para esperar la descarga de imágenes de la web. Si es None, no se establece un tiempo de espera y la llamada puede bloquearse indefinidamente.
Asigna etiquetas a la(s) imagen(es) pasadas como entradas.
ImageSegmentationPipeline
clase transformers.ImageSegmentationPipeline
< source >( *args**kwargs )
Parámetros
- model (PreTrainedModel) — El modelo que se utilizará en la pipeline para realizar predicciones. Debe ser un modelo que herede de PreTrainedModel.
- image_processor (BaseImageProcessor) — El procesador de imágenes que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de 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 utilizará DataLoader (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del lote a utilizar; para la inferencia, esto no siempre es beneficioso, lea Batching with pipelines . - args_parser (ArgumentHandler, opcional) — Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.
- device (
intostrotorch.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. Pasadevice="cpu"(o-1) para forzar la CPU, un ordinal positivo o"cuda:1"para seleccionar un acelerador específico, o untorch.device/strnativo. Este argumento no se puede combinar con un modelo ya cargado medianteaccelerate(es decir, uno con unhf_device_map). - dtype (
strotorch.dtype, opcional, valor predeterminado"auto") — Precisión en la que se carga el modelo, se reenvía afrom_pretrained. El valor predeterminado es"auto", que carga el modelo en el dtype en el que se guardó (leído deconfig.dtypedel checkpoint, o inferido de los pesos si no está disponible). Pase untorch.float16,torch.bfloat16,torch.float32, … explícito para sobrescribirlo. - binary_output (
bool, opcional, valor predeterminadoFalse) — Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida crudos, por ejemplo, texto.
Pipeline de segmentación de imágenes que utiliza cualquier AutoModelForXXXSegmentation. Este pipeline predice máscaras de objetos y sus clases.
Ejemplo:
>>> 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() utilizando el siguiente identificador de tarea: "image-segmentation".
Vea la lista de modelos disponibles en huggingface.co/models.
__call__
< source >( inputs: typing.Union[str, ForwardRef('Image.Image'), list[str], list['Image.Image']]**kwargs: Any )
Parámetros
- inputs (
str,list[str],PIL.Imageolist[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 PIL.
- subtask (
str, opcional) — Tarea de segmentación a realizar, elija entre [semantic,instanceypanoptic] 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 máscaras para eliminar segmentos pequeños y desconectados. - timeout (
float, opcional, valor predeterminado None) — El tiempo máximo en segundos para esperar la descarga de imágenes de la web. Si es None, no se establece un tiempo de espera y la llamada puede bloquearse indefinidamente.
Realiza segmentación (detecta máscaras y clases) en la(s) imagen(es) pasadas como entradas.
KeypointMatchingPipeline
Pipeline de correspondencia de puntos clave que utiliza cualquier AutoModelForKeypointMatching. Este pipeline corresponde puntos clave entre dos imágenes.
__call__
< source >( inputs: list[collections.abc.Sequence[typing.Union[ForwardRef('Image.Image'), str]]] | collections.abc.Sequence[typing.Union[ForwardRef('Image.Image'), str]]threshold: float = 0.0**kwargs: Any ) → Union[list[Match], list[list[Match]]]
Parámetros
- inputs (
str,list[str],PIL.Imageolist[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 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 luego deben pasarse como una cadena de caracteres. 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) — El umbral a utilizar para el emparejamiento de puntos clave. Los puntos clave emparejados con una puntuación de coincidencia inferior se filtrarán. 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 descarga 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
clase transformers.ObjectDetectionPipeline
< source >( *args**kwargs )
Parámetros
- model (PreTrainedModel) — El modelo que se utilizará en la pipeline para realizar predicciones. Debe ser un modelo que herede de PreTrainedModel.
- image_processor (BaseImageProcessor) — El procesador de imágenes que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de 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 utilizará DataLoader (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del lote a utilizar; para la inferencia, esto no siempre es beneficioso, lea Batching with pipelines . - args_parser (ArgumentHandler, opcional) — Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.
- device (
intostrotorch.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. Pasadevice="cpu"(o-1) para forzar la CPU, un ordinal positivo o"cuda:1"para seleccionar un acelerador específico, o untorch.device/strnativo. Este argumento no se puede combinar con un modelo ya cargado medianteaccelerate(es decir, uno con unhf_device_map). - dtype (
strotorch.dtype, opcional, valor predeterminado"auto") — Precisión en la que se carga el modelo, se reenvía afrom_pretrained. El valor predeterminado es"auto", que carga el modelo en el dtype en el que se guardó (leído deconfig.dtypedel checkpoint, o inferido de los pesos si no está disponible). Pase untorch.float16,torch.bfloat16,torch.float32, … explícito para sobrescribirlo. - binary_output (
bool, opcional, valor predeterminadoFalse) — Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida crudos, 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:
>>> 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
Este pipeline de detección de objetos se puede cargar actualmente desde pipeline() utilizando el siguiente identificador de tarea: "object-detection".
Vea la lista de modelos disponibles en huggingface.co/models.
__call__
< source >( *args**kwargs )
Parámetros
- inputs (
str,list[str],PIL.Imageolist[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 PIL.
- threshold (
float, opcional, valor predeterminado 0.5) — La probabilidad necesaria para realizar una predicción. - timeout (
float, opcional, valor predeterminado None) — El tiempo máximo en segundos para esperar la descarga de imágenes de la web. Si es None, no se establece un tiempo de espera y la llamada puede bloquearse indefinidamente.
Detecta objetos (cajas delimitadoras y clases) en la(s) imagen(es) pasadas como entradas.
VideoClassificationPipeline
clase transformers.VideoClassificationPipeline
< source >( *args**kwargs )
Parámetros
- model (PreTrainedModel) — El modelo que se utilizará en la pipeline para realizar predicciones. Debe ser un modelo que herede de PreTrainedModel.
- image_processor (BaseImageProcessor) — El procesador de imágenes que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de BaseImageProcessor.
- video_processor (BaseVideoProcessor) — El procesador de video que se utilizará en la pipeline para codificar los datos de video para el modelo. Este objeto hereda de 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 utilizará DataLoader (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del lote a utilizar; para la inferencia, esto no siempre es beneficioso, lea Batching with pipelines . - args_parser (ArgumentHandler, opcional) — Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.
- device (
intostrotorch.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. Pasadevice="cpu"(o-1) para forzar la CPU, un ordinal positivo o"cuda:1"para seleccionar un acelerador específico, o untorch.device/strnativo. Este argumento no se puede combinar con un modelo ya cargado medianteaccelerate(es decir, uno con unhf_device_map). - dtype (
strotorch.dtype, opcional, valor predeterminado"auto") — Precisión en la que se carga el modelo, se reenvía afrom_pretrained. El valor predeterminado es"auto", que carga el modelo en el dtype en el que se guardó (leído deconfig.dtypedel checkpoint, o inferido de los pesos si no está disponible). Pase untorch.float16,torch.bfloat16,torch.float32, … explícito para sobrescribirlo. - binary_output (
bool, opcional, valor predeterminadoFalse) — Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida crudos, 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() utilizando el siguiente identificador de tarea: "video-classification".
Vea la lista de modelos disponibles en huggingface.co/models.
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; cuando no se encuentra ninguno, el pipeline generará un error.
__call__
< source >( inputs: str | list[str] | None**kwargs )
Parámetros
- inputs (
str,list[str]) — El pipeline maneja tres tipos de vídeos:- Una cadena de texto que contiene un enlace http que apunta a un video
- Una cadena que contiene una ruta local a un video
El pipeline acepta un único video o un lote de videos, que luego deben pasarse como una cadena de caracteres. 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 predeterminadoself.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 vídeo. Si no se proporciona, el valor predeterminado será 1, es decir, se utilizará cada fotograma. - function_to_apply(
str, optional, por defecto “softmax”) — La función que se aplica a la salida del modelo. Por defecto, el pipeline aplicará la función softmax a la salida del modelo. Opciones válidas: [“softmax”, “sigmoid”, “none”]. Tenga en cuenta que pasar el valorNonede Python predeterminado resultará en “softmax”, por lo que debe pasar la cadena “none” para deshabilitar cualquier posprocesamiento.
Asigna etiquetas a los vídeos pasados como entradas.
ZeroShotImageClassificationPipeline
clase transformers.ZeroShotImageClassificationPipeline
< source >( **kwargs )
Parámetros
- model (PreTrainedModel) — El modelo que se utilizará en la pipeline para realizar predicciones. Debe ser un modelo que herede de PreTrainedModel.
- image_processor (BaseImageProcessor) — El procesador de imágenes que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de 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 utilizará DataLoader (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del lote a utilizar; para la inferencia, esto no siempre es beneficioso, lea Batching with pipelines . - args_parser (ArgumentHandler, opcional) — Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.
- device (
intostrotorch.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. Pasadevice="cpu"(o-1) para forzar la CPU, un ordinal positivo o"cuda:1"para seleccionar un acelerador específico, o untorch.device/strnativo. Este argumento no se puede combinar con un modelo ya cargado medianteaccelerate(es decir, uno con unhf_device_map). - dtype (
strotorch.dtype, opcional, valor predeterminado"auto") — Precisión en la que se carga el modelo, se reenvía afrom_pretrained. El valor predeterminado es"auto", que carga el modelo en el dtype en el que se guardó (leído deconfig.dtypedel checkpoint, o inferido de los pesos si no está disponible). Pase untorch.float16,torch.bfloat16,torch.float32, … explícito para sobrescribirlo. - binary_output (
bool, opcional, valor predeterminadoFalse) — Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida crudos, por ejemplo, texto.
Pipeline de clasificación de imágenes sin ejemplos (zero-shot) que utiliza CLIPModel. Este pipeline predice la clase de una imagen cuando se proporciona una imagen y un conjunto de candidate_labels.
Ejemplo:
>>> 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
Este pipeline de clasificación de imágenes se puede cargar actualmente desde pipeline() utilizando el siguiente identificador de tarea: "zero-shot-image-classification".
Vea la lista de modelos disponibles en huggingface.co/models.
__call__
< source >( image: typing.Union[str, list[str], ForwardRef('Image.Image'), list['Image.Image']]candidate_labels: list**kwargs: Any )
Parámetros
- image (
str,list[str],PIL.Imageolist[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 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 sustituyendo el marcador de posición por candidate_labels. Pasa ”{}” si candidate_labels ya están formateados. - timeout (
float, opcional, valor predeterminado None) — El tiempo máximo en segundos para esperar la descarga de imágenes de la web. Si es None, no se establece un tiempo de espera y la llamada puede bloquearse indefinidamente.
Asigna etiquetas a la(s) imagen(es) pasadas como entradas.
ZeroShotObjectDetectionPipeline
clase transformers.ZeroShotObjectDetectionPipeline
< source >( **kwargs )
Parámetros
- model (PreTrainedModel) — El modelo que se utilizará en la pipeline para realizar predicciones. Debe ser un modelo que herede de PreTrainedModel.
- image_processor (BaseImageProcessor) — El procesador de imágenes que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de 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 utilizará DataLoader (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del lote a utilizar; para la inferencia, esto no siempre es beneficioso, lea Batching with pipelines . - args_parser (ArgumentHandler, opcional) — Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.
- device (
intostrotorch.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. Pasadevice="cpu"(o-1) para forzar la CPU, un ordinal positivo o"cuda:1"para seleccionar un acelerador específico, o untorch.device/strnativo. Este argumento no se puede combinar con un modelo ya cargado medianteaccelerate(es decir, uno con unhf_device_map). - dtype (
strotorch.dtype, opcional, valor predeterminado"auto") — Precisión en la que se carga el modelo, se reenvía afrom_pretrained. El valor predeterminado es"auto", que carga el modelo en el dtype en el que se guardó (leído deconfig.dtypedel checkpoint, o inferido de los pesos si no está disponible). Pase untorch.float16,torch.bfloat16,torch.float32, … explícito para sobrescribirlo. - binary_output (
bool, opcional, valor predeterminadoFalse) — Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida crudos, 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 proporcionas una imagen y un conjunto de candidate_labels.
Ejemplo:
>>> 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
Este pipeline de detección de objetos se puede cargar actualmente desde pipeline() utilizando el siguiente identificador de tarea: "zero-shot-object-detection".
Vea la lista de modelos disponibles en huggingface.co/models.
__call__
< source >( image: typing.Union[str, ForwardRef('Image.Image'), list[dict[str, typing.Any]]]candidate_labels: str | list[str] | None = None**kwargs: Any )
Parámetros
- image (
str,PIL.Imageolist[dict[str, Any]]) — El pipeline maneja tres tipos de imágenes:- Una cadena de texto 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
Puede usar este parámetro para enviar directamente una lista de imágenes, o un dataset o un generador, de la siguiente manera:
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.
FillMaskPipeline
clase transformers.FillMaskPipeline
< source >( model: PreTrainedModeltokenizer: PreTrainedTokenizer | None = Nonefeature_extractor: PreTrainedFeatureExtractor | None = Noneimage_processor: BaseImageProcessor | None = Nonevideo_processor: BaseVideoProcessor | None = Noneprocessor: ProcessorMixin | None = Nonetask: str = ''device: int | torch.device | None = Nonebinary_output: bool = False**kwargs )
Parámetros
- model (PreTrainedModel) — El modelo que se utilizará en la pipeline para realizar predicciones. Debe ser un modelo que herede de PreTrainedModel.
- tokenizer (PreTrainedTokenizer) — El tokenizador que se utilizará en la pipeline para codificar los datos para el modelo. Este objeto hereda de PreTrainedTokenizer.
- 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 utilizará DataLoader (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del lote a utilizar; para la inferencia, esto no siempre es beneficioso, lea Batching with pipelines . - args_parser (ArgumentHandler, opcional) — Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.
- device (
intostrotorch.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. Pasadevice="cpu"(o-1) para forzar la CPU, un ordinal positivo o"cuda:1"para seleccionar un acelerador específico, o untorch.device/strnativo. Este argumento no se puede combinar con un modelo ya cargado medianteaccelerate(es decir, uno con unhf_device_map). - dtype (
strotorch.dtype, opcional, valor predeterminado"auto") — Precisión en la que se carga el modelo, se reenvía afrom_pretrained. El valor predeterminado es"auto", que carga el modelo en el dtype en el que se guardó (leído deconfig.dtypedel checkpoint, o inferido de los pesos si no está disponible). Pase untorch.float16,torch.bfloat16,torch.float32, … explícito para sobrescribirlo. - binary_output (
bool, opcional, valor predeterminadoFalse) — Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida crudos, por ejemplo, texto. - top_k (
int, opcional, valor predeterminado 5) — El número de predicciones a devolver. - targets (
strolist[str], opcional) — Si se pasa, 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 usará el primer token resultante (con una advertencia, y eso podría ser más lento). - tokenizer_kwargs (
dict, opcional) — Diccionario adicional de argumentos de palabra clave que se pasan al tokenizador.
__call__
< source >( inputs: str | list[str]**kwargs: Any ) → A list or a list of list of dict
Parámetros
- inputs (
strolist[str]) — Uno o varios textos (o una lista de prompts) con tokens enmascarados. - targets (
strolist[str], opcional) — Si se pasa, 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 usará el primer token resultante (con una advertencia, y eso 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
clase transformers.TableQuestionAnsweringPipeline
< source >( args_parser = <transformers.pipelines.table_question_answering.TableQuestionAnsweringArgumentHandler object at 0x7f6a12674950>**kwargs )
Parámetros
- model (PreTrainedModel) — El modelo que se utilizará en la pipeline para realizar predicciones. Debe ser un modelo que herede de PreTrainedModel.
- tokenizer (PreTrainedTokenizer) — El tokenizador que se utilizará en la pipeline para codificar los datos para el modelo. Este objeto hereda de PreTrainedTokenizer.
- 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 utilizará DataLoader (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del lote a utilizar; para la inferencia, esto no siempre es beneficioso, lea Batching with pipelines . - args_parser (ArgumentHandler, opcional) — Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.
- device (
intostrotorch.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. Pasadevice="cpu"(o-1) para forzar la CPU, un ordinal positivo o"cuda:1"para seleccionar un acelerador específico, o untorch.device/strnativo. Este argumento no se puede combinar con un modelo ya cargado medianteaccelerate(es decir, uno con unhf_device_map). - dtype (
strotorch.dtype, opcional, valor predeterminado"auto") — Precisión en la que se carga el modelo, se reenvía afrom_pretrained. El valor predeterminado es"auto", que carga el modelo en el dtype en el que se guardó (leído deconfig.dtypedel checkpoint, o inferido de los pesos si no está disponible). Pase untorch.float16,torch.bfloat16,torch.float32, … explícito para sobrescribirlo. - binary_output (
bool, opcional, valor predeterminadoFalse) — Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida crudos, 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:
>>> 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
Este pipeline de respuesta a preguntas tabulares se puede cargar actualmente desde 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.
__call__
< source >( *args**kwargs ) → A dictionary or a list of dictionaries containing results
Parámetros
- table (
pd.DataFrameoDict) — DataFrame de Pandas o diccionario que se convertirá en un DataFrame que contenga todos los valores de la tabla. Vea arriba un ejemplo de diccionario. - query (
strolist[str]) — Consulta o lista de consultas que se enviarán al modelo junto con la tabla. - sequential (
bool, opcional, valor predeterminadoFalse) — Si se realiza 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, dada su naturaleza conversacional. - padding (
bool,stro PaddingStrategy, opcional, el valor predeterminado esFalse) — Activa y controla el padding. Acepta los siguientes valores:Trueo'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 argumentomax_lengtho hasta la longitud de entrada máxima aceptable para el modelo si no se proporciona dicho argumento.Falseo'do_not_pad'(predeterminado): Sin relleno (es decir, puede generar un lote con secuencias de diferentes longitudes).
- truncation (
bool,stroTapasTruncationStrategy, opcional, por defectoFalse) — Activa y controla la truncación. Acepta los siguientes valores:Trueo'drop_rows_to_fit': Trunca a una longitud máxima especificada con el argumentomax_lengtho a la longitud de entrada máxima aceptable para el modelo si no se proporciona ese argumento. Esto truncará fila por fila, eliminando filas de la tabla.Falseo'do_not_truncate'(predeterminado): sin truncamiento (es decir, se puede generar un lote con longitudes de secuencia mayores que el tamaño máximo de entrada admisible por el modelo).
Devuelve
Un diccionario o una lista de diccionarios que contienen resultados
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 deAGGREGATOR >. - 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:
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:
TextClassificationPipeline
clase transformers.TextClassificationPipeline
< source >( **kwargs )
Parámetros
- model (PreTrainedModel) — El modelo que se utilizará en la pipeline para realizar predicciones. Debe ser un modelo que herede de PreTrainedModel.
- tokenizer (PreTrainedTokenizer) — El tokenizador que se utilizará en la pipeline para codificar los datos para el modelo. Este objeto hereda de PreTrainedTokenizer.
- 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 utilizará DataLoader (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del lote a utilizar; para la inferencia, esto no siempre es beneficioso, lea Batching with pipelines . - args_parser (ArgumentHandler, opcional) — Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.
- device (
intostrotorch.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. Pasadevice="cpu"(o-1) para forzar la CPU, un ordinal positivo o"cuda:1"para seleccionar un acelerador específico, o untorch.device/strnativo. Este argumento no se puede combinar con un modelo ya cargado medianteaccelerate(es decir, uno con unhf_device_map). - dtype (
strotorch.dtype, opcional, valor predeterminado"auto") — Precisión en la que se carga el modelo, se reenvía afrom_pretrained. El valor predeterminado es"auto", que carga el modelo en el dtype en el que se guardó (leído deconfig.dtypedel checkpoint, o inferido de los pesos si no está disponible). Pase untorch.float16,torch.bfloat16,torch.float32, … explícito para sobrescribirlo. - binary_output (
bool, opcional, valor predeterminadoFalse) — Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida crudos, por ejemplo, texto. - function_to_apply (
str, opcional, por defecto"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 sola etiqueta, se aplicará la función sigmoid 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 para obtener más información.
Ejemplo:
>>> 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
Este pipeline de clasificación de texto se puede cargar actualmente desde 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 sola 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 esta pipeline puede utilizar son modelos que han sido afinados en una tarea de clasificación de secuencias. Consulte la lista actualizada de modelos disponibles en huggingface.co/models.
__call__
< source >( inputs: str | list[str] | dict[str, str] | list[dict[str, str]]**kwargs: Any ) → A list of dict
Parámetros
- inputs (
strolist[str]odict[str], olist[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 predeterminado1) — Número de resultados a devolver. - function_to_apply (
str, opcional, por defecto"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 sola etiqueta, se aplicará la función sigmoidal 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
clase transformers.TextGenerationPipeline
< source >( *args**kwargs )
Parámetros
- model (PreTrainedModel) — El modelo que se utilizará en la pipeline para realizar predicciones. Debe ser un modelo que herede de PreTrainedModel.
- tokenizer (PreTrainedTokenizer) — El tokenizador que se utilizará en la pipeline para codificar los datos para el modelo. Este objeto hereda de PreTrainedTokenizer.
- 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 utilizará DataLoader (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del lote a utilizar; para la inferencia, esto no siempre es beneficioso, lea Batching with pipelines . - args_parser (ArgumentHandler, opcional) — Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.
- device (
intostrotorch.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. Pasadevice="cpu"(o-1) para forzar la CPU, un ordinal positivo o"cuda:1"para seleccionar un acelerador específico, o untorch.device/strnativo. Este argumento no se puede combinar con un modelo ya cargado medianteaccelerate(es decir, uno con unhf_device_map). - dtype (
strotorch.dtype, opcional, valor predeterminado"auto") — Precisión en la que se carga el modelo, se reenvía afrom_pretrained. El valor predeterminado es"auto", que carga el modelo en el dtype en el que se guardó (leído deconfig.dtypedel checkpoint, o inferido de los pesos si no está disponible). Pase untorch.float16,torch.bfloat16,torch.float32, … explícito para sobrescribirlo. - binary_output (
bool, opcional, valor predeterminadoFalse) — Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida crudos, 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:
>>> from transformers import pipeline
>>> generator = pipeline(model="openai-community/gpt2")
>>> generator("I can't believe you did such a ", do_sample=False)
[{'generated_text': "I can't believe you did such a icky thing to me. I'm so sorry. I'm so sorry. I'm so sorry. I'm so sorry. I'm so sorry. I'm so sorry. I'm so sorry. I"}]
>>> # These parameters will return suggestions, and only the newly created text making it easier for prompting suggestions.
>>> outputs = generator("My tart needs some", num_return_sequences=4, return_full_text=False)>>> from transformers import pipeline
>>> generator = pipeline(model="HuggingFaceH4/zephyr-7b-beta")
>>> # Zephyr-beta is a conversational model, so let's pass it a chat instead of a single string
>>> generator([{"role": "user", "content": "What is the capital of France? Answer in one word."}], do_sample=False, max_new_tokens=2)
[{'generated_text': [{'role': 'user', 'content': 'What is the capital of France? Answer in one word.'}, {'role': 'assistant', 'content': 'Paris'}]}]Obtenga más información sobre los fundamentos del uso de un pipeline en el tutorial de pipeline. Puede pasar parámetros de generación de texto a este pipeline para controlar los criterios de detención, 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 y Generación de texto.
Este pipeline de generación de lenguaje se puede cargar actualmente desde pipeline() utilizando el siguiente identificador de tarea: "text-generation".
Los modelos que esta pipeline puede utilizar son aquellos que han sido entrenados con un objetivo de modelado de lenguaje autoregresivo. Consulte la lista de modelos de completado de texto y la lista de modelos conversacionales en [huggingface.co/models].
__call__
< source >( text_inputs**kwargs ) → A list or a list of lists of dict
Parámetros
- text_inputs (
str,list[str],ChatTypeolist[ChatType]) — Uno o varios prompts (o una lista de prompts) para completar. Si se pasan cadenas de texto o una lista de cadenas de texto, esta pipeline continuará cada prompt. 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 predeterminadoFalse) — Devuelve los tensores de predicciones (como índices de tokens) en las salidas. Si se establece enTrue, no se devuelve el texto decodificado. - return_text (
bool, opcional) — Devuelve los textos decodificados en las salidas. - return_full_text (
bool, opcional, valor predeterminadoTrue) — Si se establece enFalse, solo se devuelve el texto añadido; de lo contrario, se devuelve el texto completo. No se puede especificar al mismo tiempo quereturn_text. - clean_up_tokenization_spaces (
bool, opcional) — Indica si se deben limpiar los espacios adicionales potenciales en la salida de texto. Por defecto, utiliza la configuraciónclean_up_tokenization_spacesdel 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. Por defecto, este valor esTruecuando el último mensaje del chat de entrada tiene el rolassistantyFalseen caso contrario, pero puedes anular manualmente ese comportamiento estableciendo esta bandera. - prefix (
str, opcional) — Prefijo añadido al prompt. - stop_sequence (
strolist[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 en la que no ocurre nada en particular"hole": Trunca a la izquierda de la entrada y deja un hueco lo suficientemente ancho para 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 al paso de codificación del tokenizador. Si la entrada de texto es un chat, se pasa aapply_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 (ver el método generate aquí).
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 cuandoreturn_text=True) — El texto generado. - generated_token_ids (
torch.Tensor, presente cuandoreturn_tensors=True) — Los ids de los tokens del texto generado.
Complete los prompts dados como entradas.
TokenClassificationPipeline
clase transformers.TokenClassificationPipeline
< source >( args_parser = <transformers.pipelines.token_classification.TokenClassificationArgumentHandler object at 0x7f6a12e05a50>**kwargs )
Parámetros
- model (PreTrainedModel) — El modelo que se utilizará en la pipeline para realizar predicciones. Debe ser un modelo que herede de PreTrainedModel.
- tokenizer (PreTrainedTokenizer) — El tokenizador que se utilizará en la pipeline para codificar los datos para el modelo. Este objeto hereda de PreTrainedTokenizer.
- 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 utilizará DataLoader (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del lote a utilizar; para la inferencia, esto no siempre es beneficioso, lea Batching with pipelines . - args_parser (ArgumentHandler, opcional) — Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.
- device (
intostrotorch.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. Pasadevice="cpu"(o-1) para forzar la CPU, un ordinal positivo o"cuda:1"para seleccionar un acelerador específico, o untorch.device/strnativo. Este argumento no se puede combinar con un modelo ya cargado medianteaccelerate(es decir, uno con unhf_device_map). - dtype (
strotorch.dtype, opcional, valor predeterminado"auto") — Precisión en la que se carga el modelo, se reenvía afrom_pretrained. El valor predeterminado es"auto", que carga el modelo en el dtype en el que se guardó (leído deconfig.dtypedel checkpoint, o inferido de los pesos si no está disponible). Pase untorch.float16,torch.bfloat16,torch.float32, … explícito para sobrescribirlo. - binary_output (
bool, opcional, valor predeterminadoFalse) — Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida crudos, por ejemplo, texto. - ignore_labels (
list[str], por defecto["O"]) — Una lista de etiquetas para ignorar. - stride (
int, opcional) — Si se proporciona stride, el 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 conaggregation_strategydiferente deNONE. El valor de este argumento define el número de tokens superpuestos entre fragmentos. En otras palabras, el modelo avanzarátokenizer.model_max_length - stridetokens en cada paso. - aggregation_strategy (
str, opcional, por defecto"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 las 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”}] Tenga en cuenta que dos etiquetas B consecutivas terminarán siendo entidades diferentes. En idiomas basados en palabras, es posible que dividamos las 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 soporten 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 en modelos basados en palabras) Utilizará la estrategia
SIMPLE, con la excepción de que las palabras no pueden terminar con etiquetas diferentes. En caso de ambigüedad, las palabras simplemente usarán la etiqueta del primer token de la palabra. - “average”: (solo funciona en modelos basados en palabras) Utilizará la estrategia
SIMPLE, con la excepción de que las palabras no pueden terminar con etiquetas diferentes. Las puntuaciones se promediarán primero entre los tokens y, a continuación, se aplicará la etiqueta máxima. - “max”: (solo funciona en modelos basados en palabras) Utilizará la estrategia
SIMPLE, con la excepción de que las palabras no pueden terminar con etiquetas diferentes. La entidad de palabra será simplemente 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 para obtener más información.
Ejemplo:
>>> 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
Este pipeline de reconocimiento de tokens se puede cargar actualmente desde 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 esta pipeline puede utilizar 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.
__call__
< source >( inputs: str | list[str]**kwargs: Any ) → A list or a list of list of dict
Parámetros
- inputs (
stroList[str]) — Uno o varios textos (o una lista de textos) para la clasificación de tokens. Puede estar pretokenizado cuandois_split_into_words=True.
Devuelve
Una lista o una lista de listas de dict
Cada resultado se presenta como una lista de diccionarios (uno para cada token de la entrada correspondiente, o para cada entidad si esta pipeline se instanció con un aggregation_strategy) con las siguientes claves:
- word (
str) — El token/palabra clasificada. Esto se obtiene decodificando los tokens seleccionados. Si deseas obtener la cadena exacta en la oración original, usastartyend. - score (
float) — La probabilidad correspondiente paraentity. - entity (
str) — La entidad predicha para ese token/palabra (se denomina entity_group cuando aggregation_strategy no es"none"). - index (
int, solo presente cuandoaggregation_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.
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
< source >( sentence: strinput_ids: ndarrayscores: ndarrayoffset_mapping: list[tuple[int, int]] | Nonespecial_tokens_mask: ndarrayaggregation_strategy: AggregationStrategyword_ids: list[int | None] | None = Noneword_to_chars_map: list[tuple[int, int]] | None = None )
Fusiona varios arrays de numpy en diccionarios con toda la información necesaria para la agregación
group_entities
< source >( entities: list )
Encuentra y agrupa los tokens adyacentes con la misma entidad predicha.
group_sub_entities
< source >( entities: list )
Agrupe los tokens adyacentes con la misma entidad predicha.
ZeroShotClassificationPipeline
clase transformers.ZeroShotClassificationPipeline
< source >( args_parser = <transformers.pipelines.zero_shot_classification.ZeroShotClassificationArgumentHandler object at 0x7f6a126906d0>**kwargs )
Parámetros
- model (PreTrainedModel) — El modelo que se utilizará en la pipeline para realizar predicciones. Debe ser un modelo que herede de PreTrainedModel.
- tokenizer (PreTrainedTokenizer) — El tokenizador que se utilizará en la pipeline para codificar los datos para el modelo. Este objeto hereda de PreTrainedTokenizer.
- 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 utilizará DataLoader (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del lote a utilizar; para la inferencia, esto no siempre es beneficioso, lea Batching with pipelines . - args_parser (ArgumentHandler, opcional) — Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.
- device (
intostrotorch.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. Pasadevice="cpu"(o-1) para forzar la CPU, un ordinal positivo o"cuda:1"para seleccionar un acelerador específico, o untorch.device/strnativo. Este argumento no se puede combinar con un modelo ya cargado medianteaccelerate(es decir, uno con unhf_device_map). - dtype (
strotorch.dtype, opcional, valor predeterminado"auto") — Precisión en la que se carga el modelo, se reenvía afrom_pretrained. El valor predeterminado es"auto", que carga el modelo en el dtype en el que se guardó (leído deconfig.dtypedel checkpoint, o inferido de los pesos si no está disponible). Pase untorch.float16,torch.bfloat16,torch.float32, … explícito para sobrescribirlo. - binary_output (
bool, opcional, valor predeterminadoFalse) — Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida crudos, 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 significa 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 usar 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:
>>> 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
Este pipeline de NLI se puede cargar actualmente desde pipeline() utilizando el siguiente identificador de tarea: "zero-shot-classification".
Los modelos que puede utilizar este pipeline son modelos que han sido ajustados finamente en una tarea de NLI. Consulte la lista actualizada de modelos disponibles en huggingface.co/models.
__call__
< source >( sequences: str | list[str]*args**kwargs ) → A dict or a list of dict
Parámetros
- sequences (
strolist[str]) — La secuencia o secuencias a clasificar; se truncarán si la entrada del modelo es demasiado grande. - candidate_labels (
strolist[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 {} 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 predeterminadoFalse) — Indica si varias etiquetas candidatas pueden ser verdaderas. Si esFalse, las puntuaciones se normalizan de modo que la suma de las probabilidades de las etiquetas para cada secuencia sea 1. Si esTrue, las etiquetas se consideran independientes y las probabilidades se normalizan para cada candidata aplicando un softmax a la puntuación de entailment 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 las secuencias dadas como entradas. Consulta la documentación de ZeroShotClassificationPipeline para obtener más información.
Multimodal
Los pipelines disponibles para tareas multimodales incluyen los siguientes.
DocumentQuestionAnsweringPipeline
clase transformers.DocumentQuestionAnsweringPipeline
< source >( *args**kwargs )
Parámetros
- model (PreTrainedModel) — El modelo que se utilizará en la pipeline para realizar predicciones. Debe ser un modelo que herede de PreTrainedModel.
- tokenizer (PreTrainedTokenizer) — El tokenizador que se utilizará en la pipeline para codificar los datos para el modelo. Este objeto hereda de PreTrainedTokenizer.
- image_processor (BaseImageProcessor) — El procesador de imágenes que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de 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 utilizará DataLoader (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del lote a utilizar; para la inferencia, esto no siempre es beneficioso, lea Batching with pipelines . - args_parser (ArgumentHandler, opcional) — Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.
- device (
intostrotorch.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. Pasadevice="cpu"(o-1) para forzar la CPU, un ordinal positivo o"cuda:1"para seleccionar un acelerador específico, o untorch.device/strnativo. Este argumento no se puede combinar con un modelo ya cargado medianteaccelerate(es decir, uno con unhf_device_map). - dtype (
strotorch.dtype, opcional, valor predeterminado"auto") — Precisión en la que se carga el modelo, se reenvía afrom_pretrained. El valor predeterminado es"auto", que carga el modelo en el dtype en el que se guardó (leído deconfig.dtypedel checkpoint, o inferido de los pesos si no está disponible). Pase untorch.float16,torch.bfloat16,torch.float32, … explícito para sobrescribirlo. - binary_output (
bool, opcional, valor predeterminadoFalse) — Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida crudos, 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:
>>> 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
Este pipeline de respuesta a preguntas sobre documentos se puede cargar actualmente desde 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.
__call__
< source >( image: typing.Union[ForwardRef('Image.Image'), str, list[dict[str, typing.Any]]]question: str | None = Noneword_boxes: tuple[str, list[float]] | None = None**kwargs: Any ) → A dict or a list of dict
Parámetros
- image (
stroPIL.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 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 hacer 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 en 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 cierta superposición. Este argumento controla el tamaño de esa superposición. - 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 pasado al modelo. El contexto se dividirá en varios fragmentos (usandodoc_stridecomo 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 predeterminadoFalse) — Si aceptamos o no "imposible" como respuesta. - lang (
str, opcional) — Idioma a utilizar durante la ejecución de OCR. El valor predeterminado es inglés. - tesseract_config (
str, opcional) — Banderas adicionales para pasar a tesseract al ejecutar OCR. - timeout (
float, opcional, valor predeterminado None) — El tiempo máximo en segundos para esperar la descarga 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 losword_boxesproporcionados). - end (
int) — El índice de la palabra final de la respuesta (en la versión OCR de la entrada o en losword_boxesproporcionados). - answer (
str) — La respuesta a la pregunta. - words (
list[int]) — El índice de cada par palabra/caja que está en la respuesta
Responda a la pregunta o preguntas dadas como entradas utilizando el o los documentos. 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 las 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
clase transformers.FeatureExtractionPipeline
< source >( model: PreTrainedModeltokenizer: PreTrainedTokenizer | None = Nonefeature_extractor: PreTrainedFeatureExtractor | None = Noneimage_processor: BaseImageProcessor | None = Nonevideo_processor: BaseVideoProcessor | None = Noneprocessor: ProcessorMixin | None = Nonetask: str = ''device: int | torch.device | None = Nonebinary_output: bool = False**kwargs )
Parámetros
- model (PreTrainedModel) — El modelo que se utilizará en la pipeline para realizar predicciones. Debe ser un modelo que herede de PreTrainedModel.
- tokenizer (PreTrainedTokenizer) — El tokenizador que se utilizará en la pipeline para codificar los datos para el modelo. Este objeto hereda de PreTrainedTokenizer.
- 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 utilizará DataLoader (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del lote a utilizar; para la inferencia, esto no siempre es beneficioso, lea Batching with pipelines . - args_parser (ArgumentHandler, opcional) — Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.
- device (
intostrotorch.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. Pasadevice="cpu"(o-1) para forzar la CPU, un ordinal positivo o"cuda:1"para seleccionar un acelerador específico, o untorch.device/strnativo. Este argumento no se puede combinar con un modelo ya cargado medianteaccelerate(es decir, uno con unhf_device_map). - dtype (
strotorch.dtype, opcional, valor predeterminado"auto") — Precisión en la que se carga el modelo, se reenvía afrom_pretrained. El valor predeterminado es"auto", que carga el modelo en el dtype en el que se guardó (leído deconfig.dtypedel checkpoint, o inferido de los pesos si no está disponible). Pase untorch.float16,torch.bfloat16,torch.float32, … explícito para sobrescribirlo. - tokenize_kwargs (
dict, opcional) — Diccionario adicional de argumentos de palabra clave que se pasan al tokenizador. - return_tensors (
bool, opcional) — Si esTrue, 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:
>>> 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
Este pipeline de extracción de características se puede cargar actualmente desde 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.
__call__
< source >( *args: str | list[str]**kwargs: Any ) → A nested list of float
Extrae las características del texto de entrada.
ImageFeatureExtractionPipeline
clase transformers.ImageFeatureExtractionPipeline
< source >( model: PreTrainedModeltokenizer: PreTrainedTokenizer | None = Nonefeature_extractor: PreTrainedFeatureExtractor | None = Noneimage_processor: BaseImageProcessor | None = Nonevideo_processor: BaseVideoProcessor | None = Noneprocessor: ProcessorMixin | None = Nonetask: str = ''device: int | torch.device | None = Nonebinary_output: bool = False**kwargs )
Parámetros
- model (PreTrainedModel) — El modelo que se utilizará en la pipeline para realizar predicciones. Debe ser un modelo que herede de PreTrainedModel.
- image_processor (BaseImageProcessor) — El procesador de imágenes que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de 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 utilizará DataLoader (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del lote a utilizar; para la inferencia, esto no siempre es beneficioso, lea Batching with pipelines . - args_parser (ArgumentHandler, opcional) — Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.
- device (
intostrotorch.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. Pasadevice="cpu"(o-1) para forzar la CPU, un ordinal positivo o"cuda:1"para seleccionar un acelerador específico, o untorch.device/strnativo. Este argumento no se puede combinar con un modelo ya cargado medianteaccelerate(es decir, uno con unhf_device_map). - dtype (
strotorch.dtype, opcional, valor predeterminado"auto") — Precisión en la que se carga el modelo, se reenvía afrom_pretrained. El valor predeterminado es"auto", que carga el modelo en el dtype en el que se guardó (leído deconfig.dtypedel checkpoint, o inferido de los pesos si no está disponible). Pase untorch.float16,torch.bfloat16,torch.float32, … explícito para sobrescribirlo. - binary_output (
bool, opcional, valor predeterminadoFalse) — Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida crudos, por ejemplo, texto. - image_processor_kwargs (
dict, opcional) — Diccionario adicional de argumentos de palabra clave que se pasan al procesador de imágenes, p. ej. {“size”: {“height”: 100, “width”: 100}} - pool (
bool, opcional, valor predeterminadoFalse) — Indica si se debe devolver la salida agrupada. Si esFalse, 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:
>>> 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
Este pipeline de extracción de características de imágenes se puede cargar actualmente desde 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.
__call__
< source >( *args: typing.Union[str, ForwardRef('Image.Image'), list['Image.Image'], list[str]]**kwargs: Any ) → A nested list of float
Parámetros
- images (
str,list[str],PIL.Imageolist[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 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 luego deben pasarse como una cadena de caracteres. 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) — El tiempo máximo en segundos para esperar la descarga de imágenes de la web. Si es None, no se usa ningún 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
clase transformers.ImageTextToTextPipeline
< source >( *args**kwargs )
Parámetros
- model (PreTrainedModel) — El modelo que se utilizará en la pipeline para realizar predicciones. Debe ser un modelo que herede de PreTrainedModel.
- processor (ProcessorMixin) —
El procesador que se utilizará en la pipeline para codificar los datos para el modelo. Este objeto hereda de
ProcessorMixin. Processor es un objeto compuesto que puede contener
tokenizer,feature_extractoryimage_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 utilizará DataLoader (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del lote a utilizar; para la inferencia, esto no siempre es beneficioso, lea Batching with pipelines . - args_parser (ArgumentHandler, opcional) — Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.
- device (
intostrotorch.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. Pasadevice="cpu"(o-1) para forzar la CPU, un ordinal positivo o"cuda:1"para seleccionar un acelerador específico, o untorch.device/strnativo. Este argumento no se puede combinar con un modelo ya cargado medianteaccelerate(es decir, uno con unhf_device_map). - dtype (
strotorch.dtype, opcional, valor predeterminado"auto") — Precisión en la que se carga el modelo, se reenvía afrom_pretrained. El valor predeterminado es"auto", que carga el modelo en el dtype en el que se guardó (leído deconfig.dtypedel checkpoint, o inferido de los pesos si no está disponible). Pase untorch.float16,torch.bfloat16,torch.float32, … explícito para sobrescribirlo. - binary_output (
bool, opcional, valor predeterminadoFalse) — Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida crudos, 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 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
Ejemplo:
>>> from transformers import pipeline
>>> pipe = pipeline(task="image-text-to-text", model="Salesforce/blip-image-captioning-base")
>>> pipe("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png", text="A photo of")
[{'generated_text': 'a photo of two birds'}]>>> from transformers import pipeline
>>> pipe = pipeline("image-text-to-text", model="llava-hf/llava-interleave-qwen-0.5b-hf")
>>> messages = [
>>> {
>>> "role": "user",
>>> "content": [
>>> {
>>> "type": "image",
>>> "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/qwen_vl_demo.jpeg",
>>> },
>>> {"type": "text", "text": "Describe this image."},
>>> ],
>>> },
>>> {
>>> "role": "assistant",
>>> "content": [
>>> {"type": "text", "text": "There is a dog and"},
>>> ],
>>> },
>>> ]
>>> pipe(text=messages, max_new_tokens=20, return_full_text=False)
[{'input_text': [{'role': 'user',
'content': [{'type': 'image',
'url': 'https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/qwen_vl_demo.jpeg'},
{'type': 'text', 'text': 'Describe this image.'}]},
{'role': 'assistant',
'content': [{'type': 'text', 'text': 'There is a dog and'}]}],
'generated_text': ' a person in the image. The dog is sitting on the sand, and the person is sitting on'}]Obtenga más información sobre los fundamentos del uso de un pipeline en el tutorial de pipeline
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.
__call__
< source >( images: typing.Union[str, list[str], list[list[str]], ForwardRef('Image.Image'), list['Image.Image'], list[list['Image.Image']], list[dict], NoneType] = Nonetext: str | list[str] | list[dict] | None = None**kwargs ) → A list or a list of list of dict
Parámetros
- images (
str,list[str],PIL.Image,list[PIL.Image],list[dict[str, Union[str, 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. Por último, este pipeline también admite el formato de chat (consulte
text) que contiene imágenes y texto en este argumento. - text (str, list[str],
list[dict[str, Union[str, PIL.Image]]]) — The text to be used for generation. If a list of strings is passed, the length of the list should be the same as the number of images. Text can also follow the chat format: a list of dictionaries where each dictionary represents a message in a conversation. Each dictionary should have two keys: ‘role’ and ‘content’. ‘role’ should be one of ‘user’, ‘system’ or ‘assistant’. ‘content’ should be a list of dictionary containing the text of the message and the type of the message. The type of the message can be either ‘text’ or ‘image’. If the type is ‘image’, no text is needed. - return_tensors (
bool, opcional, valor predeterminadoFalse) — Devuelve los tensores de predicciones (como índices de tokens) en las salidas. Si se establece enTrue, no se devuelve el texto decodificado. - return_text (
bool, opcional) — Devuelve los textos decodificados en las salidas. - return_full_text (
bool, opcional, valor predeterminadoTrue) — Si se establece enFalse, solo se devuelve el texto añadido; de lo contrario, se devuelve el texto completo. No se puede especificar al mismo tiempo quereturn_text. - clean_up_tokenization_spaces (
bool, opcional) — Indica si se deben limpiar los espacios adicionales potenciales en la salida de texto. Por defecto, utiliza la configuraciónclean_up_tokenization_spacesdel 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. Por defecto, este valor esTruecuando el último mensaje del chat de entrada tiene el rolassistantyFalseen 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 cuandoreturn_text=True) — El texto generado. - generated_token_ids (
torch.Tensor, presente cuandoreturn_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
clase transformers.AnyToAnyPipeline
< source >( *args**kwargs )
Parámetros
- model (PreTrainedModel) — El modelo que se utilizará en la pipeline para realizar predicciones. Debe ser un modelo que herede de PreTrainedModel.
- processor (ProcessorMixin) —
El procesador que se utilizará en la pipeline para codificar los datos para el modelo. Este objeto hereda de
ProcessorMixin. Processor es un objeto compuesto que puede contener
tokenizer,feature_extractoryimage_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 utilizará DataLoader (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del lote a utilizar; para la inferencia, esto no siempre es beneficioso, lea Batching with pipelines . - args_parser (ArgumentHandler, opcional) — Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.
- device (
intostrotorch.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. Pasadevice="cpu"(o-1) para forzar la CPU, un ordinal positivo o"cuda:1"para seleccionar un acelerador específico, o untorch.device/strnativo. Este argumento no se puede combinar con un modelo ya cargado medianteaccelerate(es decir, uno con unhf_device_map). - dtype (
strotorch.dtype, opcional, valor predeterminado"auto") — Precisión en la que se carga el modelo, se reenvía afrom_pretrained. El valor predeterminado es"auto", que carga el modelo en el dtype en el que se guardó (leído deconfig.dtypedel checkpoint, o inferido de los pesos si no está disponible). Pase untorch.float16,torch.bfloat16,torch.float32, … explícito para sobrescribirlo. - binary_output (
bool, opcional, valor predeterminadoFalse) — Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida crudos, 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 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
Ejemplo:
>>> from transformers import pipeline
>>> pipe = pipeline(task="any-to-any", model="google/gemma-3n-E4B-it")
>>> pipe("https://huggingface.co/datasets/Narsil/image_dummy/raw/main/parrots.png", text="A photo of")
[{'generated_text': 'a photo of two birds'}]>>> from transformers import pipeline
>>> pipe = pipeline("any-to-any", model="google/gemma-3n-E4B-it")
>>> messages = [
>>> {
>>> "role": "user",
>>> "content": [
>>> {
>>> "type": "image",
>>> "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/qwen_vl_demo.jpeg",
>>> },
>>> {"type": "text", "text": "Describe this image."},
>>> ],
>>> },
>>> {
>>> "role": "assistant",
>>> "content": [
>>> {"type": "text", "text": "There is a dog and"},
>>> ],
>>> },
>>> ]
>>> pipe(text=messages, max_new_tokens=20, return_full_text=False)
[{'input_text': [{'role': 'user',
'content': [{'type': 'image',
'url': 'https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/qwen_vl_demo.jpeg'},
{'type': 'text', 'text': 'Describe this image.'}]},
{'role': 'assistant',
'content': [{'type': 'text', 'text': 'There is a dog and'}]}],
'generated_text': ' a person in the image. The dog is sitting on the sand, and the person is sitting on'}]Obtenga más información sobre los fundamentos del uso de un pipeline en el tutorial de pipeline
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.
__call__
< source >( text: str | list[str] | list[dict]images: typing.Union[str, list[str], list[list[str]], ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonevideos: typing.Union[str, list[str], list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = Noneaudio: typing.Union[str, list[str], numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None**kwargs ) → A list or a list of list of dict
Parámetros
- text (
str,list[str],list[dict]) — The text to be used for generation. If a list of strings is passed, the length of the list should be the same as the number of images. Text can also follow the chat format: a list of dictionaries where each dictionary represents a message in a conversation. Each dictionary should have two keys: ‘role’ and ‘content’. ‘role’ should be one of ‘user’, ‘system’ or ‘assistant’. ‘content’ should be a list of dictionary containing the text of the message and the type of the message. - 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 (consulte
text) que contiene imágenes y texto en este argumento. - videos (
str,list[str],VideoInput) — El pipeline maneja tres tipos de videos:- Una cadena que contiene un enlace HTTP(s) que apunta a un video
- Una cadena que contiene una ruta local a un video
- Un video cargado y decodificado en formato de matriz
El pipeline acepta un único video o un lote de videos. Por último, este pipeline también admite el formato de chat (consulte
text) que contiene videos y texto en este argumento. - audio (
str,list[str],AudioInput) — El pipeline maneja tres tipos de audio:- 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 (consulte
text) que contiene audios y texto en este argumento. - return_tensors (
bool, opcional, valor predeterminadoFalse) — Devuelve los tensores de predicciones (como índices de tokens) en las salidas. Si se establece enTrue, no se devuelve el texto decodificado. - return_text (
bool, opcional) — Devuelve los textos decodificados en las salidas. - return_full_text (
bool, opcional, valor predeterminadoTrue) — Si se establece enFalse, solo se devuelve el texto añadido; de lo contrario, se devuelve el texto completo. No se puede especificar al mismo tiempo quereturn_text. - clean_up_tokenization_spaces (
bool, opcional) — Indica si se deben limpiar los espacios adicionales potenciales en la salida de texto. Por defecto, utiliza la configuraciónclean_up_tokenization_spacesdel 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. Por defecto, este valor esTruecuando el último mensaje del chat de entrada tiene el rolassistantyFalseen 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 cuandoreturn_text=Trueygeneration_mode="text") — El texto generado. - generated_audio (
np.ndarray, presente cuandogeneration_mode="audio") — El audio generado. - generated_image (
PIL.Image.Image, presente cuandogeneration_mode="image") — La imagen generada. - generated_token_ids (
torch.Tensor, presente cuandoreturn_tensors=Trueygeneration_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
clase transformers.MaskGenerationPipeline
< source >( **kwargs )
Parámetros
- model (PreTrainedModel) — El modelo que se utilizará en la pipeline para realizar predicciones. Debe ser un modelo que herede de PreTrainedModel.
- image_processor (BaseImageProcessor) — El procesador de imágenes que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de 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 utilizará DataLoader (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del lote a utilizar; para la inferencia, esto no siempre es beneficioso, lea Batching with pipelines . - args_parser (ArgumentHandler, opcional) — Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.
- device (
intostrotorch.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. Pasadevice="cpu"(o-1) para forzar la CPU, un ordinal positivo o"cuda:1"para seleccionar un acelerador específico, o untorch.device/strnativo. Este argumento no se puede combinar con un modelo ya cargado medianteaccelerate(es decir, uno con unhf_device_map). - dtype (
strotorch.dtype, opcional, valor predeterminado"auto") — Precisión en la que se carga el modelo, se reenvía afrom_pretrained. El valor predeterminado es"auto", que carga el modelo en el dtype en el que se guardó (leído deconfig.dtypedel checkpoint, o inferido de los pesos si no está disponible). Pase untorch.float16,torch.bfloat16,torch.float32, … explícito para sobrescribirlo. - binary_output (
bool, opcional, valor predeterminadoFalse) — Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida crudos, 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 usan más memoria de GPU.
- output_bboxes_mask (
bool, opcional, por defectoFalse) — Si se deben o no incluir las predicciones de las cajas delimitadoras en la salida. - output_rle_masks (
bool, opcional, por defectoFalse) — Si se deben o no generar las máscaras en formatoRLE
Generación automática de máscaras para imágenes usando SamForMaskGeneration. Este pipeline predice máscaras binarias para una
imagen, a partir de una imagen. Es un ChunkPipeline porque puedes separar los puntos en un mini-lote para
evitar problemas de OOM. Usa el argumento points_per_batch para controlar el número de puntos que se procesarán al
mismo tiempo. El valor predeterminado es 64.
El pipeline funciona en 3 pasos:
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 usandoimage_processor. Esta funciónyieldsun minibatch depoints_per_batch.forward: envía las salidas depreprocessal modelo. El incrustado de imagen se calcula solo una vez. Llama tanto aself.model.get_image_embeddingscomo a y se asegura de que no se calculen los gradientes, y de que los tensores y los modelos estén en el mismo dispositivo.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 bucle de minibatch): toma las máscaras de salida crudas, las redimensiona según el tamaño de la imagen y las transforma en máscaras binarias.
- image_processor.filter_masks (en cada bucle de minibatch): utiliza tanto
pred_iou_threshcomostability_scores. También aplica una variedad de filtros basados en la supresión de máximos no máximos para eliminar máscaras defectuosas. - image_processor.postprocess_masks_for_amg aplica el NSM a la máscara para conservar solo las relevantes.
Ejemplo:
>>> 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
Este pipeline de segmentación se puede cargar actualmente desde pipeline() utilizando el siguiente identificador de tarea: "mask-generation".
Vea la lista de modelos disponibles en huggingface.co/models.
__call__
< source >( image: typing.Union[str, ForwardRef('Image.Image'), list[str], list['Image.Image']]*args: Any**kwargs: Any ) → Dict
Parámetros
- image (
str,List[str],PIL.ImageoList[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 los cambios en el corte utilizado para binarizar las predicciones de máscara del modelo. - stability_score_offset (
int, opcional, valor predeterminado 1) — La cantidad que se desplaza el umbral al calcular la puntuación de estabilidad. - crops_nms_thresh (
float, opcional, valor predeterminado 0.7) — Umbral de IoU de las cajas utilizado por la supresión no máxima para filtrar máscaras duplicadas. - crops_n_layers (
int, opcional, valor predeterminado 0) — Sicrops_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 predeterminado512 / 1500) — Establece el grado de superposición de los recortes. En la primera capa de recortes, estos se superpondrán en esta fracción de la longitud de la imagen. Las capas posteriores, con más recortes, reducen esta superposición. - crop_n_points_downscale_factor (
int, opcional, valor predeterminado1) — 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) — El tiempo máximo en segundos para esperar la descarga 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 “objeto” descrito por la etiqueta y la máscara.
Genera máscaras de segmentación binaria
Clase principal: Pipeline
clase transformers.Pipeline
< source >( model: PreTrainedModeltokenizer: PreTrainedTokenizer | None = Nonefeature_extractor: PreTrainedFeatureExtractor | None = Noneimage_processor: BaseImageProcessor | None = Nonevideo_processor: BaseVideoProcessor | None = Noneprocessor: ProcessorMixin | None = Nonetask: str = ''device: int | torch.device | None = Nonebinary_output: bool = False**kwargs )
Parámetros
- model (PreTrainedModel) — El modelo que se utilizará en la pipeline para realizar predicciones. Debe ser un modelo que herede de PreTrainedModel.
- tokenizer (PreTrainedTokenizer) — El tokenizador que se utilizará en la pipeline para codificar los datos para el modelo. Este objeto hereda de PreTrainedTokenizer.
- feature_extractor (SequenceFeatureExtractor) — El extractor de características que se utilizará en la pipeline para codificar los datos para el modelo. Este objeto hereda de SequenceFeatureExtractor.
- image_processor (BaseImageProcessor) — El procesador de imágenes que se utilizará en el pipeline para codificar los datos para el modelo. Este objeto hereda de BaseImageProcessor.
- processor (ProcessorMixin) —
El procesador que se utilizará en la pipeline para codificar los datos para el modelo. Este objeto hereda de
ProcessorMixin. Processor es un objeto compuesto que puede contener
tokenizer,feature_extractoryimage_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 utilizará DataLoader (al pasar un dataset, en GPU para un modelo de Pytorch), el tamaño del lote a utilizar; para la inferencia, esto no siempre es beneficioso, lea Batching with pipelines . - args_parser (ArgumentHandler, opcional) — Referencia al objeto encargado de analizar los parámetros de pipeline proporcionados.
- device (
intostrotorch.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. Pasadevice="cpu"(o-1) para forzar la CPU, un ordinal positivo o"cuda:1"para seleccionar un acelerador específico, o untorch.device/strnativo. Este argumento no se puede combinar con un modelo ya cargado medianteaccelerate(es decir, uno con unhf_device_map). - dtype (
strotorch.dtype, opcional, valor predeterminado"auto") — Precisión en la que se carga el modelo, se reenvía afrom_pretrained. El valor predeterminado es"auto", que carga el modelo en el dtype en el que se guardó (leído deconfig.dtypedel checkpoint, o inferido de los pesos si no está disponible). Pase untorch.float16,torch.bfloat16,torch.float32, … explícito para sobrescribirlo. - binary_output (
bool, opcional, valor predeterminadoFalse) — Indica si la salida de la pipeline debe estar en un formato serializado (p. ej., pickle) o como datos de salida crudos, por ejemplo, texto.
La clase Pipeline es la clase de la que heredan todos los pipelines. Consulte esta clase para los métodos compartidos entre los diferentes pipelines.
Clase base que implementa operaciones en pipeline. El flujo de trabajo del pipeline se define como una secuencia de las siguientes
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 ('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
< source >( supported_models: list[str] | dict )
Comprueba si la clase del modelo está soportada por la pipeline.
Context Manager que permite la asignación de tensores en el dispositivo especificado por el usuario.
ensure_tensor_on_device
< source >( **inputs ) → dict[str, torch.Tensor]
Asegúrate de que los tensores de PyTorch estén en el dispositivo especificado.
Postprocess recibirá las salidas crudas del método _forward, generalmente tensores, y las reformateará en algo más manejable. Por lo general, devolverá una lista o un diccionario de resultados (que contienen solo cadenas de texto y números).
Interfaz de Scikit / Keras para las pipelines de transformers. Este método reenviará a call().
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
< source >( repo_id: strcommit_message: str | None = Nonecommit_description: str | None = Noneprivate: bool | None = Nonetoken: bool | str | None = Nonerevision: str | None = Nonecreate_pr: bool = Falsemax_shard_size: int | str | None = '50GB'tags: list[str] | None = None )
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 para el commit 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 esNone(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 (
boolostr, opcional) — El token que se usará como autorización HTTP bearer para archivos remotos. Si esTrue(valor predeterminado), se usará el token generado al ejecutarhf auth login(almacenado en~/.huggingface). - revision (
str, opcional) — Rama a la que se enviarán los archivos subidos. - create_pr (
bool, opcional, valor predeterminadoFalse) — Si se debe crear una PR con los archivos subidos o realizar el commit directamente. - max_shard_size (
intostr, opcional, valor predeterminado"50GB") — Solo aplicable a modelos. El tamaño máximo de un checkpoint antes de ser fragmentado. 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:
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
< source >( save_directory: str | os.PathLike**kwargs: Any )
Parámetros
- save_directory (
stroos.PathLike) — Una 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().
Guarde el modelo y el tokenizador del pipeline.
Interfaz de Scikit / Keras para las pipelines de transformers. Este método reenviará a call().