# FLUX.1

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

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

{% hint style="success" %}
Все примеры можно запускать на GPU-серверах, арендованных через [маркетплейс CLORE.AI](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. **Save Image**

### 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 ГБ VRAM
pipe.enable_vae_slicing()
pipe.enable_vae_tiling()

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

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

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

images = pipe(
    prompts,
    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 ГБ VRAM (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 ГБ VRAM

Используйте квантизированную версию или 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          | 12 ГБ   | 16 ГБ+        |
| FLUX.1-dev              | 16 ГБ   | 24 ГБ+        |
| С выгрузкой на CPU      | 8 ГБ    | 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 может не поместиться в память)
# - 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, batch 2
# - dev: 1024x1024, batch 1
# - 20-30 шагов для dev
# - включите тайлинг VAE для высокого разрешения
```

### [RTX 4090 24 ГБ](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=flux) (Производительность)

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

# Настройки:
# - schnell: 1024x1024, batch 4
# - dev: 1024x1024, batch 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, batch 8+
# - dev: 1024x1024, batch 4
# - 50 шагов для максимального качества
# - возможно 2048x2048
```

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

| GPU            | В час   | Изображений/час  |
| -------------- | ------- | ---------------- |
| RTX 3060 12 ГБ | \~$0.03 | \~200 (schnell)  |
| RTX 3090 24 ГБ | \~$0.06 | \~600 (schnell)  |
| RTX 4090 24 ГБ | \~$0.10 | \~1000 (schnell) |
| A100 40 ГБ     | \~$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 style",
    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
# Для обучения FLUX LoRA используйте kohya-ss или ai-toolkit
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")
```

### Multi-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      | Мягкий структурный контроль |
| Поза              | 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  | Время/изображение (1024 px) | Изображений/час |
| -------------- | ----- | --------------------------- | --------------- |
| RTX 3060 12 ГБ | 12 ГБ | \~8 сек                     | \~450           |
| RTX 3090 24 ГБ | 24 ГБ | \~4 сек                     | \~900           |
| RTX 4090 24 ГБ | 24 ГБ | \~3 сек                     | \~1200          |
| A100 40 ГБ     | 40 ГБ | \~2 сек                     | \~1800          |

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

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

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

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

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

***

## Следующие шаги

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


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-ru/generaciya-izobrazhenii/flux.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.