> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/andere-workloads/kandinsky.md).

# 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](/guides/guides_v2-de/bildgenerierung/pixart-image-gen.md) - Schnelle Erzeugung
* ComfyUI - Erweiterte Workflows


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/andere-workloads/kandinsky.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.