# 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 el Hugging Face Hub: 1. [Proveedores de inferencia](https://huggingface.co/docs/inference-providers/index): 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](https://huggingface.co/docs/inference-providers/index#partners) para obtener una lista de los proveedores compatibles. 2. [Inference Endpoints](https://huggingface.co/docs/inference-endpoints/index): 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. 3. Puntos finales locales: también puede ejecutar inferencia con servidores de inferencia locales como [llama.cpp](https://github.com/ggerganov/llama.cpp), [Ollama](https://ollama.com/), [vLLM](https://github.com/vllm-project/vllm), [LiteLLM](https://docs.litellm.ai/docs/simple_proxy) o [Text Generation Inference (TGI)](https://github.com/huggingface/text-generation-inference) conectando el cliente a estos puntos finales locales. Estos servicios se pueden llamar con el objeto [InferenceClient](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceClient). Consulte [esta guía](../guides/inference) para obtener más información sobre cómo usarlo. ## Cliente de inferencia[[huggingface_hub.InferenceClient]] #### huggingface_hub.InferenceClient[[huggingface_hub.InferenceClient]] ```python huggingface_hub.InferenceClient(model: str | None = None, provider: 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] = None, token: str | None = None, timeout: float | None = None, headers: dict[str, str] | None = None, cookies: dict[str, str] | None = None, bill_to: str | None = None, base_url: str | None = None, api_key: str | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L124) **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 usará 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 usa 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 usa. 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 2 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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`) : Tokeno para usar en la autenticación. Este es un argumento duplicado de `token` para que [InferenceClient](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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. #### audio_classification[[huggingface_hub.InferenceClient.audio_classification]] ```python audio_classification(audio: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview], model: str | None = None, top_k: int | None = None, function_to_apply: typing.Optional[ForwardRef('AudioClassificationOutputTransform')] = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L295) **Parámetros:** audio (Union[str, Path, bytes, BinaryIO]) : El contenido de audio a clasificar. Puede ser bytes de audio en bruto, 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.AudioClassificationOutputElement) que contienen las etiquetas predichas y su confianza. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py >>> 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[[huggingface_hub.InferenceClient.audio_to_audio]] ```python audio_to_audio(audio: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview], model: str | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L352) **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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.AudioToAudioOutputElement) que contienen la etiqueta de audio, el tipo de contenido y el contenido de audio en un blob. **Excepciones:** ``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: ```py >>> 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[[huggingface_hub.InferenceClient.automatic_speech_recognition]] ```python automatic_speech_recognition(audio: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview], model: str | None = None, extra_body: dict | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L404) **Parámetros:** audio (Union[str, Path, bytes, BinaryIO]) : El contenido para 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 el 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.AutomaticSpeechRecognitionOutput) Un elemento que contiene el texto transcrito y, opcionalmente, los fragmentos de marcas de tiempo. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> client.automatic_speech_recognition("hello_world.flac").text "hello world" ``` #### chat_completion[[huggingface_hub.InferenceClient.chat_completion]] ```python chat_completion(messages: list, model: str | None = None, stream: bool = False, frequency_penalty: float | None = None, logit_bias: list[float] | None = None, logprobs: bool | None = None, max_tokens: int | None = None, n: int | None = None, presence_penalty: float | None = None, response_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] = None, seed: int | None = None, stop: list[str] | None = None, stream_options: huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions | None = None, temperature: float | None = None, tool_choice: typing.Union[huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass, ForwardRef('ChatCompletionInputToolChoiceEnum'), NoneType] = None, tool_prompt: str | None = None, tools: list[huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool] | None = None, top_logprobs: int | None = None, top_p: float | None = None, extra_body: dict | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L531) **Parámetros:** messages (Lista de [ChatCompletionInputMessage](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.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. Consulte 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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*) : Si se deben devolver las probabilidades en logaritmo de los tokens de salida o no. Si es true, devuelve las probabilidades en logaritmo 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 a generar 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 de temas nuevos. response_format (`ChatCompletionInputGrammarType()`, *opcional*) : Restricciones de gramática. Puede ser un JSONSchema o una expresión regular. seed (Opcional`int`, *optional*) : Semilla para un flujo de control reproducible. El valor predeterminado es None. stop (`list[str]`, *opcional*) : Hasta cuatro cadenas que desencadenan 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.ChatCompletionInputStreamOptions), *opcional*) : Opciones para las completaciones en streaming. temperature (`float`, *opcional*) : Controla la aleatoriedad de las generaciones. Valores más bajos garantizan completados 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 de las que se muestreará. Debe estar entre 0 y 1. El valor predeterminado es 1.0. tool_choice ([ChatCompletionInputToolChoiceClass](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.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ñadirá antes de las herramientas. tools (Lista de [ChatCompletionInputTool](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.ChatCompletionOutput) o un Iterable de [ChatCompletionStreamOutput](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.ChatCompletionStreamOutput) Texto generado devuelto por el servidor: - Si `stream=False`, el texto generado se devuelve como [ChatCompletionOutput](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.ChatCompletionOutput) (valor predeterminado). - Si `stream=True`, el texto generado se devuelve token a token como una secuencia de [ChatCompletionStreamOutput](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.ChatCompletionStreamOutput). **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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. > [!TIP] > 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](https://huggingface.co/docs/huggingface_hub/guides/inference#openai-compatibility) para obtener más detalles sobre la compatibilidad con OpenAI. > [!TIP] > Puedes pasar parámetros específicos del proveedor al modelo utilizando el argumento `extra_body`. Ejemplo: ```py >>> 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: ```py >>> 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: ```py # 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. ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient( ... provider="together", # Use Together AI provider ... 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. ```py >>> 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: ```py >>> 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: ```py >>> 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: ```py >>> 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[[huggingface_hub.InferenceClient.document_question_answering]] ```python document_question_answering(image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview], question: str, model: str | None = None, doc_stride: int | None = None, handle_impossible_answer: bool | None = None, lang: str | None = None, max_answer_len: int | None = None, max_question_len: int | None = None, max_seq_len: int | None = None, top_k: int | None = None, word_boxes: list[list[float] | str] | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L933) **Parámetros:** image (`Union[str, Path, bytes, BinaryIO]`) : La imagen de entrada para el contexto. Puede ser bytes crudos, un archivo de imagen o una URL a una imagen en línea. question (`str`) : Pregunta a responder. model (`str`, *opcional*) : El modelo a utilizar para la tarea de respuesta a preguntas sobre documentos. 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 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.DocumentQuestionAnsweringOutputElement) que contienen la etiqueta predicha, la probabilidad asociada, los ids de las palabras y el número de página. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py >>> 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[[huggingface_hub.InferenceClient.feature_extraction]] ```python feature_extraction(text: str | list[str], normalize: bool | None = None, prompt_name: str | None = None, truncate: bool | None = None, truncation_direction: typing.Optional[typing.Literal['left', 'right']] = None, dimensions: int | None = None, encoding_format: typing.Optional[typing.Literal['float', 'base64']] = None, model: str | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L1020) **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 &lcub;"query": "query: ",...}, entonces 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á antes 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*) : Qué lado de la entrada debe truncarse cuando se pasa *truncate=True*. dimensions (*int*, *optional*) : 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. **Excepciones:** [*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: ```py >>> 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[[huggingface_hub.InferenceClient.fill_mask]] ```python fill_mask(text: str, model: str | None = None, targets: list[str] | None = None, top_k: int | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L1103) **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 a utilizar para la tarea de fill mask. 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 fill mask recomendado por defecto. targets (`list[str`, *optional*) : Cuando se proporciona, el modelo limitará las puntuaciones a los objetivos pasados en lugar de buscarlos en todo el vocabulario. Si los objetivos proporcionados no están en el vocabulario del modelo, se tokenizarán y se utilizará el primer token resultante (con una advertencia, y eso podría ser más lento). top_k (`int`, *opcional*) : Cuando se pasa, reemplaza el número de predicciones a devolver. **Devuelve:** `list[FillMaskOutputElement]` una lista de elementos [FillMaskOutputElement](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.FillMaskOutputElement) que contienen la etiqueta predicha, la probabilidad asociada, la referencia del token y el texto completado. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> client.fill_mask("The goal of life is .") [ 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[[huggingface_hub.InferenceClient.get_endpoint_info]] ```python get_endpoint_info(model: str | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L3250) **Parámetros:** model (`str`, *opcional*) : El modelo a utilizar para la inferencia. Puede ser un ID de modelo alojado en el 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: ```py >>> 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[[huggingface_hub.InferenceClient.health_check]] ```python health_check(model: str | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L3308) **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: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient("https://jzgu0buei5.us-east-1.aws.endpoints.huggingface.cloud") >>> client.health_check() True ``` #### image_classification[[huggingface_hub.InferenceClient.image_classification]] ```python image_classification(image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview], model: str | None = None, function_to_apply: typing.Optional[ForwardRef('ImageClassificationOutputTransform')] = None, top_k: int | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L1159) **Parámetros:** image (`Union[str, Path, bytes, BinaryIO, PIL.Image.Image]`) : La imagen a clasificar. Puede ser bytes crudos, un archivo de imagen, una URL de una imagen en línea o una imagen PIL. 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.ImageClassificationOutputElement) que contienen la etiqueta predicha y la probabilidad asociada. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py >>> 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[[huggingface_hub.InferenceClient.image_segmentation]] ```python image_segmentation(image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview], model: str | None = None, mask_threshold: float | None = None, overlap_mask_area_threshold: float | None = None, subtask: typing.Optional[ForwardRef('ImageSegmentationSubtask')] = None, threshold: float | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L1209) **Parámetros:** image (`Union[str, Path, bytes, BinaryIO, PIL.Image.Image]`) : La imagen a segmentar. Puede ser bytes crudos, un archivo de imagen, una URL de una imagen en línea o una imagen PIL. 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 la máscara 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.ImageSegmentationOutputElement) que contiene las máscaras segmentadas y los atributos asociados. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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. > [!WARNING] > Debes tener `PIL` instalado si quieres trabajar con imágenes (`pip install Pillow`). Ejemplo: ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient() >>> client.image_segmentation("cat.jpg") [ImageSegmentationOutputElement(score=0.989008, label='LABEL_184', mask=), ...] ``` #### image_to_image[[huggingface_hub.InferenceClient.image_to_image]] ```python image_to_image(image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview], prompt: str | None = None, negative_prompt: str | None = None, num_inference_steps: int | None = None, guidance_scale: float | None = None, model: str | None = None, target_size: huggingface_hub.inference._generated.types.image_to_image.ImageToImageTargetSize | None = None, **kwargs) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L1277) **Parámetros:** image (`Union[str, Path, bytes, BinaryIO, PIL.Image.Image]`) : La imagen de entrada para la traducción. Puede ser bytes crudos, un archivo de imagen, una URL a una imagen en línea o una imagen PIL. 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 imágenes. 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 más alto de guidance scale 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 a utilizar para la inferencia. Puede ser un ID de modelo alojado en el 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. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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. > [!WARNING] > Debes tener `PIL` instalado si quieres trabajar con imágenes (`pip install Pillow`). Ejemplo: ```py >>> 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[[huggingface_hub.InferenceClient.image_to_text]] ```python image_to_text(image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview], model: str | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L1432) **Parámetros:** image (`Union[str, Path, bytes, BinaryIO, PIL.Image.Image]`) : La imagen de entrada para la que se generará la descripción. Puede ser bytes crudos, un archivo de imagen, una URL de una imagen en línea o una imagen PIL. model (`str`, *opcional*) : El modelo a utilizar para la inferencia. Puede ser un ID de modelo alojado en el 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.ImageToTextOutput) El texto generado. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py >>> 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[[huggingface_hub.InferenceClient.image_to_video]] ```python image_to_video(image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview], model: str | None = None, prompt: str | None = None, negative_prompt: str | None = None, num_frames: float | None = None, num_inference_steps: int | None = None, guidance_scale: float | None = None, seed: int | None = None, target_size: huggingface_hub.inference._generated.types.image_to_video.ImageToVideoTargetSize | None = None, **kwargs) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L1353) **Parámetros:** image (`Union[str, Path, bytes, BinaryIO, PIL.Image.Image]`) : La imagen de entrada a partir de la cual se generará un video. Puede ser bytes en bruto, un archivo de imagen, una URL de una imagen en línea o una imagen PIL. model (`str`, *opcional*) : El modelo a utilizar para la inferencia. Puede ser un ID de modelo alojado en el 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 conducir 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: ```py >>> 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[[huggingface_hub.InferenceClient.object_detection]] ```python object_detection(image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview], model: str | None = None, threshold: float | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L1478) **Parámetros:** image (`Union[str, Path, bytes, BinaryIO, PIL.Image.Image]`) : La imagen sobre la que detectar objetos. Puede ser bytes crudos, un archivo de imagen, una URL de una imagen en línea o una imagen PIL. model (`str`, *opcional*) : El modelo a utilizar para la detección de objetos. 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 detección de objetos (DETR). threshold (`float`, *opcional*) : La probabilidad necesaria para realizar una predicción. **Devuelve:** `list[ObjectDetectionOutputElement]` Una lista de elementos [ObjectDetectionOutputElement](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.ObjectDetectionOutputElement) que contiene las cajas delimitadoras y los atributos asociados. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` o ``ValueError`` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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. > [!WARNING] > Debes tener `PIL` instalado si quieres trabajar con imágenes (`pip install Pillow`). Ejemplo: ```py >>> 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[[huggingface_hub.InferenceClient.question_answering]] ```python question_answering(question: str, context: str, model: str | None = None, align_to_words: bool | None = None, doc_stride: int | None = None, handle_impossible_answer: bool | None = None, max_answer_len: int | None = None, max_question_len: int | None = None, max_seq_len: int | None = None, top_k: int | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L1526) **Parámetros:** question (`str`) : Pregunta a responder. context (`str`) : El contexto de la pregunta. model (`str`) : El modelo a utilizar para la tarea de respuesta a preguntas. Puede ser un ID de modelo alojado en el 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`, list[QuestionAnsweringOutputElement](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.QuestionAnsweringOutputElement)] 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`. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py >>> 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[[huggingface_hub.InferenceClient.sentence_similarity]] ```python sentence_similarity(sentence: str, other_sentences: list, model: str | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L1610) **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 el 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. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py >>> 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[[huggingface_hub.InferenceClient.summarization]] ```python summarization(text: str, model: str | None = None, clean_up_tokenization_spaces: bool | None = None, generate_parameters: dict[str, typing.Any] | None = None, truncation: typing.Optional[ForwardRef('SummarizationTruncationStrategy')] = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L1663) **Parámetros:** text (`str`) : El texto de entrada a resumir. model (`str`, *opcional*) : El modelo a 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 recomendado por defecto para la resumición. clean_up_tokenization_spaces (`bool`, *opcional*) : Si se deben limpiar los espacios extra 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.SummarizationOutput) El texto del resumen generado. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py >>> 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[[huggingface_hub.InferenceClient.table_question_answering]] ```python table_question_answering(table: dict, query: str, model: str | None = None, padding: typing.Optional[ForwardRef('Padding')] = None, sequential: bool | None = None, truncation: bool | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L1721) **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 a utilizar 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.TableQuestionAnsweringOutputElement) una salida de respuesta a preguntas sobre tablas que contiene la respuesta, las coordenadas, las celdas y el agregador utilizado. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py >>> 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') ``` #### tabular_classification[[huggingface_hub.InferenceClient.tabular_classification]] ```python tabular_classification(table: dict, model: str | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L1783) **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 el 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. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py >>> 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"] ``` #### tabular_regression[[huggingface_hub.InferenceClient.tabular_regression]] ```python tabular_regression(table: dict, model: str | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L1838) **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 el 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. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py >>> 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] ``` #### text_classification[[huggingface_hub.InferenceClient.text_classification]] ```python text_classification(text: str, model: str | None = None, top_k: int | None = None, function_to_apply: typing.Optional[ForwardRef('TextClassificationOutputTransform')] = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L1888) **Parámetros:** text (`str`) : Una cadena de texto 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 el 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.TextClassificationOutputElement) que contienen la etiqueta predicha y la probabilidad asociada. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py >>> 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), ] ``` #### text_generation[[huggingface_hub.InferenceClient.text_generation]] ```python text_generation(prompt: str, details: bool | None = None, stream: bool | None = None, model: str | None = None, adapter_id: str | None = None, best_of: int | None = None, decoder_input_details: bool | None = None, do_sample: bool | None = None, frequency_penalty: float | None = None, grammar: huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType | None = None, max_new_tokens: int | None = None, repetition_penalty: float | None = None, return_full_text: bool | None = None, seed: int | None = None, stop: list[str] | None = None, temperature: float | None = None, top_k: int | None = None, top_n_tokens: int | None = None, top_p: float | None = None, truncate: int | None = None, typical_p: float | None = None, watermark: bool | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L2091) **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 deseas 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 a utilizar para la inferencia. Puede ser un ID de modelo alojado en el 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 secuencias de best_of y devuelve la que tiene 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*) : Activar 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.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](https://arxiv.org/pdf/1909.05858.pdf) para más detalles. return_full_text (`bool`, *opcional*) : Si se debe anteponer el prompt al texto generado seed (`int`, *opcional*) : Semilla de muestreo aleatorio stop (`list[str]`, *opcional*) : Dejar 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 deben conservar 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 típica de Decoding. Consulte [Typical Decoding for Natural Language Generation](https://arxiv.org/abs/2202.00666) para obtener más información watermark (`bool`, *opcional*) : Marca de agua con [A Watermark for Large Language Models](https://arxiv.org/abs/2301.10226) **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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.TextGenerationOutput) - si `details=True` y `stream=True`, el texto generado se devuelve token a token como un iterable de [TextGenerationStreamOutput](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.TextGenerationStreamOutput) **Excepciones:** ``ValidationError`` o [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - ``ValidationError`` -- Si los valores de entrada no son válidos. No se realiza ninguna llamada HTTP al servidor. - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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. > [!TIP] > Si deseas generar una respuesta a partir de mensajes de chat, debes usar el método [InferenceClient.chat_completion()](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py >>> 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[[huggingface_hub.InferenceClient.text_to_image]] ```python text_to_image(prompt: str, negative_prompt: str | None = None, height: int | None = None, width: int | None = None, num_inference_steps: int | None = None, guidance_scale: float | None = None, model: str | None = None, scheduler: str | None = None, seed: int | None = None, extra_body: dict[str, typing.Any] | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L2418) **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 imágenes. 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 a 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 conocer los parámetros admitidos. **Devuelve:** `Image` La imagen generada. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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. > [!WARNING] > Debes tener `PIL` instalado si quieres trabajar con imágenes (`pip install Pillow`). > [!TIP] > Puedes pasar parámetros específicos del proveedor al modelo utilizando el argumento `extra_body`. Ejemplo: ```py >>> 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") ``` Ejemplo de uso de un proveedor de terceros directamente. El uso se facturará en tu cuenta de fal.ai. ```py >>> 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. ```py >>> 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 ```py >>> 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[[huggingface_hub.InferenceClient.text_to_speech]] ```python text_to_speech(text: str, model: str | None = None, do_sample: bool | None = None, early_stopping: typing.Union[bool, ForwardRef('TextToSpeechEarlyStoppingEnum'), NoneType] = None, epsilon_cutoff: float | None = None, eta_cutoff: float | None = None, max_length: int | None = None, max_new_tokens: int | None = None, min_length: int | None = None, min_new_tokens: int | None = None, num_beam_groups: int | None = None, num_beams: int | None = None, penalty_alpha: float | None = None, temperature: float | None = None, top_k: int | None = None, top_p: float | None = None, typical_p: float | None = None, use_cache: bool | None = None, extra_body: dict[str, typing.Any] | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L2655) **Parámetros:** text (`str`) : El texto para sintetizar. model (`str`, *opcional*) : El modelo a 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 debe usar 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](https://hf.co/papers/2210.15191) 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, intuitivamente, 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](https://hf.co/papers/2210.15191) 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. Consulte [este artículo](https://hf.co/papers/1610.02424) 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 deben conservar 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 más localmente típicos cuyas probabilidades suman typical_p o más. Consulte [este artículo](https://hf.co/papers/2202.00666) 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 conocer los parámetros admitidos. **Devuelve:** `bytes` El audio generado. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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. > [!TIP] > Puedes pasar parámetros específicos del proveedor al modelo utilizando el argumento `extra_body`. Ejemplo: ```py >>> 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. ```py >>> 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. ```py >>> 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) ``` Ejemplo usando el proveedor Replicate con parámetros adicionales ```py >>> 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 ```py >>> 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[[huggingface_hub.InferenceClient.text_to_video]] ```python text_to_video(prompt: str, model: str | None = None, guidance_scale: float | None = None, negative_prompt: list[str] | None = None, num_frames: float | None = None, num_inference_steps: int | None = None, seed: int | None = None, extra_body: dict[str, typing.Any] | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L2558) **Parámetros:** prompt (`str`) : El prompt para generar un video. model (`str`, *opcional*) : El modelo a 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 más alto de la escala de guía 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 conducir 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 conocer los parámetros admitidos. **Devuelve:** `bytes` El video generado. Genera un video a partir de un texto dado. > [!TIP] > 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. ```py >>> 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. ```py >>> 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[[huggingface_hub.InferenceClient.token_classification]] ```python token_classification(text: str, model: str | None = None, aggregation_strategy: typing.Optional[ForwardRef('TokenClassificationAggregationStrategy')] = None, ignore_labels: list[str] | None = None, stride: int | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L2863) **Parámetros:** text (`str`) : Una cadena de texto que se va a clasificar. 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`, *optional*) : 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.TokenClassificationOutputElement) que contienen el grupo de entidad, la puntuación de confianza, la palabra y el índice de inicio y fin. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py >>> 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[[huggingface_hub.InferenceClient.translation]] ```python translation(text: str, model: str | None = None, src_lang: str | None = None, tgt_lang: str | None = None, clean_up_tokenization_spaces: bool | None = None, truncation: typing.Optional[ForwardRef('TranslationTruncationStrategy')] = None, generate_parameters: dict[str, typing.Any] | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L2938) **Parámetros:** text (`str`) : Una cadena de texto que se traducirá. 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 para la traducción. Obligatorio para modelos que pueden traducir a varios idiomas. clean_up_tokenization_spaces (`bool`, *opcional*) : Si se deben limpiar los espacios extra 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.TranslationOutput) El texto traducido generado. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` o ``ValueError`` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py >>> 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: ```py >>> 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[[huggingface_hub.InferenceClient.visual_question_answering]] ```python visual_question_answering(image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview], question: str, model: str | None = None, top_k: int | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L3027) **Parámetros:** image (`Union[str, Path, bytes, BinaryIO, PIL.Image.Image]`) : La imagen de entrada para el contexto. Puede ser bytes crudos, un archivo de imagen, una URL de una imagen en línea o una imagen PIL. question (`str`) : Pregunta a responder. model (`str`, *opcional*) : El modelo a utilizar para la tarea de respuesta visual a preguntas. 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 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.VisualQuestionAnsweringOutputElement) que contienen la etiqueta predicha y la probabilidad asociada. **Excepciones:** ``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: ```py >>> 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[[huggingface_hub.InferenceClient.zero_shot_classification]] ```python zero_shot_classification(text: str, candidate_labels: list, multi_label: bool | None = False, hypothesis_template: str | None = None, model: str | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L3086) **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 candidato. hypothesis_template (`str`, *opcional*) : La oración utilizada 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 a utilizar para la inferencia. Puede ser un ID de modelo alojado en el 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.ZeroShotClassificationOutputElement) que contienen las etiquetas predichas y su confianza. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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`: ```py >>> 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: ```py >>> 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[[huggingface_hub.InferenceClient.zero_shot_image_classification]] ```python zero_shot_image_classification(image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview], candidate_labels: list, model: str | None = None, hypothesis_template: str | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_client.py#L3187) **Parámetros:** image (`Union[str, Path, bytes, BinaryIO, PIL.Image.Image]`) : La imagen de entrada para la que se generará la descripción. Puede ser bytes crudos, un archivo de imagen, una URL de una imagen en línea o una imagen PIL. candidate_labels (`list[str]`) : Las etiquetas candidatas para esta imagen model (`str`, *opcional*) : El modelo a utilizar para la inferencia. Puede ser un ID de modelo alojado en el 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 utilizada junto con `candidate_labels` para intentar la clasificación de la imagen reemplazando el marcador de posición con las etiquetas candidatas. **Devuelve:** `list[ZeroShotImageClassificationOutputElement]` Lista de elementos [ZeroShotImageClassificationOutputElement](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.ZeroShotImageClassificationOutputElement) que contienen las etiquetas predichas y su confianza. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py >>> 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[[huggingface_hub.AsyncInferenceClient]] También se proporciona una versión asíncrona del cliente, basada en `asyncio` y `httpx2`. #### huggingface_hub.AsyncInferenceClient[[huggingface_hub.AsyncInferenceClient]] ```python huggingface_hub.AsyncInferenceClient(model: str | None = None, provider: 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] = None, token: str | None = None, timeout: float | None = None, headers: dict[str, str] | None = None, cookies: dict[str, str] | None = None, bill_to: str | None = None, base_url: str | None = None, api_key: str | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L112) **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 usará 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 usa 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 usa. 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 2 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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`) : Tokeno para usar en la autenticación. Este es un argumento duplicado de `token` para que [InferenceClient](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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. #### audio_classification[[huggingface_hub.AsyncInferenceClient.audio_classification]] ```python audio_classification(audio: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview], model: str | None = None, top_k: int | None = None, function_to_apply: typing.Optional[ForwardRef('AudioClassificationOutputTransform')] = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L313) **Parámetros:** audio (Union[str, Path, bytes, BinaryIO]) : El contenido de audio a clasificar. Puede ser bytes de audio en bruto, 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.AudioClassificationOutputElement) que contienen las etiquetas predichas y su confianza. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py # 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[[huggingface_hub.AsyncInferenceClient.audio_to_audio]] ```python audio_to_audio(audio: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview], model: str | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L371) **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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.AudioToAudioOutputElement) que contienen la etiqueta de audio, el tipo de contenido y el contenido de audio en un blob. **Excepciones:** ``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: ```py # 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[[huggingface_hub.AsyncInferenceClient.automatic_speech_recognition]] ```python automatic_speech_recognition(audio: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview], model: str | None = None, extra_body: dict | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L424) **Parámetros:** audio (Union[str, Path, bytes, BinaryIO]) : El contenido para 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 el 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.AutomaticSpeechRecognitionOutput) Un elemento que contiene el texto transcrito y, opcionalmente, los fragmentos de marcas de tiempo. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py # 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[[huggingface_hub.AsyncInferenceClient.chat_completion]] ```python chat_completion(messages: list, model: str | None = None, stream: bool = False, frequency_penalty: float | None = None, logit_bias: list[float] | None = None, logprobs: bool | None = None, max_tokens: int | None = None, n: int | None = None, presence_penalty: float | None = None, response_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] = None, seed: int | None = None, stop: list[str] | None = None, stream_options: huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputStreamOptions | None = None, temperature: float | None = None, tool_choice: typing.Union[huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputToolChoiceClass, ForwardRef('ChatCompletionInputToolChoiceEnum'), NoneType] = None, tool_prompt: str | None = None, tools: list[huggingface_hub.inference._generated.types.chat_completion.ChatCompletionInputTool] | None = None, top_logprobs: int | None = None, top_p: float | None = None, extra_body: dict | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L552) **Parámetros:** messages (Lista de [ChatCompletionInputMessage](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.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. Consulte 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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*) : Si se deben devolver las probabilidades en logaritmo de los tokens de salida o no. Si es true, devuelve las probabilidades en logaritmo 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 a generar 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 de temas nuevos. response_format (`ChatCompletionInputGrammarType()`, *opcional*) : Restricciones de gramática. Puede ser un JSONSchema o una expresión regular. seed (Opcional`int`, *optional*) : Semilla para un flujo de control reproducible. El valor predeterminado es None. stop (`list[str]`, *opcional*) : Hasta cuatro cadenas que desencadenan 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.ChatCompletionInputStreamOptions), *opcional*) : Opciones para las completaciones en streaming. temperature (`float`, *opcional*) : Controla la aleatoriedad de las generaciones. Valores más bajos garantizan completados 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 de las que se muestreará. Debe estar entre 0 y 1. El valor predeterminado es 1.0. tool_choice ([ChatCompletionInputToolChoiceClass](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.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ñadirá antes de las herramientas. tools (Lista de [ChatCompletionInputTool](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.ChatCompletionOutput) o un Iterable de [ChatCompletionStreamOutput](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.ChatCompletionStreamOutput) Texto generado devuelto por el servidor: - Si `stream=False`, el texto generado se devuelve como [ChatCompletionOutput](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.ChatCompletionOutput) (valor predeterminado). - Si `stream=True`, el texto generado se devuelve token a token como una secuencia de [ChatCompletionStreamOutput](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.ChatCompletionStreamOutput). **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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. > [!TIP] > 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](https://huggingface.co/docs/huggingface_hub/guides/inference#openai-compatibility) para obtener más detalles sobre la compatibilidad con OpenAI. > [!TIP] > Puedes pasar parámetros específicos del proveedor al modelo utilizando el argumento `extra_body`. Ejemplo: ```py # 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: ```py # 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: ```py # 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. ```py >>> from huggingface_hub import InferenceClient >>> client = InferenceClient( ... provider="together", # Use Together AI provider ... 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. ```py >>> 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: ```py # 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: ```py # 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: ```py # 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[[huggingface_hub.AsyncInferenceClient.close]] ```python close() ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L226) Cierre el cliente. Este método se llama automáticamente al usar el cliente como un administrador de contexto. #### document_question_answering[[huggingface_hub.AsyncInferenceClient.document_question_answering]] ```python document_question_answering(image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview], question: str, model: str | None = None, doc_stride: int | None = None, handle_impossible_answer: bool | None = None, lang: str | None = None, max_answer_len: int | None = None, max_question_len: int | None = None, max_seq_len: int | None = None, top_k: int | None = None, word_boxes: list[list[float] | str] | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L960) **Parámetros:** image (`Union[str, Path, bytes, BinaryIO]`) : La imagen de entrada para el contexto. Puede ser bytes crudos, un archivo de imagen o una URL a una imagen en línea. question (`str`) : Pregunta a responder. model (`str`, *opcional*) : El modelo a utilizar para la tarea de respuesta a preguntas sobre documentos. 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 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.DocumentQuestionAnsweringOutputElement) que contienen la etiqueta predicha, la probabilidad asociada, los ids de las palabras y el número de página. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py # 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[[huggingface_hub.AsyncInferenceClient.feature_extraction]] ```python feature_extraction(text: str | list[str], normalize: bool | None = None, prompt_name: str | None = None, truncate: bool | None = None, truncation_direction: typing.Optional[typing.Literal['left', 'right']] = None, dimensions: int | None = None, encoding_format: typing.Optional[typing.Literal['float', 'base64']] = None, model: str | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L1048) **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 &lcub;"query": "query: ",...}, entonces 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á antes 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*) : Qué lado de la entrada debe truncarse cuando se pasa *truncate=True*. dimensions (*int*, *optional*) : 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. **Excepciones:** [*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: ```py # 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[[huggingface_hub.AsyncInferenceClient.fill_mask]] ```python fill_mask(text: str, model: str | None = None, targets: list[str] | None = None, top_k: int | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L1132) **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 a utilizar para la tarea de fill mask. 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 fill mask recomendado por defecto. targets (`list[str`, *optional*) : Cuando se proporciona, el modelo limitará las puntuaciones a los objetivos pasados en lugar de buscarlos en todo el vocabulario. Si los objetivos proporcionados no están en el vocabulario del modelo, se tokenizarán y se utilizará el primer token resultante (con una advertencia, y eso podría ser más lento). top_k (`int`, *opcional*) : Cuando se pasa, reemplaza el número de predicciones a devolver. **Devuelve:** `list[FillMaskOutputElement]` una lista de elementos [FillMaskOutputElement](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.FillMaskOutputElement) que contienen la etiqueta predicha, la probabilidad asociada, la referencia del token y el texto completado. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py # Must be run in an async context >>> from huggingface_hub import AsyncInferenceClient >>> client = AsyncInferenceClient() >>> await client.fill_mask("The goal of life is .") [ 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[[huggingface_hub.AsyncInferenceClient.get_endpoint_info]] ```python get_endpoint_info(model: str | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L3302) **Parámetros:** model (`str`, *opcional*) : El modelo a utilizar para la inferencia. Puede ser un ID de modelo alojado en el 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: ```py # 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[[huggingface_hub.AsyncInferenceClient.health_check]] ```python health_check(model: str | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L3362) **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: ```py # 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 ``` #### image_classification[[huggingface_hub.AsyncInferenceClient.image_classification]] ```python image_classification(image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview], model: str | None = None, function_to_apply: typing.Optional[ForwardRef('ImageClassificationOutputTransform')] = None, top_k: int | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L1189) **Parámetros:** image (`Union[str, Path, bytes, BinaryIO, PIL.Image.Image]`) : La imagen a clasificar. Puede ser bytes crudos, un archivo de imagen, una URL de una imagen en línea o una imagen PIL. 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.ImageClassificationOutputElement) que contienen la etiqueta predicha y la probabilidad asociada. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py # 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[[huggingface_hub.AsyncInferenceClient.image_segmentation]] ```python image_segmentation(image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview], model: str | None = None, mask_threshold: float | None = None, overlap_mask_area_threshold: float | None = None, subtask: typing.Optional[ForwardRef('ImageSegmentationSubtask')] = None, threshold: float | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L1240) **Parámetros:** image (`Union[str, Path, bytes, BinaryIO, PIL.Image.Image]`) : La imagen a segmentar. Puede ser bytes crudos, un archivo de imagen, una URL de una imagen en línea o una imagen PIL. 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 la máscara 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.ImageSegmentationOutputElement) que contiene las máscaras segmentadas y los atributos asociados. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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. > [!WARNING] > Debes tener `PIL` instalado si quieres trabajar con imágenes (`pip install Pillow`). Ejemplo: ```py # 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=), ...] ``` #### image_to_image[[huggingface_hub.AsyncInferenceClient.image_to_image]] ```python image_to_image(image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview], prompt: str | None = None, negative_prompt: str | None = None, num_inference_steps: int | None = None, guidance_scale: float | None = None, model: str | None = None, target_size: huggingface_hub.inference._generated.types.image_to_image.ImageToImageTargetSize | None = None, **kwargs) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L1309) **Parámetros:** image (`Union[str, Path, bytes, BinaryIO, PIL.Image.Image]`) : La imagen de entrada para la traducción. Puede ser bytes crudos, un archivo de imagen, una URL a una imagen en línea o una imagen PIL. 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 imágenes. 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 más alto de guidance scale 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 a utilizar para la inferencia. Puede ser un ID de modelo alojado en el 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. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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. > [!WARNING] > Debes tener `PIL` instalado si quieres trabajar con imágenes (`pip install Pillow`). Ejemplo: ```py # 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[[huggingface_hub.AsyncInferenceClient.image_to_text]] ```python image_to_text(image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview], model: str | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L1466) **Parámetros:** image (`Union[str, Path, bytes, BinaryIO, PIL.Image.Image]`) : La imagen de entrada para la que se generará la descripción. Puede ser bytes crudos, un archivo de imagen, una URL de una imagen en línea o una imagen PIL. model (`str`, *opcional*) : El modelo a utilizar para la inferencia. Puede ser un ID de modelo alojado en el 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.ImageToTextOutput) El texto generado. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py # 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[[huggingface_hub.AsyncInferenceClient.image_to_video]] ```python image_to_video(image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview], model: str | None = None, prompt: str | None = None, negative_prompt: str | None = None, num_frames: float | None = None, num_inference_steps: int | None = None, guidance_scale: float | None = None, seed: int | None = None, target_size: huggingface_hub.inference._generated.types.image_to_video.ImageToVideoTargetSize | None = None, **kwargs) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L1386) **Parámetros:** image (`Union[str, Path, bytes, BinaryIO, PIL.Image.Image]`) : La imagen de entrada a partir de la cual se generará un video. Puede ser bytes en bruto, un archivo de imagen, una URL de una imagen en línea o una imagen PIL. model (`str`, *opcional*) : El modelo a utilizar para la inferencia. Puede ser un ID de modelo alojado en el 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 conducir 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: ```py # 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[[huggingface_hub.AsyncInferenceClient.object_detection]] ```python object_detection(image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview], model: str | None = None, threshold: float | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L1513) **Parámetros:** image (`Union[str, Path, bytes, BinaryIO, PIL.Image.Image]`) : La imagen sobre la que detectar objetos. Puede ser bytes crudos, un archivo de imagen, una URL de una imagen en línea o una imagen PIL. model (`str`, *opcional*) : El modelo a utilizar para la detección de objetos. 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 detección de objetos (DETR). threshold (`float`, *opcional*) : La probabilidad necesaria para realizar una predicción. **Devuelve:** `list[ObjectDetectionOutputElement]` Una lista de elementos [ObjectDetectionOutputElement](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.ObjectDetectionOutputElement) que contiene las cajas delimitadoras y los atributos asociados. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` o ``ValueError`` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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. > [!WARNING] > Debes tener `PIL` instalado si quieres trabajar con imágenes (`pip install Pillow`). Ejemplo: ```py # 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[[huggingface_hub.AsyncInferenceClient.question_answering]] ```python question_answering(question: str, context: str, model: str | None = None, align_to_words: bool | None = None, doc_stride: int | None = None, handle_impossible_answer: bool | None = None, max_answer_len: int | None = None, max_question_len: int | None = None, max_seq_len: int | None = None, top_k: int | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L1562) **Parámetros:** question (`str`) : Pregunta a responder. context (`str`) : El contexto de la pregunta. model (`str`) : El modelo a utilizar para la tarea de respuesta a preguntas. Puede ser un ID de modelo alojado en el 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`, list[QuestionAnsweringOutputElement](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.QuestionAnsweringOutputElement)] 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`. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py # 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[[huggingface_hub.AsyncInferenceClient.sentence_similarity]] ```python sentence_similarity(sentence: str, other_sentences: list, model: str | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L1647) **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 el 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. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py # 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[[huggingface_hub.AsyncInferenceClient.summarization]] ```python summarization(text: str, model: str | None = None, clean_up_tokenization_spaces: bool | None = None, generate_parameters: dict[str, typing.Any] | None = None, truncation: typing.Optional[ForwardRef('SummarizationTruncationStrategy')] = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L1701) **Parámetros:** text (`str`) : El texto de entrada a resumir. model (`str`, *opcional*) : El modelo a 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 recomendado por defecto para la resumición. clean_up_tokenization_spaces (`bool`, *opcional*) : Si se deben limpiar los espacios extra 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.SummarizationOutput) El texto del resumen generado. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py # 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[[huggingface_hub.AsyncInferenceClient.table_question_answering]] ```python table_question_answering(table: dict, query: str, model: str | None = None, padding: typing.Optional[ForwardRef('Padding')] = None, sequential: bool | None = None, truncation: bool | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L1760) **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 a utilizar 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.TableQuestionAnsweringOutputElement) una salida de respuesta a preguntas sobre tablas que contiene la respuesta, las coordenadas, las celdas y el agregador utilizado. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py # 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') ``` #### tabular_classification[[huggingface_hub.AsyncInferenceClient.tabular_classification]] ```python tabular_classification(table: dict, model: str | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L1823) **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 el 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. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py # 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"] ``` #### tabular_regression[[huggingface_hub.AsyncInferenceClient.tabular_regression]] ```python tabular_regression(table: dict, model: str | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L1879) **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 el 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. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py # 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] ``` #### text_classification[[huggingface_hub.AsyncInferenceClient.text_classification]] ```python text_classification(text: str, model: str | None = None, top_k: int | None = None, function_to_apply: typing.Optional[ForwardRef('TextClassificationOutputTransform')] = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L1930) **Parámetros:** text (`str`) : Una cadena de texto 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 el 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.TextClassificationOutputElement) que contienen la etiqueta predicha y la probabilidad asociada. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py # 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), ] ``` #### text_generation[[huggingface_hub.AsyncInferenceClient.text_generation]] ```python text_generation(prompt: str, details: bool | None = None, stream: bool | None = None, model: str | None = None, adapter_id: str | None = None, best_of: int | None = None, decoder_input_details: bool | None = None, do_sample: bool | None = None, frequency_penalty: float | None = None, grammar: huggingface_hub.inference._generated.types.text_generation.TextGenerationInputGrammarType | None = None, max_new_tokens: int | None = None, repetition_penalty: float | None = None, return_full_text: bool | None = None, seed: int | None = None, stop: list[str] | None = None, temperature: float | None = None, top_k: int | None = None, top_n_tokens: int | None = None, top_p: float | None = None, truncate: int | None = None, typical_p: float | None = None, watermark: bool | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L2134) **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 deseas 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 a utilizar para la inferencia. Puede ser un ID de modelo alojado en el 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 secuencias de best_of y devuelve la que tiene 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*) : Activar 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.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](https://arxiv.org/pdf/1909.05858.pdf) para más detalles. return_full_text (`bool`, *opcional*) : Si se debe anteponer el prompt al texto generado seed (`int`, *opcional*) : Semilla de muestreo aleatorio stop (`list[str]`, *opcional*) : Dejar 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 deben conservar 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 típica de Decoding. Consulte [Typical Decoding for Natural Language Generation](https://arxiv.org/abs/2202.00666) para obtener más información watermark (`bool`, *opcional*) : Marca de agua con [A Watermark for Large Language Models](https://arxiv.org/abs/2301.10226) **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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.TextGenerationOutput) - si `details=True` y `stream=True`, el texto generado se devuelve token a token como un iterable de [TextGenerationStreamOutput](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.TextGenerationStreamOutput) **Excepciones:** ``ValidationError`` o [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - ``ValidationError`` -- Si los valores de entrada no son válidos. No se realiza ninguna llamada HTTP al servidor. - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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. > [!TIP] > Si deseas generar una respuesta a partir de mensajes de chat, debes usar el método [InferenceClient.chat_completion()](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py # 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[[huggingface_hub.AsyncInferenceClient.text_to_image]] ```python text_to_image(prompt: str, negative_prompt: str | None = None, height: int | None = None, width: int | None = None, num_inference_steps: int | None = None, guidance_scale: float | None = None, model: str | None = None, scheduler: str | None = None, seed: int | None = None, extra_body: dict[str, typing.Any] | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L2462) **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 imágenes. 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 a 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 conocer los parámetros admitidos. **Devuelve:** `Image` La imagen generada. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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. > [!WARNING] > Debes tener `PIL` instalado si quieres trabajar con imágenes (`pip install Pillow`). > [!TIP] > Puedes pasar parámetros específicos del proveedor al modelo utilizando el argumento `extra_body`. Ejemplo: ```py # 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") ``` Ejemplo de uso de un proveedor de terceros directamente. El uso se facturará en tu cuenta de fal.ai. ```py >>> 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. ```py >>> 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 ```py >>> 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[[huggingface_hub.AsyncInferenceClient.text_to_speech]] ```python text_to_speech(text: str, model: str | None = None, do_sample: bool | None = None, early_stopping: typing.Union[bool, ForwardRef('TextToSpeechEarlyStoppingEnum'), NoneType] = None, epsilon_cutoff: float | None = None, eta_cutoff: float | None = None, max_length: int | None = None, max_new_tokens: int | None = None, min_length: int | None = None, min_new_tokens: int | None = None, num_beam_groups: int | None = None, num_beams: int | None = None, penalty_alpha: float | None = None, temperature: float | None = None, top_k: int | None = None, top_p: float | None = None, typical_p: float | None = None, use_cache: bool | None = None, extra_body: dict[str, typing.Any] | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L2700) **Parámetros:** text (`str`) : El texto para sintetizar. model (`str`, *opcional*) : El modelo a 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 debe usar 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](https://hf.co/papers/2210.15191) 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, intuitivamente, 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](https://hf.co/papers/2210.15191) 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. Consulte [este artículo](https://hf.co/papers/1610.02424) 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 deben conservar 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 más localmente típicos cuyas probabilidades suman typical_p o más. Consulte [este artículo](https://hf.co/papers/2202.00666) 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 conocer los parámetros admitidos. **Devuelve:** `bytes` El audio generado. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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. > [!TIP] > Puedes pasar parámetros específicos del proveedor al modelo utilizando el argumento `extra_body`. Ejemplo: ```py # 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. ```py >>> 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. ```py >>> 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) ``` Ejemplo usando el proveedor Replicate con parámetros adicionales ```py >>> 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 ```py >>> 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[[huggingface_hub.AsyncInferenceClient.text_to_video]] ```python text_to_video(prompt: str, model: str | None = None, guidance_scale: float | None = None, negative_prompt: list[str] | None = None, num_frames: float | None = None, num_inference_steps: int | None = None, seed: int | None = None, extra_body: dict[str, typing.Any] | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L2603) **Parámetros:** prompt (`str`) : El prompt para generar un video. model (`str`, *opcional*) : El modelo a 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 más alto de la escala de guía 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 conducir 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 conocer los parámetros admitidos. **Devuelve:** `bytes` El video generado. Genera un video a partir de un texto dado. > [!TIP] > 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. ```py >>> 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. ```py >>> 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[[huggingface_hub.AsyncInferenceClient.token_classification]] ```python token_classification(text: str, model: str | None = None, aggregation_strategy: typing.Optional[ForwardRef('TokenClassificationAggregationStrategy')] = None, ignore_labels: list[str] | None = None, stride: int | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L2909) **Parámetros:** text (`str`) : Una cadena de texto que se va a clasificar. 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`, *optional*) : 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.TokenClassificationOutputElement) que contienen el grupo de entidad, la puntuación de confianza, la palabra y el índice de inicio y fin. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py # 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[[huggingface_hub.AsyncInferenceClient.translation]] ```python translation(text: str, model: str | None = None, src_lang: str | None = None, tgt_lang: str | None = None, clean_up_tokenization_spaces: bool | None = None, truncation: typing.Optional[ForwardRef('TranslationTruncationStrategy')] = None, generate_parameters: dict[str, typing.Any] | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L2985) **Parámetros:** text (`str`) : Una cadena de texto que se traducirá. 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 para la traducción. Obligatorio para modelos que pueden traducir a varios idiomas. clean_up_tokenization_spaces (`bool`, *opcional*) : Si se deben limpiar los espacios extra 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.TranslationOutput) El texto traducido generado. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` o ``ValueError`` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py # 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: ```py >>> 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[[huggingface_hub.AsyncInferenceClient.visual_question_answering]] ```python visual_question_answering(image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview], question: str, model: str | None = None, top_k: int | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L3075) **Parámetros:** image (`Union[str, Path, bytes, BinaryIO, PIL.Image.Image]`) : La imagen de entrada para el contexto. Puede ser bytes crudos, un archivo de imagen, una URL de una imagen en línea o una imagen PIL. question (`str`) : Pregunta a responder. model (`str`, *opcional*) : El modelo a utilizar para la tarea de respuesta visual a preguntas. 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 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.VisualQuestionAnsweringOutputElement) que contienen la etiqueta predicha y la probabilidad asociada. **Excepciones:** ``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: ```py # 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[[huggingface_hub.AsyncInferenceClient.zero_shot_classification]] ```python zero_shot_classification(text: str, candidate_labels: list, multi_label: bool | None = False, hypothesis_template: str | None = None, model: str | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L3135) **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 candidato. hypothesis_template (`str`, *opcional*) : La oración utilizada 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 a utilizar para la inferencia. Puede ser un ID de modelo alojado en el 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](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.ZeroShotClassificationOutputElement) que contienen las etiquetas predichas y su confianza. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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`: ```py # 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: ```py # 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[[huggingface_hub.AsyncInferenceClient.zero_shot_image_classification]] ```python zero_shot_image_classification(image: typing.Union[bytes, typing.BinaryIO, str, pathlib.Path, ForwardRef('Image'), bytearray, memoryview], candidate_labels: list, model: str | None = None, hypothesis_template: str | None = None) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/inference/_generated/_async_client.py#L3238) **Parámetros:** image (`Union[str, Path, bytes, BinaryIO, PIL.Image.Image]`) : La imagen de entrada para la que se generará la descripción. Puede ser bytes crudos, un archivo de imagen, una URL de una imagen en línea o una imagen PIL. candidate_labels (`list[str]`) : Las etiquetas candidatas para esta imagen model (`str`, *opcional*) : El modelo a utilizar para la inferencia. Puede ser un ID de modelo alojado en el 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 utilizada junto con `candidate_labels` para intentar la clasificación de la imagen reemplazando el marcador de posición con las etiquetas candidatas. **Devuelve:** `list[ZeroShotImageClassificationOutputElement]` Lista de elementos [ZeroShotImageClassificationOutputElement](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_types#huggingface_hub.ZeroShotImageClassificationOutputElement) que contienen las etiquetas predichas y su confianza. **Excepciones:** [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.InferenceTimeoutError) o `HfHubHTTPError` - [InferenceTimeoutError](/docs/huggingface_hub/v2.4.0/es/package_reference/inference_client#huggingface_hub.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: ```py # 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[[huggingface_hub.InferenceTimeoutError]] #### huggingface_hub.InferenceTimeoutError[[huggingface_hub.InferenceTimeoutError]] ```python huggingface_hub.InferenceTimeoutError(message: str) ``` [Fuente](https://github.com/huggingface/huggingface_hub/blob/v2.4.0/src/huggingface_hub/errors.py#L155) Error que se produce cuando un modelo no está disponible o la solicitud agota el tiempo de espera.