Kandinsky

Generieren Sie Bilder mit Kandinskys mehrsprachigem Modell auf Clore.ai

Erzeuge Bilder mit leistungsstarkem multilingualem Textverständnis.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die über CLORE.AI Marketplace.

Was ist Kandinsky?

Kandinsky ist ein Bildgenerierungsmodell, entwickelt von Sber AI:

• Starkes mehrsprachiges Textverständnis

• Hochwertige Bildgenerierung

• Bildmischung und Interpolation

• Unterstützung für Inpainting und Outpainting

• Open-Source-Gewichte

Ressourcen

• GitHub: ai-forever/Kandinsky-3

• HuggingFace: kandinsky-community

• Paper: Kandinsky-Paper

Modellversionen

Version	Auflösung	Qualität	Geschwindigkeit
Kandinsky 2.1	768x768	Gut	Schnell
Kandinsky 2.2	1024x1024	Besser	Mittel
Kandinsky 3	1024x1024	Am besten	Langsamer

Hardware-Anforderungen

Modell	VRAM	Empfohlene GPU
Kandinsky 2.2	8GB	RTX 3070
Kandinsky 3	12GB	RTX 3090
Kandinsky 3 (hohe Auflösung)	16GB	RTX 4090

Schnelle Bereitstellung

Docker-Image:

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel

Ports:

22/tcp
7860/http

Befehl:

pip install diffusers transformers accelerate gradio && \
python -c "
import gradio as gr
import torch
from diffusers import AutoPipelineForText2Image

pipe = AutoPipelineForText2Image.from_pretrained(
    'kandinsky-community/kandinsky-3',
    variant='fp16',
    torch_dtype=torch.float16
).to('cuda')

def generate(prompt, negative, steps, guidance, seed):
    generator = torch.Generator('cuda').manual_seed(seed) if seed > 0 else None
    image = pipe(
        prompt=prompt,
        negative_prompt=negative,
        num_inference_steps=steps,
        guidance_scale=guidance,
        generator=generator
    ).images[0]
    return image

gr.Interface(
    fn=generate,
    inputs=[
        gr.Textbox(label='Prompt'),
        gr.Textbox(label='Negative Prompt', value='low quality, blurry'),
        gr.Slider(10, 100, value=50, label='Steps'),
        gr.Slider(1, 20, value=4, label='Guidance'),
        gr.Number(value=-1, label='Seed')
    ],
    outputs=gr.Image(),
    title='Kandinsky 3'
).launch(server_name='0.0.0.0', server_port=7860)
"

Zugriff auf Ihren Dienst

Nach der Bereitstellung finden Sie Ihre http_pub URL in Meine Bestellungen:

1. Gehen Sie zur Meine Bestellungen Seite

2. Klicken Sie auf Ihre Bestellung

3. Finden Sie die http_pub URL (z. B., abc123.clorecloud.net)

Verwenden Sie https://IHRE_HTTP_PUB_URL anstelle von localhost in den Beispielen unten.

Installation

pip install diffusers transformers accelerate torch

Grundlegende Verwendung

Kandinsky 3

import torch
from diffusers import AutoPipelineForText2Image

pipe = AutoPipelineForText2Image.from_pretrained(
    "kandinsky-community/kandinsky-3",
    variant="fp16",
    torch_dtype=torch.float16
)
pipe.to("cuda")

image = pipe(
    prompt="Ein Katzenastronaut, der im Weltraum schwebt, digitale Kunst, lebendige Farben",
    num_inference_steps=50,
    guidance_scale=4.0
).images[0]

image.save("cat_astronaut.png")

Kandinsky 2.2

import torch
from diffusers import KandinskyV22Pipeline, KandinskyV22PriorPipeline

# Lade Prior (Textencoder)
prior = KandinskyV22PriorPipeline.from_pretrained(
    "kandinsky-community/kandinsky-2-2-prior",
    torch_dtype=torch.float16
).to("cuda")

# Lade Decoder
decoder = KandinskyV22Pipeline.from_pretrained(
    "kandinsky-community/kandinsky-2-2-decoder",
    torch_dtype=torch.float16
).to("cuda")

# Erzeuge Bild-Embeddings
prompt = "Ein schöner Sonnenuntergang über Bergen, im Stil eines Ölgemäldes"
image_embeds, negative_embeds = prior(
    prompt=prompt,
    guidance_scale=1.0
).to_tuple()

# Erzeuge Bild
image = decoder(
    image_embeds=image_embeds,
    negative_image_embeds=negative_embeds,
    height=768,
    width=768,
    num_inference_steps=50
).images[0]

image.save("sunset.png")

Mehrsprachige Prompts

Kandinsky unterstützt mehrere Sprachen:

import torch
from diffusers import AutoPipelineForText2Image

pipe = AutoPipelineForText2Image.from_pretrained(
    "kandinsky-community/kandinsky-3",
    variant="fp16",
    torch_dtype=torch.float16
).to("cuda")

# Englisch
image_en = pipe("A red fox in a snowy forest").images[0]

# Russisch
image_ru = pipe("Красная лиса в снежном лесу").images[0]

# Chinesisch
image_zh = pipe("雪林中的红狐狸").images[0]

# Deutsch
image_de = pipe("Ein roter Fuchs im verschneiten Wald").images[0]

# Alle erzeugen ähnliche Bilder!

Bildmischung

import torch
from diffusers import KandinskyV22PriorPipeline, KandinskyV22Pipeline
from diffusers.utils import load_image

prior = KandinskyV22PriorPipeline.from_pretrained(
    "kandinsky-community/kandinsky-2-2-prior",
    torch_dtype=torch.float16
).to("cuda")

decoder = KandinskyV22Pipeline.from_pretrained(
    "kandinsky-community/kandinsky-2-2-decoder",
    torch_dtype=torch.float16
).to("cuda")

# Zwei Prompts zum Mischen
prompt1 = "A cat"
prompt2 = "A dog"

# Hole Embeddings für beide
embeds1, neg1 = prior(prompt1).to_tuple()
embeds2, neg2 = prior(prompt2).to_tuple()

# Mische Embeddings (je 50%)
mixed_embeds = 0.5 * embeds1 + 0.5 * embeds2
mixed_neg = 0.5 * neg1 + 0.5 * neg2

# Erzeuge gemischtes Bild
image = decoder(
    image_embeds=mixed_embeds,
    negative_image_embeds=mixed_neg,
    height=768,
    width=768
).images[0]

image.save("cat_dog_mix.png")

Inpainting

import torch
from diffusers import AutoPipelineForInpainting
from diffusers.utils import load_image

pipe = AutoPipelineForInpainting.from_pretrained(
    "kandinsky-community/kandinsky-2-2-decoder-inpaint",
    torch_dtype=torch.float16
).to("cuda")

# Lade Bild und Maske
image = load_image("photo.png")
mask = load_image("mask.png")

# Inpainting
result = pipe(
    prompt="Eine goldene Krone",
    image=image,
    mask_image=mask,
    num_inference_steps=50
).images[0]

result.save("inpainted.png")

Bild-zu-Bild

import torch
from diffusers import AutoPipelineForImage2Image
from diffusers.utils import load_image

pipe = AutoPipelineForImage2Image.from_pretrained(
    "kandinsky-community/kandinsky-3",
    variant="fp16",
    torch_dtype=torch.float16
).to("cuda")

init_image = load_image("sketch.png")

image = pipe(
    prompt="Eine detaillierte digitale Darstellung einer Burg, Fantasy-Kunst",
    image=init_image,
    strength=0.75,
    num_inference_steps=50
).images[0]

image.save("castle.png")

Batch-Erzeugung

import torch
from diffusers import AutoPipelineForText2Image
import os

pipe = AutoPipelineForText2Image.from_pretrained(
    "kandinsky-community/kandinsky-3",
    variant="fp16",
    torch_dtype=torch.float16
).to("cuda")

prompts = [
    "Ein ruhiger japanischer Garten mit Kirschblüten",
    "Eine Cyberpunk-Stadt bei Nacht mit Neonlichtern",
    "Eine antike Bibliothek voller magischer Bücher",
    "Eine gemütliche Hütte in den Bergen im Winter"
]

os.makedirs("outputs", exist_ok=True)

for i, prompt in enumerate(prompts):
    image = pipe(
        prompt=prompt,
        num_inference_steps=50,
        guidance_scale=4.0
    ).images[0]

    image.save(f"outputs/image_{i}.png")
    print(f"Erzeugt: {prompt[:30]}...")

    torch.cuda.empty_cache()

Gradio-Oberfläche

import gradio as gr
import torch
from diffusers import AutoPipelineForText2Image

pipe = AutoPipelineForText2Image.from_pretrained(
    "kandinsky-community/kandinsky-3",
    variant="fp16",
    torch_dtype=torch.float16
).to("cuda")

def generate(prompt, negative_prompt, steps, guidance, width, height, seed):
    generator = torch.Generator("cuda").manual_seed(seed) if seed > 0 else None

    image = pipe(
        prompt=prompt,
        negative_prompt=negative_prompt,
        num_inference_steps=steps,
        guidance_scale=guidance,
        width=width,
        height=height,
        generator=generator
    ).images[0]

    return image

demo = gr.Interface(
    fn=generate,
    inputs=[
        gr.Textbox(label="Prompt", placeholder="Beschreibe dein Bild..."),
        gr.Textbox(label="Negative Prompt", value="niedrige Qualität, verschwommen, verzerrt"),
        gr.Slider(10, 100, value=50, step=5, label="Schritte"),
        gr.Slider(1, 20, value=4, step=0.5, label="Guidance Scale"),
        gr.Slider(512, 1024, value=1024, step=64, label="Breite"),
        gr.Slider(512, 1024, value=1024, step=64, label="Höhe"),
        gr.Number(value=-1, label="Seed (-1 für zufällig)")
    ],
    outputs=gr.Image(label="Erzeugtes Bild"),
    title="Kandinsky 3 - Bildgenerierung",
    description="Erzeuge Bilder mit mehrsprachigen Prompts. Läuft auf CLORE.AI."
)

demo.launch(server_name="0.0.0.0", server_port=7860)

Speicheroptimierung

import torch
from diffusers import AutoPipelineForText2Image

pipe = AutoPipelineForText2Image.from_pretrained(
    "kandinsky-community/kandinsky-3",
    variant="fp16",
    torch_dtype=torch.float16
)

# Aktiviere Speicheroptimierungen
pipe.enable_model_cpu_offload()

# Oder für sehr wenig VRAM
pipe.enable_sequential_cpu_offload()

# Attention-Slicing aktivieren
pipe.enable_attention_slicing()

image = pipe(
    prompt="Eine schöne Landschaft",
    num_inference_steps=50
).images[0]

Leistung

Modell	Auflösung	GPU	Zeit
Kandinsky 3	1024x1024	RTX 3090	15s
Kandinsky 3	1024x1024	RTX 4090	10s
Kandinsky 2.2	768x768	RTX 3090	8s
Kandinsky 2.2	768x768	RTX 4090	5s

Fehlerbehebung

Kein Speicher mehr

Problem: CUDA OOM bei der Generierung

Lösungen:

• CPU-Offloading aktivieren

• Auflösung reduzieren

• Verwende Kandinsky 2.2 statt 3

• Aufmerksamkeitsslicing aktivieren

pipe.enable_model_cpu_offload()
pipe.enable_attention_slicing()

Schlechte Textrendering

Problem: Text in Bildern sieht falsch aus

Lösungen:

• Kandinsky hat Probleme mit der Textrendering (wie die meisten Diffusionsmodelle)

• Text in der Nachbearbeitung hinzufügen

• Verwende Prompts, die Text vermeiden

Farben sehen falsch aus

Problem: Bildfarben sind ausgewaschen oder übersättigt

Lösungen:

• Passe die Guidance-Skala an (versuche 3–6)

• Gib Farbpräferenzen im Prompt an

• Nachbearbeitung mit Farbkorrektur

Langsame Generierung

Problem: Dauert zu lange zu generieren

Lösungen:

• Reduziere Inferenzschritte (30 ist oft genug)

• Verwende fp16-Präzision

• Verwende Kandinsky 2.2 für schnellere Ergebnisse

• Reduziere die Auflösung für Vorschauen

Vergleich mit anderen Modellen

Funktion	Kandinsky 3	SDXL	FLUX
Mehrsprachig	Ausgezeichnet	Begrenzt	Begrenzt
Bildqualität	Hoch	Sehr hoch	Am höchsten
Geschwindigkeit	Mittel	Mittel	Langsam
VRAM	12GB	12GB	24GB
Inpainting	Ja	Ja	Begrenzt

Kostenabschätzung

Typische CLORE.AI-Marktplatztarife (Stand 2024):

GPU	Stundensatz	Tagessatz	4-Stunden-Sitzung
RTX 3060	~$0.03	~$0.70	~$0.12
RTX 3090	~$0.06	~$1.50	~$0.25
RTX 4090	~$0.10	~$2.30	~$0.40
A100 40GB	~$0.17	~$4.00	~$0.70
A100 80GB	~$0.25	~$6.00	~$1.00

Preise variieren je nach Anbieter. Prüfe CLORE.AI Marketplace auf aktuelle Preise.

Nächste Schritte

• FLUX Generation - Höchste Bildqualität

• Stable Diffusion - Beliebteste Option

• PixArt - Schnelle Erzeugung

• ComfyUI - Erweiterte Workflows