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

# Entrenar un estilo personalizado

> Entrena estilos de imagen personalizados con tus propios datasets y genera resultados consistentes con guía sobre curaduría, etiquetado y buenas prácticas de iteración.

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="Entrenar un estilo personalizado (LoRA)" description="Entrena un estilo personalizado usando tus propias imágenes para generar arte con IA con estéticas visuales consistentes." />

## Descripción general

LoRA (Low-Rank Adaptation) es una técnica de ajuste fino que enseña a un modelo de IA un nuevo estilo visual usando un pequeño conjunto de imágenes de ejemplo. Funciona inyectando nuevos “pesos de estilo” en un modelo existente, lo que hace que el entrenamiento sea rápido y eficiente.

Esta guía recorre el flujo completo:

<Steps>
  <Step title="Prepara las imágenes de entrenamiento" icon="images">
    Cura y sube imágenes de alta calidad que representen el estilo deseado
  </Step>

  <Step title="Envía el trabajo de entrenamiento" icon="play">
    Envía una solicitud POST a `/styles/train` con tus URLs de imágenes y la configuración
  </Step>

  <Step title="Monitorea el progreso" icon="clock">
    Sigue el estado del trabajo con el `job_id` devuelto
  </Step>

  <Step title="Genera con tu estilo" icon="sparkles">
    Aplica tu estilo entrenado a la generación de imágenes
  </Step>
</Steps>

***

## Prepara las imágenes de entrenamiento

### Curar tu dataset

La calidad de tus imágenes de entrenamiento impacta directamente en los resultados. Los distintos tipos de entrenamiento tienen requisitos diferentes:

| Tipo          | Caso de uso                                 | Consejos                                  |
| ------------- | ------------------------------------------- | ----------------------------------------- |
| **Style**     | Estilos artísticos, estéticas visuales      | Estilo consistente en sujetos variados    |
| **Character** | Semejanza personal, personajes consistentes | Poses, expresiones e iluminación variadas |
| **Object**    | Elementos u objetos específicos             | Múltiples ángulos, objeto consistente     |

### ¿Cuántas imágenes?

La calidad importa mucho más que la cantidad. Un pequeño conjunto de imágenes excelentes superará a un conjunto grande de imágenes mediocres.

| Tamaño del dataset | Guía                                                               |
| ------------------ | ------------------------------------------------------------------ |
| **5 imágenes**     | Mínimo viable. Puede funcionar para estilos simples y consistentes |
| **10-30 imágenes** | Recomendado. Mejor balance entre calidad y cobertura               |
| **50+ imágenes**   | Rendimientos decrecientes salvo que el estilo tenga alta variación |

<Warning>
  **Calidad > Cantidad**

  15 imágenes de alta calidad producirán mejores resultados que 50 de baja calidad. Prioriza:

  * Alta resolución (1024x1024 mínimo)
  * Estilo consistente en todas las imágenes
  * Sin marcas de agua, textos superpuestos o artefactos de compresión
  * Sujetos variados manteniendo la coherencia de estilo
</Warning>

<Info>
  **Datasets de ejemplo**

  * **Entrenamiento de personaje**: fotos de una persona con poses, expresiones y condiciones de iluminación variadas. Evita incluir otras personas en las imágenes.
  * **Entrenamiento de estilo**: una colección de obras de arte con un estilo consistente. Por ejemplo, [The Metropolitan Museum of Art Ukiyo-E Dataset](https://www.kaggle.com/datasets/kengoichiki/the-metropolitan-museum-of-art-ukiyoe-dataset) ofrece grabados japoneses en madera ideales para entrenar un estilo artístico.
</Info>

### Sube las imágenes

Antes de entrenar, sube tus imágenes para obtener URLs alojadas. Usa el endpoint `/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>
  Guarda los valores `image_url` devueltos — los pasarás al endpoint de entrenamiento.
</Tip>

***

## Entrena tu estilo

### Ejemplo básico de entrenamiento

Envía las URLs de tus imágenes para iniciar el entrenamiento:

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

### Tipos de entrenamiento

El parámetro `type` establece valores predeterminados inteligentes optimizados para tu caso de uso:

| Tipo        | Ideal para                                  |
| ----------- | ------------------------------------------- |
| `Style`     | Estilos artísticos, estéticas visuales      |
| `Character` | Semejanza personal, personajes consistentes |
| `Object`    | Elementos o productos específicos           |
| `Default`   | Entrenamiento genérico                      |

### Parámetros

#### Parámetros obligatorios

<ParamField path="name" type="string" required>
  Un nombre descriptivo para tu estilo personalizado.

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

<ParamField path="urls" type="array" required>
  Arreglo de URLs de imágenes con las que entrenar. Incluye más imágenes para mejores resultados.
</ParamField>

#### Parámetros opcionales

<ParamField path="model" type="string" default="flux_dev">
  Modelo base para entrenamiento:

  **Modelos de imagen:**

  * `flux_dev` - Alta calidad, versátil
  * `flux_schnell` - El modelo en tiempo real de BFL
  * `qwen` - El modelo de Alibaba
  * `z-image` - El modelo de imagen eficiente de Alibaba
  * `wan22` - Solo generación de imagen

  **Modelos de video:**

  * `wan` - El modelo de video de Alibaba
</ParamField>

<ParamField path="type" type="string" default="Default">
  Categoría de entrenamiento: `Style`, `Object`, `Character` o `Default`
</ParamField>

<ParamField path="trigger_word" type="string">
  Palabra personalizada para activar este estilo en los prompts. Si no se especifica, se usa el nombre del estilo.

  <Tip>Elige palabras de activación únicas que no aparezcan en prompts típicos. Usa guiones bajos para triggers de varias palabras: `ukiyo_style`</Tip>
</ParamField>

<Accordion title="Parámetros avanzados" icon="sliders">
  <ParamField path="learning_rate" type="number">
    Controla la intensidad del entrenamiento. Valores más altos entrenan más rápido pero pueden sobreajustar.

    **Rango recomendado:** 0.0001 - 0.001
  </ParamField>

  <ParamField path="max_train_steps" type="integer">
    Máximo de iteraciones de entrenamiento. Rango: 1-2000
  </ParamField>

  <ParamField path="batch_size" type="integer">
    Imágenes procesadas simultáneamente. Lotes más grandes = entrenamiento más rápido pero más memoria.
  </ParamField>
</Accordion>

### Ajustar parámetros avanzados

Comienza con los valores por defecto que establece el campo `type` — funcionan bien en la mayoría de los casos. Solo ajústalos si observas problemas específicos:

<AccordionGroup>
  <Accordion title="Tasa de aprendizaje" icon="gauge">
    Controla con qué agresividad el modelo se adapta a tus imágenes de entrenamiento.

    | Valor                    | Cuándo usarlo                                                  |
    | ------------------------ | -------------------------------------------------------------- |
    | **0.0001** (menor)       | Problemas de sobreajuste, estilos complejos, datasets pequeños |
    | **0.0003** (por defecto) | La mayoría de los casos                                        |
    | **0.0005-0.001** (mayor) | Entrenamiento más rápido                                       |

    **Señales de que necesitas ajustar:**

    * Las salidas se ven idénticas a las imágenes de entrenamiento → baja la tasa
    * La influencia del estilo es débil tras el entrenamiento → sube la tasa ligeramente
  </Accordion>

  <Accordion title="Pasos de entrenamiento" icon="shoe-prints">
    Cuánto tiempo entrena el modelo con tus imágenes.

    | Tamaño del dataset | Pasos recomendados |
    | ------------------ | ------------------ |
    | 5-10 imágenes      | 300-500 pasos      |
    | 15-30 imágenes     | 500-800 pasos      |
    | 50+ imágenes       | 800-1500 pasos     |

    **Señales de que necesitas ajustar:**

    * Las salidas son demasiado rígidas e ignoran los prompts → reduce los pasos
    * La influencia del estilo es débil → aumenta los pasos
    * Las imágenes generadas se ven exactamente como los datos de entrenamiento → reduce los pasos (sobreajuste)
  </Accordion>
</AccordionGroup>

<Tip>
  **Ajuste iterativo**

  Si tu primer intento de entrenamiento no produce los resultados que quieres:

  1. Comienza ajustando `max_train_steps` (la solución más común)
  2. Luego prueba `learning_rate` si los pasos solos no bastan
</Tip>

### Formato de respuesta

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

***

## Monitorea el progreso del entrenamiento

El entrenamiento suele tardar de 5 a 15 minutos. Consulta la API de Jobs para verificar el estado:

<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="Valores del estado del trabajo" icon="diagram-project">
  Los trabajos de entrenamiento pasan por estos estados:

  1. **queued** - En espera en la cola
  2. **processing** - Entrenamiento activo
  3. **completed** - Entrenamiento finalizado con éxito
  4. **failed** - El entrenamiento encontró un error
  5. **cancelled** - Trabajo cancelado manualmente
</Accordion>

***

## Usa tu estilo entrenado

Una vez completado el entrenamiento, aplica tu estilo a la generación de imágenes usando el parámetro `styles`:

<Warning>
  **Propiedad del estilo entre la app y la API**

  La API y la webapp de Krea operan como identidades de usuario distintas dentro de tu espacio de trabajo. Los estilos son privados del usuario que los creó, así que:

  * **Los estilos entrenados en la app** no son accesibles desde la API a menos que se compartan
  * **Los estilos entrenados desde la API** no son accesibles en la app a menos que se compartan

  Para compartir un estilo con tu espacio de trabajo (funciona en ambos sentidos):

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

### Intensidad del estilo

El parámetro `strength` (0.0-1.0) controla con qué fuerza se aplica tu estilo:

| Intensidad | Efecto                                                       |
| ---------- | ------------------------------------------------------------ |
| 0.5-0.7    | Influencia sutil, mantiene la flexibilidad del prompt        |
| 0.8-0.9    | Aplicación fuerte del estilo, punto de partida recomendado   |
| 0.95-1.0   | Máximo apego al estilo, puede reducir la respuesta al prompt |

<Tip>
  Comienza con `0.8` y ajusta según los resultados. Valores más bajos dan más libertad creativa; valores más altos imponen un apego más estricto al estilo.
</Tip>

### Combinar múltiples estilos

Aplica varios estilos agregándolos al arreglo `styles`:

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

***

## Buenas prácticas

<AccordionGroup>
  <Accordion title="Selección de imágenes" icon="images">
    * Usa tantas imágenes de alta calidad como tengas para obtener resultados óptimos
    * Asegura un estilo consistente en todas las imágenes de entrenamiento
    * Incluye variedad de sujetos manteniendo la coherencia de estilo
    * Evita marcas de agua, textos superpuestos o artefactos
    * Usa imágenes de al menos 1024x1024 de resolución
  </Accordion>

  <Accordion title="Configuración del entrenamiento" icon="sliders">
    * Comienza con los parámetros por defecto usando el campo `type`
    * Para estilos: 500-1000 pasos suelen ser suficientes
    * Tasas de aprendizaje más bajas (0.0001-0.0003) previenen el sobreajuste
    * Aumenta los pasos si el estilo no es lo suficientemente fuerte
    * Reduce los pasos si la salida es demasiado rígida
  </Accordion>

  <Accordion title="Palabras de activación" icon="wand-magic-sparkles">
    * Usa la misma palabra de activación si planeas combinar varios estilos
    * Las palabras de activación se inyectan automáticamente en el prompt si incluyes el estilo
    * Evita palabras comunes que aparezcan en prompts típicos
    * Usa guiones bajos para triggers de varias palabras: `my_custom_style`
  </Accordion>
</AccordionGroup>