> ## Documentation Index
> Fetch the complete documentation index at: https://www.krea.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Einen benutzerdefinierten Stil trainieren

> Trainiere benutzerdefinierte Bildstile aus eigenen Datensätzen und generiere konsistente Ergebnisse — mit Hinweisen zu Kuratierung, Tagging und iterativen Best Practices.

export const HeroHeader = ({image, video, title, description}) => {
  return <div className="relative aspect-[2/1] h-[30vh] w-full rounded-lg overflow-hidden mb-8">
      {}
      {video && <video autoPlay muted loop playsInline className="absolute top-0 left-0 w-full h-full object-cover hidden md:block m-0" style={{
    zIndex: 1,
    objectPosition: "20% 20%"
  }}>
          <source src={video} type="video/webm" />
        </video>}

      {}
      <img src={image} alt="" className={`absolute top-0 left-0 m-0 w-full h-full object-cover ${video ? "md:hidden" : "block"}`} style={{
    zIndex: 1,
    objectPosition: "20% 20%"
  }} />

      {}
      <div className="absolute inset-0 bg-gradient-to-t from-black/70 via-black/30 to-black/10 flex flex-col justify-end p-8 dark:hidden" style={{
    zIndex: 2
  }}>
        <h1 className="text-4xl font-bold text-white m-0 drop-shadow-[0_2px_4px_rgba(0,0,0,0.5)]">
          {title}
        </h1>
        <p className="text-lg text-white/95 mt-2 drop-shadow-[0_1px_2px_rgba(0,0,0,0.5)]">
          {description}
        </p>
      </div>

      {}
      <div className="absolute inset-0 bg-gradient-to-t from-black/80 via-black/40 to-black/20 hidden dark:flex flex-col justify-end p-8" style={{
    zIndex: 2
  }}>
        <h1 className="text-4xl font-bold text-white m-0 drop-shadow-[0_2px_4px_rgba(0,0,0,0.5)]">
          {title}
        </h1>
        <p className="text-lg text-white/95 mt-2 drop-shadow-[0_1px_2px_rgba(0,0,0,0.5)]">
          {description}
        </p>
      </div>
    </div>;
};

<HeroHeader image="https://s.krea.ai/docs-lora.webp" title="Einen benutzerdefinierten Stil trainieren (LoRA)" description="Trainiere einen benutzerdefinierten Stil mit deinen eigenen Bildern, um KI-Kunst mit konsistenter visueller Ästhetik zu generieren." />

## Überblick

LoRA (Low-Rank Adaptation) ist eine Fine-Tuning-Technik, die einem KI-Modell einen neuen visuellen Stil anhand einer kleinen Menge von Beispielbildern beibringt. Sie funktioniert, indem neue „Style Weights“ in ein bestehendes Modell injiziert werden — das macht das Training schnell und effizient.

Dieser Leitfaden führt dich durch den vollständigen Workflow:

<Steps>
  <Step title="Trainingsbilder vorbereiten" icon="images">
    Kuratiere und lade hochwertige Bilder hoch, die deinen gewünschten Stil repräsentieren
  </Step>

  <Step title="Trainings-Job einreichen" icon="play">
    Sende eine POST-Anfrage an `/styles/train` mit deinen Bild-URLs und der Konfiguration
  </Step>

  <Step title="Fortschritt überwachen" icon="clock">
    Verfolge den Status deines Trainings-Jobs mit der zurückgegebenen `job_id`
  </Step>

  <Step title="Mit deinem Stil generieren" icon="sparkles">
    Wende deinen trainierten Stil auf die Bildgenerierung an
  </Step>
</Steps>

***

## Trainingsbilder vorbereiten

### Deinen Datensatz kuratieren

Die Qualität deiner Trainingsbilder wirkt sich direkt auf die Ergebnisse aus. Unterschiedliche Trainings-Typen haben unterschiedliche Anforderungen:

| Typ           | Anwendungsfall                                  | Tipps                                             |
| ------------- | ----------------------------------------------- | ------------------------------------------------- |
| **Style**     | Künstlerische Stile, visuelle Ästhetik          | Konsistenter Stil über verschiedene Motive hinweg |
| **Character** | Persönliche Ähnlichkeit, konsistente Charaktere | Verschiedene Posen, Ausdrücke, Beleuchtung        |
| **Object**    | Bestimmte Gegenstände, Produkte                 | Mehrere Winkel, konsistentes Objekt               |

### Wie viele Bilder?

Qualität zählt weit mehr als Quantität. Ein kleiner Satz exzellenter Bilder übertrifft einen großen Satz mittelmäßiger Bilder.

| Datensatzgröße   | Empfehlung                                                  |
| ---------------- | ----------------------------------------------------------- |
| **5 Bilder**     | Minimum. Kann für einfache, konsistente Stile funktionieren |
| **10–30 Bilder** | Empfohlen. Bestes Verhältnis von Qualität und Abdeckung     |
| **50+ Bilder**   | Nur bei sehr variantenreichen Stilen sinnvoll               |

<Warning>
  **Qualität > Quantität**

  15 hochwertige Bilder liefern bessere Ergebnisse als 50 minderwertige. Priorisiere:

  * Hohe Auflösung (mindestens 1024x1024)
  * Konsistenter Stil über alle Bilder hinweg
  * Keine Wasserzeichen, Text-Overlays oder Kompressionsartefakte
  * Vielfältige Motive bei gleichbleibendem Stil
</Warning>

<Info>
  **Beispiel-Datensätze**

  * **Character-Training**: Fotos einer Person in verschiedenen Posen, mit unterschiedlichen Ausdrücken und Lichtverhältnissen. Vermeide andere Personen in den Bildern.
  * **Style-Training**: Eine Sammlung von Kunstwerken in einem konsistenten Stil. Zum Beispiel bietet [The Metropolitan Museum of Art Ukiyo-E Dataset](https://www.kaggle.com/datasets/kengoichiki/the-metropolitan-museum-of-art-ukiyoe-dataset) japanische Holzschnitte, die sich ideal für das Trainieren eines künstlerischen Stils eignen.
</Info>

### Bilder hochladen

Lade deine Bilder vor dem Training hoch, um gehostete URLs zu erhalten. Verwende den `/assets`-Endpoint:

<CodeGroup>
  ```python Python theme={null}
  import requests
  import os
  from dotenv import load_dotenv
  import mimetypes

  load_dotenv()

  API_BASE = "https://api.krea.ai"
  API_TOKEN = os.getenv("API_TOKEN")

  image_dir = "training_images"
  uploaded_urls = []

  for filename in os.listdir(image_dir):
      if filename.lower().endswith(('.jpg', '.jpeg', '.png', '.webp')):
          filepath = os.path.join(image_dir, filename)
          mime_type, _ = mimetypes.guess_type(filepath)

          with open(filepath, 'rb') as f:
              response = requests.post(
                  f"{API_BASE}/assets",
                  headers={"Authorization": f"Bearer {API_TOKEN}"},
                  files={"file": (filename, f, mime_type)},
                  data={"description": f"Training image: {filename}"}
              )

          if response.ok:
              data = response.json()
              uploaded_urls.append(data["image_url"])
              print(f"Uploaded: {filename}")
          else:
              print(f"Failed: {filename}")

  print(f"\nUploaded {len(uploaded_urls)} images")
  ```

  ```bash cURL theme={null}
  # Ein einzelnes Bild hochladen
  curl -X POST https://api.krea.ai/assets \
    -H "Authorization: Bearer YOUR_API_TOKEN" \
    -F "file=@/path/to/image.jpg" \
    -F "description=Training image"

  # Antwort: {"id": "...", "image_url": "https://..."}
  ```
</CodeGroup>

<Tip>
  Speichere die zurückgegebenen `image_url`-Werte — du übergibst sie später an den Trainings-Endpoint.
</Tip>

***

## Deinen Stil trainieren

### Einfaches Trainingsbeispiel

Reiche deine Bild-URLs ein, um das Training zu starten:

<CodeGroup>
  ```python Python theme={null}
  import requests
  import os
  from dotenv import load_dotenv

  load_dotenv()

  API_BASE = "https://api.krea.ai"
  API_TOKEN = os.getenv("API_TOKEN")

  # Training-URLs aus dem Upload-Schritt
  urls = [
      "https://krea.ai/assets/img1.jpg",
      "https://krea.ai/assets/img2.jpg",
      "https://krea.ai/assets/img3.jpg",
      # ... weitere Bilder
  ]

  response = requests.post(
      f"{API_BASE}/styles/train",
      headers={
          "Authorization": f"Bearer {API_TOKEN}",
          "Content-Type": "application/json"
      },
      json={
          "name": "Ukiyo-E Style",
          "urls": urls,
          "model": "flux_dev",
          "type": "Style",
          "max_train_steps": 500
      }
  )

  response.raise_for_status()
  job = response.json()
  print(f"Training started! Job ID: {job['job_id']}")
  ```

  ```bash cURL theme={null}
  curl -X POST https://api.krea.ai/styles/train \
    -H "Authorization: Bearer YOUR_API_TOKEN" \
    -H "Content-Type: application/json" \
    -d '{
      "name": "Ukiyo-E Style",
      "urls": [
        "https://krea.ai/assets/img1.jpg",
        "https://krea.ai/assets/img2.jpg",
        "https://krea.ai/assets/img3.jpg"
      ],
      "model": "flux_dev",
      "type": "Style",
      "max_train_steps": 500
    }'
  ```
</CodeGroup>

### Trainingstypen

Der `type`-Parameter setzt intelligente Standardwerte, die auf deinen Anwendungsfall optimiert sind:

| Typ         | Am besten geeignet für                          |
| ----------- | ----------------------------------------------- |
| `Style`     | Künstlerische Stile, visuelle Ästhetik          |
| `Character` | Persönliche Ähnlichkeit, konsistente Charaktere |
| `Object`    | Bestimmte Gegenstände, Produkte                 |
| `Default`   | Allgemeines Training                            |

### Parameter

#### Erforderliche Parameter

<ParamField path="name" type="string" required>
  Ein sprechender Name für deinen benutzerdefinierten Stil.

  **Beispiel:** `"Ukiyo-E Style"`, `"Product Photos"`
</ParamField>

<ParamField path="urls" type="array" required>
  Array von Bild-URLs, mit denen trainiert werden soll. Mehr Bilder führen zu besseren Ergebnissen.
</ParamField>

#### Optionale Parameter

<ParamField path="model" type="string" default="flux_dev">
  Basismodell für das Training:

  **Bildmodelle:**

  * `flux_dev` – Hohe Qualität, vielseitig
  * `flux_schnell` – BFLs Realtime-Modell
  * `qwen` – Alibabas Modell
  * `z-image` – Alibabas effizientes Bildmodell
  * `wan22` – Nur Bildgenerierung

  **Videomodelle:**

  * `wan` – Alibabas Videomodell
</ParamField>

<ParamField path="type" type="string" default="Default">
  Trainingskategorie: `Style`, `Object`, `Character` oder `Default`
</ParamField>

<ParamField path="trigger_word" type="string">
  Benutzerdefiniertes Wort, um diesen Stil in Prompts zu aktivieren. Wenn nicht angegeben, wird der Stilname verwendet.

  <Tip>Wähle einzigartige Trigger-Wörter, die in typischen Prompts nicht vorkommen. Verwende Unterstriche für mehrteilige Trigger: `ukiyo_style`</Tip>
</ParamField>

<Accordion title="Erweiterte Parameter" icon="sliders">
  <ParamField path="learning_rate" type="number">
    Steuert die Trainingsintensität. Höhere Werte trainieren schneller, können aber zu Overfitting führen.

    **Empfohlener Bereich:** 0.0001 – 0.001
  </ParamField>

  <ParamField path="max_train_steps" type="integer">
    Maximale Anzahl an Trainings-Iterationen. Bereich: 1–2000
  </ParamField>

  <ParamField path="batch_size" type="integer">
    Bilder, die gleichzeitig verarbeitet werden. Größere Batches = schnelleres Training, aber mehr Speicherbedarf.
  </ParamField>
</Accordion>

### Erweiterte Parameter tunen

Beginne mit den durch das `type`-Feld gesetzten Standardwerten — sie funktionieren in den meisten Fällen gut. Passe diese nur an, wenn du konkrete Probleme siehst:

<AccordionGroup>
  <Accordion title="Learning Rate" icon="gauge">
    Steuert, wie aggressiv sich das Modell an deine Trainingsbilder anpasst.

    | Wert                     | Wann verwenden                                          |
    | ------------------------ | ------------------------------------------------------- |
    | **0.0001** (niedriger)   | Overfitting-Probleme, komplexe Stile, kleine Datensätze |
    | **0.0003** (Standard)    | Die meisten Anwendungsfälle                             |
    | **0.0005–0.001** (höher) | Schnelleres Training                                    |

    **Anzeichen, dass du anpassen solltest:**

    * Ausgaben sehen identisch zu Trainingsbildern aus → Rate senken
    * Stileinfluss ist nach dem Training schwach → Rate leicht erhöhen
  </Accordion>

  <Accordion title="Trainings-Schritte" icon="shoe-prints">
    Wie lange das Modell auf deinen Bildern trainiert.

    | Datensatzgröße | Empfohlene Schritte |
    | -------------- | ------------------- |
    | 5–10 Bilder    | 300–500 Schritte    |
    | 15–30 Bilder   | 500–800 Schritte    |
    | 50+ Bilder     | 800–1500 Schritte   |

    **Anzeichen, dass du anpassen solltest:**

    * Ausgaben sind zu starr und ignorieren Prompts → Schritte reduzieren
    * Stileinfluss ist schwach → Schritte erhöhen
    * Generierte Bilder sehen exakt wie Trainingsdaten aus → Schritte reduzieren (Overfitting)
  </Accordion>
</AccordionGroup>

<Tip>
  **Iteratives Tuning**

  Wenn dein erster Trainingsversuch nicht die gewünschten Ergebnisse liefert:

  1. Passe zuerst `max_train_steps` an (häufigste Lösung)
  2. Wenn das nicht hilft, probiere `learning_rate`
</Tip>

### Antwortformat

```json theme={null}
{
  "job_id": "550e8400-e29b-41d4-a716-446655440000",
  "status": "queued",
  "created_at": "2024-01-15T10:30:00Z"
}
```

***

## Trainingsfortschritt überwachen

Das Training dauert typischerweise 5–15 Minuten. Polle die Jobs-API, um den Status zu prüfen:

<CodeGroup>
  ```python Python theme={null}
  import requests
  import time
  import os
  from dotenv import load_dotenv

  load_dotenv()

  API_BASE = "https://api.krea.ai"
  API_TOKEN = os.getenv("API_TOKEN")
  job_id = "your-job-id"

  while True:
      response = requests.get(
          f"{API_BASE}/jobs/{job_id}",
          headers={"Authorization": f"Bearer {API_TOKEN}"}
      )
      job = response.json()
      status = job["status"]

      print(f"Status: {status}")

      if status == "completed":
          style_id = job["result"]["style_id"]
          print(f"Training complete! Style ID: {style_id}")
          break
      elif status in ["failed", "cancelled"]:
          print(f"Training {status}")
          break

      time.sleep(30)
  ```

  ```bash cURL theme={null}
  # Job-Status prüfen (wiederholen, bis abgeschlossen)
  curl -X GET https://api.krea.ai/jobs/YOUR_JOB_ID \
    -H "Authorization: Bearer YOUR_API_TOKEN"
  ```
</CodeGroup>

<Accordion title="Job-Status-Werte" icon="diagram-project">
  Trainings-Jobs durchlaufen diese Zustände:

  1. **queued** – Wartet in der Warteschlange
  2. **processing** – Aktives Training
  3. **completed** – Training erfolgreich abgeschlossen
  4. **failed** – Training ist auf einen Fehler gestoßen
  5. **cancelled** – Job manuell abgebrochen
</Accordion>

***

## Deinen trainierten Stil verwenden

Sobald das Training abgeschlossen ist, wendest du deinen Stil über den `styles`-Parameter auf die Bildgenerierung an:

<Warning>
  **Style-Ownership zwischen App und API**

  Die API und die Krea-Web-App agieren als separate Nutzer-Identitäten innerhalb deines Workspaces. Stile sind privat für den Nutzer, der sie erstellt hat, das heißt:

  * **In der App trainierte Stile** sind nicht per API zugänglich, außer sie werden geteilt
  * **Per API trainierte Stile** sind nicht in der App zugänglich, außer sie werden geteilt

  Um einen Stil mit deinem Workspace zu teilen (funktioniert in beide Richtungen):

  ```bash theme={null}
  curl -X POST https://api.krea.ai/styles/YOUR_STYLE_ID/share/workspace \
    -H "Authorization: Bearer YOUR_API_TOKEN"
  ```
</Warning>

<CodeGroup>
  ```python Python theme={null}
  import requests
  import time
  import os
  from dotenv import load_dotenv

  load_dotenv()

  API_BASE = "https://api.krea.ai"
  API_TOKEN = os.getenv("API_TOKEN")
  STYLE_ID = "w29t6pvy0"

  response = requests.post(
      f"{API_BASE}/generate/image/krea/krea-2/medium",
      headers={
          "Authorization": f"Bearer {API_TOKEN}",
          "Content-Type": "application/json"
      },
      json={
          "prompt": "An abstract, colorful, surreal composition of symmetry and balance. Swirling colors, imagery of trees and coalescing patterns converge. The lantern of light and death. It is as if the world was at once dark, and yet again lit.",
          "aspect_ratio": "1:1",
          "resolution": "1K",
          "styles": [
              {
                  "id": STYLE_ID,
                  "strength": 0.95
              }
          ]
      }
  )

  job = response.json()
  job_id = job["job_id"]
  print(f"Generation started! Job ID: {job_id}")

  # Auf Fertigstellung pollen
  while True:
      check = requests.get(
          f"{API_BASE}/jobs/{job_id}",
          headers={"Authorization": f"Bearer {API_TOKEN}"}
      )
      status_data = check.json()

      if status_data["status"] == "completed":
          image_url = status_data["result"]["urls"][0]
          print(f"Image ready: {image_url}")
          break
      elif status_data["status"] == "failed":
          print("Generation failed")
          break

      time.sleep(2)
  ```

  ```bash cURL theme={null}
  # Mit Stil generieren
  curl -X POST https://api.krea.ai/generate/image/krea/krea-2/medium \
    -H "Authorization: Bearer YOUR_API_TOKEN" \
    -H "Content-Type: application/json" \
    -d '{
      "prompt": "An abstract, colorful, surreal composition of symmetry and balance. Swirling colors, imagery of trees and coalescing patterns converge. The lantern of light and death. It is as if the world was at once dark, and yet again lit.",
      "aspect_ratio": "1:1",
      "resolution": "1K",
      "styles": [
        {
          "id": "w29t6pvy0",
          "strength": 0.95
        }
      ]
    }'

  # Anschließend /jobs/{job_id} für das Ergebnis pollen
  ```
</CodeGroup>

### Stil-Stärke

Der `strength`-Parameter (0.0–1.0) steuert, wie stark dein Stil angewendet wird:

| Stärke   | Effekt                                                     |
| -------- | ---------------------------------------------------------- |
| 0.5–0.7  | Subtiler Einfluss, behält Prompt-Flexibilität              |
| 0.8–0.9  | Starke Stilanwendung, empfohlener Startwert                |
| 0.95–1.0 | Maximale Stiltreue, kann Prompt-Empfänglichkeit reduzieren |

<Tip>
  Starte mit `0.8` Stärke und passe je nach Ergebnis an. Niedrigere Werte geben mehr kreative Freiheit; höhere Werte erzwingen strengere Stiltreue.
</Tip>

### Mehrere Stile kombinieren

Wende mehrere Stile an, indem du sie dem `styles`-Array hinzufügst:

```python theme={null}
"styles": [
    {"id": "style-id-1", "strength": 0.6},
    {"id": "style-id-2", "strength": 0.4}
]
```

***

## Best Practices

<AccordionGroup>
  <Accordion title="Bildauswahl" icon="images">
    * Verwende so viele hochwertige Bilder wie möglich für optimale Ergebnisse
    * Sorge für konsistenten Stil über alle Trainingsbilder hinweg
    * Bringe Motiv-Vielfalt ein, ohne die Stilkonsistenz zu verlieren
    * Vermeide Wasserzeichen, Text-Overlays oder Artefakte
    * Verwende Bilder mit mindestens 1024x1024 Auflösung
  </Accordion>

  <Accordion title="Trainingskonfiguration" icon="sliders">
    * Starte mit den Standardparametern über das `type`-Feld
    * Für Stile: 500–1000 Schritte reichen meist aus
    * Niedrigere Learning Rates (0.0001–0.0003) verhindern Overfitting
    * Erhöhe die Schritte, wenn der Stil nicht stark genug ist
    * Reduziere die Schritte, wenn die Ausgabe zu starr ist
  </Accordion>

  <Accordion title="Trigger-Wörter" icon="wand-magic-sparkles">
    * Verwende dasselbe Trigger-Wort, wenn du planst, mehrere Stile zu kombinieren
    * Trigger-Wörter werden automatisch in den Prompt eingefügt, wenn du den Stil verwendest
    * Vermeide gängige Wörter, die in typischen Prompts vorkommen
    * Verwende Unterstriche für mehrteilige Trigger: `my_custom_style`
  </Accordion>
</AccordionGroup>