# DreamBooth

Обучите Stable Diffusion генерировать изображения конкретных объектов.

{% hint style="success" %}
Все примеры можно запускать на GPU-серверах, арендуемых через [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Аренда на CLORE.AI

1. Посетите [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Отфильтруйте по типу GPU, объему VRAM и цене
3. Выберите **On-Demand** (фиксированная ставка) или **Spot** (цена по ставке)
4. Настройте ваш заказ:
   * Выберите Docker-образ
   * Установите порты (TCP для SSH, HTTP для веб-интерфейсов)
   * Добавьте переменные окружения при необходимости
   * Введите команду запуска
5. Выберите способ оплаты: **CLORE**, **BTC**, или **USDT/USDC**
6. Создайте заказ и дождитесь развертывания

### Доступ к вашему серверу

* Найдите данные для подключения в **Моих заказах**
* Веб-интерфейсы: используйте URL HTTP-порта
* SSH: `ssh -p <port> root@<proxy-address>`

## Что такое DreamBooth?

DreamBooth дообучает SD на ваших изображениях:

* Обучение на 5-20 изображениях
* Генерация новых изображений вашего объекта
* Любой стиль или контекст
* Работает с SD 1.5 и SDXL

## Требования

| Модель        | VRAM  | Время обучения |
| ------------- | ----- | -------------- |
| SD 1.5        | 12GB  | 15–30 мин      |
| SDXL          | 24 ГБ | 30–60 мин      |
| SD 1.5 + LoRA | 8GB   | 10–20 мин      |

## Быстрое развертывание

**Docker-образ:**

```
pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel
```

**Порты:**

```
22/tcp
7860/http
```

**Команда:**

```bash
pip install diffusers transformers accelerate bitsandbytes && \
pip install xformers peft && \
python dreambooth_train.py
```

## Доступ к вашему сервису

После развертывания найдите ваш `http_pub` URL в **Моих заказах**:

1. Перейдите на **Моих заказах** страницу
2. Нажмите на ваш заказ
3. Найдите `http_pub` URL (например, `abc123.clorecloud.net`)

Используйте `https://YOUR_HTTP_PUB_URL` вместо `localhost` в примерах ниже.

## Установка

```bash
pip install diffusers transformers accelerate
pip install bitsandbytes xformers peft
```

## Подготовка данных для обучения

1. Соберите 5-20 изображений вашего объекта
2. Обрезать до лица/объекта
3. Изменить размер до 512x512 (или 1024x1024 для SDXL)
4. Удалить фон при необходимости

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

            # Центрированная обрезка до квадрата
            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))

            # Изменение размера
            img = img.resize((size, size), Image.LANCZOS)
            img.save(os.path.join(output_dir, filename))

prepare_images("./raw_photos", "./training_data")
```

## DreamBooth с LoRA (Рекомендуется)

Память-эффективное обучение:

```python
from diffusers import StableDiffusionPipeline, DDPMScheduler
from diffusers.loaders import LoraLoaderMixin
import torch

# Скрипт обучения
from accelerate import Accelerator
from diffusers import AutoencoderKL, UNet2DConditionModel
from transformers import CLIPTextModel, CLIPTokenizer
from peft import LoraConfig, get_peft_model

# Загрузка моделей
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")

# Добавить LoRA в 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)
```

## Использование тренировочного скрипта diffusers

```bash

# Клонировать скрипты для обучения
git clone https://github.com/huggingface/diffusers
cd diffusers/examples/dreambooth

# Установить зависимости
pip install -r requirements.txt

# Обучение с 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
```

## Параметры обучения

| Параметр           | Рекомендуется             | Эффект                                |
| ------------------ | ------------------------- | ------------------------------------- |
| learning\_rate     | от 1e-4 до 5e-6           | Больше = быстрее, меньше = стабильнее |
| max\_train\_steps  | 400-1000                  | Больше = лучше подгонка               |
| train\_batch\_size | 1-2                       | Больше требует больше видеопамяти     |
| resolution         | 512 (SD1.5) / 1024 (SDXL) | Размер обучения                       |

## Instance Prompt

Выберите уникальный идентификатор:

```bash

# Хорошие промпты
"a photo of sks person"      # sks = уникальный токен
"a photo of xyz dog"
"a photo of abc car"

# Токен (sks, xyz, abc) должен быть редким
```

## С сохранением класса

Предотвратить переобучение:

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

## Использование обученной модели

### Загрузить LoRA

```python
from diffusers import StableDiffusionPipeline
import torch

pipe = StableDiffusionPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    torch_dtype=torch.float16
).to("cuda")

# Загрузите ваш обученный LoRA
pipe.load_lora_weights("./dreambooth_model")

# Генерация
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")
```

### Полное дообучение

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

## Интерфейс 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 (используйте 'sks' для вашего объекта)"),
        gr.Textbox(label="Negative Prompt", value="размытое, некрасивое"),
        gr.Slider(20, 50, value=30, step=1, label="Шаги"),
        gr.Slider(5, 15, value=7.5, step=0.5, label="Guidance"),
        gr.Number(value=-1, label="Seed")
    ],
    outputs=gr.Image(label="Generated Image"),
    title="Генератор портретов DreamBooth"
)

demo.launch(server_name="0.0.0.0", server_port=7860)
```

## Советы по обучению

### Для людей

* Используйте разные углы (фронт, бок, 3/4)
* Разные условия освещения
* Различные выражения лиц
* Чистые, высококачественные фотографии

### Для объектов

* Несколько ракурсов
* Разные фоны
* Последовательное освещение
* Без перекрытий

### Для стилей

* 10-20 примеров изображений
* Последовательный художественный стиль
* Различные объекты в этом стиле

## Устранение неполадок

### Переобучение

* Уменьшить max\_train\_steps
* Понизить learning\_rate
* Использовать сохранение приоритета (prior preservation)
* Больше обучающих изображений

### Недообучение

* Увеличить max\_train\_steps
* Увеличить learning\_rate
* Больше обучающих изображений
* Проверить качество изображений

### Стиль не выучен

* Увеличить ранг LoRA (r=16 или 32)
* Обучать дольше
* Использовать больше примеров

## Оценка стоимости

Типичные ставки на маркетплейсе CLORE.AI (по состоянию на 2024):

| GPU       | Почасовая ставка | Дневная ставка | Сессия 4 часа |
| --------- | ---------------- | -------------- | ------------- |
| 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       |

*Цены варьируются в зависимости от провайдера и спроса. Проверьте* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *для текущих тарифов.*

**Экономьте деньги:**

* Используйте **Spot** рынок для гибких рабочих нагрузок (часто на 30–50% дешевле)
* Платите с помощью **CLORE** токенов
* Сравнивайте цены у разных провайдеров

## Дальнейшие шаги

* [Обучение Kohya](https://docs.clore.ai/guides/guides_v2-ru/obuchenie/kohya-training) - Продвинутое обучение
* Stable Diffusion WebUI - Использовать модели
* [Тонкая настройка LoRA](https://docs.clore.ai/guides/guides_v2-ru/obuchenie/kohya-training) - Обучение LLM