imagen#
Aprende a usar Xinference para generar imágenes.
Introducción#
La API de Imágenes ofrece dos métodos para interactuar con imágenes:
El endpoint de texto a imagen crea imágenes desde cero basándose en texto.
El endpoint de imagen a imagen le permite generar variaciones de una imagen dada.
API endpoint |
Endpoints compatibles con OpenAI |
|---|---|
Text-to-Image API |
/v1/images/generations |
Image-to-image API |
/v1/images/variations |
Lista de modelos compatibles#
La API de texto a imagen en Xinference admite los siguientes modelos:
sd-turbo
sdxl-turbo
stable-diffusion-v1.5
stable-diffusion-xl-base-1.0
sd3-medium
sd3.5-medium
sd3.5-large
sd3.5-large-turbo
FLUX.1-schnell
FLUX.1-dev
Kolors
hunyuandit-v1.2
hunyuandit-v1.2-distilled
cogview4
Qwen-Image
Lista de modelos compatibles
Flux.1-Kontext-dev
Qwen-Image-Edit
Inicio rápido#
Traducción directa al español: «texto a imagen».#
Puedes probar la API de Text-to-image usando cURL, OpenAI Client o Xinference.
curl -X 'POST' \
'http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1/images/generations' \
-H 'accept: application/json' \
-H 'Content-Type: application/json' \
-d '{
"model": "<MODEL_UID>",
"prompt": "an apple",
}'
import openai
client = openai.Client(
api_key="cannot be empty",
base_url="http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1"
)
client.images.generate(
model=<MODEL_UID>,
prompt="an apple"
)
from xinference.client import Client
client = Client("http://<XINFERENCE_HOST>:<XINFERENCE_PORT>")
model = client.get_model("<MODEL_UID>")
input_text = "an apple"
model.text_to_image(input_text)
{
"created": 1697536913,
"data": [
{
"url": "/home/admin/.xinference/image/605d2f545ac74142b8031455af31ee33.jpg",
"b64_json": null
}
]
}
Traducción de imagen a imagen#
La API de imagen a imagen simula la API de creación de variantes de imágenes de OpenAI. Podemos probar la API de imagen a imagen mediante cURL, el cliente de OpenAI o el cliente Python de Xinference.
curl -X 'POST' \
'http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1/images/variations' \
-F model=<MODEL_UID> \
-F image=@xxx.jpg \
-F prompt="an apple"
import openai
client = openai.Client(
api_key="cannot be empty",
base_url="http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1"
)
client.images.create_variation(
model=<MODEL_UID>,
image=open("image_edit_original.png", "rb"),
prompt="an apple"
)
from xinference.client import Client
client = Client("http://<XINFERENCE_HOST>:<XINFERENCE_PORT>")
model = client.get_model("<MODEL_UID>")
input_text = "an apple"
with open("xxx.jpg", "rb") as f:
model.image_to_image(f.read(), input_text)
{
"created": 1697536913,
"data": [
{
"url": "/home/admin/.xinference/image/605d2f545ac74142b8031455af31ee33.jpg",
"b64_json": null
}
]
}
Optimización de memoria de modelos de imágenes grandes (por ejemplo, SD3-Medium, FLUX.1)#
Nota
A partir de v0.16.1, Xinference habilita la cuantización por defecto para modelos de imágenes grandes como las series Flux.1 y SD3.5. Si utilizas una versión de Xinference posterior a v0.16.1, no necesitas hacer nada para ejecutar estos modelos de imágenes grandes en máquinas con poca memoria de GPU.
Los parámetros adicionales útiles pasados al cargar el modelo incluyen:
--cpu_offload True: especificaTruepara descargar componentes del modelo a la CPU durante la inferencia y ahorrar memoria, lo que provoca un ligero aumento en la latencia de inferencia. La descarga de modelos mueve los componentes del modelo a la GPU solo cuando es necesario ejecutarlos, manteniendo el resto de los componentes en la CPU.--quantize_text_encoder <text encoder layer>: Utilizamos la bibliotecabitsandbytespara cargar y cuantificar el codificador de texto T5-XXL a una precisión de 8 bits. Esto te permite seguir utilizando todo el codificador de texto con un impacto mínimo en el rendimiento.--text_encoder_3 None, para sd3-medium, eliminar el codificador de texto T5-XXL de 4.7 mil millones de parámetros, que consume mucha memoria durante la inferencia, puede reducir significativamente los requisitos de memoria, con solo una ligera pérdida de rendimiento.--transformer_nf4 True: usar cuantificación nf4 en el transformer.--quantize: Solo es efectivo en el motor MLX en Mac. Flux.1-dev y Flux.1-schnell utilizan el motor MLX para cálculos en Mac, yquantizese puede utilizar para cuantificar el modelo.
Para la WebUI, solo necesita agregar parámetros adicionales, por ejemplo, agregue la clave cpu_offload con el valor True para habilitar la descarga a la CPU.
A continuación se enumeran los parámetros utilizados por defecto desde v0.16.1.
model |
quantize_text_encoder |
quantize |
transformer_nf4 |
|---|---|---|---|
FLUX.1-dev |
text_encoder_2 |
True |
False |
FLUX.1-schnell |
text_encoder_2 |
True |
False |
sd3-medium |
text_encoder_3 |
N/A |
False |
sd3.5-medium |
text_encoder_3 |
N/A |
False |
sd3.5-large |
text_encoder_3 |
N/A |
True |
sd3.5-large-turbo |
text_encoder_3 |
N/A |
True |
Qwen-Image |
text_encoder |
N/A |
False |
Qwen-Image-Edit |
text_encoder |
N/A |
False |
Nota
Si deseas desactivar ciertas cuantificaciones, solo necesitas establecer la opción correspondiente en False. Por ejemplo, para la interfaz web, establece la clave quantize_text_encoder y el valor False, o para la línea de comandos, especifica --quantize_text_encoder False para desactivar la cuantificación del codificador de texto.
Para CogView4, hemos descubierto que la cuantización tiene un impacto significativo en el modelo. Por lo tanto, cuando la memoria de video es limitada, recomendamos habilitar la opción de descarga de CPU en la interfaz web, y al cargar el modelo desde la línea de comandos, especificar --cpu_offload True.
Formato de archivo GGUF#
El formato de archivo GGUF proporciona ricas opciones de cuantificación para el módulo transformer. Para usar archivos GGUF, puedes especificar la opción adicional gguf_quantization en la interfaz web, o --gguf_quantization en la línea de comandos, para habilitar la compatibilidad integrada de Xinference con la cuantificación GGUF para modelos. A continuación se muestran los modelos compatibles de forma nativa.
model |
Compatible con el formato de cuantización GGUF. |
|
|---|---|---|
FLUX.1-dev |
F16, Q2_K, Q3_K_S, Q4_0, Q4_1, Q4_K_S, Q5_0, Q5_1, Q5_K_S, Q6_K, Q8_0 |
|
FLUX.1-schnell |
F16, Q2_K, Q3_K_S, Q4_0, Q4_1, Q4_K_S, Q5_0, Q5_1, Q5_K_S, Q6_K, Q8_0 |
|
sd3.5-medium |
F16, Q3_K_M, Q3_K_S, Q4_0, Q4_1, Q4_K_M, Q4_K_S, Q5_0, Q5_1, Q5_K_M, Q5_K_S, Q6_K, Q8_0 |
|
sd3.5-large |
F16, Q4_0, Q4_1, Q5_0, Q5_1, Q8_0 |
|
sd3.5-large-turbo |
F16, Q4_0, Q4_1, Q5_0, Q5_1, Q8_0 |
|
Qwen-Image |
F16, Q3_K_M, Q3_K_S, Q4_0, Q4_1, Q4_K_M, Q4_K_S, Q5_0, Q5_1, Q5_K_M, Q5_K_S, Q6_K, Q8_0 |
|
Qwen-Image-Edit |
Q2_K, Q3_K_M, Q3_K_S, Q4_0, Q4_1, Q4_K_M, Q4_K_S, Q5_0, Q5_1, Q5_K_M, Q5_K_S, Q6_K, Q8_0 |
|
Qwen-Image-Edit-2509 |
Q2_K, Q3_K_M, Q3_K_S, Q4_0, Q4_1, Q4_K_M, Q4_K_S, Q5_0, Q5_1, Q5_K_M, Q5_K_S, Q6_K, Q8_0 |
|
Nota
Recomendamos encarecidamente activar la opción adicional cpu_offload en la WebUI y establecerla en True, o en la línea de comandos, especificar --cpu_offload True.
Por ejemplo:
xinference launch --model-name FLUX.1-dev --model-type image --gguf_quantization Q2_K --cpu_offload True
Usando la cuantización Q2_K, solo necesitas aproximadamente 5 GB de VRAM para ejecutar Flux.1-dev.
Para modelos sin soporte integrado de cuantificación GGUF, o si prefieres descargar el archivo GGUF por ti mismo, puedes especificar la opción adicional gguf_model_path en la interfaz web o usar la línea de comandos con –gguf_model_path /ruta/al/modelo_cuantizado.gguf.
Lightning LORA soporte#
Lightning LORA destila el modelo en forma de LoRA, manteniendo el rendimiento del modelo mientras reduce los pasos de inferencia y acelera significativamente la velocidad de inferencia. Los siguientes modelos actualmente soportan este LoRA:
model |
Versiones de Lightning compatibles |
|
|---|---|---|
Qwen-Image |
4steps-V1.0-bf16, 4steps-V1.0, 8steps-V1.0, 8steps-V1.1-bf16, 8steps-V1.1 |
|
Qwen-Image-Edit |
4steps-V1.0-bf16, 4steps-V1.0, 8steps-V1.0-bf16, 8steps-V1.0 |
|
Qwen-Image-Edit-2509 |
4steps-V1.0-bf16, 4steps-V1.0-fp32, 8steps-V1.0-bf16, 8steps-V1.0-fp32 |
|
4 pasos u 8 pasos se refieren al número de pasos de inferencia (num_inference_steps). Cuando se especifica lightning_version, Xinference establece automáticamente los pasos de inferencia.
Al usarlo, puede seleccionar la versión de lightning en la interfaz o especificarla a través de la línea de comandos.

En la línea de comandos, use --lightning_version <version>.
Para los usuarios que hayan descargado el archivo lightning LoRA por su cuenta, pueden especificarlo en la interfaz a través de Lightning Model Path o usar el parámetro de línea de comandos --lightning_model_path.
Por ejemplo, al usar 4steps-V1.0, el tiempo de inferencia se redujo de 34 segundos a 3 segundos.
OCR#
La API de OCR acepta bytes de imagen y devuelve texto de OCR.
Puedes probar la API de OCR mediante cURL o el cliente Python de Xinference.
curl -X 'POST' \
'http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1/images/ocr' \
-F model=<MODEL_UID> \
-F 'kwargs={"model_size":"large"}' \
-F image=@xxx.jpg
from xinference.client import Client
client = Client("http://<XINFERENCE_HOST>:<XINFERENCE_PORT>")
model = client.get_model("<MODEL_UID>", model_size="large")
with open("xxx.jpg", "rb") as f:
model.ocr(f.read())
<OCR result string>