Skip to main content

Panoramica

LoRA (Low-Rank Adaptation) è una tecnica di fine-tuning che insegna a un modello di IA un nuovo stile visivo utilizzando un piccolo insieme di immagini di esempio. Funziona iniettando nuovi “style weights” in un modello esistente, rendendo l’addestramento veloce ed efficiente. Questa guida illustra il flusso completo:

Prepara le immagini di addestramento

Cura e carica immagini di alta qualità che rappresentino lo stile desiderato

Invia il job di addestramento

Invia una richiesta POST a /styles/train con gli URL delle tue immagini e la configurazione

Monitora i progressi

Traccia lo stato del tuo job di addestramento tramite il job_id restituito

Genera con il tuo stile

Applica lo stile addestrato alla generazione di immagini

Prepara le immagini di addestramento

Curare il tuo dataset

La qualità delle immagini di addestramento influisce direttamente sui risultati. Tipi di addestramento diversi hanno requisiti diversi:
TipoCaso d’usoSuggerimenti
StyleStili artistici, estetiche visiveStile coerente su soggetti vari
CharacterSomiglianza personale, personaggi coerentiPose, espressioni, illuminazione variate
ObjectOggetti specifici, prodottiPiù angolazioni, oggetto coerente

Quante immagini?

La qualità conta molto più della quantità. Un piccolo insieme di immagini eccellenti supererà un ampio insieme di immagini mediocri.
Dimensione del datasetIndicazioni
5 immaginiMinimo praticabile. Può funzionare per stili semplici e coerenti
10-30 immaginiConsigliato. Miglior equilibrio tra qualità e copertura
50+ immaginiRitorni decrescenti a meno che lo stile non abbia grande variazione
Qualità > Quantità15 immagini di alta qualità produrranno risultati migliori di 50 di bassa qualità. Dai priorità a:
  • Alta risoluzione (minimo 1024x1024)
  • Stile coerente in tutte le immagini
  • Nessun watermark, sovrapposizione di testo o artefatti di compressione
  • Soggetti variati mantenendo coerenza stilistica
Dataset di esempio
  • Addestramento di personaggi: foto di una persona con pose, espressioni e condizioni di illuminazione variate. Evita di includere altre persone nelle immagini.
  • Addestramento di stile: una collezione di opere d’arte in uno stile coerente. Ad esempio, The Metropolitan Museum of Art Ukiyo-E Dataset fornisce stampe xilografiche giapponesi ideali per addestrare uno stile artistico.

Carica le immagini

Prima dell’addestramento, carica le tue immagini per ottenere URL ospitati. Usa l’endpoint /assets:
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")
Salva i valori image_url restituiti — li passerai all’endpoint di addestramento.

Addestra il tuo stile

Esempio di addestramento base

Invia gli URL delle tue immagini per iniziare l’addestramento:
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']}")

Tipi di addestramento

Il parametro type imposta valori predefiniti intelligenti ottimizzati per il tuo caso d’uso:
TipoIdeale per
StyleStili artistici, estetiche visive
CharacterSomiglianza personale, personaggi coerenti
ObjectOggetti specifici, prodotti
DefaultAddestramento generico

Parametri

Parametri obbligatori

name
string
required
Un nome descrittivo per il tuo stile personalizzato.Esempio: "Ukiyo-E Style", "Product Photos"
urls
array
required
Array di URL di immagini su cui addestrare. Includi più immagini per risultati migliori.

Parametri opzionali

model
string
default:"flux_dev"
Modello di base per l’addestramento:Modelli di immagini:
  • flux_dev - Alta qualità, versatile
  • flux_schnell - Modello realtime di BFL
  • qwen - Modello di Alibaba
  • z-image - Modello di immagini efficiente di Alibaba
  • wan22 - Solo generazione di immagini
Modelli video:
  • wan - Modello video di Alibaba
type
string
default:"Default"
Categoria di addestramento: Style, Object, Character o Default
trigger_word
string
Parola personalizzata per attivare questo stile nei prompt. Se non specificata, viene utilizzato il nome dello stile.
Scegli trigger word uniche che non compaiano nei prompt tipici. Usa underscore per trigger di più parole: ukiyo_style
learning_rate
number
Controlla l’intensità dell’addestramento. Valori più alti addestrano più velocemente ma possono causare overfitting.Intervallo consigliato: 0.0001 - 0.001
max_train_steps
integer
Iterazioni massime di addestramento. Intervallo: 1-2000
batch_size
integer
Immagini elaborate simultaneamente. Batch più grandi = addestramento più veloce ma più memoria.

Ottimizzare i parametri avanzati

Inizia con i valori predefiniti impostati dal campo type: funzionano bene per la maggior parte dei casi. Modificali solo se noti problemi specifici:
Controlla con quanta aggressività il modello si adatta alle tue immagini di addestramento.
ValoreQuando usarlo
0.0001 (più basso)Problemi di overfitting, stili complessi, dataset piccoli
0.0003 (predefinito)La maggior parte dei casi d’uso
0.0005-0.001 (più alto)Addestramento più rapido
Segnali che indicano di regolare:
  • Gli output sembrano identici alle immagini di addestramento → abbassa il valore
  • L’influenza dello stile è debole dopo l’addestramento → aumenta leggermente il valore
Per quanto tempo il modello viene addestrato sulle tue immagini.
Dimensione del datasetStep consigliati
5-10 immagini300-500 step
15-30 immagini500-800 step
50+ immagini800-1500 step
Segnali che indicano di regolare:
  • Gli output sono troppo rigidi, ignorano i prompt → riduci gli step
  • L’influenza dello stile è debole → aumenta gli step
  • Le immagini generate somigliano esattamente ai dati di addestramento → riduci gli step (overfitting)
Ottimizzazione iterativaSe il primo tentativo di addestramento non produce i risultati desiderati:
  1. Inizia regolando max_train_steps (la correzione più comune)
  2. Poi prova learning_rate se gli step da soli non aiutano

Formato della risposta

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

Monitora i progressi dell’addestramento

L’addestramento richiede tipicamente 5-15 minuti. Effettua polling sull’API Jobs per verificare lo stato:
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)
I job di addestramento attraversano questi stati:
  1. queued - In attesa in coda
  2. processing - Addestramento attivo
  3. completed - Addestramento terminato con successo
  4. failed - L’addestramento ha riscontrato un errore
  5. cancelled - Job cancellato manualmente

Usa il tuo stile addestrato

Una volta completato l’addestramento, applica il tuo stile alla generazione di immagini usando il parametro styles:
Proprietà degli stili tra app e APIL’API e la web app di Krea operano come identità utente separate all’interno del tuo workspace. Gli stili sono privati per l’utente che li ha creati, quindi:
  • Gli stili addestrati dall’app non sono accessibili tramite l’API a meno che non vengano condivisi
  • Gli stili addestrati dall’API non sono accessibili nell’app a meno che non vengano condivisi
Per condividere uno stile con il tuo workspace (funziona in entrambe le direzioni):
curl -X POST https://api.krea.ai/styles/YOUR_STYLE_ID/share/workspace \
  -H "Authorization: Bearer YOUR_API_TOKEN"
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)

Intensità dello stile

Il parametro strength (0.0-1.0) controlla quanto fortemente viene applicato il tuo stile:
IntensitàEffetto
0.5-0.7Influenza sottile, mantiene flessibilità del prompt
0.8-0.9Applicazione forte dello stile, punto di partenza consigliato
0.95-1.0Massima aderenza allo stile, può ridurre la reattività al prompt
Inizia con un’intensità di 0.8 e regola in base ai risultati. Valori più bassi offrono maggiore libertà creativa; valori più alti impongono un’aderenza più stretta allo stile.

Combinare più stili

Applica più stili aggiungendoli all’array styles:
"styles": [
    {"id": "style-id-1", "strength": 0.6},
    {"id": "style-id-2", "strength": 0.4}
]

Buone pratiche

  • Usa quante più immagini di alta qualità hai per risultati ottimali
  • Assicura uno stile coerente in tutte le immagini di addestramento
  • Includi varietà nei soggetti mantenendo coerenza stilistica
  • Evita watermark, sovrapposizioni di testo o artefatti
  • Usa immagini di almeno 1024x1024 di risoluzione
  • Inizia con i parametri predefiniti usando il campo type
  • Per gli stili: 500-1000 step sono di solito sufficienti
  • Learning rate più bassi (0.0001-0.0003) prevengono l’overfitting
  • Aumenta gli step se lo stile non è abbastanza forte
  • Riduci gli step se l’output è troppo rigido
  • Usa la stessa trigger word se prevedi di combinare più stili
  • Le trigger word vengono iniettate automaticamente nel prompt se includi lo stile
  • Evita parole comuni che compaiono nei prompt tipici
  • Usa underscore per trigger di più parole: my_custom_style