> ## 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.

# Entraîner un style personnalisé

> Entraînez des styles d'image personnalisés à partir de vos propres jeux de données et générez des résultats cohérents grâce à des conseils sur la curation, l'étiquetage et les bonnes pratiques d'itération.

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="Entraîner un style personnalisé (LoRA)" description="Entraînez un style personnalisé à l'aide de vos propres images pour générer des œuvres IA avec une esthétique visuelle cohérente." />

## Vue d'ensemble

LoRA (Low-Rank Adaptation) est une technique de fine-tuning qui apprend à un modèle d'IA un nouveau style visuel à partir d'un petit ensemble d'images d'exemple. Elle fonctionne en injectant de nouveaux « poids de style » dans un modèle existant, ce qui rend l'entraînement à la fois rapide et efficace.

Ce guide vous accompagne tout au long du workflow complet :

<Steps>
  <Step title="Préparer les images d'entraînement" icon="images">
    Sélectionnez et téléversez des images de haute qualité qui représentent le style souhaité
  </Step>

  <Step title="Soumettre le job d'entraînement" icon="play">
    Envoyez une requête POST à `/styles/train` avec les URL de vos images et votre configuration
  </Step>

  <Step title="Suivre la progression" icon="clock">
    Suivez l'état de votre job d'entraînement à l'aide du `job_id` renvoyé
  </Step>

  <Step title="Générer avec votre style" icon="sparkles">
    Appliquez votre style entraîné à la génération d'images
  </Step>
</Steps>

***

## Préparer les images d'entraînement

### Constituer votre jeu de données

La qualité de vos images d'entraînement a un impact direct sur les résultats. Les différents types d'entraînement ont des exigences différentes :

| Type          | Cas d'usage                                     | Conseils                                |
| ------------- | ----------------------------------------------- | --------------------------------------- |
| **Style**     | Styles artistiques, esthétiques visuelles       | Style cohérent sur des sujets variés    |
| **Character** | Ressemblance personnelle, personnages cohérents | Poses, expressions et éclairages variés |
| **Object**    | Éléments spécifiques, produits                  | Angles multiples, objet cohérent        |

### Combien d'images ?

La qualité importe bien plus que la quantité. Un petit ensemble d'excellentes images surpassera un grand ensemble d'images médiocres.

| Taille du jeu de données | Recommandation                                                        |
| ------------------------ | --------------------------------------------------------------------- |
| **5 images**             | Minimum viable. Peut convenir pour des styles simples et cohérents    |
| **10-30 images**         | Recommandé. Meilleur équilibre entre qualité et couverture            |
| **50+ images**           | Rendements décroissants sauf si le style présente une forte variation |

<Warning>
  **Qualité > Quantité**

  15 images de haute qualité produiront de meilleurs résultats que 50 images de basse qualité. Priorisez :

  * Une haute résolution (1024x1024 minimum)
  * Un style cohérent sur toutes les images
  * Aucun filigrane, superposition de texte ou artefact de compression
  * Des sujets variés tout en maintenant la cohérence stylistique
</Warning>

<Info>
  **Exemples de jeux de données**

  * **Entraînement de personnage** : photos d'une personne avec des poses, expressions et conditions d'éclairage variées. Évitez d'inclure d'autres personnes dans les images.
  * **Entraînement de style** : une collection d'œuvres dans un style cohérent. Par exemple, [le jeu de données Ukiyo-E du Metropolitan Museum of Art](https://www.kaggle.com/datasets/kengoichiki/the-metropolitan-museum-of-art-ukiyoe-dataset) propose des estampes japonaises idéales pour entraîner un style artistique.
</Info>

### Téléverser les images

Avant l'entraînement, téléversez vos images pour obtenir des URL hébergées. Utilisez le point de terminaison `/assets` :

<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}
  # Upload a single image
  curl -X POST https://api.krea.ai/assets \
    -H "Authorization: Bearer YOUR_API_TOKEN" \
    -F "file=@/path/to/image.jpg" \
    -F "description=Training image"

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

<Tip>
  Enregistrez les valeurs `image_url` renvoyées — vous les transmettrez au point de terminaison d'entraînement.
</Tip>

***

## Entraîner votre style

### Exemple d'entraînement de base

Soumettez les URL de vos images pour démarrer l'entraînement :

<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 from the upload step
  urls = [
      "https://krea.ai/assets/img1.jpg",
      "https://krea.ai/assets/img2.jpg",
      "https://krea.ai/assets/img3.jpg",
      # ... more images
  ]

  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>

### Types d'entraînement

Le paramètre `type` définit des valeurs par défaut intelligentes optimisées pour votre cas d'usage :

| Type        | Idéal pour                                      |
| ----------- | ----------------------------------------------- |
| `Style`     | Styles artistiques, esthétiques visuelles       |
| `Character` | Ressemblance personnelle, personnages cohérents |
| `Object`    | Éléments spécifiques, produits                  |
| `Default`   | Entraînement générique                          |

### Paramètres

#### Paramètres requis

<ParamField path="name" type="string" required>
  Un nom descriptif pour votre style personnalisé.

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

<ParamField path="urls" type="array" required>
  Tableau d'URL d'images sur lesquelles s'entraîner. Ajoutez plus d'images pour de meilleurs résultats.
</ParamField>

#### Paramètres optionnels

<ParamField path="model" type="string" default="flux_dev">
  Modèle de base pour l'entraînement :

  **Modèles d'image :**

  * `flux_dev` - Haute qualité, polyvalent
  * `flux_schnell` - Modèle temps réel de BFL
  * `qwen` - Modèle d'Alibaba
  * `z-image` - Modèle d'image efficace d'Alibaba
  * `wan22` - Génération d'images uniquement

  **Modèles vidéo :**

  * `wan` - Modèle vidéo d'Alibaba
</ParamField>

<ParamField path="type" type="string" default="Default">
  Catégorie d'entraînement : `Style`, `Object`, `Character` ou `Default`
</ParamField>

<ParamField path="trigger_word" type="string">
  Mot personnalisé pour activer ce style dans les prompts. Lorsqu'il n'est pas spécifié, utilise le nom du style.

  <Tip>Choisissez des mots déclencheurs uniques qui n'apparaîtront pas dans des prompts typiques. Utilisez des underscores pour les déclencheurs à plusieurs mots : `ukiyo_style`</Tip>
</ParamField>

<Accordion title="Paramètres avancés" icon="sliders">
  <ParamField path="learning_rate" type="number">
    Contrôle l'intensité de l'entraînement. Des valeurs plus élevées entraînent plus vite mais peuvent conduire au surapprentissage.

    **Plage recommandée :** 0,0001 - 0,001
  </ParamField>

  <ParamField path="max_train_steps" type="integer">
    Nombre maximal d'itérations d'entraînement. Plage : 1-2000
  </ParamField>

  <ParamField path="batch_size" type="integer">
    Images traitées simultanément. Des lots plus grands = entraînement plus rapide mais plus de mémoire.
  </ParamField>
</Accordion>

### Ajuster les paramètres avancés

Commencez avec les valeurs par défaut définies par le champ `type` — elles fonctionnent bien dans la plupart des cas. Ne les ajustez que si vous rencontrez des problèmes spécifiques :

<AccordionGroup>
  <Accordion title="Learning Rate" icon="gauge">
    Contrôle l'agressivité avec laquelle le modèle s'adapte à vos images d'entraînement.

    | Valeur                        | Quand l'utiliser                                                        |
    | ----------------------------- | ----------------------------------------------------------------------- |
    | **0,0001** (plus faible)      | Problèmes de surapprentissage, styles complexes, petits jeux de données |
    | **0,0003** (par défaut)       | La plupart des cas d'usage                                              |
    | **0,0005-0,001** (plus élevé) | Entraînement plus rapide                                                |

    **Signes qu'il faut ajuster :**

    * Les résultats sont identiques aux images d'entraînement → réduisez le taux
    * L'influence du style est faible après l'entraînement → augmentez légèrement le taux
  </Accordion>

  <Accordion title="Étapes d'entraînement" icon="shoe-prints">
    Durée pendant laquelle le modèle s'entraîne sur vos images.

    | Taille du jeu de données | Étapes recommandées |
    | ------------------------ | ------------------- |
    | 5-10 images              | 300-500 étapes      |
    | 15-30 images             | 500-800 étapes      |
    | 50+ images               | 800-1500 étapes     |

    **Signes qu'il faut ajuster :**

    * Les résultats sont trop rigides et ignorent les prompts → réduisez les étapes
    * L'influence du style est faible → augmentez les étapes
    * Les images générées ressemblent exactement aux données d'entraînement → réduisez les étapes (surapprentissage)
  </Accordion>
</AccordionGroup>

<Tip>
  **Réglage itératif**

  Si votre première tentative d'entraînement ne produit pas les résultats souhaités :

  1. Commencez par ajuster `max_train_steps` (correction la plus courante)
  2. Puis essayez `learning_rate` si les étapes seules ne suffisent pas
</Tip>

### Format de réponse

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

***

## Suivre la progression de l'entraînement

L'entraînement prend généralement de 5 à 15 minutes. Interrogez l'API Jobs pour vérifier l'état :

<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}
  # Check job status (repeat until completed)
  curl -X GET https://api.krea.ai/jobs/YOUR_JOB_ID \
    -H "Authorization: Bearer YOUR_API_TOKEN"
  ```
</CodeGroup>

<Accordion title="Valeurs d'état des jobs" icon="diagram-project">
  Les jobs d'entraînement passent par ces états :

  1. **queued** - En attente dans la file
  2. **processing** - Entraînement en cours
  3. **completed** - Entraînement terminé avec succès
  4. **failed** - L'entraînement a rencontré une erreur
  5. **cancelled** - Job annulé manuellement
</Accordion>

***

## Utiliser votre style entraîné

Une fois l'entraînement terminé, appliquez votre style à la génération d'images à l'aide du paramètre `styles` :

<Warning>
  **Propriété du style entre l'application et l'API**

  L'API et l'application web Krea fonctionnent comme des identités utilisateur distinctes au sein de votre workspace. Les styles sont privés à l'utilisateur qui les a créés ; ainsi :

  * **Les styles entraînés dans l'application** ne sont pas accessibles via l'API sauf s'ils sont partagés
  * **Les styles entraînés via l'API** ne sont pas accessibles dans l'application sauf s'ils sont partagés

  Pour partager un style avec votre workspace (fonctionne dans les deux sens) :

  ```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}")

  # Poll for completion
  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}
  # Generate with style
  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
        }
      ]
    }'

  # Then poll /jobs/{job_id} for the result
  ```
</CodeGroup>

### Intensité du style

Le paramètre `strength` (0,0-1,0) contrôle avec quelle force votre style est appliqué :

| Intensité | Effet                                                             |
| --------- | ----------------------------------------------------------------- |
| 0,5-0,7   | Influence subtile, préserve la flexibilité du prompt              |
| 0,8-0,9   | Application marquée du style, point de départ recommandé          |
| 0,95-1,0  | Adhérence maximale au style, peut réduire la réactivité au prompt |

<Tip>
  Commencez avec une intensité de `0.8` et ajustez en fonction des résultats. Des valeurs plus faibles offrent plus de liberté créative ; des valeurs plus élevées imposent une adhérence plus stricte au style.
</Tip>

### Combiner plusieurs styles

Appliquez plusieurs styles en les ajoutant au tableau `styles` :

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

***

## Bonnes pratiques

<AccordionGroup>
  <Accordion title="Sélection des images" icon="images">
    * Utilisez autant d'images de haute qualité que possible pour des résultats optimaux
    * Assurez-vous d'un style cohérent sur toutes les images d'entraînement
    * Incluez une variété de sujets tout en maintenant la cohérence stylistique
    * Évitez les filigranes, superpositions de texte ou artefacts
    * Utilisez des images d'au moins 1024x1024 de résolution
  </Accordion>

  <Accordion title="Configuration de l'entraînement" icon="sliders">
    * Commencez avec les paramètres par défaut en utilisant le champ `type`
    * Pour les styles : 500-1000 étapes suffisent généralement
    * Des taux d'apprentissage plus faibles (0,0001-0,0003) préviennent le surapprentissage
    * Augmentez les étapes si le style n'est pas assez marqué
    * Diminuez les étapes si le résultat est trop rigide
  </Accordion>

  <Accordion title="Mots déclencheurs" icon="wand-magic-sparkles">
    * Utilisez le même mot déclencheur si vous prévoyez de combiner plusieurs styles
    * Les mots déclencheurs sont automatiquement injectés dans le prompt lorsque vous incluez le style
    * Évitez les mots courants qui apparaissent dans des prompts typiques
    * Utilisez des underscores pour les déclencheurs à plusieurs mots : `my_custom_style`
  </Accordion>
</AccordionGroup>