FLUX.1

在 Clore.ai 上运行 Black Forest Labs 的 FLUX.1 图像生成

更快的替代方案！ FLUX.2 Klein 在 < 0.5 秒内生成图像（相比 FLUX.1 的 10–30 秒），且质量相当。此指南仍适用于 LoRA 训练和 ControlNet 工作流。

来自 Black Forest Labs 的最先进图像生成模型，在 CLORE.AI GPU 上运行。

所有示例都可以在通过以下方式租用的 GPU 服务器上运行： CLORE.AI 市场.

为什么选择 FLUX.1？

• 最佳质量 - 优于 SDXL 和 Midjourney v5

• 文本呈现 - 图像中实际可读的文本

• 提示遵循能力 - 优秀的指令遵从性

• 快速变体 - 用于快速生成的 FLUX.1-schnell

1024x1024

A100	性能	质量	显存	许可
FLUX.1-schnell	快速（4 步）	很棒	12GB+	Apache 2.0
FLUX.1-dev	中等（20 步）	优秀	16GB+	非商业
FLUX.1-pro	仅 API	最佳	-	商业

在 CLORE.AI 上快速部署

Docker 镜像：

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

端口：

22/tcp
7860/http

为最简便部署，请使用 带有 FLUX 节点的 ComfyUI.

安装方法

方法 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

IC-Light 可作为 ComfyUI 节点使用：

FLUX.1-schnell（快速）

所需节点：

1. 加载扩散模型（Load Diffusion Model） → flux1-schnell.safetensors

2. DualCLIPLoader → clip_l.safetensors + t5xxl_fp16.safetensors

3. CLIP 文本编码 → 你的提示（prompt）

4. 空的 SD3 潜在图像（Empty SD3 Latent Image） → 设置尺寸

5. KSampler → steps: 4, cfg: 1.0

6. VAE 解码 → ae.safetensors

7. 保存图像

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()  # 节约约 10GB 显存
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 年代科幻美学，宇航员插画

# 复杂场景
一个舒适的图书馆内部，落地书架, 
壁炉旁的一把皮椅，窗外可见下雨,
温暖的灯光，写实摄影

内存优化

针对 12GB 显存（RTX 3060）

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.float16  # 在旧 GPU 上使用 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]

适用于 8GB 显存

使用量化版本或在 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

性能比较

A100	步数	时间（4090）	质量
FLUX.1-schnell	4	~3 秒	很棒
FLUX.1-dev	20	≈12 秒	优秀
FLUX.1-dev	50	~30 秒	最佳
SDXL	30	≈8 秒	良好

GPU 要求

设置	最低	推荐
FLUX.1-schnell	12GB	16GB+
FLUX.1-dev	16GB	24GB+
启用 CPU 卸载时	8GB	12GB+
量化（GGUF）	6GB	8GB+

GPU 预设

RTX 3060 12GB（入门）

# 使用量化模型
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 24GB（理想）

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
# - dev 使用 20-30 步
# - 为高分辨率启用 VAE 平铺（tiling）

RTX 4090 24GB（性能）

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 40GB/80GB（生产）

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）
按日费率	~$0.17	~1500（schnell）

# 使用固定种子以获得一致结果

内存不足

# 使用 CPU 卸载
pipe.enable_model_cpu_offload()

# 或顺序 CPU 卸载（更慢但显存占用更少）
pipe.enable_sequential_cpu_offload()

# 降低分辨率
height=768, width=768

生成速度慢

• 使用 FLUX.1-schnell（4 步）

• 启用 torch.compile： pipe.unet = torch.compile(pipe.unet)

• 在较旧 GPU 上使用 fp16 而不是 bf16

质量差

• 使用更多步数（FLUX-dev：30-50）

• 增加 guidance_scale（dev 建议 3.0-4.0）

• 编写更详细的提示词

---

FLUX LoRA

LoRA（低秩适配）权重允许你在不重新训练整个模型的情况下微调 FLUX 以获得特定风格、角色或概念。HuggingFace 和 CivitAI 上有成百上千个社区 LoRA 可用。

安装

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

# 直接从 HuggingFace 仓库加载 LoRA
pipe.load_lora_weights(
    "username/my-flux-lora",          # HF 仓库 ID
    weight_name="my_lora.safetensors" # 仓库中的文件名
)

image = pipe(
    "触发词 一个美丽的风景",
    num_inference_steps=20,
    guidance_scale=3.5,
).images[0]
image.save("output.png")

LoRA 比例（强度）

# 使用 cross_attention_kwargs 控制 LoRA 影响
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 风格",
    num_inference_steps=25,
    guidance_scale=3.5,
).images[0]
image.save("combined_lora.png")

卸载 LoRA

# 移除 LoRA 权重以恢复基础模型
pipe.unload_lora_weights()

训练你自己的 FLUX LoRA

# 使用 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	浏览已训练的模型

---

FLUX 的 ControlNet

ControlNet 允许使用结构性输入（如 canny 边缘、深度图和姿态骨架）来引导 FLUX 的生成。XLabs-AI 已发布首批专为 FLUX.1 设计的 ControlNet 模型。

安装

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 加载管线（pipeline）
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")

FLUX 的多 ControlNet（Multi-ControlNet）

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 模型

A100	仓库（Repo）	模型变体
Canny（边缘）	XLabs-AI/flux-controlnet-canny-diffusers	基于边缘的引导生成
深度	XLabs-AI/flux-controlnet-depth-diffusers	基于深度的引导生成
HED/软边（Soft Edge）	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 步 （相比 FLUX.1-dev 的 20–50 步），使其非常适合快速原型和高吞吐工作流。

与 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
质量	很棒	优秀
显存	12GB+	16GB+

许可说明： 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,       # schnell 禁用 CFG
    max_sequence_length=256,
    generator=torch.Generator(device="cpu").manual_seed(0),
).images[0]

image.save("schnell_output.png")
print("在 RTX 4090 上约 3 秒生成完成！")

高吞吐批量生成

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(
        os.makedirs("./variations", exist_ok=True)
        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 = {
    "方形":    (1024, 1024),
    "肖像":  (768,  1360),
    "横向": (1360, 768),
    "高长":      (576,  1792),
    "宽幅":      (1792, 576),
}

prompt = "一只雄伟的狼在雪林中，专业野生动物摄影"

for name, (width, height) in resolutions.items():
    image = pipe(
        os.makedirs("./variations", exist_ok=True)
        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

# 针对 12GB 显存（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	显存	每张图像时间（1024px）	图像/小时
RTX 3060 12GB	12GB	≈8 秒	~450
RTX 3090 24GB	24GB	~4 秒	~900
RTX 4090 24GB	24GB	~3 秒	~1200
按日费率	40GB	~2 秒	~1800

何时使用 schnell 与 dev

在以下情况下使用 FLUX.1-schnell：

• 快速原型 / 测试提示

• 大批量生成

• 商业项目（Apache 2.0）

• 有限的 GPU 预算

• 实时或近实时应用

在以下情况下使用 FLUX.1-dev：

• 当最高图像质量是优先项

• 精细细节和复杂场景

• 研究 / 艺术工作

• 与 LoRA/ControlNet 结合（dev 通常响应更好）

---

使用以下方式支付

• ComfyUI - 最佳的 FLUX 界面

• - 将重光图像转换为 3D - 简单的替代方案

• ControlNet - 引导式生成

• Kohya 训练 - 训练 FLUX LoRAs