Datasets:
File size: 10,002 Bytes
9bc4c0e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 | """Undistilled FLUX9B with real CFG, negative prompts and reference images.
CFG batching/parallelism change execution layout, not the guidance equation.
The denoising call is derived from the pinned installed official pipeline;
only its two transformer calls are replaced. No approximation cache is used.
"""
import copy
import inspect
import json
import textwrap
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
import torch
from diffusers import Flux2KleinPipeline
import diffusers.pipelines.flux2.pipeline_flux2_klein as upstream
from vivarium_prompt_templates import build_prompt
ROOT = Path(__file__).resolve().parents[1]
def _forward(model, kwargs, device):
with torch.inference_mode(), torch.autocast(device.type, dtype=torch.bfloat16):
return model(**kwargs)[0]
def _cfg_prediction(self, hidden, timestep, positive, negative, txt, neg_txt, img, image_tokens):
if getattr(self,'_native_mark_graph_steps',False):
torch.compiler.cudagraph_mark_step_begin()
common = dict(hidden_states=hidden, timestep=timestep/1000, guidance=None, img_ids=img,
joint_attention_kwargs=self.attention_kwargs, return_dict=False)
pos = dict(common, encoder_hidden_states=positive, txt_ids=txt)
if not self.do_classifier_free_guidance:
return self.transformer(**pos)[0][:,:image_tokens]
neg = dict(common, encoder_hidden_states=negative, txt_ids=neg_txt)
mode = self._native_cfg_mode
if mode == 'batched':
merged = dict(common, hidden_states=torch.cat([hidden,hidden],dim=0),
timestep=torch.cat([timestep,timestep],dim=0)/1000,
encoder_hidden_states=torch.cat([positive,negative],dim=0),
txt_ids=torch.cat([txt,neg_txt],dim=0), img_ids=torch.cat([img,img],dim=0))
pred = self.transformer(**merged)[0][:,:image_tokens]
positive_noise, negative_noise = pred.chunk(2,dim=0)
elif mode == 'parallel':
device=self._native_second_device
neg={k:(v.to(device) if isinstance(v,torch.Tensor) else v) for k,v in neg.items()}
future=self._native_executor.submit(_forward,self._native_negative_transformer,neg,device)
positive_noise=self.transformer(**pos)[0][:,:image_tokens]
negative_noise=future.result()[:,:image_tokens].to(hidden.device)
else:
with self.transformer.cache_context('cond'): positive_noise=self.transformer(**pos)[0][:,:image_tokens]
with self.transformer.cache_context('uncond'): negative_noise=self.transformer(**neg)[0][:,:image_tokens]
return negative_noise+self.guidance_scale*(positive_noise-negative_noise)
def _native_call():
source=textwrap.dedent(inspect.getsource(inspect.unwrap(Flux2KleinPipeline.__call__)))
source=source[source.index('def __call__('):]
start=source.index(' with self.transformer.cache_context("cond"):')
end=source.index(' # compute the previous noisy sample',start)
old=source[start:end]
assert old.count('self.transformer(')==2 and 'neg_noise_pred + guidance_scale' in old
new=''' noise_pred = self._native_cfg_prediction(
latent_model_input, timestep, prompt_embeds,
negative_prompt_embeds if self.do_classifier_free_guidance else None,
text_ids, negative_text_ids if self.do_classifier_free_guidance else None,
latent_image_ids, latents.size(1))
'''
namespace=dict(vars(upstream))
exec(compile(source[:start]+new+source[end:],'<pinned-flux-native-cfg>','exec'),namespace)
return torch.no_grad()(namespace['__call__'])
class NativeFluxPipeline(Flux2KleinPipeline):
__call__=_native_call()
_native_cfg_prediction=_cfg_prediction
def create_native_pipeline(kind='characters', device='cuda:0', fuse=True, qkv=True,
compile_mode='default', cfg_mode='batched', second_device='cuda:1',base_path=None):
assert kind in ('characters','backgrounds') and cfg_mode in ('sequential','batched','parallel')
torch.set_num_threads(8)
torch.backends.cuda.matmul.allow_tf32=True
registry=ROOT/'model-downloads.json'
model=json.loads(registry.read_text())['FLUX.2-klein-base-9B'] if registry.is_file() else dict(repo='black-forest-labs/FLUX.2-klein-base-9B',revision='32773329fbe7e81a90ef971740e8ba4b0364ecf3',path='/nonexistent-vivarium-base-cache')
path=Path(base_path) if base_path else Path(model['path'])
if base_path is None and not path.is_absolute(): path=ROOT/path
kwargs=dict(torch_dtype=torch.bfloat16)
if path.is_dir(): kwargs['local_files_only']=True
else: kwargs['revision']=model['revision']
pipe=NativeFluxPipeline.from_pretrained(str(path) if path.is_dir() else model['repo'],**kwargs).to(device)
assert not pipe.config.is_distilled, 'Only undistilled base9B is permitted.'
pipe.set_progress_bar_config(disable=True)
adapter=ROOT/'outputs/9B'/kind/'selected/pytorch_lora_weights.safetensors'
if not adapter.is_file(): adapter=ROOT/'loras'/f'flux-{kind}.safetensors'
if not adapter.is_file(): adapter=ROOT/kind/'pytorch_lora_weights.safetensors'
if adapter.is_file():
pipe.load_lora_weights(str(adapter.parent),weight_name=adapter.name,adapter_name='vivarium')
else:
pipe.load_lora_weights('laion/FLUX.2-klein-base-9B-vivarium-loras',revision='5bd654514cc35a1c0d0de878c3a514019896a44e',subfolder=kind,weight_name='pytorch_lora_weights.safetensors',adapter_name='vivarium')
pipe.set_adapters('vivarium',adapter_weights=1.)
if fuse:
pipe.fuse_lora(adapter_names=['vivarium'],safe_fusing=True)
pipe.unload_lora_weights()
if qkv:
assert fuse, 'Fuse adapter projections before fusing QKV.'
pipe.transformer.fuse_qkv_projections()
pipe.transformer.eval()
pipe._native_cfg_mode=cfg_mode
pipe._native_mark_graph_steps=compile_mode=='reduce-overhead'
if pipe._native_mark_graph_steps: assert cfg_mode=='batched', 'CUDAGraph profile requires batched CFG.'
pipe._native_kind=kind
pipe._native_text_cache={}
if cfg_mode=='parallel':
second=torch.device(second_device)
assert torch.device(device)!=second
pipe._native_second_device=second
pipe._native_negative_transformer=copy.deepcopy(pipe.transformer).to(second).eval()
pipe._native_executor=ThreadPoolExecutor(max_workers=1)
if compile_mode:
# Repeated blocks carry distinct attention processors. Keep their guards
# cached across both resolutions and successive category pipelines.
torch._dynamo.config.cache_size_limit=1024
for transformer in ([pipe.transformer,pipe._native_negative_transformer] if cfg_mode=='parallel' else [pipe.transformer]):
transformer.compile_repeated_blocks(fullgraph=False,dynamic=compile_mode!='reduce-overhead',mode=compile_mode)
return pipe
def encode_text(pipe,text):
with torch.inference_mode(),torch.autocast(pipe._execution_device.type,dtype=torch.bfloat16):
return pipe.encode_prompt(text,device=pipe._execution_device,max_sequence_length=256)[0]
def generate_native_image(pipe,prompt=None,seed=28008,steps=50,guidance=4.,negative_prompt='',image=None,
width=None,height=None,cache_negative=True,prompt_embeds=None,description=None):
assert steps in (40,50), 'Production trials retain40 or50 denoising steps.'
if prompt is not None and description is not None:
raise ValueError('Use a full prompt or a templated description, not both.')
if prompt is None and prompt_embeds is None: prompt=build_prompt(pipe._native_kind,description)
kwargs=dict(width=width or (832 if pipe._native_kind=='characters' else 1376),
height=height or (1248 if pipe._native_kind=='characters' else 768),
num_inference_steps=steps,guidance_scale=guidance,max_sequence_length=256,
generator=torch.Generator(pipe._execution_device).manual_seed(seed))
if prompt_embeds is None: kwargs['prompt']=prompt
else: kwargs['prompt_embeds']=prompt_embeds
if image is not None: kwargs['image']=image
with torch.inference_mode(),torch.autocast(pipe._execution_device.type,dtype=torch.bfloat16):
if guidance>1 and (cache_negative or negative_prompt):
if negative_prompt not in pipe._native_text_cache:
pipe._native_text_cache[negative_prompt]=encode_text(pipe,negative_prompt)
kwargs['negative_prompt_embeds']=pipe._native_text_cache[negative_prompt]
return pipe(**kwargs).images
if __name__=='__main__':
import argparse
from PIL import Image
p=argparse.ArgumentParser()
p.add_argument('kind',choices=['characters','backgrounds'])
text=p.add_mutually_exclusive_group()
text.add_argument('--prompt',help='Complete prompt; overrides the warm-painted template.')
text.add_argument('--description',help='Subject/location description; recommended warm-painted style is added.')
p.add_argument('--negative-prompt',default='')
p.add_argument('--reference',type=Path)
p.add_argument('--steps',type=int,choices=[40,50],default=50)
p.add_argument('--seed',type=int,default=28008)
p.add_argument('--cfg-mode',choices=['sequential','batched','parallel'],default='batched')
p.add_argument('--no-compile',action='store_true')
p.add_argument('--base-path',type=Path)
p.add_argument('--output',type=Path,default=ROOT/'native-preview.png')
a=p.parse_args()
pipe=create_native_pipeline(a.kind,compile_mode=None if a.no_compile else 'default',cfg_mode=a.cfg_mode,base_path=a.base_path)
images=generate_native_image(pipe,a.prompt,a.seed,a.steps,negative_prompt=a.negative_prompt,
image=Image.open(a.reference).convert('RGB') if a.reference else None,description=a.description)
a.output.parent.mkdir(parents=True,exist_ok=True); images[0].save(a.output)
print('Saved',a.output)
|