Diffusers documentation

Flux

Diffusers

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.42.1).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Flux

Flux는 diffusion transformer 기반의 텍스트-이미지 생성 모델 시리즈입니다. Flux에 대해 더 자세히 알고 싶으시다면, Flux의 개발사인 Black Forest Labs의 원본 블로그 포스트를 확인해 보세요.

Flux의 원래 모델 체크포인트는 여기에서 찾을 수 있습니다. 원래 추론 코드는 여기에서 찾을 수 있습니다.

Flux는 소비자용 하드웨어에서 실행할 때 비용이 상당히 높을 수 있습니다. 그러나 일련의 최적화를 수행하여 더 빠르고 메모리에 부담이 적은 방식으로 실행할 수 있습니다. 자세한 내용은 이 섹션을 확인하세요. 또한, Flux는 추론 지연 시간의 트레이드오프를 감수하고 메모리 효율성을 위해 양자화를 활용할 수 있습니다. 더 자세한 내용은 이 블로그 게시물을 참고하세요. 포괄적인 리소스 목록은 이 gist에서 확인하세요.

Caching은 중간 결과를 저장하고 재사용하여 추론 속도를 높이는 데에도 도움이 될 수 있습니다.

Flux는 다음 변형으로 제공됩니다:

모델 유형	모델 ID
Timestep-distilled	`black-forest-labs/FLUX.1-schnell`
가이던스 증류	`black-forest-labs/FLUX.1-dev`
Fill Inpainting/Outpainting (Guidance-distilled)	`black-forest-labs/FLUX.1-Fill-dev`
Canny Control (Guidance-distilled)	`black-forest-labs/FLUX.1-Canny-dev`
깊이 제어(Guidance-distilled)	`black-forest-labs/FLUX.1-Depth-dev`
Canny Control (LoRA)	`black-forest-labs/FLUX.1-Canny-dev-lora`
깊이 제어(LoRA)	`black-forest-labs/FLUX.1-Depth-dev-lora`
Redux(어댑터)	`black-forest-labs/FLUX.1-Redux-dev`
Kontext	`black-forest-labs/FLUX.1-kontext`

모든 체크포인트는 용도가 다르며, 아래에서 자세히 설명합니다.

Timestep-distilled

max_sequence_length은 256을 초과할 수 없습니다.
guidance_scale은 0이어야 합니다.
이 모델은 timestep-distilled 모델이므로, 더 적은 샘플링 단계에서 이점을 얻습니다.

import torch
from diffusers import FluxPipeline

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

prompt = "A cat holding a sign that says hello world"
out = pipe(
    prompt=prompt,
    guidance_scale=0.,
    height=768,
    width=1360,
    num_inference_steps=4,
    max_sequence_length=256,
).images[0]
out.save("image.png")

가이던스 증류

가이던스 증류 변형은 고품질 생성을 위해 약 50개의 샘플링 단계가 필요합니다.
max_sequence_length에 대한 제한이 없습니다.

import torch
from diffusers import FluxPipeline

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

prompt = "a tiny astronaut hatching from an egg on the moon"
out = pipe(
    prompt=prompt,
    guidance_scale=3.5,
    height=768,
    width=1360,
    num_inference_steps=50,
).images[0]
out.save("image.png")

Fill Inpainting/Outpainting

Flux Fill 파이프라인은 일반적인 inpainting 파이프라인과 달리 strength를 입력으로 요구하지 않습니다.
인페인팅과 아웃페인팅을 모두 지원합니다.

import torch
from diffusers import FluxFillPipeline
from diffusers.utils import load_image

image = load_image("https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/cup.png")
mask = load_image("https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/cup_mask.png")

repo_id = "black-forest-labs/FLUX.1-Fill-dev"
pipe = FluxFillPipeline.from_pretrained(repo_id, dtype=torch.bfloat16).to("cuda")  # or "mps", "xpu", "cpu"

image = pipe(
    prompt="a white paper cup",
    image=image,
    mask_image=mask,
    height=1632,
    width=1232,
    max_sequence_length=512,
    generator=torch.Generator("cpu").manual_seed(0)
).images[0]
image.save(f"output.png")

Canny Control

참고: black-forest-labs/Flux.1-Canny-dev은 ControlNetModel 모델이 아닙니다. ControlNet 모델은 UNet/Transformer와 별개의 구성 요소로, 잔차가 실제 기반 모델에 추가됩니다. Canny Control은 입력 제어 조건과 채널별 연결을 사용하고, 조건을 최대한 밀접하게 따르도록 transformer가 구조 제어를 학습하도록 보장함으로써 ControlNet 모델과 실질적으로 동일한 결과를 달성하는 대안 아키텍처입니다.

# !pip install -U controlnet-aux
import torch
from controlnet_aux import CannyDetector
from diffusers import FluxControlPipeline
from diffusers.utils import load_image

pipe = FluxControlPipeline.from_pretrained("black-forest-labs/FLUX.1-Canny-dev", dtype=torch.bfloat16).to("cuda")  # or "mps", "xpu", "cpu"

prompt = "A robot made of exotic candies and chocolates of different kinds. The background is filled with confetti and celebratory gifts."
control_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png")

processor = CannyDetector()
control_image = processor(control_image, low_threshold=50, high_threshold=200, detect_resolution=1024, image_resolution=1024)

image = pipe(
    prompt=prompt,
    control_image=control_image,
    height=1024,
    width=1024,
    num_inference_steps=50,
    guidance_scale=30.0,
).images[0]
image.save("output.png")

LoRA 변형을 사용하여 Canny Control도 가능합니다. 사용 방법은 다음과 같습니다:

# !pip install -U controlnet-aux
import torch
from controlnet_aux import CannyDetector
from diffusers import FluxControlPipeline
from diffusers.utils import load_image

pipe = FluxControlPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", dtype=torch.bfloat16).to("cuda")  # or "mps", "xpu", "cpu"
pipe.load_lora_weights("black-forest-labs/FLUX.1-Canny-dev-lora")

prompt = "A robot made of exotic candies and chocolates of different kinds. The background is filled with confetti and celebratory gifts."
control_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png")

processor = CannyDetector()
control_image = processor(control_image, low_threshold=50, high_threshold=200, detect_resolution=1024, image_resolution=1024)

image = pipe(
    prompt=prompt,
    control_image=control_image,
    height=1024,
    width=1024,
    num_inference_steps=50,
    guidance_scale=30.0,
).images[0]
image.save("output.png")

깊이 제어

참고: black-forest-labs/Flux.1-Depth-dev은 ControlNet 모델이 아닙니다. ControlNetModel 모델은 실제 기반 모델에 잔차가 추가되는 UNet/Transformer와 별개의 구성 요소입니다. Depth Control은 입력 제어 조건과 채널별 연결을 사용하고, 조건을 최대한 밀접하게 따르도록 transformer가 구조 제어를 학습하도록 보장함으로써 ControlNet 모델과 실질적으로 동일한 결과를 달성하는 대안 아키텍처입니다.

# !pip install git+https://github.com/huggingface/image_gen_aux
import torch
from diffusers import FluxControlPipeline, FluxTransformer2DModel
from diffusers.utils import load_image
from image_gen_aux import DepthPreprocessor

pipe = FluxControlPipeline.from_pretrained("black-forest-labs/FLUX.1-Depth-dev", dtype=torch.bfloat16).to("cuda")  # or "mps", "xpu", "cpu"

prompt = "A robot made of exotic candies and chocolates of different kinds. The background is filled with confetti and celebratory gifts."
control_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png")

processor = DepthPreprocessor.from_pretrained("LiheYoung/depth-anything-large-hf")
control_image = processor(control_image)[0].convert("RGB")

image = pipe(
    prompt=prompt,
    control_image=control_image,
    height=1024,
    width=1024,
    num_inference_steps=30,
    guidance_scale=10.0,
    generator=torch.Generator().manual_seed(42),
).images[0]
image.save("output.png")

Depth Control은 이 조건의 LoRA 변형으로도 가능합니다. 사용 방법은 다음과 같습니다:

# !pip install git+https://github.com/huggingface/image_gen_aux
import torch
from diffusers import FluxControlPipeline, FluxTransformer2DModel
from diffusers.utils import load_image
from image_gen_aux import DepthPreprocessor

pipe = FluxControlPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", dtype=torch.bfloat16).to("cuda")  # or "mps", "xpu", "cpu"
pipe.load_lora_weights("black-forest-labs/FLUX.1-Depth-dev-lora")

prompt = "A robot made of exotic candies and chocolates of different kinds. The background is filled with confetti and celebratory gifts."
control_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png")

processor = DepthPreprocessor.from_pretrained("LiheYoung/depth-anything-large-hf")
control_image = processor(control_image)[0].convert("RGB")

image = pipe(
    prompt=prompt,
    control_image=control_image,
    height=1024,
    width=1024,
    num_inference_steps=30,
    guidance_scale=10.0,
    generator=torch.Generator().manual_seed(42),
).images[0]
image.save("output.png")

Redux

Flux Redux 파이프라인은 FLUX.1 기반 모델용 어댑터입니다. 이미지-투-이미지 생성을 위해 flux-dev와 flux-schnell 모두와 함께 사용할 수 있습니다.
FluxPriorReduxPipeline를 먼저 사용하여 prompt_embeds와 pooled_prompt_embeds를 얻은 후, 이를 FluxPipeline에 전달하여 이미지-이미지 생성을 수행할 수 있습니다.
FluxPriorReduxPipeline를 기본 파이프라인과 함께 사용할 경우, VRAM을 절약하기 위해 기본 파이프라인에서 text_encoder=None과 text_encoder_2=None을 설정할 수 있습니다.

import torch
from diffusers import FluxPriorReduxPipeline, FluxPipeline
from diffusers.utils import load_image
device = "cuda"  # or "mps", "xpu", "cpu"
dtype = torch.bfloat16


repo_redux = "black-forest-labs/FLUX.1-Redux-dev"
repo_base = "black-forest-labs/FLUX.1-dev" 
pipe_prior_redux = FluxPriorReduxPipeline.from_pretrained(repo_redux, dtype=dtype).to(device)
pipe = FluxPipeline.from_pretrained(
    repo_base, 
    text_encoder=None,
    text_encoder_2=None,
    dtype=torch.bfloat16
).to(device)

image = load_image("https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/style_ziggy/img5.png")
pipe_prior_output = pipe_prior_redux(image)
images = pipe(
    guidance_scale=2.5,
    num_inference_steps=50,
    generator=torch.Generator("cpu").manual_seed(0),
    **pipe_prior_output,
).images
images[0].save("flux-redux.png")

Kontext

Flux Kontext는 이미지 생성 과정에 대한 인-컨텍스트(in-context) 제어를 가능하게 하는 모델로, 편집, 정제, 재조명, 스타일 전이, 캐릭터 커스터마이징 등을 수행할 수 있습니다.

import torch
from diffusers import FluxKontextPipeline
from diffusers.utils import load_image

pipe = FluxKontextPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-Kontext-dev", dtype=torch.bfloat16
)
pipe.to("cuda")  # or "mps", "xpu", "cpu"

image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/yarn-art-pikachu.png").convert("RGB")
prompt = "Make Pikachu hold a sign that says 'Black Forest Labs is awesome', yarn art style, detailed, vibrant colors"
image = pipe(
    image=image,
    prompt=prompt,
    guidance_scale=2.5,
    generator=torch.Generator().manual_seed(42),
).images[0]
image.save("flux-kontext.png")

Flux Kontext에는 무결성 안전성 검사기가 포함되어 있으며, 이미지 생성 단계 이후에 실행해야 합니다. 안전성 검사기를 실행하려면 black-forest-labs/flux 공식 저장소를 설치하고 다음 코드를 추가하세요:

from flux.content_filters import PixtralContentFilter

# ... pipeline invocation to generate images

integrity_checker = PixtralContentFilter(torch.device("cuda"))
image_ = np.array(image) / 255.0
image_ = 2 * image_ - 1
image_ = torch.from_numpy(image_).to("cuda", dtype=torch.float32).unsqueeze(0).permute(0, 3, 1, 2)
if integrity_checker.test_image(image_):
    raise ValueError("Your image has been flagged. Choose another prompt/image or try again.")

Kontext Inpainting

FluxKontextInpaintPipeline은 고정된 마스크 영역 내에서 이미지 수정을 지원합니다. 현재 텍스트 기반 조건부 생성과 이미지 참조 기반 조건부 생성을 모두 지원합니다.

텍스트 전용

이미지 조건

Flux Turbo LoRA와 Flux Control, Fill, Redux를 결합하기

Flux Turbo LoRA를 Flux Control 및 Fill, Redux와 같은 다른 파이프라인과 결합하여 몇 단계의 추론을 활성화할 수 있습니다. 아래 예제는 깊이(depth)용 Flux Control LoRA와 ByteDance/Hyper-SD의 turbo LoRA에 대해 이를 수행하는 방법을 보여줍니다.

from diffusers import FluxControlPipeline
from image_gen_aux import DepthPreprocessor
from diffusers.utils import load_image
from huggingface_hub import hf_hub_download
import torch

control_pipe = FluxControlPipeline.from_pretrained("black-forest-labs/FLUX.1-dev", dtype=torch.bfloat16)
control_pipe.load_lora_weights("black-forest-labs/FLUX.1-Depth-dev-lora", adapter_name="depth")
control_pipe.load_lora_weights(
    hf_hub_download("ByteDance/Hyper-SD", "Hyper-FLUX.1-dev-8steps-lora.safetensors"), adapter_name="hyper-sd"
)
control_pipe.set_adapters(["depth", "hyper-sd"], adapter_weights=[0.85, 0.125])
control_pipe.enable_model_cpu_offload()

prompt = "A robot made of exotic candies and chocolates of different kinds. The background is filled with confetti and celebratory gifts."
control_image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/robot.png")

processor = DepthPreprocessor.from_pretrained("LiheYoung/depth-anything-large-hf")
control_image = processor(control_image)[0].convert("RGB")

image = control_pipe(
    prompt=prompt,
    control_image=control_image,
    height=1024,
    width=1024,
    num_inference_steps=8,
    guidance_scale=10.0,
    generator=torch.Generator().manual_seed(42),
).images[0]
image.save("output.png")

Flux LoRA를 사용할 때 unload_lora_weights()에 대한 참고

When unloading the Control LoRA weights, call pipe.unload_lora_weights(reset_to_overwritten_params=True) to reset the pipe.transformer completely back to its original form. The resultant pipeline can then be used with methods like DiffusionPipeline.from_pipe(). More details about this argument are available in this PR.

IP-Adapter

IP-Adapter의 작동 원리를 자세히 알아보려면 IP-Adapter를 확인하세요.

IP-Adapter를 사용하면 텍스트 프롬프트 외에도 이미지로 Flux를 프롬프트할 수 있습니다. 이는 텍스트만으로 설명하기 어려운 복잡한 개념을 설명해야 하고 참조 이미지가 있는 경우 특히 유용합니다.

import torch
from diffusers import FluxPipeline
from diffusers.utils import load_image

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev", dtype=torch.bfloat16
).to("cuda")  # or "mps", "xpu", "cpu"

image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/flux_ip_adapter_input.jpg").resize((1024, 1024))

pipe.load_ip_adapter(
    "XLabs-AI/flux-ip-adapter",
    weight_name="ip_adapter.safetensors",
    image_encoder_pretrained_model_name_or_path="openai/clip-vit-large-patch14"
)
pipe.set_ip_adapter_scale(1.0)

image = pipe(
    width=1024,
    height=1024,
    prompt="wearing sunglasses",
    negative_prompt="",
    true_cfg_scale=4.0,
    generator=torch.Generator().manual_seed(4444),
    ip_adapter_image=image,
).images[0]

image.save('flux_ip_adapter_output.jpg')

프롬프트 "wearing sunglasses"를 사용한 IP-Adapter 예시

최적화

Flux는 매우 큰 모델로, 모든 모델링 구성 요소를 로드하는 데 약 50GB의 RAM/VRAM이 필요합니다. 메모리 요구 사항을 낮추려면 아래 최적화 중 일부를 활성화하세요.

그룹 오프로딩

Group offloading은 모델 전체나 가중치가 아닌 내부 레이어 그룹을 오프로딩하여 VRAM 사용량을 줄입니다. 파이프라인의 모든 모델 구성 요소에 apply_group_offloading()을 사용해야 합니다. offload_type 매개변수를 사용하면 블록 수준과 리프 수준 오프로딩을 전환할 수 있습니다. leaf_level로 설정하면 모듈 수준에서 오프로딩하는 대신 가장 낮은 리프 수준의 매개변수를 CPU로 오프로딩합니다.

비동기 데이터 스트리밍을 지원하는 CUDA 장치에서 use_stream=True를 설정하면 데이터 전송과 계산을 오버랩하여 추론을 가속화할 수 있습니다.

파이프라인의 서로 다른 구성 요소에 대해 블록 수준과 리프 수준의 오프로딩을 혼합하는 것이 가능합니다.

import torch
from diffusers import FluxPipeline
from diffusers.hooks import apply_group_offloading

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

apply_group_offloading(
    pipe.transformer,
    offload_type="leaf_level",
    offload_device=torch.device("cpu"),
    onload_device=torch.device("cuda"),
    use_stream=True,
)
apply_group_offloading(
    pipe.text_encoder, 
    offload_device=torch.device("cpu"),
    onload_device=torch.device("cuda"),
    offload_type="leaf_level",
    use_stream=True,
)
apply_group_offloading(
    pipe.text_encoder_2, 
    offload_device=torch.device("cpu"),
    onload_device=torch.device("cuda"),
    offload_type="leaf_level",
    use_stream=True,
)
apply_group_offloading(
    pipe.vae, 
    offload_device=torch.device("cpu"),
    onload_device=torch.device("cuda"),
    offload_type="leaf_level",
    use_stream=True,
)

prompt="A cat wearing sunglasses and working as a lifeguard at pool."

generator = torch.Generator().manual_seed(181201)
image = pipe(
    prompt,
    width=576,
    height=1024,
    num_inference_steps=30,
    generator=generator
).images[0]
image

FP16 추론 실행

Flux는 FP16으로 고품질 이미지를 생성할 수 있습니다(즉, Turing/Volta GPU에서 추론을 가속하기 위해). 하지만 FP32/BF16과 비교할 때 다른 출력을 생성합니다. 이 문제는 텍스트 인코더의 일부 활성화 값이 FP16으로 실행될 때 클리핑되어야 하며, 이로 인해 전체 이미지에 영향을 미치기 때문입니다. 따라서 텍스트 인코더를 FP32 추론으로 강제 실행하면 이러한 출력 차이를 제거할 수 있습니다. 자세한 내용은 여기를 참조하세요.

FP16 추론 코드:

import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", dtype=torch.bfloat16) # can replace schnell with dev
# to run on low vram GPUs (i.e. between 4 and 32 GB VRAM)
pipe.enable_sequential_cpu_offload()
pipe.vae.enable_slicing()
pipe.vae.enable_tiling()

pipe.to(torch.float16) # casting here instead of in the pipeline constructor because doing so in the constructor loads all models into CPU memory at once

prompt = "A cat holding a sign that says hello world"
out = pipe(
    prompt=prompt,
    guidance_scale=0.,
    height=768,
    width=1360,
    num_inference_steps=4,
    max_sequence_length=256,
).images[0]
out.save("image.png")

양자화

Quantization은 모델 가중치를 더 낮은 정밀도의 데이터 타입으로 저장하여 매우 큰 모델의 메모리 요구 사항을 줄이는 데 도움이 됩니다. 그러나 quantization은 비디오 모델에 따라 비디오 품질에 다양한 영향을 미칠 수 있습니다.

지원되는 양자화 백엔드와 사용 사례에 맞는 양자화 백엔드 선택에 대해 자세히 알아보려면 Quantization 개요를 참조하세요. 아래 예제는 bitsandbytes를 사용하여 양자화된 FluxPipeline을 추론에 로드하는 방법을 보여줍니다.

import torch
from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig, FluxTransformer2DModel, FluxPipeline
from transformers import BitsAndBytesConfig as BitsAndBytesConfig, T5EncoderModel

quant_config = BitsAndBytesConfig(load_in_8bit=True)
text_encoder_8bit = T5EncoderModel.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    subfolder="text_encoder_2",
    quantization_config=quant_config,
    dtype=torch.float16,
)

quant_config = DiffusersBitsAndBytesConfig(load_in_8bit=True)
transformer_8bit = FluxTransformer2DModel.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    subfolder="transformer",
    quantization_config=quant_config,
    dtype=torch.float16,
)

pipeline = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    text_encoder_2=text_encoder_8bit,
    transformer=transformer_8bit,
    dtype=torch.float16,
    device_map="balanced",
)

prompt = "a tiny astronaut hatching from an egg on the moon"
image = pipeline(prompt, guidance_scale=3.5, height=768, width=1360, num_inference_steps=50).images[0]
image.save("flux.png")

FluxTransformer2DModel의 단일 파일 로딩

FluxTransformer2DModel은 Black Forest Labs에서 배포한 원래 형식의 체크포인트를 로드하는 것을 지원합니다. 이는 커뮤니티에서 공개한 모델의 파인튜닝 버전이나 양자화 버전을 로드하려는 경우에도 유용합니다.

FP8 추론은 사용하는 GPU 유형, CUDA 버전, torch 버전에 따라 불안정할 수 있습니다. 머신에서 FP8 추론을 실행하려면 optimum-quanto 라이브러리를 사용하는 것이 권장됩니다.

다음 예제는 16GB 미만의 VRAM으로 Flux를 실행하는 방법을 보여줍니다.

optimum-quanto를 먼저 설치하세요

pip install optimum-quanto

다음 예제를 실행합니다

import torch
from diffusers import FluxTransformer2DModel, FluxPipeline
from transformers import T5EncoderModel, CLIPTextModel
from optimum.quanto import freeze, qfloat8, quantize

bfl_repo = "black-forest-labs/FLUX.1-dev"
dtype = torch.bfloat16

transformer = FluxTransformer2DModel.from_single_file("https://huggingface.co/Kijai/flux-fp8/blob/main/flux1-dev-fp8.safetensors", dtype=dtype)
quantize(transformer, weights=qfloat8)
freeze(transformer)

text_encoder_2 = T5EncoderModel.from_pretrained(bfl_repo, subfolder="text_encoder_2", dtype=dtype)
quantize(text_encoder_2, weights=qfloat8)
freeze(text_encoder_2)

pipe = FluxPipeline.from_pretrained(bfl_repo, transformer=None, text_encoder_2=None, dtype=dtype)
pipe.transformer = transformer
pipe.text_encoder_2 = text_encoder_2

pipe.enable_model_cpu_offload()

prompt = "A cat holding a sign that says hello world"
image = pipe(
    prompt,
    guidance_scale=3.5,
    output_type="pil",
    num_inference_steps=20,
    generator=torch.Generator("cpu").manual_seed(0)
).images[0]

image.save("flux-fp8-dev.png")

Diffusers

Flux

Timestep-distilled

가이던스 증류

Fill Inpainting/Outpainting

Canny Control

깊이 제어

Redux

Kontext

Kontext Inpainting

Flux Turbo LoRA와 Flux Control, Fill, Redux를 결합하기

Flux LoRA를 사용할 때 unload_lora_weights()에 대한 참고

IP-Adapter

최적화

그룹 오프로딩

FP16 추론 실행

양자화

FluxTransformer2DModel의 단일 파일 로딩

FluxPipeline

클래스 diffusers.FluxPipeline

__call__

encode_prompt

FluxImg2ImgPipeline

클래스 diffusers.FluxImg2ImgPipeline

__call__

encode_prompt

FluxInpaintPipeline

클래스 diffusers.FluxInpaintPipeline

__call__

encode_prompt

FluxControlNetInpaintPipeline

class diffusers.FluxControlNetInpaintPipeline

__call__

encode_prompt

FluxControlNetImg2ImgPipeline

클래스 diffusers.FluxControlNetImg2ImgPipeline

__call__

encode_prompt

FluxControlPipeline

클래스 diffusers.FluxControlPipeline

__call__

encode_prompt

FluxControlImg2ImgPipeline

클래스 diffusers.FluxControlImg2ImgPipeline

__call__

encode_prompt

FluxPriorReduxPipeline

클래스 diffusers.FluxPriorReduxPipeline

__call__

encode_prompt

FluxFillPipeline

클래스 diffusers.FluxFillPipeline

__call__

encode_prompt

FluxKontextPipeline

클래스 diffusers.FluxKontextPipeline

__call__

encode_prompt

FluxKontextInpaintPipeline

클래스 diffusers.FluxKontextInpaintPipeline

__call__

텍스트만 사용하여 인페인팅

이미지 조건부 인페인팅

encode_prompt

call

call

call

call

call

call

call

call

call

call

call