update config dict

app.py

@@ -30,30 +30,34 @@ from config import *
 # - a list of available models from the config file
 # - a list of available schedulers from the config file
 # - a dict that contains code to for reproduction
-initial_config, devices, models, schedulers, code = get_inital_config()
-
-device                  = initial_config["device"]
-model                   = initial_config["model"]
-scheduler               = initial_config["scheduler"]
-variant                 = initial_config["variant"]
-allow_tensorfloat32     = initial_config["allow_tensorfloat32"]
-use_safetensors         = initial_config["use_safetensors"]
-data_type               = initial_config["data_type"]
-safety_checker          = initial_config["safety_checker"]
-requires_safety_checker = initial_config["requires_safety_checker"]
-manual_seed             = initial_config["manual_seed"]
-inference_steps         = initial_config["inference_steps"]
-guidance_scale          = initial_config["guidance_scale"]
-prompt                  = initial_config["prompt"]
-negative_prompt         = initial_config["negative_prompt"]
+config, devices, model_configs, scheduler_configs, code = get_inital_config()
+
+models = list(model_configs.keys())
+schedulers = list(scheduler_configs.keys())
+
+device                  = config["device"]
+model                   = config["model"]
+scheduler               = config["scheduler"]
+variant                 = config["variant"]
+allow_tensorfloat32     = config["allow_tensorfloat32"]
+use_safetensors         = config["use_safetensors"]
+data_type               = config["data_type"]
+safety_checker          = config["safety_checker"]
+requires_safety_checker = config["requires_safety_checker"]
+manual_seed             = config["manual_seed"]
+inference_steps         = config["inference_steps"]
+guidance_scale          = config["guidance_scale"]
+prompt                  = config["prompt"]
+negative_prompt         = config["negative_prompt"]
 
 config_history = []
 
 def device_change(device):
     
     code[code_pos_device] = f'''device = "{device}"'''
+    config['device'] = device
     
-    return get_sorted_code()
+    return get_sorted_code(), str(config)
 
 def models_change(model, scheduler):
         
@@ -74,16 +78,19 @@ def models_change(model, scheduler):
             use_safetensors=use_safetensors, 
             torch_dtype=data_type, 
             variant=variant).to(device)'''
+    config['model'] = model
 
     safety_checker_change(safety_checker)
     requires_safety_checker_change(requires_safety_checker)
 
-    return get_sorted_code(), use_safetensors, scheduler
+    return get_sorted_code(), use_safetensors, scheduler, str(config)
 
 def data_type_change(selected_data_type):
 
+    config['data_type'] = data_type
+
     get_data_type(selected_data_type)
-    return get_sorted_code()
+    return get_sorted_code(), str(config)
 
 def get_data_type(selected_data_type):
     
@@ -98,9 +105,11 @@ def get_data_type(selected_data_type):
 
 def tensorfloat32_change(allow_tensorfloat32):  
     
+    config['allow_tensorfloat32'] = allow_tensorfloat32
+
     get_tensorfloat32(allow_tensorfloat32)
     
-    return get_sorted_code()
+    return get_sorted_code(), str(config)
 
 def get_tensorfloat32(allow_tensorfloat32):
     
@@ -110,27 +119,33 @@ def get_tensorfloat32(allow_tensorfloat32):
 
 def variant_change(variant):
     
+    config['variant'] = variant
+    
     if str(variant) == 'None':
         code[code_pos_variant] = f'variant = {variant}'
     else:
         code[code_pos_variant] = f'variant = "{variant}"'
 
-    return get_sorted_code()
+    return get_sorted_code(), str(config)
     
 def safety_checker_change(safety_checker):
     
+    config['safety_checker'] = safety_checker
+    
     if not safety_checker or str(safety_checker).lower == 'false':
         code[code_pos_safety_checker] = f'pipeline.safety_checker = None'
     else:
         code[code_pos_safety_checker] = ''
     
-    return get_sorted_code()
+    return get_sorted_code(), str(config)
 
 def requires_safety_checker_change(requires_safety_checker):
     
     code[code_pos_requires_safety_checker] = f'pipeline.requires_safety_checker = {requires_safety_checker}'
     
-    return get_sorted_code()
+    config['requires_safety_checker'] = requires_safety_checker
+    
+    return get_sorted_code(), str(config)
 
 def schedulers_change(scheduler):
     
@@ -138,11 +153,13 @@ def schedulers_change(scheduler):
 
         code[code_pos_scheduler] = f'pipeline.scheduler = {scheduler}.from_config(pipeline.scheduler.config)'
     
-        return get_sorted_code(), scheduler_configs[scheduler]
+        config['scheduler'] = scheduler
+        
+        return get_sorted_code(), scheduler_configs[scheduler], str(config)
 
     else:
         
-        return get_sorted_code(), ''
+        return get_sorted_code(), '', str(config)
 
 def get_scheduler(scheduler, config):
     
@@ -202,7 +219,7 @@ def run_inference(model,
                 
         pipeline.scheduler = get_scheduler(scheduler, pipeline.scheduler.config)
         
-        
+        manual_seed = int(manual_seed)
         if manual_seed < 0 or manual_seed is None or manual_seed == '':
             generator = torch.Generator(device)
         else:
@@ -217,8 +234,8 @@ def run_inference(model,
             num_inference_steps=int(inference_steps), 
             guidance_scale=float(guidance_scale)).images[0]
     
-
-        return "Done.", image
+        config_history.append(config)
+        return image, dict_list_to_markdown_table(config_history)
     
     else:
     
@@ -254,7 +271,7 @@ with gr.Blocks() as demo:
     gr.Markdown("### Device specific settings")
     with gr.Row():
         in_devices = gr.Dropdown(label="Device:", value=device, choices=devices, filterable=True, multiselect=False, allow_custom_value=True)
-        in_data_type = gr.Radio(label="Data Type:", value=data_type, choices=["bfloat16", "float16"], info="`blfoat16` is not supported on MPS devices right now; Half-precision weights, will save GPU memory, see https://huggingface.co/docs/diffusers/main/en/optimization/fp16")
+        in_data_type = gr.Radio(label="Data Type:", value=data_type, choices=["bfloat16", "float16"], info="`bfloat16` is not supported on MPS devices right now; 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=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 ")
         in_variant = gr.Radio(label="Variant:", 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 ")
         
@@ -294,18 +311,18 @@ with gr.Blocks() as demo:
         out_image = gr.Image()
         out_code = gr.Code(get_sorted_code(), label="Code")
     with gr.Row():
-        out_current_config = gr.Code(value=str(initial_config), label="Current config")
+        out_current_config = gr.Code(value=str(config), label="Current config")
     with gr.Row():
         out_config_history = gr.Markdown(dict_list_to_markdown_table(config_history))
     
-    in_devices.change(device_change, inputs=[in_devices], outputs=[out_code])
-    in_data_type.change(data_type_change, inputs=[in_data_type], outputs=[out_code])
-    in_allow_tensorfloat32.change(tensorfloat32_change, inputs=[in_allow_tensorfloat32], outputs=[out_code])
-    in_variant.change(variant_change, inputs=[in_variant], outputs=[out_code])
-    in_models.change(models_change, inputs=[in_models, in_schedulers], outputs=[out_code, in_use_safetensors, in_schedulers])
-    in_safety_checker.change(safety_checker_change, inputs=[in_safety_checker], outputs=[out_code])
-    in_requires_safety_checker.change(requires_safety_checker_change, inputs=[in_requires_safety_checker], outputs=[out_code])
-    in_schedulers.change(schedulers_change, inputs=[in_schedulers], outputs=[out_code, out_scheduler_description])
+    in_devices.change(device_change, inputs=[in_devices], outputs=[out_code, out_current_config])
+    in_data_type.change(data_type_change, inputs=[in_data_type], outputs=[out_code, out_current_config])
+    in_allow_tensorfloat32.change(tensorfloat32_change, inputs=[in_allow_tensorfloat32], outputs=[out_code, out_current_config])
+    in_variant.change(variant_change, inputs=[in_variant], outputs=[out_code, out_current_config])
+    in_models.change(models_change, inputs=[in_models, in_schedulers], outputs=[out_code, in_use_safetensors, in_schedulers, out_current_config])
+    in_safety_checker.change(safety_checker_change, inputs=[in_safety_checker], outputs=[out_code, out_current_config])
+    in_requires_safety_checker.change(requires_safety_checker_change, inputs=[in_requires_safety_checker], outputs=[out_code, out_current_config])
+    in_schedulers.change(schedulers_change, inputs=[in_schedulers], outputs=[out_code, out_scheduler_description, out_current_config])
     btn_start_pipeline.click(run_inference, inputs=[
         in_models, 
         in_devices,
@@ -320,7 +337,9 @@ with gr.Blocks() as demo:
         in_inference_steps,
         in_manual_seed,
         in_guidance_scale
-        ], outputs=[out_image])
+        ], outputs=[
+            out_image,
+            out_config_history])
 
     demo.load(fn=init_config, inputs=out_current_config, 
         outputs=[

config.py

@@ -3,6 +3,7 @@ import base64
 import json
 import torch
 
+code = {}
 code_pos_device = '001_code'
 code_pos_data_type = '002_data_type'
 code_pos_tf32 = '003_tf32'
@@ -35,16 +36,8 @@ def get_inital_config():
 
     appConfig = load_app_config()
 
-    # default model is None
     model_configs = appConfig.get("models", {})
-    # default model is None
-    models = list(model_configs.keys())
-    model = None
-    
-    # default scheduler is None
     scheduler_configs = appConfig.get("schedulers", {})
-    schedulers = list(scheduler_configs.keys())
-    scheduler = None
     
     # default device
     devices =  appConfig.get("devices", [])
@@ -65,7 +58,7 @@ def get_inital_config():
         "model": None,
         "scheduler": None,
         "variant": None,
-        "allow_tensorflow32": allow_tensorfloat32,
+        "allow_tensorfloat32": allow_tensorfloat32,
         "use_safetensors": False,
         "data_type": data_type,
         "safety_checker": False,
@@ -78,21 +71,19 @@ def get_inital_config():
     }
 
     # code output order
-    code = {}
-
     code[code_pos_device] = f'device = "{device}"'
-    code[code_pos_variant] = f'variant = {initial_config['variant']}'
-    code[code_pos_tf32] = f'torch.backends.cuda.matmul.allow_tf32 = {initial_config['allow_tensorfloat32']}'
+    code[code_pos_variant] = f'variant = {initial_config["variant"]}'
+    code[code_pos_tf32] = f'torch.backends.cuda.matmul.allow_tf32 = {initial_config["allow_tensorfloat32"]}'
     code[code_pos_data_type] = 'data_type = torch.bfloat16'
     code[code_pos_init_pipeline] = 'sys.exit("No model selected!")'
     code[code_pos_safety_checker] = 'pipeline.safety_checker = None'
-    code[code_pos_requires_safety_checker] = f'pipeline.requires_safety_checker = {initial_config['requires_safety_checker']}'
+    code[code_pos_requires_safety_checker] = f'pipeline.requires_safety_checker = {initial_config["requires_safety_checker"]}'
     code[code_pos_scheduler] = 'sys.exit("No scheduler selected!")'
     code[code_pos_generator] = f'generator = torch.Generator("{device}")'
-    code[code_pos_prompt] = f'prompt = "{initial_config['prompt']}"'
-    code[code_pos_negative_prompt] = f'negative_prompt = "{initial_config['negative_prompt']}"'
-    code[code_pos_inference_steps] = f'inference_steps = {initial_config['inference_steps']}'
-    code[code_pos_guidance_scale] = f'guidance_scale = {initial_config['guidance_scale']}'
+    code[code_pos_prompt] = f'prompt = "{initial_config["prompt"]}"'
+    code[code_pos_negative_prompt] = f'negative_prompt = "{initial_config["negative_prompt"]}"'
+    code[code_pos_inference_steps] = f'inference_steps = {initial_config["inference_steps"]}'
+    code[code_pos_guidance_scale] = f'guidance_scale = {initial_config["guidance_scale"]}'
     code[code_pos_run_inference] = f'''image = pipeline(
         prompt=prompt,
         negative_prompt=negative_prompt,
@@ -100,7 +91,7 @@ def get_inital_config():
         num_inference_steps=inference_steps, 
         guidance_scale=guidance_scale).images[0]'''
 
-    return initial_config, devices, models, schedulers, code
+    return initial_config, devices, model_configs, scheduler_configs, code
 
 def init_config(request: gr.Request, inital_config):