# FLUX.1

{% hint style="info" %}
**Более быстрая альтернатива!** [**FLUX.2 Klein**](https://docs.clore.ai/guides/guides_v2-ru/generaciya-izobrazhenii/flux2-klein) генерирует изображения за < 0,5 секунды (против 10–30 с для FLUX.1) с сопоставимым качеством. Это руководство по-прежнему актуально для обучения LoRA и рабочих процессов ControlNet.
{% endhint %}

Современная модель генерации изображений от Black Forest Labs на GPU CLORE.AI.

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

## Почему FLUX.1?

* **Лучшее качество** - Превосходит SDXL и Midjourney v5
* **Отрисовка текста** - Текст на изображениях действительно читаем
* **Следование подсказке** - Отличное соблюдение инструкций
* **Быстрые варианты** - FLUX.1-schnell для быстрой генерации

## Варианты моделей

| Модель         | Скорость          | Качество | VRAM   | Лицензия      |
| -------------- | ----------------- | -------- | ------ | ------------- |
| FLUX.1-schnell | Быстро (4 шага)   | Отлично  | 12ГБ+  | Apache 2.0    |
| FLUX.1-dev     | Средне (20 шагов) | Отлично  | 16 ГБ+ | Некомерческое |
| FLUX.1-pro     | Только API        | Лучшее   | -      | Коммерческое  |

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

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

```
ghcr.io/huggingface/text-generation-inference:latest
```

**Порты:**

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

Для простейшего развёртывания используйте **ComfyUI с нодами FLUX**.

## Методы установки

### Метод 1: ComfyUI (рекомендуется)

```bash
# Установите ComfyUI
git clone https://github.com/comfyanonymous/ComfyUI
cd ComfyUI
pip install -r requirements.txt

# Скачайте модели FLUX
cd models/unet
wget https://huggingface.co/black-forest-labs/FLUX.1-schnell/resolve/main/flux1-schnell.safetensors

# Скачайте необходимые компоненты
cd ../clip
wget https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/clip_l.safetensors
wget https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/t5xxl_fp16.safetensors

cd ../vae
wget https://huggingface.co/black-forest-labs/FLUX.1-schnell/resolve/main/ae.safetensors

# Запустите ComfyUI
python main.py --listen 0.0.0.0
```

### Метод 2: Diffusers

```bash
pip install diffusers transformers accelerate torch

python << 'PYEOF'
import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    "Кот в скафандре на Марсе",
    num_inference_steps=4,
    guidance_scale=0.0,
).images[0]

image.save("flux_output.png")
PYEOF
```

### Метод 3: Fooocus

Fooocus имеет встроенную поддержку FLUX:

```bash
git clone https://github.com/lllyasviel/Fooocus
cd Fooocus
pip install -r requirements.txt

# Скачайте модель FLUX в models/checkpoints/
python launch.py --listen
```

## Рабочий процесс ComfyUI

### FLUX.1-schnell (Быстрый)

Необходимые ноды:

1. **Load Diffusion Model** → flux1-schnell.safetensors
2. **DualCLIPLoader** → clip\_l.safetensors + t5xxl\_fp16.safetensors
3. **CLIP Text Encode** → ваша подсказка
4. **Empty SD3 Latent Image** → установить размеры
5. **KSampler** → шаги: 4, cfg: 1.0
6. **VAE Decode** → ae.safetensors
7. **Сохранить изображение**

### FLUX.1-dev (Качество)

Та же рабочая схема, но:

* Шаги: 20-50
* CFG: 3.5
* Используйте guidance\_scale в подсказке

## Python API

### Базовая генерация

```python
import torch
from diffusers import FluxPipeline

# Загрузить модель
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.to("cuda")

# Генерация
image = pipe(
    prompt="Спокойный японский сад с цветущей вишней",
    height=1024,
    width=1024,
    num_inference_steps=4,
    guidance_scale=0.0,
).images[0]

image.save("output.png")
```

### С оптимизацией памяти

```python
from diffusers import FluxPipeline
import torch

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)

# Включить оптимизации
pipe.enable_model_cpu_offload()  # Экономит ~10 ГБ видеопамяти
pipe.enable_vae_slicing()
pipe.enable_vae_tiling()

image = pipe(
    "Портрет киберпанк-самурая",
    height=1024,
    width=1024,
    num_inference_steps=4,
).images[0]
```

### Пакетная генерация

```python
prompts = [
    "Закат над горами",
    "Футуристический город ночью",
    "Подводный коралловый риф",
]

images = pipe(
    подсказки,
    height=1024,
    width=1024,
    num_inference_steps=4,
).images

for i, img in enumerate(images):
    img.save(f"output_{i}.png")
```

## FLUX.1-dev (Более высокое качество)

```python
from diffusers import FluxPipeline
import torch

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    prompt="Гиперреалистичный портрет пожилого рыбака",
    height=1024,
    width=1024,
    num_inference_steps=50,
    guidance_scale=3.5,
).images[0]
```

## Советы по промптам

### FLUX отлично справляется с:

* **Текст в изображениях**: "Неоновая вывеска с надписью 'OPEN 24/7'"
* **Сложные сцены**: "Оживлённая улица Токио ночью с отражениями"
* **Конкретные стили**: "Масляная живопись в стиле Моне"
* **Детализированные описания**: Длинные, подробные подсказки работают хорошо

### Примеры подсказок

```
# Фотореалистичное
Профессиональная фотография щенка золотистого ретривера, играющего в осенних листьях, 
мелкая глубина резкости, тёплый послеполуденный свет, Canon EOS R5

# Художественное
Импрессионистская картина парижского кафе под дождём, 
масло на холсте, видимые мазки кисти, тёплые цвета

# Отрисовка текста
Винтажный кинопостер с заголовком "COSMIC VOYAGE" жирными ретро-буквами,
эстетика научной фантастики 1960-х, иллюстрация астронавта

# Сложная сцена
Уютный интерьер библиотеки с книжными полками от пола до потолка, 
кожаное кресло у камина, дождь виден в окне,
тёплый свет лампы, фотореалистично
```

## Оптимизация памяти

### Для 12 ГБ видеопамяти (RTX 3060)

```python
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.float16  # Используйте fp16 вместо bf16
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_slicing()
pipe.enable_vae_tiling()

# Генерировать в более низком разрешении
image = pipe(prompt, height=768, width=768, num_inference_steps=4).images[0]
```

### Для 8ГБ видеопамяти

Используйте квантизированную версию или ComfyUI с GGUF:

```bash
# В ComfyUI установите ноды GGUF
cd custom_nodes
git clone https://github.com/city96/ComfyUI-GGUF

# Скачайте квантизированную модель
wget https://huggingface.co/city96/FLUX.1-schnell-gguf/resolve/main/flux1-schnell-Q4_K_S.gguf
```

## Сравнение производительности

| Модель         | Шаги | Время (4090) | Качество |
| -------------- | ---- | ------------ | -------- |
| FLUX.1-schnell | 4    | \~3 с        | Отлично  |
| FLUX.1-dev     | 20   | \~12 с       | Отлично  |
| FLUX.1-dev     | 50   | \~30 сек     | Лучшее   |
| SDXL           | 30   | \~8 с        | Хорошо   |

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

| Настройка               | Минимум | Рекомендуется |
| ----------------------- | ------- | ------------- |
| FLUX.1-schnell          | 12GB    | 16 ГБ+        |
| FLUX.1-dev              | 16GB    | 24 ГБ+        |
| С выгрузкой на CPU      | 8GB     | 12ГБ+         |
| Квантизированная (GGUF) | 6 ГБ    | 8 ГБ+         |

## Пресеты GPU

### RTX 3060 12 ГБ (Бюджет)

```python
# Используйте квантованную модель
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.float16
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()

# Настройки:
# - только schnell (dev может привести к OOM)
# - 512x512 до 768x768
# - 4 шага
# - Размер батча 1
```

### RTX 3090 24 ГБ (Оптимально)

```python
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_vae_tiling()

# Настройки:
# - schnell: 1024x1024, батч 2
# - dev: 1024x1024, батч 1
# - 20-30 шагов для dev
# - Включите VAE tiling для высокого разрешения
```

### RTX 4090 24 ГБ (Производительность)

```python
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.float16
)
pipe.to("cuda")

# Настройки:
# - schnell: 1024x1024, батч 4
# - dev: 1024x1024, батч 2
# - 30-50 шагов для лучшего качества
# - Можно делать 1536x1536 с тайлингом
```

### A100 40 ГБ/80 ГБ (Производство)

```python
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.to("cuda")

# Настройки:
# - schnell: 1024x1024, батч 8+
# - dev: 1024x1024, батч 4
# - 50 шагов для максимального качества
# - Возможны 2048x2048
```

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

| GPU           | Ежечасно | Изображений/час  |
| ------------- | -------- | ---------------- |
| RTX 3060 12GB | \~$0.03  | \~200 (schnell)  |
| RTX 3090 24GB | \~$0.06  | \~600 (schnell)  |
| RTX 4090 24GB | \~$0.10  | \~1000 (schnell) |
| A100 40GB     | \~$0.17  | \~1500 (schnell) |

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

### Недостаточно памяти

```python
# Используйте выгрузку на CPU
pipe.enable_model_cpu_offload()

# Или последовательную выгрузку на CPU (медленнее, но требует меньше VRAM)
pipe.enable_sequential_cpu_offload()

# Уменьшить разрешение
height=768, width=768
```

### Медленная генерация

* Используйте FLUX.1-schnell (4 шага)
* Включите torch.compile: `pipe.unet = torch.compile(pipe.unet)`
* Используйте fp16 вместо bf16 на старых GPU

### Плохое качество

* Используйте больше шагов (FLUX-dev: 30-50)
* Увеличьте guidance\_scale (3.0-4.0 для dev)
* Пишите более подробные промпты

***

## FLUX LoRA

Весы LoRA (Low-Rank Adaptation) позволяют донастраивать FLUX под конкретные стили, персонажей или концепции без повторного обучения всей модели. Сотни пользовательских LoRA доступны на HuggingFace и CivitAI.

### Установка

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

### Загрузка одного LoRA

```python
import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# Загрузите веса LoRA из локального файла
pipe.load_lora_weights("path/to/lora.safetensors")

image = pipe(
    "Портрет в стиле Ван Гога, завихряющиеся мазки кисти",
    num_inference_steps=20,
    guidance_scale=3.5,
    generator=torch.Generator(device="cuda").manual_seed(42),
).images[0]
image.save("flux_lora_output.png")
```

### Загрузка с HuggingFace Hub

```python
import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# Загрузите LoRA прямо из репозитория HuggingFace
pipe.load_lora_weights(
    "username/my-flux-lora",          # ID репозитория HF
    weight_name="my_lora.safetensors" # имя файла в репозитории
)

image = pipe(
    "trigger_word красивый пейзаж",
    num_inference_steps=20,
    guidance_scale=3.5,
).images[0]
image.save("output.png")
```

### Масштаб LoRA (Сила)

```python
# Контролируйте влияние LoRA с помощью cross_attention_kwargs
image = pipe(
    "Киберпанк-персонаж, неоновые огни",
    num_inference_steps=20,
    guidance_scale=3.5,
    cross_attention_kwargs={"scale": 0.8},  # 0.0 = без эффекта, 1.0 = полный эффект
).images[0]
```

### Комбинация нескольких LoRA

```python
from diffusers import FluxPipeline
import torch

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# Загрузите первую LoRA
pipe.load_lora_weights(
    "path/to/style_lora.safetensors",
    adapter_name="style"
)

# Загрузите вторую LoRA
pipe.load_lora_weights(
    "path/to/character_lora.safetensors",
    adapter_name="character"
)

# Объедините с весами
pipe.set_adapters(["style", "character"], adapter_weights=[0.7, 0.9])

image = pipe(
    "character_trigger в роскошном костюме, artistic_trigger стиль",
    num_inference_steps=25,
    guidance_scale=3.5,
).images[0]
image.save("combined_lora.png")
```

### Выгрузка LoRA

```python
# Удалите веса LoRA, чтобы восстановить базовую модель
pipe.unload_lora_weights()
```

### Обучение собственной FLUX LoRA

```bash
# Используйте kohya-ss или ai-toolkit для обучения FLUX LoRA
git clone https://github.com/ostris/ai-toolkit
cd ai-toolkit
pip install -r requirements.txt

# Подготовьте датасет: 10-30 изображений с подписями
# Отредактируйте конфигурационный YAML, затем:
python run.py config/flux_lora_train.yaml
```

### Рекомендуемые источники LoRA

| Источник    | URL                   | Примечания                    |
| ----------- | --------------------- | ----------------------------- |
| CivitAI     | civitai.com           | Большая библиотека сообщества |
| HuggingFace | huggingface.co/models | Фильтровать по FLUX           |
| Replicate   | replicate.com         | Просмотр обученных моделей    |

***

## ControlNet для FLUX

ControlNet позволяет направлять генерацию FLUX с помощью структурных входов, таких как границы по Canny, карты глубины и скелеты позы. XLabs-AI выпустила первые модели ControlNet специально для FLUX.1.

### Установка

```bash
pip install diffusers transformers accelerate controlnet-aux pillow
```

### FLUX ControlNet Canny (XLabs-AI)

```python
import torch
import numpy as np
from PIL import Image
from diffusers import FluxControlNetPipeline, FluxControlNetModel
from diffusers.utils import load_image
from controlnet_aux import CannyDetector

# Загрузите модель FLUX ControlNet (вариант Canny)
controlnet = FluxControlNetModel.from_pretrained(
    "XLabs-AI/flux-controlnet-canny-diffusers",
    torch_dtype=torch.bfloat16
)

# Загрузите пайплайн с ControlNet
pipe = FluxControlNetPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    controlnet=controlnet,
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# Подготовьте контрольное изображение (границы Canny)
input_image = load_image("your_input.jpg").resize((1024, 1024))
canny = CannyDetector()
control_image = canny(input_image, low_threshold=50, high_threshold=200)

# Генерация с руководством ControlNet
image = pipe(
    prompt="Футуристический городской пейзаж с неоновыми вывесками, фотореалистично, 8K",
    control_image=control_image,
    controlnet_conditioning_scale=0.7,
    num_inference_steps=25,
    guidance_scale=3.5,
    generator=torch.Generator(device="cuda").manual_seed(0),
).images[0]

image.save("controlnet_flux_output.png")
```

### FLUX ControlNet Depth

```python
import torch
from PIL import Image
from diffusers import FluxControlNetPipeline, FluxControlNetModel
from diffusers.utils import load_image
from transformers import pipeline as hf_pipeline

# Загрузите оценщик глубины
depth_estimator = hf_pipeline("depth-estimation", model="LiheYoung/depth-anything-small-hf")

# Подготовьте карту глубины
input_image = load_image("portrait.jpg").resize((1024, 1024))
depth_result = depth_estimator(input_image)["depth"]
depth_image = depth_result.convert("RGB")

# Загрузите ControlNet Depth
controlnet = FluxControlNetModel.from_pretrained(
    "XLabs-AI/flux-controlnet-depth-diffusers",
    torch_dtype=torch.bfloat16
)

pipe = FluxControlNetPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    controlnet=controlnet,
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    prompt="Мраморная статуя воина, драматическое освещение, музейное фото",
    control_image=depth_image,
    controlnet_conditioning_scale=0.6,
    num_inference_steps=20,
    guidance_scale=3.5,
).images[0]
image.save("depth_controlnet_output.png")
```

### Мульти-ControlNet для FLUX

```python
import torch
from diffusers import FluxControlNetPipeline, FluxMultiControlNetModel, FluxControlNetModel
from diffusers.utils import load_image
from controlnet_aux import CannyDetector

# Загрузить несколько ControlNet
controlnet_canny = FluxControlNetModel.from_pretrained(
    "XLabs-AI/flux-controlnet-canny-diffusers",
    torch_dtype=torch.bfloat16
)
controlnet_depth = FluxControlNetModel.from_pretrained(
    "XLabs-AI/flux-controlnet-depth-diffusers",
    torch_dtype=torch.bfloat16
)

# Объедините в MultiControlNet
multi_controlnet = FluxMultiControlNetModel([controlnet_canny, controlnet_depth])

pipe = FluxControlNetPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    controlnet=multi_controlnet,
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    prompt="Рыцарь в доспехах стоит в лесу, драматическое освещение",
    control_image=[canny_image, depth_image],
    controlnet_conditioning_scale=[0.7, 0.5],
    num_inference_steps=25,
    guidance_scale=3.5,
).images[0]
```

### Доступные модели FLUX ControlNet

| Модель             | Репозиторий                                 | Случай использования          |
| ------------------ | ------------------------------------------- | ----------------------------- |
| Canny              | XLabs-AI/flux-controlnet-canny-diffusers    | Генерация с опорой на границы |
| Depth              | XLabs-AI/flux-controlnet-depth-diffusers    | Генерация с опорой на глубину |
| HED/Мягкие границы | XLabs-AI/flux-controlnet-hed-diffusers      | Мягкое структурное управление |
| Pose               | XLabs-AI/flux-controlnet-openpose-diffusers | Портреты с управлением позой  |

### Советы по ControlNet

* **conditioning\_scale 0.5–0.8** лучше всего для FLUX (слишком высокое значение теряет креативность)
* Используйте **1024×1024** или кратные для лучшего качества
* Комбинируйте с LoRA для контроля стиля + структуры
* Меньше шагов (20–25) обычно достаточно с ControlNet

***

## FLUX.1-schnell: Режим быстрой генерации

FLUX.1-schnell — это дистиллированный, оптимизированный по скорости вариант FLUX. Он генерирует высококачественные изображения всего за **4 шага** (против 20–50 для FLUX.1-dev), что делает его идеальным для быстрого прототипирования и рабочих процессов с высокой пропускной способностью.

### Ключевые отличия от FLUX.1-dev

| Функция         | FLUX.1-schnell                                             | FLUX.1-dev    |
| --------------- | ---------------------------------------------------------- | ------------- |
| Шаги            | 4                                                          | 20–50         |
| Скорость (4090) | \~3 с                                                      | \~12–30 с     |
| Лицензия        | **Apache 2.0** (бесплатно для коммерческого использования) | Некомерческое |
| guidance\_scale | 0.0 (без CFG)                                              | 3.5           |
| Качество        | Отлично                                                    | Отлично       |
| VRAM            | 12ГБ+                                                      | 16 ГБ+        |

> **Примечание по лицензии:** FLUX.1-schnell распространяется по Apache 2.0 — вы можете свободно использовать его в коммерческих продуктах. FLUX.1-dev требует отдельной коммерческой лицензии от Black Forest Labs.

### Быстрый старт

```python
import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    prompt="Потрясающий вид Нью-Йорка с воздуха в золотой час, фотореалистично",
    height=1024,
    width=1024,
    num_inference_steps=4,   # Нужны всего 4 шага!
    guidance_scale=0.0,       # CFG отключён для schnell
    max_sequence_length=256,
    generator=torch.Generator(device="cpu").manual_seed(0),
).images[0]

image.save("schnell_output.png")
print("Сгенерировано примерно за 3 секунды на RTX 4090!")
```

### Высокопроизводительная пакетная генерация

```python
import torch
from diffusers import FluxPipeline
from pathlib import Path

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.to("cuda")  # Держите на GPU для скорости, не используйте cpu_offload

output_dir = Path("schnell_outputs")
output_dir.mkdir(exist_ok=True)

prompts = [
    "Спокойное горное озеро на рассвете, туманная атмосфера",
    "Оживлённый токийский уличный рынок ночью, неоновые отражения",
    "Макрофотография росной паутины",
    "Древняя библиотека с плавающими книгами и магическим светом",
    "Футуристический подводный город с биолюминесцентной морской жизнью",
]

# Пакетная генерация
for i, prompt in enumerate(prompts):
    image = pipe(
        prompt=prompt,
        height=1024,
        width=1024,
        num_inference_steps=4,
        guidance_scale=0.0,
        generator=torch.Generator(device="cuda").manual_seed(i),
    ).images[0]
    image.save(output_dir / f"image_{i:04d}.png")
    print(f"Сгенерировано {i+1}/{len(prompts)}: {prompt[:50]}...")
```

### Несколько соотношений сторон с schnell

```python
import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# FLUX поддерживает гибкие соотношения сторон
resolutions = {
    "square":    (1024, 1024),
    "portrait":  (768,  1360),
    "landscape": (1360, 768),
    "tall":      (576,  1792),
    "wide":      (1792, 576),
}

prompt = "Величественный волк в заснеженном лесу, профессиональная фотография дикой природы"

for name, (width, height) in resolutions.items():
    image = pipe(
        prompt=prompt,
        height=height,
        width=width,
        num_inference_steps=4,
        guidance_scale=0.0,
    ).images[0]
    image.save(f"schnell_{name}.png")
    print(f"Сохранено {name}: {width}x{height}")
```

### schnell с оптимизациями памяти

```python
import torch
from diffusers import FluxPipeline

# Для 12 ГБ VRAM (RTX 3060/3080)
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.float16  # fp16 экономит память на старых GPU
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_slicing()
pipe.enable_vae_tiling()

image = pipe(
    prompt="Уютная хижина в осеннем лесу, тёплый свет через окна",
    height=768,
    width=768,
    num_inference_steps=4,
    guidance_scale=0.0,
).images[0]
image.save("schnell_low_vram.png")
```

### Бенчмарки производительности (schnell)

| GPU           | VRAM  | Время/изображение (1024px) | Изображений/час |
| ------------- | ----- | -------------------------- | --------------- |
| RTX 3060 12GB | 12GB  | \~8 с                      | \~450           |
| RTX 3090 24GB | 24 ГБ | \~4 с                      | \~900           |
| RTX 4090 24GB | 24 ГБ | \~3 с                      | \~1200          |
| A100 40GB     | 40GB  | \~2 с                      | \~1800          |

### Когда использовать schnell или dev

**Используйте FLUX.1-schnell, когда:**

* Быстрое прототипирование / тестирование подсказок
* Пакетная генерация большого объёма
* Коммерческие проекты (Apache 2.0)
* Ограниченный бюджет GPU
* Приложения в реальном времени или близкие к реальному времени

**Используйте FLUX.1-dev, когда:**

* Приоритет — максимальное качество изображения
* Тонкие детали и сложные сцены
* Исследования / художественные работы
* Комбинация с LoRA/ControlNet (dev обычно лучше реагирует)

***

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

* [ComfyUI](https://docs.clore.ai/guides/guides_v2-ru/generaciya-izobrazhenii/comfyui) - Лучший интерфейс для FLUX
* [Fooocus](https://docs.clore.ai/guides/guides_v2-ru/generaciya-izobrazhenii/fooocus-simple-sd) - Простая альтернатива
* [ControlNet](https://docs.clore.ai/guides/guides_v2-ru/obrabotka-izobrazhenii/controlnet-advanced) - Управляемая генерация
* [Обучение Kohya](https://docs.clore.ai/guides/guides_v2-ru/obuchenie/kohya-training) - Обучайте FLUX LoRA