# DreamBooth Entraîner Stable Diffusion pour générer des images de sujets spécifiques. {% hint style="success" %} Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace). {% endhint %} ## Location sur CLORE.AI 1. Visitez [CLORE.AI Marketplace](https://clore.ai/marketplace) 2. Filtrer par type de GPU, VRAM et prix 3. Choisir **À la demande** (tarif fixe) ou **Spot** (prix d'enchère) 4. Configurez votre commande : * Sélectionnez l'image Docker * Définissez les ports (TCP pour SSH, HTTP pour les interfaces web) * Ajoutez des variables d'environnement si nécessaire * Entrez la commande de démarrage 5. Sélectionnez le paiement : **CLORE**, **BTC**, ou **USDT/USDC** 6. Créez la commande et attendez le déploiement ### Accédez à votre serveur * Trouvez les détails de connexion dans **Mes commandes** * Interfaces Web : utilisez l'URL du port HTTP * SSH : `ssh -p root@` ## Qu'est-ce que DreamBooth ? DreamBooth affine SD sur vos images : * Entraîner sur 5 à 20 images * Générer de nouvelles images de votre sujet * N'importe quel style ou contexte * Fonctionne avec SD 1.5 et SDXL ## Exigences | Modèle | VRAM | Temps d'entraînement | | ------------- | ----- | -------------------- | | SD 1.5 | 12Go | 15-30 min | | SDXL | 24 Go | 30-60 min | | SD 1.5 + LoRA | 8 Go | 10-20 min | ## Déploiement rapide **Image Docker :** ``` pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel ``` **Ports :** ``` 22/tcp 7860/http ``` **Commande :** ```bash pip install diffusers transformers accelerate bitsandbytes && \ pip install xformers peft && \ python dreambooth_train.py ``` ## Accéder à votre service Après le déploiement, trouvez votre `http_pub` URL dans **Mes commandes**: 1. Aller à la **Mes commandes** page 2. Cliquez sur votre commande 3. Trouvez l' `http_pub` URL (par ex., `abc123.clorecloud.net`) Utilisez `https://VOTRE_HTTP_PUB_URL` au lieu de `localhost` dans les exemples ci-dessous. ## Installation ```bash pip install diffusers transformers accelerate pip install bitsandbytes xformers peft ``` ## Préparer les données d'entraînement 1. Collecter 5 à 20 images de votre sujet 2. Rogner sur le visage/le sujet 3. Redimensionner à 512x512 (ou 1024x1024 pour SDXL) 4. Supprimer les arrière-plans si nécessaire ```python from PIL import Image import os def prepare_images(input_dir, output_dir, size=512): os.makedirs(output_dir, exist_ok=True) for filename in os.listdir(input_dir): if filename.endswith(('.jpg', '.png', '.jpeg')): img = Image.open(os.path.join(input_dir, filename)) img = img.convert('RGB') # Rogner au centre en carré min_dim = min(img.size) left = (img.width - min_dim) // 2 top = (img.height - min_dim) // 2 img = img.crop((left, top, left + min_dim, top + min_dim)) # Redimensionner img = img.resize((size, size), Image.LANCZOS) img.save(os.path.join(output_dir, filename)) prepare_images("./raw_photos", "./training_data") ``` ## DreamBooth avec LoRA (Recommandé) Entraînement économe en mémoire : ```python from diffusers import StableDiffusionPipeline, DDPMScheduler from diffusers.loaders import LoraLoaderMixin import torch # Script d'entraînement from accelerate import Accelerator from diffusers import AutoencoderKL, UNet2DConditionModel from transformers import CLIPTextModel, CLIPTokenizer from peft import LoraConfig, get_peft_model # Charger les modèles model_id = "runwayml/stable-diffusion-v1-5" tokenizer = CLIPTokenizer.from_pretrained(model_id, subfolder="tokenizer") text_encoder = CLIPTextModel.from_pretrained(model_id, subfolder="text_encoder") vae = AutoencoderKL.from_pretrained(model_id, subfolder="vae") unet = UNet2DConditionModel.from_pretrained(model_id, subfolder="unet") # Ajouter LoRA à l'UNet lora_config = LoraConfig( r=8, lora_alpha=32, target_modules=["to_q", "to_k", "to_v", "to_out.0"], lora_dropout=0.1, ) unet = get_peft_model(unet, lora_config) ``` ## Utilisation du script d'entraînement de diffusers ```bash # Cloner les scripts d'entraînement git clone https://github.com/huggingface/diffusers cd diffusers/examples/dreambooth # Installer les dépendances pip install -r requirements.txt # Entraîner avec LoRA accelerate launch train_dreambooth_lora.py \ --pretrained_model_name_or_path="runwayml/stable-diffusion-v1-5" \ --instance_data_dir="./training_data" \ --instance_prompt="a photo of sks person" \ --output_dir="./dreambooth_model" \ --resolution=512 \ --train_batch_size=1 \ --gradient_accumulation_steps=1 \ --learning_rate=1e-4 \ --lr_scheduler="constant" \ --lr_warmup_steps=0 \ --max_train_steps=500 \ --seed=42 ``` ## Paramètres d'entraînement | Paramètre | Recommandé | Effet | | --------------------- | ------------------------- | ------------------------------------------------ | | taux\_d'apprentissage | 1e-4 à 5e-6 | Plus élevé = plus rapide, plus bas = plus stable | | max\_train\_steps | 400-1000 | Plus = meilleur ajustement | | train\_batch\_size | 1-2 | Plus élevé nécessite plus de VRAM | | résolution | 512 (SD1.5) / 1024 (SDXL) | Taille d'entraînement | ## Prompt d'instance Choisissez un identifiant unique : ```bash # Bons prompts "a photo of sks person" # sks = jeton unique "a photo of xyz dog" "a photo of abc car" # Le jeton (sks, xyz, abc) doit être rare ``` ## Avec préservation de la classe Prévenir le surapprentissage : ```bash accelerate launch train_dreambooth_lora.py \ --pretrained_model_name_or_path="runwayml/stable-diffusion-v1-5" \ --instance_data_dir="./my_dog_photos" \ --instance_prompt="a photo of sks dog" \ --class_data_dir="./regular_dog_photos" \ --class_prompt="a photo of dog" \ --with_prior_preservation \ --prior_loss_weight=1.0 \ --num_class_images=200 \ --output_dir="./dreambooth_dog" \ --max_train_steps=800 ``` ## SDXL DreamBooth ```bash accelerate launch train_dreambooth_lora_sdxl.py \ --pretrained_model_name_or_path="stabilityai/stable-diffusion-xl-base-1.0" \ --instance_data_dir="./training_data" \ --instance_prompt="a photo of sks person" \ --output_dir="./dreambooth_sdxl" \ --resolution=1024 \ --train_batch_size=1 \ --gradient_accumulation_steps=4 \ --learning_rate=1e-4 \ --max_train_steps=500 \ --mixed_precision="fp16" ``` ## Utilisation du modèle entraîné ### Charger LoRA ```python from diffusers import StableDiffusionPipeline import torch pipe = StableDiffusionPipeline.from_pretrained( "runwayml/stable-diffusion-v1-5", torch_dtype=torch.float16 ).to("cuda") # Charger votre LoRA entraîné pipe.load_lora_weights("./dreambooth_model") # Générer image = pipe( "a photo of sks person as an astronaut on mars", num_inference_steps=30, guidance_scale=7.5 ).images[0] image.save("astronaut.png") ``` ### Affinage complet ```python pipe = StableDiffusionPipeline.from_pretrained( "./dreambooth_model", torch_dtype=torch.float16 ).to("cuda") image = pipe("a photo of sks person in a suit").images[0] ``` ## Interface Gradio ```python import gradio as gr from diffusers import StableDiffusionPipeline import torch pipe = StableDiffusionPipeline.from_pretrained( "runwayml/stable-diffusion-v1-5", torch_dtype=torch.float16 ).to("cuda") pipe.load_lora_weights("./dreambooth_model") def generate(prompt, negative_prompt, steps, guidance, 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, generator=generator ).images[0] return image demo = gr.Interface( fn=generate, inputs=[ gr.Textbox(label="Prompt (utilisez 'sks' pour votre sujet)"), gr.Textbox(label="Prompt négatif", value="flou, laid"), gr.Slider(20, 50, value=30, step=1, label="Étapes"), gr.Slider(5, 15, value=7.5, step=0.5, label="Guidage"), gr.Number(value=-1, label="Graine") ], outputs=gr.Image(label="Generated Image"), title="Générateur de portraits DreamBooth" ) demo.launch(server_name="0.0.0.0", server_port=7860) ``` ## Conseils d'entraînement ### Pour les personnes * Utiliser des angles variés (face, profil, 3/4) * Différentes conditions d'éclairage * Expressions variées * Photos claires et haute résolution ### Pour les objets * Plusieurs angles * Arrière-plans différents * Éclairage cohérent * Pas d'occlusion ### Pour les styles * 10-20 images d'exemple * Style artistique cohérent * Différents sujets dans ce style ## Dépannage ### Surapprentissage * Réduire max\_train\_steps * Diminuer le taux\_d'apprentissage * Utiliser la préservation du prior * Plus d'images d'entraînement ### Sous-apprentissage * Augmenter max\_train\_steps * Taux\_d'apprentissage plus élevé * Plus d'images d'entraînement * Vérifier la qualité des images ### Style non appris * Augmenter le rang LoRA (r=16 ou 32) * Entraîner plus longtemps * Utiliser plus d'exemples ## Estimation des coûts Tarifs typiques du marché CLORE.AI (à partir de 2024) : | GPU | Tarif horaire | Tarif journalier | Session de 4 heures | | --------- | ------------- | ---------------- | ------------------- | | 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 | *Les prix varient selon le fournisseur et la demande. Vérifiez* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *pour les tarifs actuels.* **Économisez de l'argent :** * Utilisez **Spot** market pour les charges de travail flexibles (souvent 30-50 % moins cher) * Payer avec **CLORE** jetons * Comparer les prix entre différents fournisseurs ## Prochaines étapes * [Entraînement Kohya](https://docs.clore.ai/guides/guides_v2-fr/entrainement/kohya-training) - Entraînement avancé * Stable Diffusion WebUI - Utiliser des modèles * [Affinage LoRA](https://docs.clore.ai/guides/guides_v2-fr/entrainement/kohya-training) - Entraînement LLM