Hub Python Library documentation

Inferencia

Hub Python Library

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Inferencia

La inferencia es el proceso de utilizar un modelo entrenado para realizar predicciones sobre nuevos datos. Dado que este proceso puede ser intensivo en cómputo, ejecutarlo en un servicio dedicado o externo puede ser una opción interesante. La biblioteca huggingface_hub proporciona una interfaz unificada para ejecutar inferencia en múltiples servicios para modelos alojados en Hugging Face Hub:

Proveedores de inferencia: un acceso unificado y simplificado a cientos de modelos de aprendizaje automático, impulsado por nuestros socios de inferencia serverless. Este nuevo enfoque se basa en nuestra anterior API de inferencia serverless, ofreciendo más modelos, un rendimiento mejorado y una mayor fiabilidad gracias a proveedores de primer nivel. Consulta la documentación para obtener una lista de los proveedores compatibles.
Inference Endpoints: un producto para desplegar modelos en producción de forma sencilla. La inferencia se ejecuta en Hugging Face en una infraestructura dedicada y totalmente gestionada en un proveedor de nube de su elección.
Puntos finales locales: también puede ejecutar inferencia con servidores de inferencia locales como llama.cpp, Ollama, vLLM, LiteLLM o Text Generation Inference (TGI) conectando el cliente a estos puntos finales locales.

Estos servicios se pueden llamar con el objeto InferenceClient. Consulte esta guía para obtener más información sobre cómo usarlo.

Cliente de inferencia

clase huggingface_hub.InferenceClient

( model: str | None = Noneprovider: typing.Union[typing.Literal['baseten', 'cerebras', 'cohere', 'deepinfra', 'fal-ai', 'featherless-ai', 'fireworks-ai', 'groq', 'hf-inference', 'novita', 'nscale', 'openai', 'ovhcloud', 'publicai', 'replicate', 'scaleway', 'together', 'wavespeed', 'zai-org'], typing.Literal['auto'], NoneType] = Nonetoken: str | None = Nonetimeout: float | None = Noneheaders: dict[str, str] | None = Nonecookies: dict[str, str] | None = Nonebill_to: str | None = Nonebase_url: str | None = Noneapi_key: str | None = None )

Parámetros

model (str, optional) — El modelo con el que se ejecutará la inferencia. Puede ser un identificador de modelo alojado en el Hugging Face Hub, por ejemplo meta-llama/Meta-Llama-3-8B-Instruct o una URL de un Inference Endpoint desplegado. El valor predeterminado es None, en cuyo caso se selecciona automáticamente un modelo recomendado para la tarea. Nota: para una mejor compatibilidad con el cliente de OpenAI, model se ha aliasado como base_url. Estos dos argumentos son mutuamente excluyentes. Si se pasa una URL como model o base_url para la finalización de chat, se añadirá la ruta de sufijo (/v1)/chat/completions a la URL.
provider (str, opcional) — Nombre del proveedor que se utilizará para la inferencia. Puede ser "baseten", "cerebras", "cohere", "deepinfra", "fal-ai", "featherless-ai", "fireworks-ai", "groq", "hf-inference", "novita", "nscale", "openai", "ovhcloud", "publicai", "replicate", "scaleway", "together", "wavespeed" o "zai-org". El valor predeterminado es “auto”: enrutamiento automático, que por defecto utiliza el proveedor “fastest”; puedes cambiar al orden de proveedores “cheapest” o “preferred” en https://hf.co/settings/inference-providers. Si el modelo es una URL o se pasa base_url, entonces provider no se utiliza.
token (str, opcional) — Token de Hugging Face. Si no se proporciona, se usará el token guardado localmente. Nota: para una mejor compatibilidad con el cliente de OpenAI, token se ha aliasado como api_key. Estos dos argumentos son mutuamente excluyentes y tienen exactamente el mismo comportamiento.
timeout (float, optional) — El número máximo de segundos para esperar una respuesta del servidor. El valor predeterminado es None, lo que significa que se repetirá hasta que el servidor esté disponible.
headers (dict[str, str], optional) — Encabezados adicionales para enviar al servidor. De forma predeterminada, solo se envían los encabezados de autorización y user-agent. Los valores de este diccionario reemplazarán los valores predeterminados.
bill_to (str, optional) — La cuenta de facturación que se utilizará para las solicitudes. De forma predeterminada, las solicitudes se facturan en la cuenta del usuario. Las solicitudes solo pueden facturarse a una organización de la que el usuario sea miembro y que haya suscrito Enterprise Hub.
cookies (dict[str, str], optional) — Cookies adicionales para enviar al servidor.
base_url (str, optional) — URL base para ejecutar la inferencia. Este es un argumento duplicado de model para que InferenceClient siga el mismo patrón que el cliente openai.OpenAI. No se puede usar si model está establecido. El valor predeterminado es None.
api_key (str, optional) — Token para la autenticación. Este es un argumento duplicado de token para que InferenceClient siga el mismo patrón que el cliente openai.OpenAI. No se puede usar si token está establecido. El valor predeterminado es None.

Inicializa un nuevo Inference Client.

InferenceClient busca ofrecer una experiencia unificada para realizar inferencia. El cliente puede usarse de forma transparente con la Inference API (gratuita), con Inference Endpoints autoalojados o con Inference Providers de terceros.

clasificación_de_audio

( audio: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview]model: str | None = Nonetop_k: int | None = Nonefunction_to_apply: typing.Optional[ForwardRef('AudioClassificationOutputTransform')] = None ) → list[AudioClassificationOutputElement]

Parámetros

audio (Union[str, Path, bytes, BinaryIO]) — El contenido de audio a clasificar. Puede ser bytes de audio sin procesar, un archivo de audio local o una URL que apunte a un archivo de audio.
model (str, opcional) — El modelo a utilizar para la clasificación de audio. Puede ser un ID de modelo alojado en el Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo recomendado por defecto para la clasificación de audio.
top_k (int, opcional) — Cuando se especifica, limita la salida a las K clases más probables.
function_to_apply ("AudioClassificationOutputTransform", opcional) — La función que se aplica a las salidas del modelo para obtener las puntuaciones.

Devuelve

list[AudioClassificationOutputElement]

Lista de elementos AudioClassificationOutputElement que contienen las etiquetas predichas y su confianza.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Realiza la clasificación de audio en el contenido de audio proporcionado.

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()
>>> client.audio_classification("audio.flac")
[
    AudioClassificationOutputElement(score=0.4976358711719513, label='hap'),
    AudioClassificationOutputElement(score=0.3677836060523987, label='neu'),
    ...
]

audio_to_audio

( audio: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview]model: str | None = None ) → list[AudioToAudioOutputElement]

Parámetros

audio (Union[str, Path, bytes, BinaryIO]) — El contenido de audio para el modelo. Puede ser bytes de audio sin procesar, un archivo de audio local o una URL que apunte a un archivo de audio.
model (str, opcional) — El modelo puede ser cualquier modelo que reciba un archivo de audio y devuelva otro archivo de audio. Puede ser un ID de modelo alojado en el Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo recomendado por defecto para audio_to_audio.

Devuelve

list[AudioToAudioOutputElement]

Una lista de elementos AudioToAudioOutputElement que contienen la etiqueta de audio, el tipo de contenido y el contenido de audio en un blob.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Realiza múltiples tareas relacionadas con audio a audio, según el modelo (por ejemplo: mejora de voz, separación de fuentes).

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()
>>> audio_output = client.audio_to_audio("audio.flac")
>>> for i, item in enumerate(audio_output):
>>>     with open(f"output_{i}.flac", "wb") as f:
            f.write(item.blob)

automatic_speech_recognition

( audio: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview]model: str | None = Noneextra_body: dict | None = None ) → AutomaticSpeechRecognitionOutput

Parámetros

audio (Union[str, Path, bytes, BinaryIO]) — El contenido que se debe transcribir. Puede ser bytes de audio en bruto, un archivo de audio local o una URL a un archivo de audio.
model (str, opcional) — El modelo a utilizar para ASR. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo recomendado por defecto para ASR.
extra_body (dict, opcional) — Parámetros adicionales específicos del proveedor para pasar al modelo. Consulte la documentación del proveedor para los parámetros admitidos.

Devuelve

AutomaticSpeechRecognitionOutput

Un elemento que contiene el texto transcrito y, opcionalmente, los fragmentos de marcas de tiempo.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Realice reconocimiento automático de voz (ASR o audio a texto) en el contenido de audio proporcionado.

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()
>>> client.automatic_speech_recognition("hello_world.flac").text
"hello world"

chat_completion

( messages: listmodel: str | None = Nonestream: bool = Falsefrequency_penalty: float | None = Nonelogit_bias: list[float] | None = Nonelogprobs: bool | None = Nonemax_tokens: int | None = Nonen: int | None = Nonepresence_penalty: float | None = Noneresponse_format: typing.Union[huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatText, huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatJSONSchema, huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatJSONObject, NoneType] = Noneseed: int | None = Nonestop: list[str] | None = Nonestream_options: huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions | None = Nonetemperature: float | None = Nonetool_choice: typing.Union[huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass, ForwardRef('ChatCompletionInputToolChoiceEnum'), NoneType] = Nonetool_prompt: str | None = Nonetools: list[huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool] | None = Nonetop_logprobs: int | None = Nonetop_p: float | None = Noneextra_body: dict | None = None ) → ChatCompletionOutput or Iterable of ChatCompletionStreamOutput

Parámetros

messages (Lista de ChatCompletionInputMessage) — Historial de conversación que consiste en pares de roles y contenido.
model (str, opcional) — El modelo a utilizar para la chat-completion. Puede ser un ID de modelo alojado en el Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo recomendado por defecto para la generación de texto basada en chat. Vea https://huggingface.co/tasks/text-generation para más detalles. Si model es un ID de modelo, se pasa al servidor como el parámetro model. Si desea definir una URL personalizada mientras establece model en el payload de la solicitud, debe establecer base_url al inicializar InferenceClient.
frequency_penalty (float, opcional) — Penaliza los nuevos tokens en función de su frecuencia existente en el texto hasta el momento. Rango: [-2.0, 2.0]. Valor predeterminado: 0.0.
logit_bias (list[float], opcional) — Ajusta la probabilidad de que ciertos tokens aparezcan en la salida generada.
logprobs (bool, opcional) — Indica si se deben devolver las probabilidades logarítmicas de los tokens de salida. Si es true, devuelve las probabilidades logarítmicas de cada token de salida devuelto en el contenido del mensaje.
max_tokens (int, opcional) — Número máximo de tokens permitidos en la respuesta. El valor predeterminado es 100.
n (int, opcional) — El número de completados que se generarán para cada indicación.
presence_penalty (float, opcional) — Número entre -2.0 y 2.0. Los valores positivos penalizan los nuevos tokens en función de si aparecen en el texto hasta ahora, aumentando la probabilidad de que el modelo hable sobre temas nuevos.
response_format (ChatCompletionInputGrammarType(), opcional) — Restricciones de gramática. Puede ser un JSONSchema o una expresión regular.
seed (Opcionalint, optional) — Semilla para un flujo de control reproducible. El valor predeterminado es None.
stop (list[str], opcional) — Hasta cuatro cadenas que provocan el final de la respuesta. El valor predeterminado es None.
stream (bool, opcional) — Habilita la transmisión en tiempo real de las respuestas. El valor predeterminado es False.
stream_options (ChatCompletionInputStreamOptions, opcional) — Opciones para las completaciones en streaming.
temperature (float, opcional) — Controla la aleatoriedad de las generaciones. Valores más bajos garantizan complementos menos aleatorios. Rango: [0, 2]. Valor predeterminado: 1.0.
top_logprobs (int, opcional) — Un entero entre 0 y 5 que especifica el número de tokens más probables a devolver en cada posición de token, cada uno con una probabilidad logarítmica asociada. logprobs debe establecerse en true si se utiliza este parámetro.
top_p (float, opcional) — Fracción de las palabras siguientes más probables desde las que muestrear. Debe estar entre 0 y 1. El valor predeterminado es 1.0.
tool_choice (ChatCompletionInputToolChoiceClass o ChatCompletionInputToolChoiceEnum(), opcional) — La herramienta que se usará para la finalización. El valor predeterminado es “auto”.
tool_prompt (str, opcional) — Un prompt que se añade antes de las herramientas.
tools (Lista de ChatCompletionInputTool, opcional) — Una lista de herramientas que el modelo puede llamar. Actualmente, solo se admiten funciones como herramienta. Utilice esto para proporcionar una lista de funciones para las que el modelo puede generar entradas JSON.
extra_body (dict, opcional) — Parámetros adicionales específicos del proveedor para pasar al modelo. Consulte la documentación del proveedor para los parámetros admitidos.

Devuelve

ChatCompletionOutput o iterable de ChatCompletionStreamOutput

Texto generado devuelto por el servidor:

Si stream=False, el texto generado se devuelve como ChatCompletionOutput (valor predeterminado).
Si stream=True, el texto generado se devuelve token a token como una secuencia de ChatCompletionStreamOutput.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Un método para completar conversaciones utilizando un modelo de lenguaje especificado.

El método client.chat_completion tiene el alias client.chat.completions.create para ser compatible con el cliente de OpenAI. Las entradas y salidas son estrictamente las mismas y el uso de cualquiera de las dos sintaxis producirá los mismos resultados. Consulte la Guía de inferencia para obtener más detalles sobre la compatibilidad con OpenAI.

Puedes pasar parámetros específicos del proveedor al modelo utilizando el argumento extra_body.

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> messages = [{"role": "user", "content": "What is the capital of France?"}]
>>> client = InferenceClient("meta-llama/Meta-Llama-3-8B-Instruct")
>>> client.chat_completion(messages, max_tokens=100)
ChatCompletionOutput(
    choices=[
        ChatCompletionOutputComplete(
            finish_reason='eos_token',
            index=0,
            message=ChatCompletionOutputMessage(
                role='assistant',
                content='The capital of France is Paris.',
                name=None,
                tool_calls=None
            ),
            logprobs=None
        )
    ],
    created=1719907176,
    id='',
    model='meta-llama/Meta-Llama-3-8B-Instruct',
    object='text_completion',
    system_fingerprint='2.0.4-sha-f426a33',
    usage=ChatCompletionOutputUsage(
        completion_tokens=8,
        prompt_tokens=17,
        total_tokens=25
    )
)

Ejemplo usando streaming:

>>> from huggingface_hub import InferenceClient
>>> messages = [{"role": "user", "content": "What is the capital of France?"}]
>>> client = InferenceClient("meta-llama/Meta-Llama-3-8B-Instruct")
>>> for token in client.chat_completion(messages, max_tokens=10, stream=True):
...     print(token)
ChatCompletionStreamOutput(choices=[ChatCompletionStreamOutputChoice(delta=ChatCompletionStreamOutputDelta(content='The', role='assistant'), index=0, finish_reason=None)], created=1710498504)
ChatCompletionStreamOutput(choices=[ChatCompletionStreamOutputChoice(delta=ChatCompletionStreamOutputDelta(content=' capital', role='assistant'), index=0, finish_reason=None)], created=1710498504)
(...)
ChatCompletionStreamOutput(choices=[ChatCompletionStreamOutputChoice(delta=ChatCompletionStreamOutputDelta(content=' may', role='assistant'), index=0, finish_reason=None)], created=1710498504)

Ejemplo usando la sintaxis de OpenAI:

# instead of `from openai import OpenAI`
from huggingface_hub import InferenceClient

# instead of `client = OpenAI(...)`
client = InferenceClient(
    base_url=...,
    api_key=...,
)

output = client.chat.completions.create(
    model="meta-llama/Meta-Llama-3-8B-Instruct",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Count to 10"},
    ],
    stream=True,
    max_tokens=1024,
)

for chunk in output:
    print(chunk.choices[0].delta.content)

Ejemplo de uso de un proveedor de terceros directamente con parámetros adicionales (específicos del proveedor). El uso se facturará en su cuenta de Together AI.

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient(
...     provider="together",  # Use Together AI provider
...     api_key="<together_api_key>",  # Pass your Together API key directly
... )
>>> client.chat_completion(
...     model="meta-llama/Meta-Llama-3-8B-Instruct",
...     messages=[{"role": "user", "content": "What is the capital of France?"}],
...     extra_body={"safety_model": "Meta-Llama/Llama-Guard-7b"},
... )

Ejemplo de uso de un proveedor de terceros a través de Hugging Face Routing. El uso se facturará en tu cuenta de Hugging Face.

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient(
...     provider="novita",  # Use Novita provider
...     api_key="hf_...",  # Pass your HF token
... )
>>> client.chat_completion(
...     model="meta-llama/Meta-Llama-3-8B-Instruct",
...     messages=[{"role": "user", "content": "What is the capital of France?"}],
... )

Ejemplo usando Imagen + Texto como entrada:

>>> from huggingface_hub import InferenceClient

# provide a remote URL
>>> image_url ="https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
# or a base64-encoded image
>>> image_path = "/path/to/image.jpeg"
>>> with open(image_path, "rb") as f:
...     base64_image = base64.b64encode(f.read()).decode("utf-8")
>>> image_url = f"data:image/jpeg;base64,{base64_image}"

>>> client = InferenceClient("meta-llama/Llama-3.2-11B-Vision-Instruct")
>>> output = client.chat.completions.create(
...     messages=[
...         {
...             "role": "user",
...             "content": [
...                 {
...                     "type": "image_url",
...                     "image_url": {"url": image_url},
...                 },
...                 {
...                     "type": "text",
...                     "text": "Describe this image in one sentence.",
...                 },
...             ],
...         },
...     ],
... )
>>> output
The image depicts the iconic Statue of Liberty situated in New York Harbor, New York, on a clear day.

Ejemplo usando herramientas:

>>> client = InferenceClient("meta-llama/Meta-Llama-3-70B-Instruct")
>>> messages = [
...     {
...         "role": "system",
...         "content": "Don't make assumptions about what values to plug into functions. Ask for clarification if a user request is ambiguous.",
...     },
...     {
...         "role": "user",
...         "content": "What's the weather like the next 3 days in San Francisco, CA?",
...     },
... ]
>>> tools = [
...     {
...         "type": "function",
...         "function": {
...             "name": "get_current_weather",
...             "description": "Get the current weather",
...             "parameters": {
...                 "type": "object",
...                 "properties": {
...                     "location": {
...                         "type": "string",
...                         "description": "The city and state, e.g. San Francisco, CA",
...                     },
...                     "format": {
...                         "type": "string",
...                         "enum": ["celsius", "fahrenheit"],
...                         "description": "The temperature unit to use. Infer this from the users location.",
...                     },
...                 },
...                 "required": ["location", "format"],
...             },
...         },
...     },
...     {
...         "type": "function",
...         "function": {
...             "name": "get_n_day_weather_forecast",
...             "description": "Get an N-day weather forecast",
...             "parameters": {
...                 "type": "object",
...                 "properties": {
...                     "location": {
...                         "type": "string",
...                         "description": "The city and state, e.g. San Francisco, CA",
...                     },
...                     "format": {
...                         "type": "string",
...                         "enum": ["celsius", "fahrenheit"],
...                         "description": "The temperature unit to use. Infer this from the users location.",
...                     },
...                     "num_days": {
...                         "type": "integer",
...                         "description": "The number of days to forecast",
...                     },
...                 },
...                 "required": ["location", "format", "num_days"],
...             },
...         },
...     },
... ]

>>> response = client.chat_completion(
...     model="meta-llama/Meta-Llama-3-70B-Instruct",
...     messages=messages,
...     tools=tools,
...     tool_choice="auto",
...     max_tokens=500,
... )
>>> response.choices[0].message.tool_calls[0].function
ChatCompletionOutputFunctionDefinition(
    arguments={
        'location': 'San Francisco, CA',
        'format': 'fahrenheit',
        'num_days': 3
    },
    name='get_n_day_weather_forecast',
    description=None
)

Ejemplo usando response_format:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient("meta-llama/Meta-Llama-3-70B-Instruct")
>>> messages = [
...     {
...         "role": "user",
...         "content": "I saw a puppy a cat and a raccoon during my bike ride in the park. What did I see and when?",
...     },
... ]
>>> response_format = {
...     "type": "json",
...     "value": {
...         "properties": {
...             "location": {"type": "string"},
...             "activity": {"type": "string"},
...             "animals_seen": {"type": "integer", "minimum": 1, "maximum": 5},
...             "animals": {"type": "array", "items": {"type": "string"}},
...         },
...         "required": ["location", "activity", "animals_seen", "animals"],
...     },
... }
>>> response = client.chat_completion(
...     messages=messages,
...     response_format=response_format,
...     max_tokens=500,
... )
>>> response.choices[0].message.content
'{

y": "bike ride",
": ["puppy", "cat", "raccoon"],
_seen": 3,
n": "park"}'

document_question_answering

( image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview]question: strmodel: str | None = Nonedoc_stride: int | None = Nonehandle_impossible_answer: bool | None = Nonelang: str | None = Nonemax_answer_len: int | None = Nonemax_question_len: int | None = Nonemax_seq_len: int | None = Nonetop_k: int | None = Noneword_boxes: list[list[float] | str] | None = None ) → list[DocumentQuestionAnsweringOutputElement]

Parámetros

image (Union[str, Path, bytes, BinaryIO]) — La imagen de entrada para el contexto. Puede ser bytes en bruto, un archivo de imagen o una URL a una imagen en línea.
question (str) — Pregunta a responder.
model (str, opcional) — El modelo que se utilizará para la tarea de respuesta a preguntas sobre documentos. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo de respuesta a preguntas sobre documentos recomendado por defecto. El valor predeterminado es None.
doc_stride (int, opcional) — 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.
handle_impossible_answer (bool, opcional) — Si se acepta "imposible" como respuesta
lang (str, opcional) — Idioma a utilizar durante la ejecución de OCR. El valor predeterminado es inglés.
max_answer_len (int, opcional) — La longitud máxima de las respuestas predichas (p. ej., solo se consideran las respuestas con una longitud menor).
max_question_len (int, opcional) — La longitud máxima de la pregunta después de la tokenización. Se truncará si es necesario.
max_seq_len (int, opcional) — 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 (usando doc_stride como solapamiento) si es necesario.
top_k (int, opcional) — El número de respuestas a devolver (se elegirán por orden de probabilidad). Puede devolver menos de top_k respuestas si no hay suficientes opciones disponibles dentro del contexto.
word_boxes (list[Union[list[float], str, opcional) — Una lista de palabras y cajas delimitadoras (normalizadas de 0 a 1000). Si se proporciona, la inferencia omitirá el paso de OCR y usará las cajas delimitadoras proporcionadas en su lugar.

Devuelve

list[DocumentQuestionAnsweringOutputElement]

una lista de elementos DocumentQuestionAnsweringOutputElement que contienen la etiqueta predicha, la probabilidad asociada, los ids de las palabras y el número de página.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Responde preguntas sobre imágenes de documentos.

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()
>>> client.document_question_answering(image="https://huggingface.co/spaces/impira/docquery/resolve/2359223c1837a7587402bda0f2643382a6eefeab/invoice.png", question="What is the invoice number?")
[DocumentQuestionAnsweringOutputElement(answer='us-001', end=16, score=0.9999666213989258, start=16)]

feature_extraction

( text: str | list[str]normalize: bool | None = Noneprompt_name: str | None = Nonetruncate: bool | None = Nonetruncation_direction: typing.Optional[typing.Literal['left', 'right']] = Nonedimensions: int | None = Noneencoding_format: typing.Optional[typing.Literal['float', 'base64']] = Nonemodel: str | None = None ) → np.ndarray

Parámetros

text (str o list[str]) — El texto o lista de textos para incrustar.
model (str, opcional) — El modelo a utilizar para la tarea de extracción de características. Puede ser un ID de modelo alojado en el Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo de extracción de características recomendado por defecto. El valor predeterminado es None.
normalize (bool, opcional) — Si se normalizan o no los embeddings. Solo disponible en servidores impulsados por Text-Embedding-Inference.
prompt_name (str, opcional) — El nombre del prompt que debe usarse para la codificación. Si no se establece, no se aplicará ningún prompt. Debe ser una clave en el diccionario prompts de la configuración de Sentence Transformers. Por ejemplo, si prompt_name es “query” y prompts es {“query”: “query: ”,…}, la oración “What is the capital of France?” se codificará como “query: What is the capital of France?” porque el texto del prompt se añadirá al principio de cualquier texto a codificar.
truncate (bool, opcional) — Si se deben truncar los embeddings o no. Solo disponible en servidores impulsados por Text-Embedding-Inference.
truncation_direction (Literal[“left”, “right”], opcional) — Indica qué lado de la entrada debe truncarse cuando se pasa truncate=True.
dimensions (int, opcional) — El número de dimensiones que deben tener las incrustaciones de salida resultantes. Solo disponible en puntos finales de incrustaciones compatibles con OpenAI.
encoding_format (Literal[“float”, “base64”], opcional) — El formato de las incrustaciones de salida. Puede ser “float” o “base64”. Solo disponible en puntos finales de incrustaciones compatibles con OpenAI.

Devuelve

np.ndarray

El embedding que representa el texto de entrada como un array numpy de float32.

Lanza

[InferenceTimeoutError] o [HfHubHTTPError]

[InferenceTimeoutError] — Si el modelo no está disponible o la solicitud expira.
[HfHubHTTPError] — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Genera embeddings para un texto o lote de textos dado.

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()
>>> client.feature_extraction("Hi, who are you?")
array([[ 2.424802  ,  2.93384   ,  1.1750331 , ...,  1.240499, -0.13776633, -0.7889173 ],
[-0.42943227, -0.6364878 , -1.693462  , ...,  0.41978157, -2.4336355 ,  0.6162071 ],
...,
[ 0.28552425, -0.928395  , -1.2077185 , ...,  0.76810825, -2.1069427 ,  0.6236161 ]], dtype=float32)

fill_mask

( text: strmodel: str | None = Nonetargets: list[str] | None = Nonetop_k: int | None = None ) → list[FillMaskOutputElement]

Parámetros

text (str) — una cadena de la que se rellenará, debe contener el token [MASK] (consulte la tarjeta del modelo para el nombre exacto de la máscara).
model (str, opcional) — El modelo que se usará para la tarea de fill mask. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se usará el modelo de fill mask recomendado por defecto.
targets (list[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

list[FillMaskOutputElement]

una lista de elementos FillMaskOutputElement que contienen la etiqueta predicha, la probabilidad asociada, la referencia del token y el texto completado.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Rellene un hueco con una palabra que falta (un token, para ser precisos).

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()
>>> client.fill_mask("The goal of life is <mask>.")
[
    FillMaskOutputElement(score=0.06897063553333282, token=11098, token_str=' happiness', sequence='The goal of life is happiness.'),
    FillMaskOutputElement(score=0.06554922461509705, token=45075, token_str=' immortality', sequence='The goal of life is immortality.')
]

get_endpoint_info

( model: str | None = None ) → dict[str, Any]

Parámetros

model (str, opcional) — El modelo que se usará para la inferencia. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Este parámetro anula el modelo definido a nivel de instancia. El valor predeterminado es None.

Devuelve

dict[str, Any]

Información sobre el punto de conexión.

Obtén información sobre el punto de acceso desplegado.

Este punto de solo está disponible en puntos de acceso impulsados por Text-Generation-Inference (TGI) o Text-Embedding-Inference (TEI). Los puntos de acceso impulsados por transformers devuelven una carga vacía.

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient("meta-llama/Meta-Llama-3-70B-Instruct")
>>> client.get_endpoint_info()
{
    'model_id': 'meta-llama/Meta-Llama-3-70B-Instruct',
    'model_sha': None,
    'model_dtype': 'torch.float16',
    'model_device_type': 'cuda',
    'model_pipeline_tag': None,
    'max_concurrent_requests': 128,
    'max_best_of': 2,
    'max_stop_sequences': 4,
    'max_input_length': 8191,
    'max_total_tokens': 8192,
    'waiting_served_ratio': 0.3,
    'max_batch_total_tokens': 1259392,
    'max_waiting_tokens': 20,
    'max_batch_size': None,
    'validation_workers': 32,
    'max_client_batch_size': 4,
    'version': '2.0.2',
    'sha': 'dccab72549635c7eb5ddb17f43f0b7cdff07c214',
    'docker_label': 'sha-dccab72'
}

health_check

( model: str | None = None ) → bool

Parámetros

model (str, opcional) — URL del Inference Endpoint. Este parámetro reemplaza al modelo definido a nivel de instancia. El valor predeterminado es None.

Devuelve

bool

True si todo funciona correctamente.

Comprueba el estado del punto de acceso desplegado.

La comprobación de estado solo está disponible con Inference Endpoints impulsados por Text-Generation-Inference (TGI) o Text-Embedding-Inference (TEI).

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient("https://jzgu0buei5.us-east-1.aws.endpoints.huggingface.cloud")
>>> client.health_check()
True

clasificación_de_imágenes

( image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview]model: str | None = Nonefunction_to_apply: typing.Optional[ForwardRef('ImageClassificationOutputTransform')] = Nonetop_k: int | None = None ) → list[ImageClassificationOutputElement]

Parámetros

image (Union[str, Path, bytes, BinaryIO, PIL.Image.Image]) — The image to classify. It can be raw bytes, an image file, a URL to an online image, or a PIL Image.
model (str, opcional) — El modelo a utilizar para la clasificación de imágenes. Puede ser un ID de modelo alojado en el Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo recomendado por defecto para la clasificación de imágenes.
function_to_apply ("ImageClassificationOutputTransform", opcional) — La función que se aplica a las salidas del modelo para obtener las puntuaciones.
top_k (int, opcional) — Cuando se especifica, limita la salida a las K clases más probables.

Devuelve

list[ImageClassificationOutputElement]

una lista de elementos ImageClassificationOutputElement que contienen la etiqueta predicha y la probabilidad asociada.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Realiza la clasificación de imágenes en la imagen proporcionada utilizando el modelo especificado.

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()
>>> client.image_classification("https://upload.wikimedia.org/wikipedia/commons/thumb/4/43/Cute_dog.jpg/320px-Cute_dog.jpg")
[ImageClassificationOutputElement(label='Blenheim spaniel', score=0.9779096841812134), ...]

image_segmentation

( image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview]model: str | None = Nonemask_threshold: float | None = Noneoverlap_mask_area_threshold: float | None = Nonesubtask: typing.Optional[ForwardRef('ImageSegmentationSubtask')] = Nonethreshold: float | None = None ) → list[ImageSegmentationOutputElement]

Parámetros

image (Union[str, Path, bytes, BinaryIO, PIL.Image.Image]) — The image to segment. It can be raw bytes, an image file, a URL to an online image, or a PIL Image.
model (str, opcional) — El modelo a utilizar para la segmentación de imágenes. Puede ser un ID de modelo alojado en el Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo recomendado por defecto para la segmentación de imágenes.
mask_threshold (float, opcional) — Umbral a utilizar al convertir las máscaras predichas en valores binarios.
overlap_mask_area_threshold (float, opcional) — Umbral de solapamiento de máscaras para eliminar segmentos pequeños y desconectados.
subtask ("ImageSegmentationSubtask", opcional) — Tarea de segmentación a realizar, según las capacidades del modelo.
threshold (float, opcional) — Umbral de probabilidad para filtrar las máscaras predichas.

Devuelve

list[ImageSegmentationOutputElement]

Una lista de elementos ImageSegmentationOutputElement que contiene las máscaras segmentadas y los atributos asociados.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Realice la segmentación de imágenes en la imagen proporcionada utilizando el modelo especificado.

Debes tener PIL instalado si quieres trabajar con imágenes (pip install Pillow).

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()
>>> client.image_segmentation("cat.jpg")
[ImageSegmentationOutputElement(score=0.989008, label='LABEL_184', mask=<PIL.PngImagePlugin.PngImageFile image mode=L size=400x300 at 0x7FDD2B129CC0>), ...]

image_to_image

( image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview]prompt: str | None = Nonenegative_prompt: str | None = Nonenum_inference_steps: int | None = Noneguidance_scale: float | None = Nonemodel: str | None = Nonetarget_size: huggingface_hub.inference._generated.types.image_to_image.ImageToImageTargetSize | None = None**kwargs ) → Image

Parámetros

image (Union[str, Path, bytes, BinaryIO, PIL.Image.Image]) — The input image for translation. It can be raw bytes, an image file, a URL to an online image, or a PIL Image.
prompt (str, opcional) — El texto de la indicación para guiar la generación de la imagen.
negative_prompt (str, opcional) — Un prompt para guiar lo que NO debe incluirse en la generación de la imagen.
num_inference_steps (int, opcional) — Para modelos de difusión. El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.
guidance_scale (float, opcional) — Para modelos de difusión. Un valor de escala de guía más alto anima al modelo a generar imágenes estrechamente vinculadas al prompt de texto a costa de una menor calidad de imagen.
model (str, opcional) — El modelo que se usará para la inferencia. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Este parámetro anula el modelo definido a nivel de instancia. El valor predeterminado es None.
target_size (ImageToImageTargetSize, opcional) — El tamaño en píxeles de la imagen de salida. Este parámetro solo es compatible con algunos proveedores y para modelos específicos. Se ignorará cuando no sea compatible.

Devuelve

Image

La imagen traducida.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Realice la traducción de imagen a imagen utilizando un modelo especificado.

Debes tener PIL instalado si quieres trabajar con imágenes (pip install Pillow).

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()
>>> image = client.image_to_image("cat.jpg", prompt="turn the cat into a tiger")
>>> image.save("tiger.jpg")

image_to_text

( image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview]model: str | None = None ) → ImageToTextOutput

Parámetros

image (Union[str, Path, bytes, BinaryIO, PIL.Image.Image]) — The input image to caption. It can be raw bytes, an image file, a URL to an online image, or a PIL Image.
model (str, opcional) — El modelo que se usará para la inferencia. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Este parámetro anula el modelo definido a nivel de instancia. El valor predeterminado es None.

Devuelve

ImageToTextOutput

El texto generado.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Toma una imagen de entrada y devuelve texto.

Los modelos pueden tener salidas muy diferentes según su caso de uso (descripción de imágenes, reconocimiento óptico de caracteres (OCR), Pix2Struct, etc.). Consulte la tarjeta del modelo para conocer más detalles sobre las especificidades de un modelo.

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()
>>> client.image_to_text("cat.jpg")
'a cat standing in a grassy field '
>>> client.image_to_text("https://upload.wikimedia.org/wikipedia/commons/thumb/4/43/Cute_dog.jpg/320px-Cute_dog.jpg")
'a dog laying on the grass next to a flower pot '

image_to_video

( image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview]model: str | None = Noneprompt: str | None = Nonenegative_prompt: str | None = Nonenum_frames: float | None = Nonenum_inference_steps: int | None = Noneguidance_scale: float | None = Noneseed: int | None = Nonetarget_size: huggingface_hub.inference._generated.types.image_to_video.ImageToVideoTargetSize | None = None**kwargs ) → bytes

Parámetros

image (Union[str, Path, bytes, BinaryIO, PIL.Image.Image]) — The input image to generate a video from. It can be raw bytes, an image file, a URL to an online image, or a PIL Image.
model (str, opcional) — El modelo que se usará para la inferencia. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Este parámetro anula el modelo definido a nivel de instancia. El valor predeterminado es None.
prompt (str, opcional) — El texto de la indicación para guiar la generación del video.
negative_prompt (str, opcional) — Un prompt para guiar lo que NO debe incluirse en la generación de video.
num_frames (float, opcional) — El parámetro num_frames determina cuántos fotogramas de vídeo se generan.
num_inference_steps (int, opcional) — Para modelos de difusión. El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.
guidance_scale (float, opcional) — Para modelos de difusión. Un valor de escala de guía más alto anima al modelo a generar videos estrechamente vinculados al prompt de texto a costa de una menor calidad de imagen.
seed (int, opcional) — La semilla a utilizar para la generación del video.
target_size (ImageToVideoTargetSize, opcional) — El tamaño en píxeles de los fotogramas del video de salida.
num_inference_steps (int, opcional) — El número de pasos de desruido. Más pasos de desruido suelen dar lugar a un video de mayor calidad a costa de una inferencia más lenta.
seed (int, opcional) — Semilla para el generador de números aleatorios.

Devuelve

bytes

El video generado.

Genere un video a partir de una imagen de entrada.

Ejemplos:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()
>>> video = client.image_to_video("cat.jpg", model="Wan-AI/Wan2.2-I2V-A14B", prompt="turn the cat into a tiger")
>>> with open("tiger.mp4", "wb") as f:
...     f.write(video)

object_detection

( image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview]model: str | None = Nonethreshold: float | None = None ) → list[ObjectDetectionOutputElement]

Parámetros

image (Union[str, Path, bytes, BinaryIO, PIL.Image.Image]) — The image to detect objects on. It can be raw bytes, an image file, a URL to an online image, or a PIL Image.
model (str, opcional) — El modelo a utilizar para la detección de objetos. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo recomendado por defecto para la detección de objetos (DETR).
threshold (float, opcional) — La probabilidad necesaria para realizar una predicción.

Devuelve

list[ObjectDetectionOutputElement]

Una lista de elementos ObjectDetectionOutputElement que contiene las cajas delimitadoras y los atributos asociados.

Lanza

InferenceTimeoutError o HfHubHTTPError o ValueError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.
ValueError — Si la salida de la solicitud no es una List.

Realiza la detección de objetos en la imagen proporcionada utilizando el modelo especificado.

Debes tener PIL instalado si quieres trabajar con imágenes (pip install Pillow).

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()
>>> client.object_detection("people.jpg")
[ObjectDetectionOutputElement(score=0.9486683011054993, label='person', box=ObjectDetectionBoundingBox(xmin=59, ymin=39, xmax=420, ymax=510)), ...]

question_answering

( question: strcontext: strmodel: str | None = Nonealign_to_words: bool | None = Nonedoc_stride: int | None = Nonehandle_impossible_answer: bool | None = Nonemax_answer_len: int | None = Nonemax_question_len: int | None = Nonemax_seq_len: int | None = Nonetop_k: int | None = None ) → Union[QuestionAnsweringOutputElement, listQuestionAnsweringOutputElement]

Parámetros

question (str) — Pregunta a responder.
context (str) — El contexto de la pregunta.
model (str) — El modelo que se usará para la tarea de respuesta a preguntas. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado.
align_to_words (bool, opcional) — Intenta alinear la respuesta con palabras reales. Mejora la calidad en idiomas separados por espacios. Puede perjudicar en idiomas no separados por espacios (como el japonés o el chino)
doc_stride (int, opcional) — Si el contexto es demasiado largo 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.
handle_impossible_answer (bool, opcional) — Si se acepta "imposible" como respuesta.
max_answer_len (int, opcional) — La longitud máxima de las respuestas predichas (p. ej., solo se consideran las respuestas con una longitud menor).
max_question_len (int, opcional) — La longitud máxima de la pregunta después de la tokenización. Se truncará si es necesario.
max_seq_len (int, opcional) — 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 (usando docStride como solapamiento) si es necesario.
top_k (int, opcional) — El número de respuestas a devolver (se elegirán por orden de probabilidad). Tenga en cuenta que devolvemos menos de topk respuestas si no hay suficientes opciones disponibles dentro del contexto.

Devuelve

Union[QuestionAnsweringOutputElement, listQuestionAnsweringOutputElement]

When top_k is 1 or not provided, it returns a single QuestionAnsweringOutputElement. When top_k is greater than 1, it returns a list of QuestionAnsweringOutputElement.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Obtener la respuesta a una pregunta a partir de un texto dado.

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()
>>> client.question_answering(question="What's my name?", context="My name is Clara and I live in Berkeley.")
QuestionAnsweringOutputElement(answer='Clara', end=16, score=0.9326565265655518, start=11)

sentence_similarity

( sentence: strother_sentences: listmodel: str | None = None ) → list[float]

Parámetros

sentence (str) — La oración principal con la que se comparan las demás.
other_sentences (list[str]) — La lista de oraciones con las que comparar.
model (str, opcional) — El modelo a utilizar para la tarea de similitud de oraciones. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo de similitud de oraciones recomendado por defecto. El valor predeterminado es None.

Devuelve

list[float]

El embedding que representa el texto de entrada.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Calcule la similitud semántica entre una oración y una lista de otras oraciones comparando sus embeddings.

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()
>>> client.sentence_similarity(
...     "Machine learning is so easy.",
...     other_sentences=[
...         "Deep learning is so straightforward.",
...         "This is so difficult, like rocket science.",
...         "I can't believe how much I struggled with this.",
...     ],
... )
[0.7785726189613342, 0.45876261591911316, 0.2906220555305481]

resumen

( text: strmodel: str | None = Noneclean_up_tokenization_spaces: bool | None = Nonegenerate_parameters: dict[str, typing.Any] | None = Nonetruncation: typing.Optional[ForwardRef('SummarizationTruncationStrategy')] = None ) → SummarizationOutput

Parámetros

text (str) — El texto de entrada a resumir.
model (str, opcional) — El modelo que se utilizará para la inferencia. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo recomendado por defecto para la resumición.
clean_up_tokenization_spaces (bool, opcional) — Si se deben limpiar los espacios adicionales potenciales en la salida de texto.
generate_parameters (dict[str, Any], opcional) — Parametrización adicional del algoritmo de generación de texto.
truncation ("SummarizationTruncationStrategy", opcional) — La estrategia de truncamiento a utilizar.

Devuelve

SummarizationOutput

El texto del resumen generado.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Genere un resumen de un texto dado utilizando un modelo especificado.

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()
>>> client.summarization("The Eiffel tower...")
SummarizationOutput(generated_text="The Eiffel tower is one of the most famous landmarks in the world....")

table_question_answering

( table: dictquery: strmodel: str | None = Nonepadding: typing.Optional[ForwardRef('Padding')] = Nonesequential: bool | None = Nonetruncation: bool | None = None ) → TableQuestionAnsweringOutputElement

Parámetros

table (str) — Una tabla de datos representada como un diccionario de listas donde las entradas son encabezados y las listas son todos los valores; todas las listas deben tener el mismo tamaño.
query (str) — La consulta en texto plano que deseas hacer a la tabla.
model (str) — El modelo que se usará para la tarea de respuesta a preguntas sobre tablas. Puede ser un ID de modelo alojado en el Hugging Face Hub o una URL de un Inference Endpoint desplegado.
padding ("Padding", opcional) — Activa y controla el relleno.
sequential (bool, opcional) — 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.
truncation (bool, opcional) — Activa y controla la truncación.

Devuelve

TableQuestionAnsweringOutputElement

una salida de respuesta a preguntas sobre tablas que contiene la respuesta, las coordenadas, las celdas y el agregador utilizado.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Obtener la respuesta a una pregunta a partir de la información proporcionada en una tabla.

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()
>>> query = "How many stars does the transformers repository have?"
>>> table = {"Repository": ["Transformers", "Datasets", "Tokenizers"], "Stars": ["36542", "4512", "3934"]}
>>> client.table_question_answering(table, query, model="google/tapas-base-finetuned-wtq")
TableQuestionAnsweringOutputElement(answer='36542', coordinates=[[0, 1]], cells=['36542'], aggregator='AVERAGE')

clasificación_tabular

( table: dictmodel: str | None = None ) → List

Parámetros

table (dict[str, Any]) — Conjunto de atributos a clasificar.
model (str, opcional) — El modelo a utilizar para la tarea de clasificación tabular. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo de clasificación tabular recomendado por defecto. El valor predeterminado es None.

Devuelve

List

una lista de etiquetas, una por cada fila de la tabla inicial.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Clasificar una categoría objetivo (un grupo) en función de un conjunto de atributos.

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()
>>> table = {
...     "fixed_acidity": ["7.4", "7.8", "10.3"],
...     "volatile_acidity": ["0.7", "0.88", "0.32"],
...     "citric_acid": ["0", "0", "0.45"],
...     "residual_sugar": ["1.9", "2.6", "6.4"],
...     "chlorides": ["0.076", "0.098", "0.073"],
...     "free_sulfur_dioxide": ["11", "25", "5"],
...     "total_sulfur_dioxide": ["34", "67", "13"],
...     "density": ["0.9978", "0.9968", "0.9976"],
...     "pH": ["3.51", "3.2", "3.23"],
...     "sulphates": ["0.56", "0.68", "0.82"],
...     "alcohol": ["9.4", "9.8", "12.6"],
... }
>>> client.tabular_classification(table=table, model="julien-c/wine-quality")
["5", "5", "5"]

regresión_tabular

( table: dictmodel: str | None = None ) → List

Parámetros

table (dict[str, Any]) — Conjunto de atributos almacenados en una tabla. Los atributos utilizados para predecir el objetivo pueden ser numéricos y categóricos.
model (str, opcional) — El modelo a utilizar para la tarea de regresión tabular. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo de regresión tabular recomendado por defecto. El valor predeterminado es None.

Devuelve

List

una lista de valores numéricos objetivo predichos.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Predecir un valor numérico objetivo dado un conjunto de atributos/características en una tabla.

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()
>>> table = {
...     "Height": ["11.52", "12.48", "12.3778"],
...     "Length1": ["23.2", "24", "23.9"],
...     "Length2": ["25.4", "26.3", "26.5"],
...     "Length3": ["30", "31.2", "31.1"],
...     "Species": ["Bream", "Bream", "Bream"],
...     "Width": ["4.02", "4.3056", "4.6961"],
... }
>>> client.tabular_regression(table, model="scikit-learn/Fish-Weight")
[110, 120, 130]

clasificación_de_texto

( text: strmodel: str | None = Nonetop_k: int | None = Nonefunction_to_apply: typing.Optional[ForwardRef('TextClassificationOutputTransform')] = None ) → list[TextClassificationOutputElement]

Parámetros

text (str) — A string to be classified.
model (str, opcional) — El modelo a utilizar para la tarea de clasificación de texto. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo de clasificación de texto recomendado por defecto. El valor predeterminado es None.
top_k (int, opcional) — Cuando se especifica, limita la salida a las K clases más probables.
function_to_apply ("TextClassificationOutputTransform", opcional) — La función que se aplica a las salidas del modelo para obtener las puntuaciones.

Devuelve

list[TextClassificationOutputElement]

una lista de elementos TextClassificationOutputElement que contienen la etiqueta predicha y la probabilidad asociada.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Realiza la clasificación de texto (p. ej., análisis de sentimiento) en el texto proporcionado.

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()
>>> client.text_classification("I like you")
[
    TextClassificationOutputElement(label='POSITIVE', score=0.9998695850372314),
    TextClassificationOutputElement(label='NEGATIVE', score=0.0001304351753788069),
]

generación_de_texto

( prompt: strdetails: bool | None = Nonestream: bool | None = Nonemodel: str | None = Noneadapter_id: str | None = Nonebest_of: int | None = Nonedecoder_input_details: bool | None = Nonedo_sample: bool | None = Nonefrequency_penalty: float | None = Nonegrammar: huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType | None = Nonemax_new_tokens: int | None = Nonerepetition_penalty: float | None = Nonereturn_full_text: bool | None = Noneseed: int | None = Nonestop: list[str] | None = Nonetemperature: float | None = Nonetop_k: int | None = Nonetop_n_tokens: int | None = Nonetop_p: float | None = Nonetruncate: int | None = Nonetypical_p: float | None = Nonewatermark: bool | None = None ) → Union[str, TextGenerationOutput, Iterable[str], Iterable[TextGenerationStreamOutput]]

Parámetros

prompt (str) — Texto de entrada.
details (bool, opcional) — Por defecto, text_generation devuelve una cadena de texto. Pasa details=True si deseas una salida detallada (tokens, probabilidades, semilla, motivo de finalización, etc.). Solo disponible para modelos que se ejecutan con el backend text-generation-inference.
stream (bool, opcional) — Por defecto, text_generation devuelve el texto generado completo. Pasa stream=True si quieres que se devuelva un flujo de tokens. Solo disponible para modelos que se ejecutan con el backend text-generation-inference.
model (str, opcional) — El modelo que se usará para la inferencia. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Este parámetro anula el modelo definido a nivel de instancia. El valor predeterminado es None.
adapter_id (str, opcional) — ID del adaptador Lora.
best_of (int, opcional) — Genera best_of secuencias y devuelve la que tenga los logprobs de tokens más altos.
decoder_input_details (bool, opcional) — Devuelve los logprobs y los ids de los tokens de entrada del decodificador. Debes establecer también details=True para que se tenga en cuenta. El valor predeterminado es False.
do_sample (bool, opcional) — Activa el muestreo de logits
frequency_penalty (float, opcional) — Número entre -2.0 y 2.0. Los valores positivos penalizan los nuevos tokens en función de su frecuencia existente en el texto hasta el momento, lo que reduce la probabilidad de que el modelo repita la misma línea textualmente.
grammar (TextGenerationInputGrammarType, opcional) — Restricciones de gramática. Puede ser un JSONSchema o una expresión regular.
max_new_tokens (int, opcional) — Número máximo de tokens generados. El valor predeterminado es 100.
repetition_penalty (float, opcional) — El parámetro para la penalización de repetición. 1.0 significa sin penalización. Consulte este artículo para más detalles.
return_full_text (bool, opcional) — Si se debe anteponer el prompt al texto generado
seed (int, opcional) — Semilla para el muestreo aleatorio
stop (list[str], opcional) — Deja de generar tokens si se genera un miembro de stop.
temperature (float, opcional) — El valor utilizado para modular la distribución de logits.
top_n_tokens (int, opcional) — Devuelve información sobre los top_n_tokens tokens más probables en cada paso de generación, en lugar de solo el token muestreado.
top_k (int, *opcional`) — El número de tokens del vocabulario con mayor probabilidad que se conservan para el filtrado top-k.
top_p (float, *optional) -- If set to < 1, only the smallest set of most probable tokens with probabilities that add up to top_p` or higher are kept for generation.
truncate (int, *opcional`) — Trunca los tokens de entrada al tamaño indicado.
typical_p (float, *opcional`) — Masa de Typical Decoding Consulte Typical Decoding for Natural Language Generation para obtener más información
watermark (bool, opcional) — Marca de agua con A Watermark for Large Language Models

Devuelve

Union[str, TextGenerationOutput, Iterable[str], Iterable[TextGenerationStreamOutput]]

Texto generado devuelto por el servidor:

si stream=False y details=False, el texto generado se devuelve como un str (predeterminado)
si stream=True y details=False, el texto generado se devuelve token a token como un Iterable[str]
si stream=False y details=True, el texto generado se devuelve con más detalles como un TextGenerationOutput
si details=True y stream=True, el texto generado se devuelve token a token como un iterable de TextGenerationStreamOutput

Lanza

ValidationError o InferenceTimeoutError o HfHubHTTPError

ValidationError — Si los valores de entrada no son válidos. No se realiza ninguna llamada HTTP al servidor.
InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Dado un prompt, genera el siguiente texto.

Si deseas generar una respuesta a partir de mensajes de chat, debes usar el método InferenceClient.chat_completion(). Acepta una lista de mensajes en lugar de un único texto de entrada y gestiona la plantilla de chat por ti.

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()

# Case 1: generate text
>>> client.text_generation("The huggingface_hub library is ", max_new_tokens=12)
'100% open source and built to be easy to use.'

# Case 2: iterate over the generated tokens. Useful for large generation.
>>> for token in client.text_generation("The huggingface_hub library is ", max_new_tokens=12, stream=True):
...     print(token)
100
%
open
source
and
built
to
be
easy
to
use
.

# Case 3: get more details about the generation process.
>>> client.text_generation("The huggingface_hub library is ", max_new_tokens=12, details=True)
TextGenerationOutput(
    generated_text='100% open source and built to be easy to use.',
    details=TextGenerationDetails(
        finish_reason='length',
        generated_tokens=12,
        seed=None,
        prefill=[
            TextGenerationPrefillOutputToken(id=487, text='The', logprob=None),
            TextGenerationPrefillOutputToken(id=53789, text=' hugging', logprob=-13.171875),
            (...)
            TextGenerationPrefillOutputToken(id=204, text=' ', logprob=-7.0390625)
        ],
        tokens=[
            TokenElement(id=1425, text='100', logprob=-1.0175781, special=False),
            TokenElement(id=16, text='%', logprob=-0.0463562, special=False),
            (...)
            TokenElement(id=25, text='.', logprob=-0.5703125, special=False)
        ],
        best_of_sequences=None
    )
)

# Case 4: iterate over the generated tokens with more details.
# Last object is more complete, containing the full generated text and the finish reason.
>>> for details in client.text_generation("The huggingface_hub library is ", max_new_tokens=12, details=True, stream=True):
...     print(details)
...
TextGenerationStreamOutput(token=TokenElement(id=1425, text='100', logprob=-1.0175781, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=16, text='%', logprob=-0.0463562, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=1314, text=' open', logprob=-1.3359375, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=3178, text=' source', logprob=-0.28100586, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=273, text=' and', logprob=-0.5961914, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=3426, text=' built', logprob=-1.9423828, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=271, text=' to', logprob=-1.4121094, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=314, text=' be', logprob=-1.5224609, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=1833, text=' easy', logprob=-2.1132812, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=271, text=' to', logprob=-0.08520508, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=745, text=' use', logprob=-0.39453125, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(
    id=25,
    text='.',
    logprob=-0.5703125,
    special=False),
    generated_text='100% open source and built to be easy to use.',
    details=TextGenerationStreamOutputStreamDetails(finish_reason='length', generated_tokens=12, seed=None)
)

# Case 5: generate constrained output using grammar
>>> response = client.text_generation(
...     prompt="I saw a puppy a cat and a raccoon during my bike ride in the park",
...     model="HuggingFaceH4/zephyr-orpo-141b-A35b-v0.1",
...     max_new_tokens=100,
...     repetition_penalty=1.3,
...     grammar={
...         "type": "json",
...         "value": {
...             "properties": {
...                 "location": {"type": "string"},
...                 "activity": {"type": "string"},
...                 "animals_seen": {"type": "integer", "minimum": 1, "maximum": 5},
...                 "animals": {"type": "array", "items": {"type": "string"}},
...             },
...             "required": ["location", "activity", "animals_seen", "animals"],
...         },
...     },
... )
>>> json.loads(response)
{
    "activity": "bike riding",
    "animals": ["puppy", "cat", "raccoon"],
    "animals_seen": 3,
    "location": "park"
}

text_to_image

( prompt: strnegative_prompt: str | None = Noneheight: int | None = Nonewidth: int | None = Nonenum_inference_steps: int | None = Noneguidance_scale: float | None = Nonemodel: str | None = Nonescheduler: str | None = Noneseed: int | None = Noneextra_body: dict[str, typing.Any] | None = None ) → Image

Parámetros

prompt (str) — El prompt para generar una imagen.
negative_prompt (str, opcional) — Un prompt para guiar lo que NO debe incluirse en la generación de la imagen.
height (int, opcional) — La altura en píxeles de la imagen de salida
width (int, opcional) — El ancho en píxeles de la imagen de salida
num_inference_steps (int, opcional) — El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.
guidance_scale (float, opcional) — Un valor de escala de guía más alto anima al modelo a generar imágenes estrechamente vinculadas al prompt de texto, pero valores demasiado altos pueden causar saturación y otros artefactos.
model (str, opcional) — El modelo que se utilizará para la inferencia. Puede ser un ID de modelo alojado en el Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo de texto a imagen recomendado por defecto. El valor predeterminado es None.
scheduler (str, opcional) — Sustituye el programador por uno compatible.
seed (int, opcional) — Semilla para el generador de números aleatorios.
extra_body (dict[str, Any], opcional) — Parámetros adicionales específicos del proveedor para pasar al modelo. Consulte la documentación del proveedor para los parámetros admitidos.

Devuelve

Image

La imagen generada.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Genere una imagen a partir de un texto dado utilizando un modelo especificado.

Debes tener PIL instalado si quieres trabajar con imágenes (pip install Pillow).

Puedes pasar parámetros específicos del proveedor al modelo utilizando el argumento extra_body.

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()

>>> image = client.text_to_image("An astronaut riding a horse on the moon.")
>>> image.save("astronaut.png")

>>> image = client.text_to_image(
...     "An astronaut riding a horse on the moon.",
...     negative_prompt="low resolution, blurry",
...     model="stabilityai/stable-diffusion-2-1",
... )
>>> image.save("better_astronaut.png")

Example using a third-party provider directly. Usage will be billed on your fal.ai account.

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient(
...     provider="fal-ai",  # Use fal.ai provider
...     api_key="fal-ai-api-key",  # Pass your fal.ai API key
... )
>>> image = client.text_to_image(
...     "A majestic lion in a fantasy forest",
...     model="black-forest-labs/FLUX.1-schnell",
... )
>>> image.save("lion.png")

Ejemplo de uso de un proveedor de terceros a través de Hugging Face Routing. El uso se facturará en tu cuenta de Hugging Face.

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient(
...     provider="replicate",  # Use replicate provider
...     api_key="hf_...",  # Pass your HF token
... )
>>> image = client.text_to_image(
...     "An astronaut riding a horse on the moon.",
...     model="black-forest-labs/FLUX.1-dev",
... )
>>> image.save("astronaut.png")

Ejemplo usando el proveedor Replicate con parámetros adicionales

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient(
...     provider="replicate",  # Use replicate provider
...     api_key="hf_...",  # Pass your HF token
... )
>>> image = client.text_to_image(
...     "An astronaut riding a horse on the moon.",
...     model="black-forest-labs/FLUX.1-schnell",
...     extra_body={"output_quality": 100},
... )
>>> image.save("astronaut.png")

text_to_speech

( text: strmodel: str | None = Nonedo_sample: bool | None = Noneearly_stopping: typing.Union[bool, ForwardRef('TextToSpeechEarlyStoppingEnum'), NoneType] = Noneepsilon_cutoff: float | None = Noneeta_cutoff: float | None = Nonemax_length: int | None = Nonemax_new_tokens: int | None = Nonemin_length: int | None = Nonemin_new_tokens: int | None = Nonenum_beam_groups: int | None = Nonenum_beams: int | None = Nonepenalty_alpha: float | None = Nonetemperature: float | None = Nonetop_k: int | None = Nonetop_p: float | None = Nonetypical_p: float | None = Noneuse_cache: bool | None = Noneextra_body: dict[str, typing.Any] | None = None ) → bytes

Parámetros

text (str) — El texto que se va a sintetizar.
model (str, opcional) — El modelo que se utilizará para la inferencia. Puede ser un ID de modelo alojado en el Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo de texto a voz recomendado por defecto. El valor predeterminado es None.
do_sample (bool, opcional) — Si se usa muestreo en lugar de decodificación codiciosa al generar nuevos tokens.
early_stopping (Union[bool, "TextToSpeechEarlyStoppingEnum"], opcional) — Controla la condición de parada para los métodos basados en beam.
epsilon_cutoff (float, opcional) — Si se establece en un float estrictamente entre 0 y 1, solo se muestrearán tokens con una probabilidad condicional mayor que epsilon_cutoff. En el artículo, los valores sugeridos van desde 3e-4 hasta 9e-4, dependiendo del tamaño del modelo. Consulte Truncation Sampling as Language Model Desmoothing para más detalles.
eta_cutoff (float, opcional) — El muestreo Eta es un híbrido del muestreo localmente típico y el muestreo epsilon. Si se establece en un float estrictamente entre 0 y 1, un token solo se considera si es mayor que eta_cutoff o sqrt(eta_cutoff)
- exp(-entropy(softmax(next_token_logits))). El segundo término es, de forma intuitiva, la probabilidad esperada del siguiente token, escalada por sqrt(eta_cutoff). En el artículo, los valores sugeridos van desde 3e-4 hasta 2e-3, dependiendo del tamaño del modelo. Consulte Truncation Sampling as Language Model Desmoothing para más detalles.
max_length (int, opcional) — La longitud máxima (en tokens) del texto generado, incluido el texto de entrada.
max_new_tokens (int, opcional) — El número máximo de tokens a generar. Tiene prioridad sobre max_length.
min_length (int, opcional) — La longitud mínima (en tokens) del texto generado, incluyendo la entrada.
min_new_tokens (int, opcional) — El número mínimo de tokens a generar. Tiene prioridad sobre min_length.
num_beam_groups (int, opcional) — Número de grupos en los que dividir num_beams para garantizar diversidad entre los distintos grupos de beams. Vea este artículo para más detalles.
num_beams (int, opcional) — Número de haces a utilizar para la búsqueda por haces.
penalty_alpha (float, opcional) — El valor equilibra la confianza del modelo y la penalización por degeneración en la decodificación de búsqueda contrastiva.
temperature (float, opcional) — El valor utilizado para modular las probabilidades del siguiente token.
top_k (int, opcional) — El número de tokens del vocabulario con mayor probabilidad que se conservan para el filtrado top-k.
top_p (float, opcional) — Si se establece en un float < 1, solo se conservan para la generación el conjunto más pequeño de tokens más probables cuyas probabilidades suman top_p o más.
typical_p (float, opcional) — La tipicidad local mide qué tan similar es la probabilidad condicional de predecir el siguiente token objetivo a la probabilidad condicional esperada de predecir un token aleatorio a continuación, dado el texto parcial ya generado. Si se establece en float < 1, se conservan para la generación el conjunto más pequeño de tokens localmente más típicos cuyas probabilidades suman typical_p o más. Consulte este artículo para más detalles.
use_cache (bool, opcional) — Si el modelo debe usar las atenciones de claves/valores pasadas para acelerar la decodificación
extra_body (dict[str, Any], opcional) — Parámetros adicionales específicos del proveedor para pasar al modelo. Consulte la documentación del proveedor para los parámetros admitidos.

Devuelve

bytes

El audio generado.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Sintetiza un audio de una voz pronunciando un texto dado.

Puedes pasar parámetros específicos del proveedor al modelo utilizando el argumento extra_body.

Ejemplo:

>>> from pathlib import Path
>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()

>>> audio = client.text_to_speech("Hello world")
>>> Path("hello_world.flac").write_bytes(audio)

Ejemplo de uso de un proveedor de terceros directamente. El uso se facturará en tu cuenta de Replicate.

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient(
...     provider="replicate",
...     api_key="your-replicate-api-key",  # Pass your Replicate API key directly
... )
>>> audio = client.text_to_speech(
...     text="Hello world",
...     model="OuteAI/OuteTTS-0.3-500M",
... )
>>> Path("hello_world.flac").write_bytes(audio)

Ejemplo de uso de un proveedor de terceros a través de Hugging Face Routing. El uso se facturará en tu cuenta de Hugging Face.

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient(
...     provider="replicate",
...     api_key="hf_...",  # Pass your HF token
... )
>>> audio =client.text_to_speech(
...     text="Hello world",
...     model="OuteAI/OuteTTS-0.3-500M",
... )
>>> Path("hello_world.flac").write_bytes(audio)

Example using Replicate provider with extra parameters

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient(
...     provider="replicate",  # Use replicate provider
...     api_key="hf_...",  # Pass your HF token
... )
>>> audio = client.text_to_speech(
...     "Hello, my name is Kororo, an awesome text-to-speech model.",
...     model="hexgrad/Kokoro-82M",
...     extra_body={"voice": "af_nicole"},
... )
>>> Path("hello.flac").write_bytes(audio)

Ejemplo de generación de música con “YuE-s1-7B-anneal-en-cot” en fal.ai

>>> from huggingface_hub import InferenceClient
>>> lyrics = '''
... [verse]
... In the town where I was born
... Lived a man who sailed to sea
... And he told us of his life
... In the land of submarines
... So we sailed on to the sun
... 'Til we found a sea of green
... And we lived beneath the waves
... In our yellow submarine

... [chorus]
... We all live in a yellow submarine
... Yellow submarine, yellow submarine
... We all live in a yellow submarine
... Yellow submarine, yellow submarine
... '''
>>> genres = "pavarotti-style tenor voice"
>>> client = InferenceClient(
...     provider="fal-ai",
...     model="m-a-p/YuE-s1-7B-anneal-en-cot",
...     api_key=...,
... )
>>> audio = client.text_to_speech(lyrics, extra_body={"genres": genres})
>>> with open("output.mp3", "wb") as f:
...     f.write(audio)

text_to_video

( prompt: strmodel: str | None = Noneguidance_scale: float | None = Nonenegative_prompt: list[str] | None = Nonenum_frames: float | None = Nonenum_inference_steps: int | None = Noneseed: int | None = Noneextra_body: dict[str, typing.Any] | None = None ) → bytes

Parámetros

prompt (str) — El prompt para generar un video.
model (str, opcional) — El modelo que se utilizará para la inferencia. Puede ser un ID de modelo alojado en el Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo de texto a video recomendado por defecto. El valor predeterminado es None.
guidance_scale (float, opcional) — Un valor de escala de guía más alto anima al modelo a generar videos estrechamente vinculados al prompt de texto, pero valores demasiado altos pueden causar saturación y otros artefactos.
negative_prompt (list[str], opcional) — Una o varias indicaciones para guiar lo que NO debe incluirse en la generación del video.
num_frames (float, opcional) — El parámetro num_frames determina cuántos fotogramas de vídeo se generan.
num_inference_steps (int, opcional) — El número de pasos de desruido. Más pasos de desruido suelen dar lugar a un video de mayor calidad a costa de una inferencia más lenta.
seed (int, opcional) — Semilla para el generador de números aleatorios.
extra_body (dict[str, Any], opcional) — Parámetros adicionales específicos del proveedor para pasar al modelo. Consulte la documentación del proveedor para los parámetros admitidos.

Devuelve

bytes

El video generado.

Genera un video a partir de un texto dado.

Puedes pasar parámetros específicos del proveedor al modelo utilizando el argumento extra_body.

Ejemplo:

Ejemplo de uso de un proveedor de terceros directamente. El uso se facturará en tu cuenta de fal.ai.

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient(
...     provider="fal-ai",  # Using fal.ai provider
...     api_key="fal-ai-api-key",  # Pass your fal.ai API key
... )
>>> video = client.text_to_video(
...     "A majestic lion running in a fantasy forest",
...     model="tencent/HunyuanVideo",
... )
>>> with open("lion.mp4", "wb") as file:
...     file.write(video)

Ejemplo de uso de un proveedor de terceros a través de Hugging Face Routing. El uso se facturará en tu cuenta de Hugging Face.

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient(
...     provider="replicate",  # Using replicate provider
...     api_key="hf_...",  # Pass your HF token
... )
>>> video = client.text_to_video(
...     "A cat running in a park",
...     model="genmo/mochi-1-preview",
... )
>>> with open("cat.mp4", "wb") as file:
...     file.write(video)

token_classification

( text: strmodel: str | None = Noneaggregation_strategy: typing.Optional[ForwardRef('TokenClassificationAggregationStrategy')] = Noneignore_labels: list[str] | None = Nonestride: int | None = None ) → list[TokenClassificationOutputElement]

Parámetros

text (str) — A string to be classified.
model (str, opcional) — El modelo a utilizar para la tarea de clasificación de tokens. Puede ser un ID de modelo alojado en el Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo de clasificación de tokens recomendado por defecto. El valor predeterminado es None.
aggregation_strategy ("TokenClassificationAggregationStrategy", opcional) — La estrategia utilizada para fusionar tokens en función de las predicciones del modelo
ignore_labels (list[str, opcional) — Una lista de etiquetas para ignorar
stride (int, opcional) — El número de tokens superpuestos entre fragmentos al dividir el texto de entrada.

Devuelve

list[TokenClassificationOutputElement]

Lista de elementos TokenClassificationOutputElement que contienen el grupo de entidad, la puntuación de confianza, la palabra y el índice de inicio y fin.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Realiza la clasificación de tokens en el texto dado. Se utiliza habitualmente para el análisis de oraciones, ya sea gramatical o para el reconocimiento de entidades nombradas (NER), con el fin de comprender las palabras clave contenidas en el texto.

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()
>>> client.token_classification("My name is Sarah Jessica Parker but you can call me Jessica")
[
    TokenClassificationOutputElement(
        entity_group='PER',
        score=0.9971321225166321,
        word='Sarah Jessica Parker',
        start=11,
        end=31,
    ),
    TokenClassificationOutputElement(
        entity_group='PER',
        score=0.9773476123809814,
        word='Jessica',
        start=52,
        end=59,
    )
]

traducción

( text: strmodel: str | None = Nonesrc_lang: str | None = Nonetgt_lang: str | None = Noneclean_up_tokenization_spaces: bool | None = Nonetruncation: typing.Optional[ForwardRef('TranslationTruncationStrategy')] = Nonegenerate_parameters: dict[str, typing.Any] | None = None ) → TranslationOutput

Parámetros

text (str) — A string to be translated.
model (str, opcional) — El modelo a utilizar para la tarea de traducción. Puede ser un ID de modelo alojado en el Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo de traducción recomendado por defecto. El valor predeterminado es None.
src_lang (str, opcional) — El idioma de origen del texto. Obligatorio para modelos que pueden traducir desde varios idiomas.
tgt_lang (str, opcional) — Idioma de destino al que traducir. Obligatorio para modelos que pueden traducir a varios idiomas.
clean_up_tokenization_spaces (bool, opcional) — Si se deben limpiar los espacios adicionales potenciales en la salida de texto.
truncation ("TranslationTruncationStrategy", opcional) — La estrategia de truncamiento a utilizar.
generate_parameters (dict[str, Any], opcional) — Parametrización adicional del algoritmo de generación de texto.

Devuelve

TranslationOutput

El texto traducido generado.

Lanza

InferenceTimeoutError o HfHubHTTPError o ValueError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.
ValueError — Si solo se proporciona uno de los argumentos src_lang y tgt_lang.

Convierte texto de un idioma a otro.

Consulte https://huggingface.co/tasks/translation para obtener más información sobre cómo elegir el mejor modelo para su caso de uso específico. Los idiomas de origen y destino suelen depender del modelo. Sin embargo, es posible especificar los idiomas de origen y destino para ciertos modelos. Si está trabajando con uno de estos modelos, puede usar los argumentos src_lang y tgt_lang para pasar la información relevante.

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()
>>> client.translation("My name is Wolfgang and I live in Berlin")
'Mein Name ist Wolfgang und ich lebe in Berlin.'
>>> client.translation("My name is Wolfgang and I live in Berlin", model="Helsinki-NLP/opus-mt-en-fr")
TranslationOutput(translation_text='Je m'appelle Wolfgang et je vis à Berlin.')

Especificación de idiomas:

>>> client.translation("My name is Sarah Jessica Parker but you can call me Jessica", model="facebook/mbart-large-50-many-to-many-mmt", src_lang="en_XX", tgt_lang="fr_XX")
"Mon nom est Sarah Jessica Parker mais vous pouvez m'appeler Jessica"

visual_question_answering

( image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview]question: strmodel: str | None = Nonetop_k: int | None = None ) → list[VisualQuestionAnsweringOutputElement]

Parámetros

image (Union[str, Path, bytes, BinaryIO, PIL.Image.Image]) — The input image for the context. It can be raw bytes, an image file, a URL to an online image, or a PIL Image.
question (str) — Pregunta a responder.
model (str, opcional) — El modelo que se utilizará para la tarea de respuesta visual a preguntas. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo de respuesta visual a preguntas recomendado por defecto. El valor predeterminado es None.
top_k (int, opcional) — El número de respuestas a devolver (se elegirán por orden de probabilidad). Tenga en cuenta que devolvemos menos de topk respuestas si no hay suficientes opciones disponibles dentro del contexto.

Devuelve

list[VisualQuestionAnsweringOutputElement]

una lista de elementos VisualQuestionAnsweringOutputElement que contienen la etiqueta predicha y la probabilidad asociada.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Responder preguntas abiertas basándose en una imagen.

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()
>>> client.visual_question_answering(
...     image="https://huggingface.co/datasets/mishig/sample_images/resolve/main/tiger.jpg",
...     question="What is the animal doing?"
... )
[
    VisualQuestionAnsweringOutputElement(score=0.778609573841095, answer='laying down'),
    VisualQuestionAnsweringOutputElement(score=0.6957435607910156, answer='sitting'),
]

zero_shot_classification

( text: strcandidate_labels: listmulti_label: bool | None = Falsehypothesis_template: str | None = Nonemodel: str | None = None ) → list[ZeroShotClassificationOutputElement]

Parámetros

text (str) — El texto de entrada a clasificar.
candidate_labels (list[str]) — El conjunto de etiquetas de clase posibles para clasificar el texto.
multi_label (bool, opcional) — Si varias etiquetas candidatas pueden ser verdaderas. Si es falso, las puntuaciones se normalizan de modo que la suma de las probabilidades de las etiquetas para cada secuencia sea 1. Si es verdadero, las etiquetas se consideran independientes y las probabilidades se normalizan para cada candidata.
hypothesis_template (str, opcional) — La oración que se utiliza junto con candidate_labels para intentar la clasificación de texto, reemplazando el marcador de posición con las etiquetas candidatas.
model (str, opcional) — El modelo que se utilizará para la inferencia. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Este parámetro anula el modelo definido a nivel de instancia. Si no se proporciona, se utilizará el modelo de clasificación zero-shot recomendado por defecto.

Devuelve

list[ZeroShotClassificationOutputElement]

Lista de elementos ZeroShotClassificationOutputElement que contienen las etiquetas predichas y su confianza.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Proporciona como entrada un texto y un conjunto de etiquetas candidatas para clasificar el texto de entrada.

Ejemplo con multi_label=False:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()
>>> text = (
...     "A new model offers an explanation for how the Galilean satellites formed around the solar system's"
...     "largest world. Konstantin Batygin did not set out to solve one of the solar system's most puzzling"
...     " mysteries when he went for a run up a hill in Nice, France."
... )
>>> labels = ["space & cosmos", "scientific discovery", "microbiology", "robots", "archeology"]
>>> client.zero_shot_classification(text, labels)
[
    ZeroShotClassificationOutputElement(label='scientific discovery', score=0.7961668968200684),
    ZeroShotClassificationOutputElement(label='space & cosmos', score=0.18570658564567566),
    ZeroShotClassificationOutputElement(label='microbiology', score=0.00730885099619627),
    ZeroShotClassificationOutputElement(label='archeology', score=0.006258360575884581),
    ZeroShotClassificationOutputElement(label='robots', score=0.004559356719255447),
]
>>> client.zero_shot_classification(text, labels, multi_label=True)
[
    ZeroShotClassificationOutputElement(label='scientific discovery', score=0.9829297661781311),
    ZeroShotClassificationOutputElement(label='space & cosmos', score=0.755190908908844),
    ZeroShotClassificationOutputElement(label='microbiology', score=0.0005462635890580714),
    ZeroShotClassificationOutputElement(label='archeology', score=0.00047131875180639327),
    ZeroShotClassificationOutputElement(label='robots', score=0.00030448526376858354),
]

Ejemplo con multi_label=True y una hypothesis_template personalizada:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()
>>> client.zero_shot_classification(
...    text="I really like our dinner and I'm very happy. I don't like the weather though.",
...    candidate_labels=["positive", "negative", "pessimistic", "optimistic"],
...    multi_label=True,
...    hypothesis_template="This text is {} towards the weather"
... )
[
    ZeroShotClassificationOutputElement(label='negative', score=0.9231801629066467),
    ZeroShotClassificationOutputElement(label='pessimistic', score=0.8760990500450134),
    ZeroShotClassificationOutputElement(label='optimistic', score=0.0008674879791215062),
    ZeroShotClassificationOutputElement(label='positive', score=0.0005250611575320363)
]

zero_shot_image_classification

( image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview]candidate_labels: listmodel: str | None = Nonehypothesis_template: str | None = None ) → list[ZeroShotImageClassificationOutputElement]

Parámetros

image (Union[str, Path, bytes, BinaryIO, PIL.Image.Image]) — The input image to caption. It can be raw bytes, an image file, a URL to an online image, or a PIL Image.
candidate_labels (list[str]) — Las etiquetas candidatas para esta imagen
model (str, opcional) — El modelo que se utilizará para la inferencia. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Este parámetro anula el modelo definido a nivel de instancia. Si no se proporciona, se utilizará el modelo de clasificación de imágenes zero-shot recomendado por defecto.
hypothesis_template (str, opcional) — La oración que se utiliza junto con candidate_labels para intentar la clasificación de la imagen, sustituyendo el marcador de posición por las etiquetas candidatas.

Devuelve

list[ZeroShotImageClassificationOutputElement]

Lista de elementos ZeroShotImageClassificationOutputElement que contienen las etiquetas predichas y su confianza.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Proporcione una imagen de entrada y etiquetas de texto para predecir las etiquetas de texto de la imagen.

Ejemplo:

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient()

>>> client.zero_shot_image_classification(
...     "https://upload.wikimedia.org/wikipedia/commons/thumb/4/43/Cute_dog.jpg/320px-Cute_dog.jpg",
...     candidate_labels=["dog", "cat", "horse"],
... )
[ZeroShotImageClassificationOutputElement(label='dog', score=0.956),...]

Cliente de inferencia asíncrona

También se proporciona una versión asíncrona del cliente, basada en asyncio y httpx2.

clase huggingface_hub.AsyncInferenceClient

( model: str | None = Noneprovider: typing.Union[typing.Literal['baseten', 'cerebras', 'cohere', 'deepinfra', 'fal-ai', 'featherless-ai', 'fireworks-ai', 'groq', 'hf-inference', 'novita', 'nscale', 'openai', 'ovhcloud', 'publicai', 'replicate', 'scaleway', 'together', 'wavespeed', 'zai-org'], typing.Literal['auto'], NoneType] = Nonetoken: str | None = Nonetimeout: float | None = Noneheaders: dict[str, str] | None = Nonecookies: dict[str, str] | None = Nonebill_to: str | None = Nonebase_url: str | None = Noneapi_key: str | None = None )

Parámetros

model (str, optional) — El modelo con el que se ejecutará la inferencia. Puede ser un identificador de modelo alojado en el Hugging Face Hub, por ejemplo meta-llama/Meta-Llama-3-8B-Instruct o una URL de un Inference Endpoint desplegado. El valor predeterminado es None, en cuyo caso se selecciona automáticamente un modelo recomendado para la tarea. Nota: para una mejor compatibilidad con el cliente de OpenAI, model se ha aliasado como base_url. Estos dos argumentos son mutuamente excluyentes. Si se pasa una URL como model o base_url para la finalización de chat, se añadirá la ruta de sufijo (/v1)/chat/completions a la URL.
provider (str, opcional) — Nombre del proveedor que se utilizará para la inferencia. Puede ser "baseten", "cerebras", "cohere", "deepinfra", "fal-ai", "featherless-ai", "fireworks-ai", "groq", "hf-inference", "novita", "nscale", "openai", "ovhcloud", "publicai", "replicate", "scaleway", "together", "wavespeed" o "zai-org". El valor predeterminado es “auto”: enrutamiento automático, que por defecto utiliza el proveedor “fastest”; puedes cambiar al orden de proveedores “cheapest” o “preferred” en https://hf.co/settings/inference-providers. Si el modelo es una URL o se pasa base_url, entonces provider no se utiliza.
token (str, opcional) — Token de Hugging Face. Si no se proporciona, se usará el token guardado localmente. Nota: para una mejor compatibilidad con el cliente de OpenAI, token se ha aliasado como api_key. Estos dos argumentos son mutuamente excluyentes y tienen exactamente el mismo comportamiento.
timeout (float, optional) — El número máximo de segundos para esperar una respuesta del servidor. El valor predeterminado es None, lo que significa que se repetirá hasta que el servidor esté disponible.
headers (dict[str, str], optional) — Encabezados adicionales para enviar al servidor. De forma predeterminada, solo se envían los encabezados de autorización y user-agent. Los valores de este diccionario reemplazarán los valores predeterminados.
bill_to (str, optional) — La cuenta de facturación que se utilizará para las solicitudes. De forma predeterminada, las solicitudes se facturan en la cuenta del usuario. Las solicitudes solo pueden facturarse a una organización de la que el usuario sea miembro y que haya suscrito Enterprise Hub.
cookies (dict[str, str], optional) — Cookies adicionales para enviar al servidor.
base_url (str, optional) — URL base para ejecutar la inferencia. Este es un argumento duplicado de model para que InferenceClient siga el mismo patrón que el cliente openai.OpenAI. No se puede usar si model está establecido. El valor predeterminado es None.
api_key (str, optional) — Token para la autenticación. Este es un argumento duplicado de token para que InferenceClient siga el mismo patrón que el cliente openai.OpenAI. No se puede usar si token está establecido. El valor predeterminado es None.

Inicializa un nuevo Inference Client.

InferenceClient busca ofrecer una experiencia unificada para realizar inferencia. El cliente puede usarse de forma transparente con la Inference API (gratuita), con Inference Endpoints autoalojados o con Inference Providers de terceros.

clasificación_de_audio

( audio: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview]model: str | None = Nonetop_k: int | None = Nonefunction_to_apply: typing.Optional[ForwardRef('AudioClassificationOutputTransform')] = None ) → list[AudioClassificationOutputElement]

Parámetros

audio (Union[str, Path, bytes, BinaryIO]) — El contenido de audio a clasificar. Puede ser bytes de audio sin procesar, un archivo de audio local o una URL que apunte a un archivo de audio.
model (str, opcional) — El modelo a utilizar para la clasificación de audio. Puede ser un ID de modelo alojado en el Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo recomendado por defecto para la clasificación de audio.
top_k (int, opcional) — Cuando se especifica, limita la salida a las K clases más probables.
function_to_apply ("AudioClassificationOutputTransform", opcional) — La función que se aplica a las salidas del modelo para obtener las puntuaciones.

Devuelve

list[AudioClassificationOutputElement]

Lista de elementos AudioClassificationOutputElement que contienen las etiquetas predichas y su confianza.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Realiza la clasificación de audio en el contenido de audio proporcionado.

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.audio_classification("audio.flac")
[
    AudioClassificationOutputElement(score=0.4976358711719513, label='hap'),
    AudioClassificationOutputElement(score=0.3677836060523987, label='neu'),
    ...
]

audio_to_audio

( audio: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview]model: str | None = None ) → list[AudioToAudioOutputElement]

Parámetros

audio (Union[str, Path, bytes, BinaryIO]) — El contenido de audio para el modelo. Puede ser bytes de audio sin procesar, un archivo de audio local o una URL que apunte a un archivo de audio.
model (str, opcional) — El modelo puede ser cualquier modelo que reciba un archivo de audio y devuelva otro archivo de audio. Puede ser un ID de modelo alojado en el Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo recomendado por defecto para audio_to_audio.

Devuelve

list[AudioToAudioOutputElement]

Una lista de elementos AudioToAudioOutputElement que contienen la etiqueta de audio, el tipo de contenido y el contenido de audio en un blob.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Realiza múltiples tareas relacionadas con audio a audio, según el modelo (por ejemplo: mejora de voz, separación de fuentes).

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> audio_output = await client.audio_to_audio("audio.flac")
>>> async for i, item in enumerate(audio_output):
>>>     with open(f"output_{i}.flac", "wb") as f:
            f.write(item.blob)

automatic_speech_recognition

( audio: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview]model: str | None = Noneextra_body: dict | None = None ) → AutomaticSpeechRecognitionOutput

Parámetros

audio (Union[str, Path, bytes, BinaryIO]) — El contenido que se debe transcribir. Puede ser bytes de audio en bruto, un archivo de audio local o una URL a un archivo de audio.
model (str, opcional) — El modelo a utilizar para ASR. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo recomendado por defecto para ASR.
extra_body (dict, opcional) — Parámetros adicionales específicos del proveedor para pasar al modelo. Consulte la documentación del proveedor para los parámetros admitidos.

Devuelve

AutomaticSpeechRecognitionOutput

Un elemento que contiene el texto transcrito y, opcionalmente, los fragmentos de marcas de tiempo.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Realice reconocimiento automático de voz (ASR o audio a texto) en el contenido de audio proporcionado.

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.automatic_speech_recognition("hello_world.flac").text
"hello world"

chat_completion

( messages: listmodel: str | None = Nonestream: bool = Falsefrequency_penalty: float | None = Nonelogit_bias: list[float] | None = Nonelogprobs: bool | None = Nonemax_tokens: int | None = Nonen: int | None = Nonepresence_penalty: float | None = Noneresponse_format: typing.Union[huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatText, huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatJSONSchema, huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputResponseFormatJSONObject, NoneType] = Noneseed: int | None = Nonestop: list[str] | None = Nonestream_options: huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions | None = Nonetemperature: float | None = Nonetool_choice: typing.Union[huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass, ForwardRef('ChatCompletionInputToolChoiceEnum'), NoneType] = Nonetool_prompt: str | None = Nonetools: list[huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool] | None = Nonetop_logprobs: int | None = Nonetop_p: float | None = Noneextra_body: dict | None = None ) → ChatCompletionOutput or Iterable of ChatCompletionStreamOutput

Parámetros

messages (Lista de ChatCompletionInputMessage) — Historial de conversación que consiste en pares de roles y contenido.
model (str, opcional) — El modelo a utilizar para la chat-completion. Puede ser un ID de modelo alojado en el Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo recomendado por defecto para la generación de texto basada en chat. Vea https://huggingface.co/tasks/text-generation para más detalles. Si model es un ID de modelo, se pasa al servidor como el parámetro model. Si desea definir una URL personalizada mientras establece model en el payload de la solicitud, debe establecer base_url al inicializar InferenceClient.
frequency_penalty (float, opcional) — Penaliza los nuevos tokens en función de su frecuencia existente en el texto hasta el momento. Rango: [-2.0, 2.0]. Valor predeterminado: 0.0.
logit_bias (list[float], opcional) — Ajusta la probabilidad de que ciertos tokens aparezcan en la salida generada.
logprobs (bool, opcional) — Indica si se deben devolver las probabilidades logarítmicas de los tokens de salida. Si es true, devuelve las probabilidades logarítmicas de cada token de salida devuelto en el contenido del mensaje.
max_tokens (int, opcional) — Número máximo de tokens permitidos en la respuesta. El valor predeterminado es 100.
n (int, opcional) — El número de completados que se generarán para cada indicación.
presence_penalty (float, opcional) — Número entre -2.0 y 2.0. Los valores positivos penalizan los nuevos tokens en función de si aparecen en el texto hasta ahora, aumentando la probabilidad de que el modelo hable sobre temas nuevos.
response_format (ChatCompletionInputGrammarType(), opcional) — Restricciones de gramática. Puede ser un JSONSchema o una expresión regular.
seed (Opcionalint, optional) — Semilla para un flujo de control reproducible. El valor predeterminado es None.
stop (list[str], opcional) — Hasta cuatro cadenas que provocan el final de la respuesta. El valor predeterminado es None.
stream (bool, opcional) — Habilita la transmisión en tiempo real de las respuestas. El valor predeterminado es False.
stream_options (ChatCompletionInputStreamOptions, opcional) — Opciones para las completaciones en streaming.
temperature (float, opcional) — Controla la aleatoriedad de las generaciones. Valores más bajos garantizan complementos menos aleatorios. Rango: [0, 2]. Valor predeterminado: 1.0.
top_logprobs (int, opcional) — Un entero entre 0 y 5 que especifica el número de tokens más probables a devolver en cada posición de token, cada uno con una probabilidad logarítmica asociada. logprobs debe establecerse en true si se utiliza este parámetro.
top_p (float, opcional) — Fracción de las palabras siguientes más probables desde las que muestrear. Debe estar entre 0 y 1. El valor predeterminado es 1.0.
tool_choice (ChatCompletionInputToolChoiceClass o ChatCompletionInputToolChoiceEnum(), opcional) — La herramienta que se usará para la finalización. El valor predeterminado es “auto”.
tool_prompt (str, opcional) — Un prompt que se añade antes de las herramientas.
tools (Lista de ChatCompletionInputTool, opcional) — Una lista de herramientas que el modelo puede llamar. Actualmente, solo se admiten funciones como herramienta. Utilice esto para proporcionar una lista de funciones para las que el modelo puede generar entradas JSON.
extra_body (dict, opcional) — Parámetros adicionales específicos del proveedor para pasar al modelo. Consulte la documentación del proveedor para los parámetros admitidos.

Devuelve

ChatCompletionOutput o iterable de ChatCompletionStreamOutput

Texto generado devuelto por el servidor:

Si stream=False, el texto generado se devuelve como ChatCompletionOutput (valor predeterminado).
Si stream=True, el texto generado se devuelve token a token como una secuencia de ChatCompletionStreamOutput.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Un método para completar conversaciones utilizando un modelo de lenguaje especificado.

El método client.chat_completion tiene el alias client.chat.completions.create para ser compatible con el cliente de OpenAI. Las entradas y salidas son estrictamente las mismas y el uso de cualquiera de las dos sintaxis producirá los mismos resultados. Consulte la Guía de inferencia para obtener más detalles sobre la compatibilidad con OpenAI.

Puedes pasar parámetros específicos del proveedor al modelo utilizando el argumento extra_body.

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> messages = [{"role": "user", "content": "What is the capital of France?"}]
>>> client = AsyncInferenceClient("meta-llama/Meta-Llama-3-8B-Instruct")
>>> await client.chat_completion(messages, max_tokens=100)
ChatCompletionOutput(
    choices=[
        ChatCompletionOutputComplete(
            finish_reason='eos_token',
            index=0,
            message=ChatCompletionOutputMessage(
                role='assistant',
                content='The capital of France is Paris.',
                name=None,
                tool_calls=None
            ),
            logprobs=None
        )
    ],
    created=1719907176,
    id='',
    model='meta-llama/Meta-Llama-3-8B-Instruct',
    object='text_completion',
    system_fingerprint='2.0.4-sha-f426a33',
    usage=ChatCompletionOutputUsage(
        completion_tokens=8,
        prompt_tokens=17,
        total_tokens=25
    )
)

Ejemplo usando streaming:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> messages = [{"role": "user", "content": "What is the capital of France?"}]
>>> client = AsyncInferenceClient("meta-llama/Meta-Llama-3-8B-Instruct")
>>> async for token in await client.chat_completion(messages, max_tokens=10, stream=True):
...     print(token)
ChatCompletionStreamOutput(choices=[ChatCompletionStreamOutputChoice(delta=ChatCompletionStreamOutputDelta(content='The', role='assistant'), index=0, finish_reason=None)], created=1710498504)
ChatCompletionStreamOutput(choices=[ChatCompletionStreamOutputChoice(delta=ChatCompletionStreamOutputDelta(content=' capital', role='assistant'), index=0, finish_reason=None)], created=1710498504)
(...)
ChatCompletionStreamOutput(choices=[ChatCompletionStreamOutputChoice(delta=ChatCompletionStreamOutputDelta(content=' may', role='assistant'), index=0, finish_reason=None)], created=1710498504)

Ejemplo usando la sintaxis de OpenAI:

# Must be run in an async context
# instead of `from openai import OpenAI`
from huggingface_hub import AsyncInferenceClient

# instead of `client = OpenAI(...)`
client = AsyncInferenceClient(
    base_url=...,
    api_key=...,
)

output = await client.chat.completions.create(
    model="meta-llama/Meta-Llama-3-8B-Instruct",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Count to 10"},
    ],
    stream=True,
    max_tokens=1024,
)

for chunk in output:
    print(chunk.choices[0].delta.content)

Ejemplo de uso de un proveedor de terceros directamente con parámetros adicionales (específicos del proveedor). El uso se facturará en su cuenta de Together AI.

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient(
...     provider="together",  # Use Together AI provider
...     api_key="<together_api_key>",  # Pass your Together API key directly
... )
>>> client.chat_completion(
...     model="meta-llama/Meta-Llama-3-8B-Instruct",
...     messages=[{"role": "user", "content": "What is the capital of France?"}],
...     extra_body={"safety_model": "Meta-Llama/Llama-Guard-7b"},
... )

Ejemplo de uso de un proveedor de terceros a través de Hugging Face Routing. El uso se facturará en tu cuenta de Hugging Face.

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient(
...     provider="novita",  # Use Novita provider
...     api_key="hf_...",  # Pass your HF token
... )
>>> client.chat_completion(
...     model="meta-llama/Meta-Llama-3-8B-Instruct",
...     messages=[{"role": "user", "content": "What is the capital of France?"}],
... )

Ejemplo usando Imagen + Texto como entrada:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient

# provide a remote URL
>>> image_url ="https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
# or a base64-encoded image
>>> image_path = "/path/to/image.jpeg"
>>> with open(image_path, "rb") as f:
...     base64_image = base64.b64encode(f.read()).decode("utf-8")
>>> image_url = f"data:image/jpeg;base64,{base64_image}"

>>> client = AsyncInferenceClient("meta-llama/Llama-3.2-11B-Vision-Instruct")
>>> output = await client.chat.completions.create(
...     messages=[
...         {
...             "role": "user",
...             "content": [
...                 {
...                     "type": "image_url",
...                     "image_url": {"url": image_url},
...                 },
...                 {
...                     "type": "text",
...                     "text": "Describe this image in one sentence.",
...                 },
...             ],
...         },
...     ],
... )
>>> output
The image depicts the iconic Statue of Liberty situated in New York Harbor, New York, on a clear day.

Ejemplo usando herramientas:

# Must be run in an async context
>>> client = AsyncInferenceClient("meta-llama/Meta-Llama-3-70B-Instruct")
>>> messages = [
...     {
...         "role": "system",
...         "content": "Don't make assumptions about what values to plug into functions. Ask for clarification if a user request is ambiguous.",
...     },
...     {
...         "role": "user",
...         "content": "What's the weather like the next 3 days in San Francisco, CA?",
...     },
... ]
>>> tools = [
...     {
...         "type": "function",
...         "function": {
...             "name": "get_current_weather",
...             "description": "Get the current weather",
...             "parameters": {
...                 "type": "object",
...                 "properties": {
...                     "location": {
...                         "type": "string",
...                         "description": "The city and state, e.g. San Francisco, CA",
...                     },
...                     "format": {
...                         "type": "string",
...                         "enum": ["celsius", "fahrenheit"],
...                         "description": "The temperature unit to use. Infer this from the users location.",
...                     },
...                 },
...                 "required": ["location", "format"],
...             },
...         },
...     },
...     {
...         "type": "function",
...         "function": {
...             "name": "get_n_day_weather_forecast",
...             "description": "Get an N-day weather forecast",
...             "parameters": {
...                 "type": "object",
...                 "properties": {
...                     "location": {
...                         "type": "string",
...                         "description": "The city and state, e.g. San Francisco, CA",
...                     },
...                     "format": {
...                         "type": "string",
...                         "enum": ["celsius", "fahrenheit"],
...                         "description": "The temperature unit to use. Infer this from the users location.",
...                     },
...                     "num_days": {
...                         "type": "integer",
...                         "description": "The number of days to forecast",
...                     },
...                 },
...                 "required": ["location", "format", "num_days"],
...             },
...         },
...     },
... ]

>>> response = await client.chat_completion(
...     model="meta-llama/Meta-Llama-3-70B-Instruct",
...     messages=messages,
...     tools=tools,
...     tool_choice="auto",
...     max_tokens=500,
... )
>>> response.choices[0].message.tool_calls[0].function
ChatCompletionOutputFunctionDefinition(
    arguments={
        'location': 'San Francisco, CA',
        'format': 'fahrenheit',
        'num_days': 3
    },
    name='get_n_day_weather_forecast',
    description=None
)

Ejemplo usando response_format:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient("meta-llama/Meta-Llama-3-70B-Instruct")
>>> messages = [
...     {
...         "role": "user",
...         "content": "I saw a puppy a cat and a raccoon during my bike ride in the park. What did I see and when?",
...     },
... ]
>>> response_format = {
...     "type": "json",
...     "value": {
...         "properties": {
...             "location": {"type": "string"},
...             "activity": {"type": "string"},
...             "animals_seen": {"type": "integer", "minimum": 1, "maximum": 5},
...             "animals": {"type": "array", "items": {"type": "string"}},
...         },
...         "required": ["location", "activity", "animals_seen", "animals"],
...     },
... }
>>> response = await client.chat_completion(
...     messages=messages,
...     response_format=response_format,
...     max_tokens=500,
... )
>>> response.choices[0].message.content
'{

y": "bike ride",
": ["puppy", "cat", "raccoon"],
_seen": 3,
n": "park"}'

cerrar

( )

Cierre el cliente.

Este método se llama automáticamente al usar el cliente como un administrador de contexto.

document_question_answering

( image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview]question: strmodel: str | None = Nonedoc_stride: int | None = Nonehandle_impossible_answer: bool | None = Nonelang: str | None = Nonemax_answer_len: int | None = Nonemax_question_len: int | None = Nonemax_seq_len: int | None = Nonetop_k: int | None = Noneword_boxes: list[list[float] | str] | None = None ) → list[DocumentQuestionAnsweringOutputElement]

Parámetros

image (Union[str, Path, bytes, BinaryIO]) — La imagen de entrada para el contexto. Puede ser bytes en bruto, un archivo de imagen o una URL a una imagen en línea.
question (str) — Pregunta a responder.
model (str, opcional) — El modelo que se utilizará para la tarea de respuesta a preguntas sobre documentos. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo de respuesta a preguntas sobre documentos recomendado por defecto. El valor predeterminado es None.
doc_stride (int, opcional) — 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.
handle_impossible_answer (bool, opcional) — Si se acepta "imposible" como respuesta
lang (str, opcional) — Idioma a utilizar durante la ejecución de OCR. El valor predeterminado es inglés.
max_answer_len (int, opcional) — La longitud máxima de las respuestas predichas (p. ej., solo se consideran las respuestas con una longitud menor).
max_question_len (int, opcional) — La longitud máxima de la pregunta después de la tokenización. Se truncará si es necesario.
max_seq_len (int, opcional) — 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 (usando doc_stride como solapamiento) si es necesario.
top_k (int, opcional) — El número de respuestas a devolver (se elegirán por orden de probabilidad). Puede devolver menos de top_k respuestas si no hay suficientes opciones disponibles dentro del contexto.
word_boxes (list[Union[list[float], str, opcional) — Una lista de palabras y cajas delimitadoras (normalizadas de 0 a 1000). Si se proporciona, la inferencia omitirá el paso de OCR y usará las cajas delimitadoras proporcionadas en su lugar.

Devuelve

list[DocumentQuestionAnsweringOutputElement]

una lista de elementos DocumentQuestionAnsweringOutputElement que contienen la etiqueta predicha, la probabilidad asociada, los ids de las palabras y el número de página.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Responde preguntas sobre imágenes de documentos.

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.document_question_answering(image="https://huggingface.co/spaces/impira/docquery/resolve/2359223c1837a7587402bda0f2643382a6eefeab/invoice.png", question="What is the invoice number?")
[DocumentQuestionAnsweringOutputElement(answer='us-001', end=16, score=0.9999666213989258, start=16)]

feature_extraction

( text: str | list[str]normalize: bool | None = Noneprompt_name: str | None = Nonetruncate: bool | None = Nonetruncation_direction: typing.Optional[typing.Literal['left', 'right']] = Nonedimensions: int | None = Noneencoding_format: typing.Optional[typing.Literal['float', 'base64']] = Nonemodel: str | None = None ) → np.ndarray

Parámetros

text (str o list[str]) — El texto o lista de textos para incrustar.
model (str, opcional) — El modelo a utilizar para la tarea de extracción de características. Puede ser un ID de modelo alojado en el Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo de extracción de características recomendado por defecto. El valor predeterminado es None.
normalize (bool, opcional) — Si se normalizan o no los embeddings. Solo disponible en servidores impulsados por Text-Embedding-Inference.
prompt_name (str, opcional) — El nombre del prompt que debe usarse para la codificación. Si no se establece, no se aplicará ningún prompt. Debe ser una clave en el diccionario prompts de la configuración de Sentence Transformers. Por ejemplo, si prompt_name es “query” y prompts es {“query”: “query: ”,…}, la oración “What is the capital of France?” se codificará como “query: What is the capital of France?” porque el texto del prompt se añadirá al principio de cualquier texto a codificar.
truncate (bool, opcional) — Si se deben truncar los embeddings o no. Solo disponible en servidores impulsados por Text-Embedding-Inference.
truncation_direction (Literal[“left”, “right”], opcional) — Indica qué lado de la entrada debe truncarse cuando se pasa truncate=True.
dimensions (int, opcional) — El número de dimensiones que deben tener las incrustaciones de salida resultantes. Solo disponible en puntos finales de incrustaciones compatibles con OpenAI.
encoding_format (Literal[“float”, “base64”], opcional) — El formato de las incrustaciones de salida. Puede ser “float” o “base64”. Solo disponible en puntos finales de incrustaciones compatibles con OpenAI.

Devuelve

np.ndarray

El embedding que representa el texto de entrada como un array numpy de float32.

Lanza

[InferenceTimeoutError] o [HfHubHTTPError]

[InferenceTimeoutError] — Si el modelo no está disponible o la solicitud expira.
[HfHubHTTPError] — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Genera embeddings para un texto o lote de textos dado.

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.feature_extraction("Hi, who are you?")
array([[ 2.424802  ,  2.93384   ,  1.1750331 , ...,  1.240499, -0.13776633, -0.7889173 ],
[-0.42943227, -0.6364878 , -1.693462  , ...,  0.41978157, -2.4336355 ,  0.6162071 ],
...,
[ 0.28552425, -0.928395  , -1.2077185 , ...,  0.76810825, -2.1069427 ,  0.6236161 ]], dtype=float32)

fill_mask

( text: strmodel: str | None = Nonetargets: list[str] | None = Nonetop_k: int | None = None ) → list[FillMaskOutputElement]

Parámetros

text (str) — una cadena de la que se rellenará, debe contener el token [MASK] (consulte la tarjeta del modelo para el nombre exacto de la máscara).
model (str, opcional) — El modelo que se usará para la tarea de fill mask. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se usará el modelo de fill mask recomendado por defecto.
targets (list[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

list[FillMaskOutputElement]

una lista de elementos FillMaskOutputElement que contienen la etiqueta predicha, la probabilidad asociada, la referencia del token y el texto completado.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Rellene un hueco con una palabra que falta (un token, para ser precisos).

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.fill_mask("The goal of life is <mask>.")
[
    FillMaskOutputElement(score=0.06897063553333282, token=11098, token_str=' happiness', sequence='The goal of life is happiness.'),
    FillMaskOutputElement(score=0.06554922461509705, token=45075, token_str=' immortality', sequence='The goal of life is immortality.')
]

get_endpoint_info

( model: str | None = None ) → dict[str, Any]

Parámetros

model (str, opcional) — El modelo que se usará para la inferencia. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Este parámetro anula el modelo definido a nivel de instancia. El valor predeterminado es None.

Devuelve

dict[str, Any]

Información sobre el punto de conexión.

Obtén información sobre el punto de acceso desplegado.

Este punto de solo está disponible en puntos de acceso impulsados por Text-Generation-Inference (TGI) o Text-Embedding-Inference (TEI). Los puntos de acceso impulsados por transformers devuelven una carga vacía.

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient("meta-llama/Meta-Llama-3-70B-Instruct")
>>> await client.get_endpoint_info()
{
    'model_id': 'meta-llama/Meta-Llama-3-70B-Instruct',
    'model_sha': None,
    'model_dtype': 'torch.float16',
    'model_device_type': 'cuda',
    'model_pipeline_tag': None,
    'max_concurrent_requests': 128,
    'max_best_of': 2,
    'max_stop_sequences': 4,
    'max_input_length': 8191,
    'max_total_tokens': 8192,
    'waiting_served_ratio': 0.3,
    'max_batch_total_tokens': 1259392,
    'max_waiting_tokens': 20,
    'max_batch_size': None,
    'validation_workers': 32,
    'max_client_batch_size': 4,
    'version': '2.0.2',
    'sha': 'dccab72549635c7eb5ddb17f43f0b7cdff07c214',
    'docker_label': 'sha-dccab72'
}

health_check

( model: str | None = None ) → bool

Parámetros

model (str, opcional) — URL del Inference Endpoint. Este parámetro reemplaza al modelo definido a nivel de instancia. El valor predeterminado es None.

Devuelve

bool

True si todo funciona correctamente.

Comprueba el estado del punto de acceso desplegado.

La comprobación de estado solo está disponible con Inference Endpoints impulsados por Text-Generation-Inference (TGI) o Text-Embedding-Inference (TEI).

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient("https://jzgu0buei5.us-east-1.aws.endpoints.huggingface.cloud")
>>> await client.health_check()
True

clasificación_de_imágenes

( image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview]model: str | None = Nonefunction_to_apply: typing.Optional[ForwardRef('ImageClassificationOutputTransform')] = Nonetop_k: int | None = None ) → list[ImageClassificationOutputElement]

Parámetros

image (Union[str, Path, bytes, BinaryIO, PIL.Image.Image]) — The image to classify. It can be raw bytes, an image file, a URL to an online image, or a PIL Image.
model (str, opcional) — El modelo a utilizar para la clasificación de imágenes. Puede ser un ID de modelo alojado en el Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo recomendado por defecto para la clasificación de imágenes.
function_to_apply ("ImageClassificationOutputTransform", opcional) — La función que se aplica a las salidas del modelo para obtener las puntuaciones.
top_k (int, opcional) — Cuando se especifica, limita la salida a las K clases más probables.

Devuelve

list[ImageClassificationOutputElement]

una lista de elementos ImageClassificationOutputElement que contienen la etiqueta predicha y la probabilidad asociada.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Realiza la clasificación de imágenes en la imagen proporcionada utilizando el modelo especificado.

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.image_classification("https://upload.wikimedia.org/wikipedia/commons/thumb/4/43/Cute_dog.jpg/320px-Cute_dog.jpg")
[ImageClassificationOutputElement(label='Blenheim spaniel', score=0.9779096841812134), ...]

image_segmentation

( image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview]model: str | None = Nonemask_threshold: float | None = Noneoverlap_mask_area_threshold: float | None = Nonesubtask: typing.Optional[ForwardRef('ImageSegmentationSubtask')] = Nonethreshold: float | None = None ) → list[ImageSegmentationOutputElement]

Parámetros

image (Union[str, Path, bytes, BinaryIO, PIL.Image.Image]) — The image to segment. It can be raw bytes, an image file, a URL to an online image, or a PIL Image.
model (str, opcional) — El modelo a utilizar para la segmentación de imágenes. Puede ser un ID de modelo alojado en el Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo recomendado por defecto para la segmentación de imágenes.
mask_threshold (float, opcional) — Umbral a utilizar al convertir las máscaras predichas en valores binarios.
overlap_mask_area_threshold (float, opcional) — Umbral de solapamiento de máscaras para eliminar segmentos pequeños y desconectados.
subtask ("ImageSegmentationSubtask", opcional) — Tarea de segmentación a realizar, según las capacidades del modelo.
threshold (float, opcional) — Umbral de probabilidad para filtrar las máscaras predichas.

Devuelve

list[ImageSegmentationOutputElement]

Una lista de elementos ImageSegmentationOutputElement que contiene las máscaras segmentadas y los atributos asociados.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Realice la segmentación de imágenes en la imagen proporcionada utilizando el modelo especificado.

Debes tener PIL instalado si quieres trabajar con imágenes (pip install Pillow).

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.image_segmentation("cat.jpg")
[ImageSegmentationOutputElement(score=0.989008, label='LABEL_184', mask=<PIL.PngImagePlugin.PngImageFile image mode=L size=400x300 at 0x7FDD2B129CC0>), ...]

image_to_image

( image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview]prompt: str | None = Nonenegative_prompt: str | None = Nonenum_inference_steps: int | None = Noneguidance_scale: float | None = Nonemodel: str | None = Nonetarget_size: huggingface_hub.inference._generated.types.image_to_image.ImageToImageTargetSize | None = None**kwargs ) → Image

Parámetros

image (Union[str, Path, bytes, BinaryIO, PIL.Image.Image]) — The input image for translation. It can be raw bytes, an image file, a URL to an online image, or a PIL Image.
prompt (str, opcional) — El texto de la indicación para guiar la generación de la imagen.
negative_prompt (str, opcional) — Un prompt para guiar lo que NO debe incluirse en la generación de la imagen.
num_inference_steps (int, opcional) — Para modelos de difusión. El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.
guidance_scale (float, opcional) — Para modelos de difusión. Un valor de escala de guía más alto anima al modelo a generar imágenes estrechamente vinculadas al prompt de texto a costa de una menor calidad de imagen.
model (str, opcional) — El modelo que se usará para la inferencia. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Este parámetro anula el modelo definido a nivel de instancia. El valor predeterminado es None.
target_size (ImageToImageTargetSize, opcional) — El tamaño en píxeles de la imagen de salida. Este parámetro solo es compatible con algunos proveedores y para modelos específicos. Se ignorará cuando no sea compatible.

Devuelve

Image

La imagen traducida.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Realice la traducción de imagen a imagen utilizando un modelo especificado.

Debes tener PIL instalado si quieres trabajar con imágenes (pip install Pillow).

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> image = await client.image_to_image("cat.jpg", prompt="turn the cat into a tiger")
>>> image.save("tiger.jpg")

image_to_text

( image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview]model: str | None = None ) → ImageToTextOutput

Parámetros

image (Union[str, Path, bytes, BinaryIO, PIL.Image.Image]) — The input image to caption. It can be raw bytes, an image file, a URL to an online image, or a PIL Image.
model (str, opcional) — El modelo que se usará para la inferencia. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Este parámetro anula el modelo definido a nivel de instancia. El valor predeterminado es None.

Devuelve

ImageToTextOutput

El texto generado.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Toma una imagen de entrada y devuelve texto.

Los modelos pueden tener salidas muy diferentes según su caso de uso (descripción de imágenes, reconocimiento óptico de caracteres (OCR), Pix2Struct, etc.). Consulte la tarjeta del modelo para conocer más detalles sobre las especificidades de un modelo.

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.image_to_text("cat.jpg")
'a cat standing in a grassy field '
>>> await client.image_to_text("https://upload.wikimedia.org/wikipedia/commons/thumb/4/43/Cute_dog.jpg/320px-Cute_dog.jpg")
'a dog laying on the grass next to a flower pot '

image_to_video

( image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview]model: str | None = Noneprompt: str | None = Nonenegative_prompt: str | None = Nonenum_frames: float | None = Nonenum_inference_steps: int | None = Noneguidance_scale: float | None = Noneseed: int | None = Nonetarget_size: huggingface_hub.inference._generated.types.image_to_video.ImageToVideoTargetSize | None = None**kwargs ) → bytes

Parámetros

image (Union[str, Path, bytes, BinaryIO, PIL.Image.Image]) — The input image to generate a video from. It can be raw bytes, an image file, a URL to an online image, or a PIL Image.
model (str, opcional) — El modelo que se usará para la inferencia. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Este parámetro anula el modelo definido a nivel de instancia. El valor predeterminado es None.
prompt (str, opcional) — El texto de la indicación para guiar la generación del video.
negative_prompt (str, opcional) — Un prompt para guiar lo que NO debe incluirse en la generación de video.
num_frames (float, opcional) — El parámetro num_frames determina cuántos fotogramas de vídeo se generan.
num_inference_steps (int, opcional) — Para modelos de difusión. El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.
guidance_scale (float, opcional) — Para modelos de difusión. Un valor de escala de guía más alto anima al modelo a generar videos estrechamente vinculados al prompt de texto a costa de una menor calidad de imagen.
seed (int, opcional) — La semilla a utilizar para la generación del video.
target_size (ImageToVideoTargetSize, opcional) — El tamaño en píxeles de los fotogramas del video de salida.
num_inference_steps (int, opcional) — El número de pasos de desruido. Más pasos de desruido suelen dar lugar a un video de mayor calidad a costa de una inferencia más lenta.
seed (int, opcional) — Semilla para el generador de números aleatorios.

Devuelve

bytes

El video generado.

Genere un video a partir de una imagen de entrada.

Ejemplos:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> video = await client.image_to_video("cat.jpg", model="Wan-AI/Wan2.2-I2V-A14B", prompt="turn the cat into a tiger")
>>> with open("tiger.mp4", "wb") as f:
...     f.write(video)

object_detection

( image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview]model: str | None = Nonethreshold: float | None = None ) → list[ObjectDetectionOutputElement]

Parámetros

image (Union[str, Path, bytes, BinaryIO, PIL.Image.Image]) — The image to detect objects on. It can be raw bytes, an image file, a URL to an online image, or a PIL Image.
model (str, opcional) — El modelo a utilizar para la detección de objetos. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo recomendado por defecto para la detección de objetos (DETR).
threshold (float, opcional) — La probabilidad necesaria para realizar una predicción.

Devuelve

list[ObjectDetectionOutputElement]

Una lista de elementos ObjectDetectionOutputElement que contiene las cajas delimitadoras y los atributos asociados.

Lanza

InferenceTimeoutError o HfHubHTTPError o ValueError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.
ValueError — Si la salida de la solicitud no es una List.

Realiza la detección de objetos en la imagen proporcionada utilizando el modelo especificado.

Debes tener PIL instalado si quieres trabajar con imágenes (pip install Pillow).

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.object_detection("people.jpg")
[ObjectDetectionOutputElement(score=0.9486683011054993, label='person', box=ObjectDetectionBoundingBox(xmin=59, ymin=39, xmax=420, ymax=510)), ...]

question_answering

( question: strcontext: strmodel: str | None = Nonealign_to_words: bool | None = Nonedoc_stride: int | None = Nonehandle_impossible_answer: bool | None = Nonemax_answer_len: int | None = Nonemax_question_len: int | None = Nonemax_seq_len: int | None = Nonetop_k: int | None = None ) → Union[QuestionAnsweringOutputElement, listQuestionAnsweringOutputElement]

Parámetros

question (str) — Pregunta a responder.
context (str) — El contexto de la pregunta.
model (str) — El modelo que se usará para la tarea de respuesta a preguntas. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado.
align_to_words (bool, opcional) — Intenta alinear la respuesta con palabras reales. Mejora la calidad en idiomas separados por espacios. Puede perjudicar en idiomas no separados por espacios (como el japonés o el chino)
doc_stride (int, opcional) — Si el contexto es demasiado largo 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.
handle_impossible_answer (bool, opcional) — Si se acepta "imposible" como respuesta.
max_answer_len (int, opcional) — La longitud máxima de las respuestas predichas (p. ej., solo se consideran las respuestas con una longitud menor).
max_question_len (int, opcional) — La longitud máxima de la pregunta después de la tokenización. Se truncará si es necesario.
max_seq_len (int, opcional) — 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 (usando docStride como solapamiento) si es necesario.
top_k (int, opcional) — El número de respuestas a devolver (se elegirán por orden de probabilidad). Tenga en cuenta que devolvemos menos de topk respuestas si no hay suficientes opciones disponibles dentro del contexto.

Devuelve

Union[QuestionAnsweringOutputElement, listQuestionAnsweringOutputElement]

When top_k is 1 or not provided, it returns a single QuestionAnsweringOutputElement. When top_k is greater than 1, it returns a list of QuestionAnsweringOutputElement.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Obtener la respuesta a una pregunta a partir de un texto dado.

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.question_answering(question="What's my name?", context="My name is Clara and I live in Berkeley.")
QuestionAnsweringOutputElement(answer='Clara', end=16, score=0.9326565265655518, start=11)

sentence_similarity

( sentence: strother_sentences: listmodel: str | None = None ) → list[float]

Parámetros

sentence (str) — La oración principal con la que se comparan las demás.
other_sentences (list[str]) — La lista de oraciones con las que comparar.
model (str, opcional) — El modelo a utilizar para la tarea de similitud de oraciones. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo de similitud de oraciones recomendado por defecto. El valor predeterminado es None.

Devuelve

list[float]

El embedding que representa el texto de entrada.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Calcule la similitud semántica entre una oración y una lista de otras oraciones comparando sus embeddings.

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.sentence_similarity(
...     "Machine learning is so easy.",
...     other_sentences=[
...         "Deep learning is so straightforward.",
...         "This is so difficult, like rocket science.",
...         "I can't believe how much I struggled with this.",
...     ],
... )
[0.7785726189613342, 0.45876261591911316, 0.2906220555305481]

resumen

( text: strmodel: str | None = Noneclean_up_tokenization_spaces: bool | None = Nonegenerate_parameters: dict[str, typing.Any] | None = Nonetruncation: typing.Optional[ForwardRef('SummarizationTruncationStrategy')] = None ) → SummarizationOutput

Parámetros

text (str) — El texto de entrada a resumir.
model (str, opcional) — El modelo que se utilizará para la inferencia. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo recomendado por defecto para la resumición.
clean_up_tokenization_spaces (bool, opcional) — Si se deben limpiar los espacios adicionales potenciales en la salida de texto.
generate_parameters (dict[str, Any], opcional) — Parametrización adicional del algoritmo de generación de texto.
truncation ("SummarizationTruncationStrategy", opcional) — La estrategia de truncamiento a utilizar.

Devuelve

SummarizationOutput

El texto del resumen generado.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Genere un resumen de un texto dado utilizando un modelo especificado.

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.summarization("The Eiffel tower...")
SummarizationOutput(generated_text="The Eiffel tower is one of the most famous landmarks in the world....")

table_question_answering

( table: dictquery: strmodel: str | None = Nonepadding: typing.Optional[ForwardRef('Padding')] = Nonesequential: bool | None = Nonetruncation: bool | None = None ) → TableQuestionAnsweringOutputElement

Parámetros

table (str) — Una tabla de datos representada como un diccionario de listas donde las entradas son encabezados y las listas son todos los valores; todas las listas deben tener el mismo tamaño.
query (str) — La consulta en texto plano que deseas hacer a la tabla.
model (str) — El modelo que se usará para la tarea de respuesta a preguntas sobre tablas. Puede ser un ID de modelo alojado en el Hugging Face Hub o una URL de un Inference Endpoint desplegado.
padding ("Padding", opcional) — Activa y controla el relleno.
sequential (bool, opcional) — 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.
truncation (bool, opcional) — Activa y controla la truncación.

Devuelve

TableQuestionAnsweringOutputElement

una salida de respuesta a preguntas sobre tablas que contiene la respuesta, las coordenadas, las celdas y el agregador utilizado.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Obtener la respuesta a una pregunta a partir de la información proporcionada en una tabla.

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> query = "How many stars does the transformers repository have?"
>>> table = {"Repository": ["Transformers", "Datasets", "Tokenizers"], "Stars": ["36542", "4512", "3934"]}
>>> await client.table_question_answering(table, query, model="google/tapas-base-finetuned-wtq")
TableQuestionAnsweringOutputElement(answer='36542', coordinates=[[0, 1]], cells=['36542'], aggregator='AVERAGE')

clasificación_tabular

( table: dictmodel: str | None = None ) → List

Parámetros

table (dict[str, Any]) — Conjunto de atributos a clasificar.
model (str, opcional) — El modelo a utilizar para la tarea de clasificación tabular. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo de clasificación tabular recomendado por defecto. El valor predeterminado es None.

Devuelve

List

una lista de etiquetas, una por cada fila de la tabla inicial.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Clasificar una categoría objetivo (un grupo) en función de un conjunto de atributos.

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> table = {
...     "fixed_acidity": ["7.4", "7.8", "10.3"],
...     "volatile_acidity": ["0.7", "0.88", "0.32"],
...     "citric_acid": ["0", "0", "0.45"],
...     "residual_sugar": ["1.9", "2.6", "6.4"],
...     "chlorides": ["0.076", "0.098", "0.073"],
...     "free_sulfur_dioxide": ["11", "25", "5"],
...     "total_sulfur_dioxide": ["34", "67", "13"],
...     "density": ["0.9978", "0.9968", "0.9976"],
...     "pH": ["3.51", "3.2", "3.23"],
...     "sulphates": ["0.56", "0.68", "0.82"],
...     "alcohol": ["9.4", "9.8", "12.6"],
... }
>>> await client.tabular_classification(table=table, model="julien-c/wine-quality")
["5", "5", "5"]

regresión_tabular

( table: dictmodel: str | None = None ) → List

Parámetros

table (dict[str, Any]) — Conjunto de atributos almacenados en una tabla. Los atributos utilizados para predecir el objetivo pueden ser numéricos y categóricos.
model (str, opcional) — El modelo a utilizar para la tarea de regresión tabular. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo de regresión tabular recomendado por defecto. El valor predeterminado es None.

Devuelve

List

una lista de valores numéricos objetivo predichos.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Predecir un valor numérico objetivo dado un conjunto de atributos/características en una tabla.

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> table = {
...     "Height": ["11.52", "12.48", "12.3778"],
...     "Length1": ["23.2", "24", "23.9"],
...     "Length2": ["25.4", "26.3", "26.5"],
...     "Length3": ["30", "31.2", "31.1"],
...     "Species": ["Bream", "Bream", "Bream"],
...     "Width": ["4.02", "4.3056", "4.6961"],
... }
>>> await client.tabular_regression(table, model="scikit-learn/Fish-Weight")
[110, 120, 130]

clasificación_de_texto

( text: strmodel: str | None = Nonetop_k: int | None = Nonefunction_to_apply: typing.Optional[ForwardRef('TextClassificationOutputTransform')] = None ) → list[TextClassificationOutputElement]

Parámetros

text (str) — Una cadena que se va a clasificar.
model (str, opcional) — El modelo a utilizar para la tarea de clasificación de texto. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo de clasificación de texto recomendado por defecto. El valor predeterminado es None.
top_k (int, opcional) — Cuando se especifica, limita la salida a las K clases más probables.
function_to_apply ("TextClassificationOutputTransform", opcional) — La función que se aplica a las salidas del modelo para obtener las puntuaciones.

Devuelve

list[TextClassificationOutputElement]

una lista de elementos TextClassificationOutputElement que contienen la etiqueta predicha y la probabilidad asociada.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Realiza la clasificación de texto (p. ej., análisis de sentimiento) en el texto proporcionado.

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.text_classification("I like you")
[
    TextClassificationOutputElement(label='POSITIVE', score=0.9998695850372314),
    TextClassificationOutputElement(label='NEGATIVE', score=0.0001304351753788069),
]

generación_de_texto

( prompt: strdetails: bool | None = Nonestream: bool | None = Nonemodel: str | None = Noneadapter_id: str | None = Nonebest_of: int | None = Nonedecoder_input_details: bool | None = Nonedo_sample: bool | None = Nonefrequency_penalty: float | None = Nonegrammar: huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType | None = Nonemax_new_tokens: int | None = Nonerepetition_penalty: float | None = Nonereturn_full_text: bool | None = Noneseed: int | None = Nonestop: list[str] | None = Nonetemperature: float | None = Nonetop_k: int | None = Nonetop_n_tokens: int | None = Nonetop_p: float | None = Nonetruncate: int | None = Nonetypical_p: float | None = Nonewatermark: bool | None = None ) → Union[str, TextGenerationOutput, AsyncIterable[str], AsyncIterable[TextGenerationStreamOutput]]

Parámetros

prompt (str) — Texto de entrada.
details (bool, opcional) — Por defecto, text_generation devuelve una cadena de texto. Pasa details=True si deseas una salida detallada (tokens, probabilidades, semilla, motivo de finalización, etc.). Solo disponible para modelos que se ejecutan con el backend text-generation-inference.
stream (bool, opcional) — Por defecto, text_generation devuelve el texto generado completo. Pasa stream=True si quieres que se devuelva un flujo de tokens. Solo disponible para modelos que se ejecutan con el backend text-generation-inference.
model (str, opcional) — El modelo que se usará para la inferencia. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Este parámetro anula el modelo definido a nivel de instancia. El valor predeterminado es None.
adapter_id (str, opcional) — ID del adaptador Lora.
best_of (int, opcional) — Genera best_of secuencias y devuelve la que tenga los logprobs de tokens más altos.
decoder_input_details (bool, opcional) — Devuelve los logprobs y los ids de los tokens de entrada del decodificador. Debes establecer también details=True para que se tenga en cuenta. El valor predeterminado es False.
do_sample (bool, opcional) — Activa el muestreo de logits
frequency_penalty (float, opcional) — Número entre -2.0 y 2.0. Los valores positivos penalizan los nuevos tokens en función de su frecuencia existente en el texto hasta el momento, lo que reduce la probabilidad de que el modelo repita la misma línea textualmente.
grammar (TextGenerationInputGrammarType, opcional) — Restricciones de gramática. Puede ser un JSONSchema o una expresión regular.
max_new_tokens (int, opcional) — Número máximo de tokens generados. El valor predeterminado es 100.
repetition_penalty (float, opcional) — El parámetro para la penalización de repetición. 1.0 significa sin penalización. Consulte este artículo para más detalles.
return_full_text (bool, opcional) — Si se debe anteponer el prompt al texto generado
seed (int, opcional) — Semilla para el muestreo aleatorio
stop (list[str], opcional) — Deja de generar tokens si se genera un miembro de stop.
temperature (float, opcional) — El valor utilizado para modular la distribución de logits.
top_n_tokens (int, opcional) — Devuelve información sobre los top_n_tokens tokens más probables en cada paso de generación, en lugar de solo el token muestreado.
top_k (int, *opcional`) — El número de tokens del vocabulario con mayor probabilidad que se conservan para el filtrado top-k.
top_p (float, *optional) -- If set to < 1, only the smallest set of most probable tokens with probabilities that add up to top_p` or higher are kept for generation.
truncate (int, *opcional`) — Trunca los tokens de entrada al tamaño indicado.
typical_p (float, *opcional`) — Masa de Typical Decoding Consulte Typical Decoding for Natural Language Generation para obtener más información
watermark (bool, opcional) — Marca de agua con A Watermark for Large Language Models

Devuelve

Union[str, TextGenerationOutput, AsyncIterable[str], AsyncIterable[TextGenerationStreamOutput]]

Texto generado devuelto por el servidor:

si stream=False y details=False, el texto generado se devuelve como un str (predeterminado)
si stream=True y details=False, el texto generado se devuelve token a token como un AsyncIterable[str]
si stream=False y details=True, el texto generado se devuelve con más detalles como un TextGenerationOutput
si details=True y stream=True, el texto generado se devuelve token a token como un iterable de TextGenerationStreamOutput

Lanza

ValidationError o InferenceTimeoutError o HfHubHTTPError

ValidationError — Si los valores de entrada no son válidos. No se realiza ninguna llamada HTTP al servidor.
InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Dado un prompt, genera el siguiente texto.

Si deseas generar una respuesta a partir de mensajes de chat, debes usar el método InferenceClient.chat_completion(). Acepta una lista de mensajes en lugar de un único texto de entrada y gestiona la plantilla de chat por ti.

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()

# Case 1: generate text
>>> await client.text_generation("The huggingface_hub library is ", max_new_tokens=12)
'100% open source and built to be easy to use.'

# Case 2: iterate over the generated tokens. Useful for large generation.
>>> async for token in await client.text_generation("The huggingface_hub library is ", max_new_tokens=12, stream=True):
...     print(token)
100
%
open
source
and
built
to
be
easy
to
use
.

# Case 3: get more details about the generation process.
>>> await client.text_generation("The huggingface_hub library is ", max_new_tokens=12, details=True)
TextGenerationOutput(
    generated_text='100% open source and built to be easy to use.',
    details=TextGenerationDetails(
        finish_reason='length',
        generated_tokens=12,
        seed=None,
        prefill=[
            TextGenerationPrefillOutputToken(id=487, text='The', logprob=None),
            TextGenerationPrefillOutputToken(id=53789, text=' hugging', logprob=-13.171875),
            (...)
            TextGenerationPrefillOutputToken(id=204, text=' ', logprob=-7.0390625)
        ],
        tokens=[
            TokenElement(id=1425, text='100', logprob=-1.0175781, special=False),
            TokenElement(id=16, text='%', logprob=-0.0463562, special=False),
            (...)
            TokenElement(id=25, text='.', logprob=-0.5703125, special=False)
        ],
        best_of_sequences=None
    )
)

# Case 4: iterate over the generated tokens with more details.
# Last object is more complete, containing the full generated text and the finish reason.
>>> async for details in await client.text_generation("The huggingface_hub library is ", max_new_tokens=12, details=True, stream=True):
...     print(details)
...
TextGenerationStreamOutput(token=TokenElement(id=1425, text='100', logprob=-1.0175781, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=16, text='%', logprob=-0.0463562, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=1314, text=' open', logprob=-1.3359375, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=3178, text=' source', logprob=-0.28100586, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=273, text=' and', logprob=-0.5961914, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=3426, text=' built', logprob=-1.9423828, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=271, text=' to', logprob=-1.4121094, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=314, text=' be', logprob=-1.5224609, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=1833, text=' easy', logprob=-2.1132812, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=271, text=' to', logprob=-0.08520508, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(id=745, text=' use', logprob=-0.39453125, special=False), generated_text=None, details=None)
TextGenerationStreamOutput(token=TokenElement(
    id=25,
    text='.',
    logprob=-0.5703125,
    special=False),
    generated_text='100% open source and built to be easy to use.',
    details=TextGenerationStreamOutputStreamDetails(finish_reason='length', generated_tokens=12, seed=None)
)

# Case 5: generate constrained output using grammar
>>> response = await client.text_generation(
...     prompt="I saw a puppy a cat and a raccoon during my bike ride in the park",
...     model="HuggingFaceH4/zephyr-orpo-141b-A35b-v0.1",
...     max_new_tokens=100,
...     repetition_penalty=1.3,
...     grammar={
...         "type": "json",
...         "value": {
...             "properties": {
...                 "location": {"type": "string"},
...                 "activity": {"type": "string"},
...                 "animals_seen": {"type": "integer", "minimum": 1, "maximum": 5},
...                 "animals": {"type": "array", "items": {"type": "string"}},
...             },
...             "required": ["location", "activity", "animals_seen", "animals"],
...         },
...     },
... )
>>> json.loads(response)
{
    "activity": "bike riding",
    "animals": ["puppy", "cat", "raccoon"],
    "animals_seen": 3,
    "location": "park"
}

text_to_image

( prompt: strnegative_prompt: str | None = Noneheight: int | None = Nonewidth: int | None = Nonenum_inference_steps: int | None = Noneguidance_scale: float | None = Nonemodel: str | None = Nonescheduler: str | None = Noneseed: int | None = Noneextra_body: dict[str, typing.Any] | None = None ) → Image

Parámetros

prompt (str) — El prompt para generar una imagen.
negative_prompt (str, opcional) — Un prompt para guiar lo que NO debe incluirse en la generación de la imagen.
height (int, opcional) — La altura en píxeles de la imagen de salida
width (int, opcional) — El ancho en píxeles de la imagen de salida
num_inference_steps (int, opcional) — El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.
guidance_scale (float, opcional) — Un valor de escala de guía más alto anima al modelo a generar imágenes estrechamente vinculadas al prompt de texto, pero valores demasiado altos pueden causar saturación y otros artefactos.
model (str, opcional) — El modelo que se utilizará para la inferencia. Puede ser un ID de modelo alojado en el Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo de texto a imagen recomendado por defecto. El valor predeterminado es None.
scheduler (str, opcional) — Sustituye el programador por uno compatible.
seed (int, opcional) — Semilla para el generador de números aleatorios.
extra_body (dict[str, Any], opcional) — Parámetros adicionales específicos del proveedor para pasar al modelo. Consulte la documentación del proveedor para los parámetros admitidos.

Devuelve

Image

La imagen generada.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Genere una imagen a partir de un texto dado utilizando un modelo especificado.

Debes tener PIL instalado si quieres trabajar con imágenes (pip install Pillow).

Puedes pasar parámetros específicos del proveedor al modelo utilizando el argumento extra_body.

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()

>>> image = await client.text_to_image("An astronaut riding a horse on the moon.")
>>> image.save("astronaut.png")

>>> image = await client.text_to_image(
...     "An astronaut riding a horse on the moon.",
...     negative_prompt="low resolution, blurry",
...     model="stabilityai/stable-diffusion-2-1",
... )
>>> image.save("better_astronaut.png")

Example using a third-party provider directly. Usage will be billed on your fal.ai account.

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient(
...     provider="fal-ai",  # Use fal.ai provider
...     api_key="fal-ai-api-key",  # Pass your fal.ai API key
... )
>>> image = client.text_to_image(
...     "A majestic lion in a fantasy forest",
...     model="black-forest-labs/FLUX.1-schnell",
... )
>>> image.save("lion.png")

Ejemplo de uso de un proveedor de terceros a través de Hugging Face Routing. El uso se facturará en tu cuenta de Hugging Face.

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient(
...     provider="replicate",  # Use replicate provider
...     api_key="hf_...",  # Pass your HF token
... )
>>> image = client.text_to_image(
...     "An astronaut riding a horse on the moon.",
...     model="black-forest-labs/FLUX.1-dev",
... )
>>> image.save("astronaut.png")

Ejemplo usando el proveedor Replicate con parámetros adicionales

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient(
...     provider="replicate",  # Use replicate provider
...     api_key="hf_...",  # Pass your HF token
... )
>>> image = client.text_to_image(
...     "An astronaut riding a horse on the moon.",
...     model="black-forest-labs/FLUX.1-schnell",
...     extra_body={"output_quality": 100},
... )
>>> image.save("astronaut.png")

text_to_speech

( text: strmodel: str | None = Nonedo_sample: bool | None = Noneearly_stopping: typing.Union[bool, ForwardRef('TextToSpeechEarlyStoppingEnum'), NoneType] = Noneepsilon_cutoff: float | None = Noneeta_cutoff: float | None = Nonemax_length: int | None = Nonemax_new_tokens: int | None = Nonemin_length: int | None = Nonemin_new_tokens: int | None = Nonenum_beam_groups: int | None = Nonenum_beams: int | None = Nonepenalty_alpha: float | None = Nonetemperature: float | None = Nonetop_k: int | None = Nonetop_p: float | None = Nonetypical_p: float | None = Noneuse_cache: bool | None = Noneextra_body: dict[str, typing.Any] | None = None ) → bytes

Parámetros

text (str) — El texto que se va a sintetizar.
model (str, opcional) — El modelo que se utilizará para la inferencia. Puede ser un ID de modelo alojado en el Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo de texto a voz recomendado por defecto. El valor predeterminado es None.
do_sample (bool, opcional) — Si se usa muestreo en lugar de decodificación codiciosa al generar nuevos tokens.
early_stopping (Union[bool, "TextToSpeechEarlyStoppingEnum"], opcional) — Controla la condición de parada para los métodos basados en beam.
epsilon_cutoff (float, opcional) — Si se establece en un float estrictamente entre 0 y 1, solo se muestrearán tokens con una probabilidad condicional mayor que epsilon_cutoff. En el artículo, los valores sugeridos van desde 3e-4 hasta 9e-4, dependiendo del tamaño del modelo. Consulte Truncation Sampling as Language Model Desmoothing para más detalles.
eta_cutoff (float, opcional) — El muestreo Eta es un híbrido del muestreo localmente típico y el muestreo epsilon. Si se establece en un float estrictamente entre 0 y 1, un token solo se considera si es mayor que eta_cutoff o sqrt(eta_cutoff)
- exp(-entropy(softmax(next_token_logits))). El segundo término es, de forma intuitiva, la probabilidad esperada del siguiente token, escalada por sqrt(eta_cutoff). En el artículo, los valores sugeridos van desde 3e-4 hasta 2e-3, dependiendo del tamaño del modelo. Consulte Truncation Sampling as Language Model Desmoothing para más detalles.
max_length (int, opcional) — La longitud máxima (en tokens) del texto generado, incluido el texto de entrada.
max_new_tokens (int, opcional) — El número máximo de tokens a generar. Tiene prioridad sobre max_length.
min_length (int, opcional) — La longitud mínima (en tokens) del texto generado, incluyendo la entrada.
min_new_tokens (int, opcional) — El número mínimo de tokens a generar. Tiene prioridad sobre min_length.
num_beam_groups (int, opcional) — Número de grupos en los que dividir num_beams para garantizar diversidad entre los distintos grupos de beams. Vea este artículo para más detalles.
num_beams (int, opcional) — Número de haces a utilizar para la búsqueda por haces.
penalty_alpha (float, opcional) — El valor equilibra la confianza del modelo y la penalización por degeneración en la decodificación de búsqueda contrastiva.
temperature (float, opcional) — El valor utilizado para modular las probabilidades del siguiente token.
top_k (int, opcional) — El número de tokens del vocabulario con mayor probabilidad que se conservan para el filtrado top-k.
top_p (float, opcional) — Si se establece en un float < 1, solo se conservan para la generación el conjunto más pequeño de tokens más probables cuyas probabilidades suman top_p o más.
typical_p (float, opcional) — La tipicidad local mide qué tan similar es la probabilidad condicional de predecir el siguiente token objetivo a la probabilidad condicional esperada de predecir un token aleatorio a continuación, dado el texto parcial ya generado. Si se establece en float < 1, se conservan para la generación el conjunto más pequeño de tokens localmente más típicos cuyas probabilidades suman typical_p o más. Consulte este artículo para más detalles.
use_cache (bool, opcional) — Si el modelo debe usar las atenciones de claves/valores pasadas para acelerar la decodificación
extra_body (dict[str, Any], opcional) — Parámetros adicionales específicos del proveedor para pasar al modelo. Consulte la documentación del proveedor para los parámetros admitidos.

Devuelve

bytes

El audio generado.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Sintetiza un audio de una voz pronunciando un texto dado.

Puedes pasar parámetros específicos del proveedor al modelo utilizando el argumento extra_body.

Ejemplo:

# Must be run in an async context
>>> from pathlib import Path
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()

>>> audio = await client.text_to_speech("Hello world")
>>> Path("hello_world.flac").write_bytes(audio)

Ejemplo de uso de un proveedor de terceros directamente. El uso se facturará en tu cuenta de Replicate.

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient(
...     provider="replicate",
...     api_key="your-replicate-api-key",  # Pass your Replicate API key directly
... )
>>> audio = client.text_to_speech(
...     text="Hello world",
...     model="OuteAI/OuteTTS-0.3-500M",
... )
>>> Path("hello_world.flac").write_bytes(audio)

Ejemplo de uso de un proveedor de terceros a través de Hugging Face Routing. El uso se facturará en tu cuenta de Hugging Face.

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient(
...     provider="replicate",
...     api_key="hf_...",  # Pass your HF token
... )
>>> audio =client.text_to_speech(
...     text="Hello world",
...     model="OuteAI/OuteTTS-0.3-500M",
... )
>>> Path("hello_world.flac").write_bytes(audio)

Example using Replicate provider with extra parameters

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient(
...     provider="replicate",  # Use replicate provider
...     api_key="hf_...",  # Pass your HF token
... )
>>> audio = client.text_to_speech(
...     "Hello, my name is Kororo, an awesome text-to-speech model.",
...     model="hexgrad/Kokoro-82M",
...     extra_body={"voice": "af_nicole"},
... )
>>> Path("hello.flac").write_bytes(audio)

Ejemplo de generación de música con “YuE-s1-7B-anneal-en-cot” en fal.ai

>>> from huggingface_hub import InferenceClient
>>> lyrics = '''
... [verse]
... In the town where I was born
... Lived a man who sailed to sea
... And he told us of his life
... In the land of submarines
... So we sailed on to the sun
... 'Til we found a sea of green
... And we lived beneath the waves
... In our yellow submarine

... [chorus]
... We all live in a yellow submarine
... Yellow submarine, yellow submarine
... We all live in a yellow submarine
... Yellow submarine, yellow submarine
... '''
>>> genres = "pavarotti-style tenor voice"
>>> client = InferenceClient(
...     provider="fal-ai",
...     model="m-a-p/YuE-s1-7B-anneal-en-cot",
...     api_key=...,
... )
>>> audio = client.text_to_speech(lyrics, extra_body={"genres": genres})
>>> with open("output.mp3", "wb") as f:
...     f.write(audio)

text_to_video

( prompt: strmodel: str | None = Noneguidance_scale: float | None = Nonenegative_prompt: list[str] | None = Nonenum_frames: float | None = Nonenum_inference_steps: int | None = Noneseed: int | None = Noneextra_body: dict[str, typing.Any] | None = None ) → bytes

Parámetros

prompt (str) — El prompt para generar un video.
model (str, opcional) — El modelo que se utilizará para la inferencia. Puede ser un ID de modelo alojado en el Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo de texto a video recomendado por defecto. El valor predeterminado es None.
guidance_scale (float, opcional) — Un valor de escala de guía más alto anima al modelo a generar videos estrechamente vinculados al prompt de texto, pero valores demasiado altos pueden causar saturación y otros artefactos.
negative_prompt (list[str], opcional) — Una o varias indicaciones para guiar lo que NO debe incluirse en la generación del video.
num_frames (float, opcional) — El parámetro num_frames determina cuántos fotogramas de vídeo se generan.
num_inference_steps (int, opcional) — El número de pasos de desruido. Más pasos de desruido suelen dar lugar a un video de mayor calidad a costa de una inferencia más lenta.
seed (int, opcional) — Semilla para el generador de números aleatorios.
extra_body (dict[str, Any], opcional) — Parámetros adicionales específicos del proveedor para pasar al modelo. Consulte la documentación del proveedor para los parámetros admitidos.

Devuelve

bytes

El video generado.

Genera un video a partir de un texto dado.

Puedes pasar parámetros específicos del proveedor al modelo utilizando el argumento extra_body.

Ejemplo:

Ejemplo de uso de un proveedor de terceros directamente. El uso se facturará en tu cuenta de fal.ai.

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient(
...     provider="fal-ai",  # Using fal.ai provider
...     api_key="fal-ai-api-key",  # Pass your fal.ai API key
... )
>>> video = client.text_to_video(
...     "A majestic lion running in a fantasy forest",
...     model="tencent/HunyuanVideo",
... )
>>> with open("lion.mp4", "wb") as file:
...     file.write(video)

Ejemplo de uso de un proveedor de terceros a través de Hugging Face Routing. El uso se facturará en tu cuenta de Hugging Face.

>>> from huggingface_hub import InferenceClient
>>> client = InferenceClient(
...     provider="replicate",  # Using replicate provider
...     api_key="hf_...",  # Pass your HF token
... )
>>> video = client.text_to_video(
...     "A cat running in a park",
...     model="genmo/mochi-1-preview",
... )
>>> with open("cat.mp4", "wb") as file:
...     file.write(video)

token_classification

( text: strmodel: str | None = Noneaggregation_strategy: typing.Optional[ForwardRef('TokenClassificationAggregationStrategy')] = Noneignore_labels: list[str] | None = Nonestride: int | None = None ) → list[TokenClassificationOutputElement]

Parámetros

text (str) — A string to be classified.
model (str, opcional) — El modelo a utilizar para la tarea de clasificación de tokens. Puede ser un ID de modelo alojado en el Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo de clasificación de tokens recomendado por defecto. El valor predeterminado es None.
aggregation_strategy ("TokenClassificationAggregationStrategy", opcional) — La estrategia utilizada para fusionar tokens en función de las predicciones del modelo
ignore_labels (list[str, opcional) — Una lista de etiquetas para ignorar
stride (int, opcional) — El número de tokens superpuestos entre fragmentos al dividir el texto de entrada.

Devuelve

list[TokenClassificationOutputElement]

Lista de elementos TokenClassificationOutputElement que contienen el grupo de entidad, la puntuación de confianza, la palabra y el índice de inicio y fin.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Realiza la clasificación de tokens en el texto dado. Se utiliza habitualmente para el análisis de oraciones, ya sea gramatical o para el reconocimiento de entidades nombradas (NER), con el fin de comprender las palabras clave contenidas en el texto.

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.token_classification("My name is Sarah Jessica Parker but you can call me Jessica")
[
    TokenClassificationOutputElement(
        entity_group='PER',
        score=0.9971321225166321,
        word='Sarah Jessica Parker',
        start=11,
        end=31,
    ),
    TokenClassificationOutputElement(
        entity_group='PER',
        score=0.9773476123809814,
        word='Jessica',
        start=52,
        end=59,
    )
]

traducción

( text: strmodel: str | None = Nonesrc_lang: str | None = Nonetgt_lang: str | None = Noneclean_up_tokenization_spaces: bool | None = Nonetruncation: typing.Optional[ForwardRef('TranslationTruncationStrategy')] = Nonegenerate_parameters: dict[str, typing.Any] | None = None ) → TranslationOutput

Parámetros

text (str) — A string to be translated.
model (str, opcional) — El modelo a utilizar para la tarea de traducción. Puede ser un ID de modelo alojado en el Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo de traducción recomendado por defecto. El valor predeterminado es None.
src_lang (str, opcional) — El idioma de origen del texto. Obligatorio para modelos que pueden traducir desde varios idiomas.
tgt_lang (str, opcional) — Idioma de destino al que traducir. Obligatorio para modelos que pueden traducir a varios idiomas.
clean_up_tokenization_spaces (bool, opcional) — Si se deben limpiar los espacios adicionales potenciales en la salida de texto.
truncation ("TranslationTruncationStrategy", opcional) — La estrategia de truncamiento a utilizar.
generate_parameters (dict[str, Any], opcional) — Parametrización adicional del algoritmo de generación de texto.

Devuelve

TranslationOutput

El texto traducido generado.

Lanza

InferenceTimeoutError o HfHubHTTPError o ValueError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.
ValueError — Si solo se proporciona uno de los argumentos src_lang y tgt_lang.

Convierte texto de un idioma a otro.

Consulte https://huggingface.co/tasks/translation para obtener más información sobre cómo elegir el mejor modelo para su caso de uso específico. Los idiomas de origen y destino suelen depender del modelo. Sin embargo, es posible especificar los idiomas de origen y destino para ciertos modelos. Si está trabajando con uno de estos modelos, puede usar los argumentos src_lang y tgt_lang para pasar la información relevante.

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.translation("My name is Wolfgang and I live in Berlin")
'Mein Name ist Wolfgang und ich lebe in Berlin.'
>>> await client.translation("My name is Wolfgang and I live in Berlin", model="Helsinki-NLP/opus-mt-en-fr")
TranslationOutput(translation_text='Je m'appelle Wolfgang et je vis à Berlin.')

Especificación de idiomas:

>>> client.translation("My name is Sarah Jessica Parker but you can call me Jessica", model="facebook/mbart-large-50-many-to-many-mmt", src_lang="en_XX", tgt_lang="fr_XX")
"Mon nom est Sarah Jessica Parker mais vous pouvez m'appeler Jessica"

visual_question_answering

( image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview]question: strmodel: str | None = Nonetop_k: int | None = None ) → list[VisualQuestionAnsweringOutputElement]

Parámetros

image (Union[str, Path, bytes, BinaryIO, PIL.Image.Image]) — The input image for the context. It can be raw bytes, an image file, a URL to an online image, or a PIL Image.
question (str) — Pregunta a responder.
model (str, opcional) — El modelo que se utilizará para la tarea de respuesta visual a preguntas. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Si no se proporciona, se utilizará el modelo de respuesta visual a preguntas recomendado por defecto. El valor predeterminado es None.
top_k (int, opcional) — El número de respuestas a devolver (se elegirán por orden de probabilidad). Tenga en cuenta que devolvemos menos de topk respuestas si no hay suficientes opciones disponibles dentro del contexto.

Devuelve

list[VisualQuestionAnsweringOutputElement]

una lista de elementos VisualQuestionAnsweringOutputElement que contienen la etiqueta predicha y la probabilidad asociada.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Responder preguntas abiertas basándose en una imagen.

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.visual_question_answering(
...     image="https://huggingface.co/datasets/mishig/sample_images/resolve/main/tiger.jpg",
...     question="What is the animal doing?"
... )
[
    VisualQuestionAnsweringOutputElement(score=0.778609573841095, answer='laying down'),
    VisualQuestionAnsweringOutputElement(score=0.6957435607910156, answer='sitting'),
]

zero_shot_classification

( text: strcandidate_labels: listmulti_label: bool | None = Falsehypothesis_template: str | None = Nonemodel: str | None = None ) → list[ZeroShotClassificationOutputElement]

Parámetros

text (str) — El texto de entrada a clasificar.
candidate_labels (list[str]) — El conjunto de etiquetas de clase posibles para clasificar el texto.
multi_label (bool, opcional) — Si varias etiquetas candidatas pueden ser verdaderas. Si es falso, las puntuaciones se normalizan de modo que la suma de las probabilidades de las etiquetas para cada secuencia sea 1. Si es verdadero, las etiquetas se consideran independientes y las probabilidades se normalizan para cada candidata.
hypothesis_template (str, opcional) — La oración que se utiliza junto con candidate_labels para intentar la clasificación de texto, reemplazando el marcador de posición con las etiquetas candidatas.
model (str, opcional) — El modelo que se utilizará para la inferencia. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Este parámetro anula el modelo definido a nivel de instancia. Si no se proporciona, se utilizará el modelo de clasificación zero-shot recomendado por defecto.

Devuelve

list[ZeroShotClassificationOutputElement]

Lista de elementos ZeroShotClassificationOutputElement que contienen las etiquetas predichas y su confianza.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Proporciona como entrada un texto y un conjunto de etiquetas candidatas para clasificar el texto de entrada.

Ejemplo con multi_label=False:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> text = (
...     "A new model offers an explanation for how the Galilean satellites formed around the solar system's"
...     "largest world. Konstantin Batygin did not set out to solve one of the solar system's most puzzling"
...     " mysteries when he went for a run up a hill in Nice, France."
... )
>>> labels = ["space & cosmos", "scientific discovery", "microbiology", "robots", "archeology"]
>>> await client.zero_shot_classification(text, labels)
[
    ZeroShotClassificationOutputElement(label='scientific discovery', score=0.7961668968200684),
    ZeroShotClassificationOutputElement(label='space & cosmos', score=0.18570658564567566),
    ZeroShotClassificationOutputElement(label='microbiology', score=0.00730885099619627),
    ZeroShotClassificationOutputElement(label='archeology', score=0.006258360575884581),
    ZeroShotClassificationOutputElement(label='robots', score=0.004559356719255447),
]
>>> await client.zero_shot_classification(text, labels, multi_label=True)
[
    ZeroShotClassificationOutputElement(label='scientific discovery', score=0.9829297661781311),
    ZeroShotClassificationOutputElement(label='space & cosmos', score=0.755190908908844),
    ZeroShotClassificationOutputElement(label='microbiology', score=0.0005462635890580714),
    ZeroShotClassificationOutputElement(label='archeology', score=0.00047131875180639327),
    ZeroShotClassificationOutputElement(label='robots', score=0.00030448526376858354),
]

Ejemplo con multi_label=True y una hypothesis_template personalizada:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()
>>> await client.zero_shot_classification(
...    text="I really like our dinner and I'm very happy. I don't like the weather though.",
...    candidate_labels=["positive", "negative", "pessimistic", "optimistic"],
...    multi_label=True,
...    hypothesis_template="This text is {} towards the weather"
... )
[
    ZeroShotClassificationOutputElement(label='negative', score=0.9231801629066467),
    ZeroShotClassificationOutputElement(label='pessimistic', score=0.8760990500450134),
    ZeroShotClassificationOutputElement(label='optimistic', score=0.0008674879791215062),
    ZeroShotClassificationOutputElement(label='positive', score=0.0005250611575320363)
]

zero_shot_image_classification

( image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview]candidate_labels: listmodel: str | None = Nonehypothesis_template: str | None = None ) → list[ZeroShotImageClassificationOutputElement]

Parámetros

image (Union[str, Path, bytes, BinaryIO, PIL.Image.Image]) — The input image to caption. It can be raw bytes, an image file, a URL to an online image, or a PIL Image.
candidate_labels (list[str]) — Las etiquetas candidatas para esta imagen
model (str, opcional) — El modelo que se utilizará para la inferencia. Puede ser un ID de modelo alojado en Hugging Face Hub o una URL de un Inference Endpoint desplegado. Este parámetro anula el modelo definido a nivel de instancia. Si no se proporciona, se utilizará el modelo de clasificación de imágenes zero-shot recomendado por defecto.
hypothesis_template (str, opcional) — La oración que se utiliza junto con candidate_labels para intentar la clasificación de la imagen, sustituyendo el marcador de posición por las etiquetas candidatas.

Devuelve

list[ZeroShotImageClassificationOutputElement]

Lista de elementos ZeroShotImageClassificationOutputElement que contienen las etiquetas predichas y su confianza.

Lanza

InferenceTimeoutError o HfHubHTTPError

InferenceTimeoutError — Si el modelo no está disponible o la solicitud expira.
HfHubHTTPError — Si la solicitud falla con un código de estado de error HTTP distinto de HTTP 503.

Proporcione una imagen de entrada y etiquetas de texto para predecir las etiquetas de texto de la imagen.

Ejemplo:

# Must be run in an async context
>>> from huggingface_hub import AsyncInferenceClient
>>> client = AsyncInferenceClient()

>>> await client.zero_shot_image_classification(
...     "https://upload.wikimedia.org/wikipedia/commons/thumb/4/43/Cute_dog.jpg/320px-Cute_dog.jpg",
...     candidate_labels=["dog", "cat", "horse"],
... )
[ZeroShotImageClassificationOutputElement(label='dog', score=0.956),...]

InferenceTimeoutError

clase huggingface_hub.InferenceTimeoutError

( message: str )

Error que se produce cuando un modelo no está disponible o la solicitud agota el tiempo de espera.

Update on GitHub

←Tipos de inferencia Puntos de inferencia→