Bild#

Erfahren Sie, wie Sie mit Xinference Bilder generieren.

Introduktion#

Die Images API bietet zwei Methoden zur Interaktion mit Bildern:

Der Endpunkt zur Text-zu-Bild-Erstellung erzeugt Bilder von Grund auf basierend auf Text.
Der Endpunkt „Bild-zu-Bild“ ermöglicht es Ihnen, Variationen eines bestimmten Bildes zu generieren.

API-Endpunkt	OpenAI-kompatibler Endpunkt
Text-to-Image API	/v1/images/generations
Image-to-image API	/v1/images/variations

Unterstützte Modellliste#

In Xinference unterstützt die Text-to-Image-API die folgenden Modelle:

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

Unterstützte Modellliste

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

Schnellstart#

Text-to-Image#

Du kannst die Text-to-Image API über cURL, den OpenAI Client oder Xinference ausprobieren.

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
    }
  ]
}

Bild-zu-Bild#

Der API für Bild-zu-Bild simuliert die OpenAI Image Variation Creation API. Wir können die Bild-zu-Bild API über cURL, den OpenAI Client oder den Python Client von Xinference ausprobieren:

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
    }
  ]
}

Speicheroptimierung für große Bildmodelle (z.B. SD3-Medium, FLUX.1)#

Bemerkung

Ab v0.16.1 aktiviert Xinference standardmäßig die Quantisierung für große Bildmodelle wie Flux.1 und die SD3.5-Serie. Wenn Sie eine neuere Version von Xinference als v0.16.1 verwenden, müssen Sie nichts tun, um diese großen Bildmodelle auf Maschinen mit kleinem GPU-Speicher auszuführen.

Nützliche zusätzliche Parameter, die beim Laden des Modells übergeben werden können, sind:

--cpu_offload True: Wenn True angegeben wird, werden während der Inferenz Komponenten des Modells auf die CPU ausgelagert, um Speicher zu sparen, was zu einer leichten Erhöhung der Inferenzlatenz führt. Das Auslagern des Modells verschiebt Modellkomponenten nur dann auf die GPU, wenn sie ausgeführt werden müssen, während die übrigen Komponenten auf der CPU verbleiben.
--quantize_text_encoder <Textencoder-Ebene>: Wir verwenden die bitsandbytes-Bibliothek, um den T5-XXL-Textencoder zu laden und auf 8-Bit-Präzision zu quantisieren. Dadurch können Sie den gesamten Textencoder weiterhin nutzen, während die Leistung nur minimal beeinträchtigt wird.
--text_encoder_3 None, für sd3-medium kann das Entfernen des speicherintensiven T5-XXL-Textencoders mit 4,7 Milliarden Parametern während der Inferenz den Speicherbedarf erheblich reduzieren, bei nur geringen Leistungseinbußen.
--transformer_nf4 True : Verwenden Sie nf4 zur Quantisierung des Transformers.
--quantize: Wirkt nur auf die MLX-Engine auf dem Mac. Flux.1-dev und Flux.1-schnell verwenden auf dem Mac die MLX-Engine für Berechnungen, quantize kann verwendet werden, um das Modell zu quantisieren.

Für die WebUI genügt es, zusätzliche Parameter hinzuzufügen, z. B. den Schlüssel cpu_offload mit dem Wert True, um das CPU-Offloading zu aktivieren.

Nachfolgend sind die Parameter aufgeführt, die standardmäßig ab v0.16.1 verwendet werden.

Modell	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

Bemerkung

Wenn Sie bestimmte Quantisierungen deaktivieren möchten, setzen Sie einfach die entsprechenden Optionen auf False. Beispielsweise setzen Sie für die Web-Oberfläche den Schlüssel quantize_text_encoder und den Wert False, oder für die Befehlszeile geben Sie --quantize_text_encoder False an, um die Quantisierung des Text-Encoders zu deaktivieren.

Für CogView4 haben wir festgestellt, dass die Quantisierung einen erheblichen Einfluss auf das Modell hat. Daher empfehlen wir, bei begrenztem VRAM die CPU-Offload-Option in der Weboberfläche zu aktivieren und beim Laden des Modells über die Befehlszeile --cpu_offload True anzugeben.

GGUF-Dateiformat#

Das GGUF-Dateiformat bietet umfangreiche Quantisierungsoptionen für Transformer-Module. Um eine GGUF-Datei zu verwenden, können Sie im Webinterface die zusätzliche Option gguf_quantization angeben oder in der Befehlszeile --gguf_quantization festlegen, um die integrierte GGUF-Quantisierungsunterstützung von Xinference für Modelle zu aktivieren. Im Folgenden sind die standardmäßig unterstützten Modelle aufgeführt.

Modell	Unterstützt das GGUF-Quantisierungsformat.
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

Bemerkung

Wir empfehlen dringend, im WebUI die zusätzliche Option cpu_offload zu aktivieren und auf True zu setzen, oder in der Befehlszeile --cpu_offload True anzugeben.

Zum Beispiel:

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

Mit der Q2_K-Quantisierung benötigst du nur etwa 5 GB VRAM, um Flux.1-dev auszuführen.

Für Modelle, die nicht nativ GGUF-Quantisierung unterstützen, oder wenn Sie die GGUF-Datei selbst herunterladen möchten, können Sie in der Web-Oberfläche die zusätzliche Option gguf_model_path angeben oder über die Befehlszeile --gguf_model_path /pfad/zum/model_quant.gguf festlegen.

Lightning LORA unterstützt#

Lightning LORA destilliert das Modell in Form einer LoRA, reduziert die Anzahl der Inferenzschritte bei gleichzeitiger Beibehaltung der Modellleistung und steigert die Inferenzgeschwindigkeit erheblich. Die folgenden Modelle unterstützen derzeit diese LoRA:

Modell	Unterstützte Lightning-Version
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 oder 8 Schritte bezieht sich auf die Anzahl der Inferenzschritte (num_inference_steps). Wenn lightning_version angegeben ist, legt Xinference die Anzahl der Inferenzschritte automatisch fest.

Bei der Verwendung kann entweder über die Oberfläche die Lightning-Version ausgewählt oder über die Befehlszeile angegeben werden.

Verwenden Sie in der Befehlszeile --lightning_version <version>.

Für Benutzer, die die Lightning LoRA-Datei selbst heruntergeladen haben, kann diese über die Oberfläche unter „Lightning Model Path“ angegeben oder über den Befehlszeilenparameter --lightning_model_path festgelegt werden.

Beispielsweise reduziert sich bei Verwendung von 4steps-V1.0 die Inferenzzeit von ursprünglich 34 Sekunden auf 3 Sekunden.

OCR#

OCR API akzeptiert Bildbytes und gibt OCR-Text zurück.

Sie können die OCR-API entweder über cURL oder den Python-Client von Xinference ausprobieren.

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>