FLUX.1

Запустите генерацию изображений FLUX.1 от Black Forest Labs на Clore.ai

Более быстрая альтернатива! FLUX.2 Klein генерирует изображения менее чем за 0,5 секунды (против 10–30 с у FLUX.1) при сопоставимом качестве. Это руководство по-прежнему актуально для обучения LoRA и рабочих процессов ControlNet.

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

Все примеры можно запускать на GPU-серверах, арендованных через маркетплейс CLORE.AI.

Почему 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 (рекомендуется)

# Установить 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

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:

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

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

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

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

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]

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

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 (Более высокое качество)

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)

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:

# В 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 ГБ (бюджетный)

# Используйте квантизированную модель
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 ГБ (оптимальный)

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 ГБ (Производительность)

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 ГБ (производство)

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)

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

Нехватка памяти

# Используйте выгрузку на 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.

Установка

pip install diffusers transformers accelerate peft

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

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

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 (сила)

# Управляйте влиянием 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

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

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

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

# Для обучения 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.

Установка

pip install diffusers transformers accelerate controlnet-aux pillow

FLUX ControlNet Canny (XLabs-AI)

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

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

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.

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

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!")

Пакетная генерация с высокой пропускной способностью

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

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 с оптимизацией памяти

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 - Лучший интерфейс для FLUX

• Fooocus - Простой вариант

• ControlNet - Управляемая генерация

• Обучение Kohya - Обучение LoRA для FLUX