import gradio as gr import torch from diffusers import DiffusionPipeline from diffusers import AutoencoderKL from config import * from helpers import * def device_change(device, config): config = set_config(config, 'device', device) return config, config, assemble_code(config) def model_refiner_change(refiner, config): config = set_config(config, 'refiner', refiner) return config, config, assemble_code(config) def cpu_offload_change(cpu_offload, config): config = set_config(config, 'cpu_offload', cpu_offload) return config, config, assemble_code(config) def models_change(model, scheduler, config): config = set_config(config, 'model', model) use_safetensors = False trigger_token = "" # no model selected (because this is UI init run) if type(model) != list and str(model) != 'None' and str(model) != 'null': use_safetensors = str(models[model]['use_safetensors']) model_description = models[model]['description'] trigger_token = models[model]['trigger_token'] # if no scheduler is selected, choose the default one for this model if scheduler == None: scheduler = models[model]['scheduler'] else: model_description = 'Please select a model.' config["use_safetensors"] = str(use_safetensors) config["scheduler"] = str(scheduler) # safety_checker_change(in_safety_checker.value, config) # requires_safety_checker_change(in_requires_safety_checker.value, config) return model_description, trigger_token, use_safetensors, scheduler, config, config, assemble_code(config) def data_type_change(data_type, config): config = set_config(config, 'data_type', data_type) return config, config, assemble_code(config) def tensorfloat32_change(allow_tensorfloat32, config): config = set_config(config, 'allow_tensorfloat32', allow_tensorfloat32) return config, config, assemble_code(config) def inference_steps_change(inference_steps, config): config = set_config(config, 'inference_steps', inference_steps) return config, config, assemble_code(config) def manual_seed_change(manual_seed, config): config = set_config(config, 'manual_seed', manual_seed) return config, config, assemble_code(config) def guidance_scale_change(guidance_scale, config): config = set_config(config, 'guidance_scale', guidance_scale) return config, config, assemble_code(config) def lora_scale_change(lora_scale, config): config = set_config(config, 'lora_scale', lora_scale) return config, config, assemble_code(config) def enable_vae_slicing_change(enable_vae_slicing, config): config = set_config(config, 'enable_vae_slicing', enable_vae_slicing) return config, config, assemble_code(config) def enable_vae_tiling_change(enable_vae_tiling, config): config = set_config(config, 'enable_vae_tiling', enable_vae_tiling) return config, config, assemble_code(config) def prompt_change(prompt, config): config = set_config(config, 'prompt', prompt) return config, config, assemble_code(config) def trigger_token_change(trigger_token, config): config = set_config(config, 'trigger_token', trigger_token) return config, config, assemble_code(config) def negative_prompt_change(negative_prompt, config): config = set_config(config, 'negative_prompt', negative_prompt) return config, config, assemble_code(config) def variant_change(variant, config): config = set_config(config, 'variant', variant) return config, config, assemble_code(config) def attention_slicing_change(attention_slicing, config): config = set_config(config, 'attention_slicing', attention_slicing) return config, config, assemble_code(config) def pre_compile_unet_change(pre_compile_unet, config): config = set_config(config, 'pre_compile_unet', pre_compile_unet) return config, config, assemble_code(config) def safety_checker_change(safety_checker, config): config = set_config(config, 'safety_checker', safety_checker) return config, config, assemble_code(config) def requires_safety_checker_change(requires_safety_checker, config): config = set_config(config, 'requires_safety_checker', requires_safety_checker) return config, config, assemble_code(config) def auto_encoders_change(auto_encoder, config): if str(auto_encoder) != 'None' and str(auto_encoder) != 'null' and type(auto_encoder) != list: auto_encoder_description = auto_encoders[auto_encoder] else: auto_encoder_description = '' config = set_config(config, 'auto_encoder', auto_encoder) return auto_encoder_description, config, config, assemble_code(config) def schedulers_change(scheduler, config): if str(scheduler) != 'None' and str(scheduler) != 'null' and type(scheduler) != list: scheduler_description = schedulers[scheduler] else: scheduler_description = 'Please select a scheduler.' config = set_config(config, 'scheduler', scheduler) return scheduler_description, config, config, assemble_code(config) def adapters_textual_inversion_change(adapter_textual_inversion, config): if str(adapter_textual_inversion) != 'None' and str(adapter_textual_inversion) != 'null' and type(adapter_textual_inversion) != list: adapter_textual_inversion_description = adapters['textual_inversion'][adapter_textual_inversion]['description'] in_adapters_textual_inversion_token = adapters['textual_inversion'][adapter_textual_inversion]['token'] else: adapter_textual_inversion_description = "" in_adapters_textual_inversion_token = "" config = set_config(config, 'adapter_textual_inversion', adapter_textual_inversion) return adapter_textual_inversion_description, in_adapters_textual_inversion_token, config, config, assemble_code(config) def adapters_lora_change(adapter_loras, config): if len(adapter_loras) > 0: adapter_lora_description = '; '.join([adapters['lora'][adapter_lora]['description'] for adapter_lora in adapter_loras]) adapter_lora_token = [adapters['lora'][adapter_lora]['token'] for adapter_lora in adapter_loras] adapter_lora_weight = [adapters['lora'][adapter_lora]['weight'] for adapter_lora in adapter_loras] adapter_lora_balancing = {} for adapter_lora in adapter_loras: if not adapter_lora in config['adapter_lora_balancing']: adapter_lora_balancing[adapter_lora] = 1 else: adapter_lora_balancing[adapter_lora] = config['adapter_lora_balancing'][adapter_lora] else: adapter_lora_description = [] adapter_lora_token = [] adapter_lora_weight = [] adapter_lora_balancing = {} config = set_config(config, 'adapter_lora', adapter_loras) config = set_config(config, 'adapter_lora_token', adapter_lora_token) config = set_config(config, 'adapter_lora_weight', adapter_lora_weight) config = set_config(config, 'adapter_lora_balancing', adapter_lora_balancing) return adapter_lora_description, adapter_lora_token, adapter_lora_weight, adapter_lora_balancing, config, config, assemble_code(config) def adapters_lora_balancing_change(adapter_lora_balancing, config): config = set_config(config, 'adapter_lora_balancing', json.loads(adapter_lora_balancing.replace("'", '"').replace('None', 'null').replace('False', 'False'))) return config, config, assemble_code(config) def textual_inversion_token_change(adapter_textual_inversion_token, config): config = set_config(config, 'adapter_textual_inversion_token', adapter_textual_inversion_token) return config, config, assemble_code(config) def re_run_inference(config, config_history, pipeline, progress=gr.Progress(track_tqdm=True)): if str(config["model"]) == 'None' and \ str(config["model"]) == 'null' and \ str(config["model"]) == '' and \ str(config["scheduler"]) == 'None': return "Please select a model AND a scheduler.", "Please select a model AND a scheduler.", None, pipeline if pipeline == None: return "Please run full inference first.", "Please run full inference first.", None, pipeline # # MANUAL SEED/GENERATOR - we probably don't need that again? # if config["manual_seed"] is None or config["manual_seed"] == '' or int(config["manual_seed"]) < 0: # generator = None # else: # generator = torch.manual_seed(int(config["manual_seed"])) if len(config["adapter_lora"]) > 0 and len(config["adapter_lora"]) == len(config["adapter_lora_weight"]): cross_attention_kwargs = {"scale": config["lora_scale"]} else: cross_attention_kwargs = None # MANUAL SEED/GENERATOR if config["manual_seed"] is None or config["manual_seed"] == '' or int(config["manual_seed"]) < 0: generator = torch.Generator() else: generator = torch.Generator().manual_seed(int(config["manual_seed"])) prompt = config["prompt"] + config["trigger_token"] + config["adapter_textual_inversion_token"] + ' '.join(config["adapter_lora_token"]) image = pipeline( prompt = prompt, generator = generator, negative_prompt = config["negative_prompt"], num_inference_steps = int(config["inference_steps"]), cross_attention_kwargs = cross_attention_kwargs, guidance_scale = float(config["guidance_scale"])).images if config['refiner'].lower() != 'none' and config['refiner'].lower() != 'null': image = refiner( prompt = prompt, num_inference_steps = int(config["inference_steps"]), image=image, ).images config_history.append(config.copy()) # expected output: out_image, out_config_history, config_history, pipeline return image[0], dict_list_to_markdown_table(config_history), config_history, pipeline def run_inference(config, config_history, pipeline, progress=gr.Progress(track_tqdm=True)): if str(config["model"]) != 'None' and str(config["model"]) != 'null' and str(config["model"]) != '' and str(config["scheduler"]) != 'None': progress(1, desc="Initializing pipeline...") torch.cuda.empty_cache() torch.backends.cuda.matmul.allow_tf32 = get_bool(config["allow_tensorfloat32"]) # Use TensorFloat-32 as of https://huggingface.co/docs/diffusers/main/en/optimization/fp16 faster, but slightly less accurate computations # INIT PIPELINE pipeline = get_pipeline(config) progress(2, desc="Setting pipeline params...") if str(config["cpu_offload"]).lower() != 'false': pipeline.enable_model_cpu_offload() # ATTENTION SLICING if str(config["attention_slicing"]).lower() == 'true': pipeline.enable_attention_slicing() # PRE COMPILE UNET if str(config["pre_compile_unet"]).lower() == 'true': pipeline.unet = torch.compile(pipeline.unet, mode="reduce-overhead", fullgraph=True) # AUTO ENCODER if str(config["auto_encoder"]).lower() != 'none' and str(config["auto_encoder"]).lower() != 'null' and str(config["auto_encoder"]).lower() != '': pipeline.vae = AutoencoderKL.from_pretrained(config["auto_encoder"], torch_dtype=get_data_type(config["data_type"])).to(config["device"]) if str(config["enable_vae_slicing"]).lower() != 'false': pipeline.enable_vae_slicing() if str(config["enable_vae_tiling"]).lower() != 'false': pipeline.enable_vae_tiling() # SAFETY CHECKER if str(config["safety_checker"]).lower() == 'false': pipeline.safety_checker = None pipeline.requires_safety_checker = get_bool(config["requires_safety_checker"]) # SCHEDULER/SOLVER pipeline.scheduler = get_scheduler(config["scheduler"], pipeline.scheduler.config) # INIT REFINER if str(config['refiner']).lower() != 'none' and str(config['refiner']).lower() != 'null': progress(3, desc="Initializing refiner...") refiner = DiffusionPipeline.from_pretrained( config['refiner'], text_encoder_2=pipeline.text_encoder_2, vae=pipeline.vae, torch_dtype=get_data_type(config["data_type"]), use_safetensors=get_bool(config["use_safetensors"]), variant = get_variant(config["variant"])).to(config["device"]) if str(config["cpu_offload"]).lower() != 'false': refiner.enable_model_cpu_offload() if str(config["enable_vae_slicing"]).lower() != 'false': refiner.enable_vae_slicing() if str(config["enable_vae_tiling"]).lower() != 'false': refiner.enable_vae_tiling() # ADAPTERS # TEXTUAL INVERSION if str(config["adapter_textual_inversion"]).lower() != 'none' and str(config["adapter_textual_inversion"]).lower() != 'null' and str(config["adapter_textual_inversion"]).lower() != '': progress(4, desc=f"Loading textual inversion adapter {config['adapter_textual_inversion']}...") pipeline.load_textual_inversion(config["adapter_textual_inversion"], token=config["adapter_textual_inversion_token"]) # LoRA if len(config["adapter_lora"]) > 0 and len(config["adapter_lora"]) == len(config["adapter_lora_weight"]): adapter_lora_balancing = [] for adapter_lora_index, adapter_lora in enumerate(config["adapter_lora"]): progress(5, desc=f"Loading LoRA adapters {config['adapter_lora']}...") if str(config["adapter_lora_weight"][adapter_lora_index]).lower() != 'none': pipeline.load_lora_weights(adapter_lora, weight_name=config["adapter_lora_weight"][adapter_lora_index], adapter_name=config["adapter_lora_token"][adapter_lora_index]) else: pipeline.load_lora_weights(adapter_lora, adapter_name=config["adapter_lora_token"][adapter_lora_index]) adapter_lora_balancing.append(config["adapter_lora_balancing"][adapter_lora]) adapter_weights = adapter_lora_balancing pipeline.set_adapters(config["adapter_lora_token"], adapter_weights=adapter_weights) cross_attention_kwargs = {"scale": float(config["lora_scale"])} else: cross_attention_kwargs = None progress(6, desc="Inferencing...") # MANUAL SEED/GENERATOR if config["manual_seed"] is None or config["manual_seed"] == '' or int(config["manual_seed"]) < 0: generator = torch.Generator() else: generator = torch.Generator().manual_seed(int(config["manual_seed"])) prompt = config["prompt"] + config["trigger_token"] + config["adapter_textual_inversion_token"] + ' '.join(config["adapter_lora_token"]) image = pipeline( prompt = prompt, negative_prompt = config["negative_prompt"], generator = generator, num_inference_steps = int(config["inference_steps"]), cross_attention_kwargs = cross_attention_kwargs, guidance_scale = float(config["guidance_scale"])).images if config['refiner'].lower() != 'none' and config['refiner'].lower() != 'null': image = refiner( prompt = prompt, num_inference_steps = int(config["inference_steps"]), image=image, ).images config_history.append(config.copy()) # expected output: out_image, out_config_history, config_history, pipeline return image[0], dict_list_to_markdown_table(config_history), config_history, pipeline else: return "Please select a model AND a scheduler.", "Please select a model AND a scheduler.", None, pipeline appConfig = load_app_config() models = appConfig.get("models", {}) schedulers = appConfig.get("schedulers", {}) devices = appConfig.get("devices", []) refiners = appConfig.get("refiners", []) auto_encoders = appConfig.get("auto_encoders", []) adapters = appConfig.get("adapters", []) js = '''function js(){ window.set_cookie = function(key, value, config){ document.cookie = key+'='+value+'; Path=/; SameSite=Strict'; return [value, config] } window.set_model_cookie = function(model, config){ document.cookie = 'model='+ model+'; Path=/; SameSite=Strict'; // some things I just don't understand, this is one of them return [model, null, null, null, model, config, null] } window.set_adapter_textual_inversion_cookie = function(adapter_textual_inversion, config){ document.cookie = 'adapter_textual_inversion='+ adapter_textual_inversion+'; Path=/; SameSite=Strict'; // some things I just don't understand, this is one of them return [adapter_textual_inversion, null, adapter_textual_inversion, config, null] } window.set_adapter_lora_cookie = function(adapter_lora, config){ document.cookie = 'adapter_lora='+ JSON.stringify(adapter_lora)+'; Path=/; SameSite=Strict'; // some things I just don't understand, this is one of them return [adapter_lora, null, null, null, adapter_lora, config, null] } window.set_cookie_2 = function(key, value, config){ document.cookie = key+'='+value+'; Path=/; SameSite=Strict'; // some things I just don't understand, this is one of them return [value, null, config, null] } } ''' # interface with gr.Blocks(analytics_enabled=False) as demo: config = gr.State(value=get_initial_config()) config_history = gr.State(value=[]) pipeline = gr.State() gr.Markdown('''## Text-2-Image Playground by Nicky Reinert | home base: https://huggingface.co/spaces/n42/pictero ''') gr.Markdown("### Device") gr.Markdown("(you may add a custom device address at any time)") with gr.Row(): in_devices = gr.Dropdown(label="Device:", value=config.value["device"], choices=devices, filterable=True, multiselect=False, allow_custom_value=True, info="") gr.Column("") gr.Column("") with gr.Accordion("Device specific settings", open=False): with gr.Row(): in_cpu_offload = gr.Radio(label="CPU Offload:", value=config.value["cpu_offload"], choices=["True", "False"], info="This may increase performance, as it offloads computations from the GPU to the CPU. But this can also lead to slower executions and lower effectiveness. Compare running time and outputs before making sure, that this setting will help you, is not supported on MPS") in_data_type = gr.Radio(label="Data Type:", value=config.value["data_type"], choices=["bfloat16", "float16", "float32"], info="`bfloat16` is not supported on MPS devices right now; `float16` may also not be supported on all devices, Half-precision weights, will save GPU memory, see https://huggingface.co/docs/diffusers/main/en/optimization/fp16") in_allow_tensorfloat32 = gr.Radio(label="Allow TensorFloat32:", value=config.value["allow_tensorfloat32"], choices=["True", "False"], info="is not supported on MPS devices right now; use TensorFloat-32 is faster, but results in slightly less accurate computations, see https://huggingface.co/docs/diffusers/main/en/optimization/fp16 ") with gr.Row(): in_variant = gr.Radio(label="Variant:", value=config.value["variant"], choices=["fp16", None], info="Use half-precision weights will save GPU memory, not all models support that, see https://huggingface.co/docs/diffusers/main/en/optimization/fp16 ") in_attention_slicing = gr.Radio(label="Attention slicing:", value=config.value["attention_slicing"], choices=["True", "False"], info="Attention operation will be cutted into multiple steps, see https://huggingface.co/docs/diffusers/optimization/mps") in_pre_compile_unet = gr.Radio(label="Pre-Compile UNet:", value=config.value["pre_compile_unet"], choices=["True", "False"], info="Can speed up the inference process, compilation takes some time, so you should only apply this option when you finalize your inference, does not work on MPS, see https://huggingface.co/docs/diffusers/optimization/torch2.0 ") gr.Column("") gr.Markdown("### Model") with gr.Row(): with gr.Column(scale=1): in_models = gr.Dropdown(choices=list(models.keys()), label="Model") with gr.Column(scale=2): out_model_description = gr.Textbox(value="", label="Description") with gr.Accordion("Model specific settings", open=False): with gr.Row(): in_trigger_token = gr.Textbox(value=config.value["trigger_token"], label="Trigger Token", info="will be added to your prompt to `activate` a fine tuned model") in_model_refiner = gr.Dropdown(value=config.value["refiner"], choices=['none'] + refiners, label="Refiner", allow_custom_value=True, multiselect=False) gr.Column("") with gr.Row(): in_use_safetensors = gr.Radio(label="Use safe tensors:", choices=["True", "False"], interactive=False) in_safety_checker = gr.Radio(label="Enable safety checker:", value=config.value["safety_checker"], choices=["True", "False"]) in_requires_safety_checker = gr.Radio(label="Requires safety checker:", value=config.value["requires_safety_checker"], choices=["True", "False"]) gr.Markdown("### Scheduler") gr.Markdown("Schedulers employ various strategies for noise control, the scheduler controls parameter adaption between each inference step, depending on the right scheduler for your model, it may only take 10 or 20 steps to achieve very good results, see https://huggingface.co/docs/diffusers/using-diffusers/loading#schedulers") with gr.Row(): with gr.Column(scale=1): in_schedulers = gr.Dropdown(value="", choices=list(schedulers.keys()), allow_custom_value=True, label="Scheduler/Solver", info="") with gr.Column(scale=2): out_scheduler_description = gr.Textbox(value="", label="Description") with gr.Accordion("Auto Encoder", open=False): with gr.Row(): gr.Markdown("**VAE** stands for Variational Auto Encoders. An 'autoencoder' is an artificial neural network that is able to encode input data and decode to output data to bascially recreate the input. The VAE whereas adds a couple of additional layers of complexity to create new and unique output.") with gr.Row(): in_auto_encoders = gr.Dropdown(value="None", choices=list(auto_encoders.keys()), label="Auto encoder", info="leave empty to not add an auto encoder") out_auto_encoder_description = gr.Textbox(value="", label="Description") gr.Column("") with gr.Row(): in_enable_vae_slicing = gr.Radio(label="Enable VAE slicing:", value=config.value["enable_vae_slicing"], choices=["True", "False"], info="decoding the batches of latents one image at a time, which may reduce memory usage, see https://huggingface.co/docs/diffusers/main/en/optimization/memory") in_enable_vae_tiling= gr.Radio(label="Enable VAE tiling:", value=config.value["enable_vae_tiling"], choices=["True", "False"], info="splitting the image into overlapping tiles, decoding the tiles, and then blending the outputs together to compose the final image, see https://huggingface.co/docs/diffusers/main/en/optimization/memory") gr.Column("") with gr.Accordion("Adapters", open=False): with gr.Row(): gr.Markdown('''Adapters allow you to apply finetuned weights to your base model. They come in many flavors depending on how they were trained. See see https://huggingface.co/docs/diffusers/using-diffusers/loading_adapters''') with gr.Row(): gr.Markdown('#### Textual Inversion Adapters') with gr.Row(): gr.Markdown('(a technique that enables a model like Stable Diffusion to learn a new concept from just a few sample images)') with gr.Row(): in_adapters_textual_inversion = gr.Dropdown(value="", choices=list(adapters['textual_inversion'].keys()), label="Textual Inversion Adapter", info="leave empty to not use an adapter") in_adapters_textual_inversion_token = gr.Textbox(value="", label="Token", info="required to activate the token, will be added to your prompt") out_adapters_textual_inversion_description = gr.Textbox(value="", label="Description") with gr.Row(): gr.Markdown('#### LoRA') with gr.Row(): gr.Markdown('(Low-Rank-Adaption is a performant fine tuning technique)') with gr.Row(): in_adapters_lora = gr.Dropdown(value="None", choices=list(adapters['lora'].keys()), multiselect=True, label="LoRA Adapter", info="leave empty to not use an adapter") out_adapters_lora_description = gr.Textbox(value="", label="Description") in_lora_scale = gr.Slider(minimum=0, maximum=1, step=0.1, label="LoRA Scale", value=config.value["lora_scale"], info="How should the LoRA model influence the result, from 0 (no influence) to 1 (full influencer)") with gr.Row(): in_adapters_lora_token = gr.Textbox(value="None", label="Token(s)", info="required to activate the token, will be added to your prompt") in_adapters_lora_weight = gr.Textbox(value="", label="Weight(s)/Checkpoint(s)") in_adapters_lora_balancing = gr.Textbox(value={}, label="Balancing", info="provide a list of balancing weights in the order of your LoRA adapter (according to `token`s)") gr.Markdown("### Inference settings") with gr.Row(): in_prompt = gr.TextArea(label="Prompt", value=config.value["prompt"]) in_negative_prompt = gr.TextArea(label="Negative prompt", value=config.value["negative_prompt"]) with gr.Row(): in_guidance_scale = gr.Slider(minimum=0, maximum=100, step=0.1, label="Guidance Scale", value=config.value["guidance_scale"], info="A low guidance scale leads to a faster inference time, with the drawback that negative prompts don’t have any effect on the denoising process.") in_inference_steps = gr.Number(label="Inference steps", value=config.value["inference_steps"], info="Each step improves the final result but also results in higher computation") in_manual_seed = gr.Number(label="Manual seed", value=config.value["manual_seed"], info="Set this to -1 or leave it empty to randomly generate an image. A fixed value will result in a similar image for every run") gr.Markdown("### Output") with gr.Row(): gr.Markdown('Hit "Re-Run" to restart the pipeline with your changes to the inference settings only') with gr.Row(): btn_start_pipeline = gr.Button(value="Run", variant="primary") btn_re_start_pipeline = gr.Button(value="Re-Run") btn_stop_pipeline = gr.Button(value="Stop", variant="stop") with gr.Row(): out_image = gr.Image() with gr.Accordion("Code and Configuration", open=False): with gr.Row(): out_code = gr.Code(assemble_code(config.value), label="Code") # out_config = gr.Code(value=str(config.value), label="Current config") out_config = gr.JSON(value=config.value, label="Current config") with gr.Row(): out_config_history = gr.Markdown(dict_list_to_markdown_table(config_history.value)) # `SPECIAL` CHANGE LISTENERS in_models.change(models_change, inputs=[in_models, in_schedulers, config], outputs=[out_model_description, in_trigger_token, in_use_safetensors, in_schedulers, config, out_config, out_code], js="(model, config) => set_model_cookie(model, config)") in_schedulers.change(schedulers_change, inputs=[in_schedulers, config], outputs=[out_scheduler_description, config, out_config, out_code], js="(value, config) => set_cookie_2('scheduler', value, config)") in_auto_encoders.change(auto_encoders_change, inputs=[in_auto_encoders, config], outputs=[out_auto_encoder_description, config, out_config, out_code], js="(value, config) => set_cookie_2('auto_encoder', value, config)") in_adapters_textual_inversion.change(adapters_textual_inversion_change, inputs=[in_adapters_textual_inversion, config], outputs=[out_adapters_textual_inversion_description, in_adapters_textual_inversion_token, config, out_config, out_code], js="(adapter_textual_inversion, config) => set_adapter_textual_inversion_cookie(adapter_textual_inversion, config)") in_adapters_lora.change(adapters_lora_change, inputs=[in_adapters_lora, config], outputs=[out_adapters_lora_description, in_adapters_lora_token, in_adapters_lora_weight, in_adapters_lora_balancing, config, out_config, out_code], js="(adapter_lora, config) => set_adapter_lora_cookie(adapter_lora, config)") # `GENERIC` CHANGE LISTENERS, SAME INPUT, SAME OUTPUT STRUCTURE in_devices.change(fn=device_change, inputs=[in_devices, config], outputs=[config, out_config, out_code], js="(value, config) => set_cookie('device', value, config)") in_data_type.change(data_type_change, inputs=[in_data_type, config], outputs=[config, out_config, out_code], js="(value, config) => set_cookie('data_type', value, config)") in_allow_tensorfloat32.change(tensorfloat32_change, inputs=[in_allow_tensorfloat32, config], outputs=[config, out_config, out_code], js="(value, config) => set_cookie('allow_tensorfloat32', value, config)") in_variant.change(variant_change, inputs=[in_variant, config], outputs=[config, out_config, out_code], js="(value, config) => set_cookie('variant', value, config)") in_attention_slicing.change(attention_slicing_change, inputs=[in_attention_slicing, config], outputs=[config, out_config, out_code], js="(value, config) => set_cookie('attention_slicing', value, config)") in_pre_compile_unet.change(pre_compile_unet_change, inputs=[in_pre_compile_unet, config], outputs=[config, out_config, out_code], js="(value, config) => set_cookie('pre_compile_unet', value, config)") in_model_refiner.change(model_refiner_change, inputs=[in_model_refiner, config], outputs=[config, out_config, out_code], js="(value, config) => set_cookie('model_refiner', value, config)") in_cpu_offload.change(cpu_offload_change, inputs=[in_cpu_offload, config], outputs=[config, out_config, out_code], js="(value, config) => set_cookie('cpu_offload', value, config)") in_safety_checker.change(safety_checker_change, inputs=[in_safety_checker, config], outputs=[config, out_config, out_code], js="(value, config) => set_cookie('safety_checker', value, config)") in_requires_safety_checker.change(requires_safety_checker_change, inputs=[in_requires_safety_checker, config], outputs=[config, out_config, out_code], js="(value, config) => set_cookie('requires_safety_checker', value, config)") in_inference_steps.change(inference_steps_change, inputs=[in_inference_steps, config], outputs=[config, out_config, out_code], js="(value, config) => set_cookie('inference_steps', value, config)") in_manual_seed.change(manual_seed_change, inputs=[in_manual_seed, config], outputs=[config, out_config, out_code], js="(value, config) => set_cookie('manual_seed', value, config)") in_guidance_scale.change(guidance_scale_change, inputs=[in_guidance_scale, config], outputs=[config, out_config, out_code], js="(value, config) => set_cookie('guidance_scale', value, config)") in_lora_scale.change(lora_scale_change, inputs=[in_lora_scale, config], outputs=[config, out_config, out_code], js="(value, config) => set_cookie('lora_scale', value, config)") in_enable_vae_slicing.change(enable_vae_slicing_change, inputs=[in_enable_vae_slicing, config], outputs=[config, out_config, out_code], js="(value, config) => set_cookie('enable_vae_slicing', value, config)") in_enable_vae_tiling.change(enable_vae_tiling_change, inputs=[in_enable_vae_tiling, config], outputs=[config, out_config, out_code], js="(value, config) => set_cookie('enable_vae_tiling', value, config)") in_adapters_textual_inversion_token.change(textual_inversion_token_change, inputs=[in_adapters_textual_inversion_token, config], outputs=[config, out_config, out_code]) in_adapters_lora_balancing.change(adapters_lora_balancing_change, inputs=[in_adapters_lora_balancing, config], outputs=[config, out_config, out_code], js="(value, config) => set_cookie('adapter_lora_balancing', value, config)") in_prompt.change(prompt_change, inputs=[in_prompt, config], outputs=[config, out_config, out_code], js="(value, config) => set_cookie('prompt', value, config)") in_trigger_token.change(trigger_token_change, inputs=[in_trigger_token, config], outputs=[config, out_config, out_code], js="(value, config) => set_cookie('trigger_token', value, config)") in_negative_prompt.change(negative_prompt_change, inputs=[in_negative_prompt, config], outputs=[config, out_config, out_code], js="(value, config) => set_cookie('negative_prompt', value, config)") ev_run_inference = btn_start_pipeline.click(run_inference, inputs=[config, config_history, pipeline], outputs=[out_image, out_config_history, config_history, pipeline]) ev_re_run_inference = btn_re_start_pipeline.click(re_run_inference, inputs=[config, config_history, pipeline], outputs=[out_image, out_config_history, config_history, pipeline]) btn_stop_pipeline.click(fn=None, inputs=None, outputs=None, cancels=[ev_run_inference, ev_re_run_inference]) # send current respect initial config to init_config to populate parameters to all relevant input fields # if GET parameter is set, it will overwrite initial config parameters demo.load(fn=get_config_from_url, js=js, inputs=[config], outputs=[ in_models, in_devices, in_cpu_offload, in_use_safetensors, in_data_type, in_model_refiner, in_variant, in_attention_slicing, in_pre_compile_unet, in_safety_checker, in_requires_safety_checker, in_auto_encoders, in_enable_vae_slicing, in_enable_vae_tiling, in_schedulers, in_prompt, in_trigger_token, in_negative_prompt, in_inference_steps, in_manual_seed, in_guidance_scale, in_adapters_textual_inversion, in_adapters_textual_inversion_token, in_adapters_lora, in_adapters_lora_token, in_adapters_lora_weight, in_adapters_lora_balancing, ]) demo.launch(show_error=True)