# Kandinsky

Erzeuge Bilder mit leistungsstarkem multilingualem Textverständnis.

{% hint style="success" %}
Alle Beispiele können auf GPU-Servern ausgeführt werden, die über [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## 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](https://github.com/ai-forever/Kandinsky-3)
* **HuggingFace:** [kandinsky-community](https://huggingface.co/kandinsky-community)
* **Paper:** [Kandinsky-Paper](https://arxiv.org/abs/2310.03502)

## 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:**

```bash
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

```bash
pip install diffusers transformers accelerate torch
```

## Grundlegende Verwendung

### Kandinsky 3

```python
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

```python
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:

```python
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

```python
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

```python
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

```python
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

```python
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

```python
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

```python
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

```python
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*](https://clore.ai/marketplace) *auf aktuelle Preise.*

## Nächste Schritte

* FLUX Generation - Höchste Bildqualität
* Stable Diffusion - Beliebteste Option
* [PixArt](https://docs.clore.ai/guides/guides_v2-de/bildgenerierung/pixart-image-gen) - Schnelle Erzeugung
* ComfyUI - Erweiterte Workflows