Immagine#

Impara come generare immagini usando Xinference.

Introduzione#

L’API Images fornisce due metodi per interagire con le immagini:

L’endpoint text-to-image crea immagini da zero a partire da un testo.
L’endpoint «immagine in immagine» ti consente di generare varianti di un’immagine data.

Endpoint API	Endpoint compatibile con OpenAI
Text-to-Image API	/v1/images/generations
Image-to-image API	/v1/images/variations

Elenco dei modelli supportati#

L’API text-to-image in Xinference supporta i seguenti modelli:

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

Elenco dei modelli supportati

Flux.1-Kontext-dev
Qwen-Image-Edit

Guida rapida#

Traduzione richiesta: «Testo in immagine»#

Puoi provare a utilizzare l’API Text-to-image tramite 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
    }
  ]
}

Generazione di immagini da immagini#

L’API di generazione da immagine a immagine simula l”API di creazione di varianti di immagini di OpenAI. Possiamo provare a utilizzare l’API di generazione da immagine a immagine tramite cURL, il client OpenAI o il client Python di 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
    }
  ]
}

Ottimizzazione della memoria per modelli di immagini di grandi dimensioni (ad esempio SD3-Medium, FLUX.1)#

Nota

A partire da v0.16.1, Xinference abilita per impostazione predefinita la quantizzazione per modelli di immagini grandi come Flux.1 e la serie SD3.5. Se stai utilizzando una versione di Xinference successiva a v0.16.1, non è necessario fare nulla per eseguire questi grandi modelli di immagini su macchine con memoria GPU ridotta.

Utili parametri aggiuntivi passati per caricare il modello includono:

--cpu_offload True: Specificando True, durante l’inferenza i componenti del modello verranno scaricati sulla CPU per risparmiare memoria, il che causerà un leggero aumento della latenza di inferenza. Lo scaricamento del modello sposta i suoi componenti sulla GPU solo quando necessario per l’esecuzione, mantenendo gli altri componenti sulla CPU.
--quantize_text_encoder <livello del codificatore di testo>: Carichiamo e quantizziamo il codificatore di testo T5-XXL a una precisione di 8 bit utilizzando la libreria bitsandbytes. Ciò consente di continuare a utilizzare l’intero codificatore di testo con un impatto minimo sulle prestazioni.
--text_encoder_3 None，per sd3-medium, rimuovere il T5-XXL text encoder da 4,7 miliardi di parametri, che richiede molta memoria durante l’inferenza, può ridurre significativamente i requisiti di memoria, con solo una lieve perdita di prestazioni.
--transformer_nf4 True : usa la quantizzazione nf4 per il trasformatore.
--quantize: ha effetto solo sul motore MLX su Mac. Flux.1-dev e Flux.1-schnell utilizzeranno il motore MLX per il calcolo su Mac, e quantize può essere utilizzato per quantizzare il modello.

Per la WebUI, è sufficiente aggiungere parametri aggiuntivi, ad esempio, aggiungere la chiave cpu_offload con il valore True per attivare lo scaricamento sulla CPU.

Di seguito sono elencati i parametri utilizzati per impostazione predefinita a partire dalla v0.16.1.

Modello	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

Se si desidera disattivare determinate quantizzazioni, è sufficiente impostare le opzioni corrispondenti su False. Ad esempio, per l’interfaccia Web UI, impostare la chiave quantize_text_encoder e il valore False, oppure per la riga di comando, specificare --quantize_text_encoder False per disattivare la quantizzazione del text encoder.

Per CogView4, abbiamo scoperto che la quantizzazione ha un impatto significativo sul modello. Pertanto, quando la memoria video è limitata, consigliamo di abilitare l’opzione di CPU offload nell’interfaccia Web UI e di specificare --cpu_offload True quando si carica il modello tramite riga di comando.

Formato file GGUF#

Il formato file GGUF fornisce ricche opzioni di quantizzazione per i moduli transformer. Per utilizzare un file GGUF, puoi specificare l’opzione aggiuntiva gguf_quantization nell’interfaccia web, oppure --gguf_quantization nella riga di comando, per abilitare la quantizzazione GGUF nei modelli supportati nativamente da Xinference. Di seguito sono elencati i modelli supportati nativamente.

Modello	Supporta il formato di quantizzazione 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

Raccomandiamo vivamente di attivare l’opzione aggiuntiva cpu_offload nell’interfaccia WebUI impostandola su True, oppure, per la riga di comando, specificare --cpu_offload True.

Ad esempio:

xinference launch --model-name FLUX.1-dev --model-type image --gguf_quantization Q2_K --cpu_offload True

Utilizzando la quantizzazione Q2_K, hai bisogno di circa 5 GB di VRAM per eseguire Flux.1-dev.

Per i modelli che non supportano nativamente la quantizzazione GGUF, o per i quali desideri scaricare manualmente il file GGUF, puoi specificare l’opzione aggiuntiva gguf_model_path nell’interfaccia Web UI oppure utilizzare il comando --gguf_model_path /path/to/model_quant.gguf da riga di comando.

Lightning LORA support#

Lightning LORA distilla il modello sotto forma di LoRA, riducendo i passi di inferenza e aumentando notevolmente la velocità di inferenza, pur mantenendo le prestazioni del modello. I seguenti modelli supportano attualmente questo LoRA:

Modello	Versioni Lightning supportate
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 o 8 passi si riferiscono al numero di passi di inferenza (num_inference_steps). Quando viene specificato lightning_version, Xinference imposta automaticamente il numero di passi di inferenza.

Durante l’uso, è possibile selezionare la versione di lightning nell’interfaccia o specificarla tramite riga di comando.

Usa --lightning_version <version> nella riga di comando.

Per gli utenti che hanno scaricato autonomamente il file LoRA lightning, è possibile specificarlo tramite Lightning Model Path nell’interfaccia o utilizzando il parametro da riga di comando --lightning_model_path.

Ad esempio, utilizzando 4steps-V1.0, il tempo di inferenza è stato ridotto da 34 secondi originali a 3 secondi.

OCR#

L’API OCR accetta byte dell’immagine e restituisce testo OCR.

Puoi provare l’API OCR tramite cURL o il client Python di 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>