refactoring and new feature: history

app.py

@@ -20,7 +20,8 @@ import requests
 from flask import Flask, render_template_string
 from gradio import Interface
 from diffusers import AutoencoderKL
-
+import pandas as pd 
+import base64
 
 def load_app_config():
     global appConfig
@@ -46,15 +47,24 @@ code_pos_init_pipeline = '050_init_pipe'
 code_pos_requires_safety_checker = '054_requires_safety_checker'
 code_pos_safety_checker = '055_safety_checker'
 code_pos_scheduler = '060_scheduler'
+code_pos_generator = '070_generator'
+code_pos_prompt = '080_prompt'
+code_pos_negative_prompt = '085_negative_prompt'
+code_pos_inference_steps = '090_inference_steps'
+code_pos_guidance_scale = '095_guidance_scale'
+code_pos_run_inference = '100_run_inference'
 
 # model config
 model_configs = appConfig.get("models", {})
 models = list(model_configs.keys())
+model = None
 scheduler_configs = appConfig.get("schedulers", {})
 schedulers = list(scheduler_configs.keys())
-devices =  appConfig.get("devices", [])
+scheduler = None
 
+devices =  appConfig.get("devices", [])
 device = None
+
 variant = None
 allow_tensorfloat32 = False
 use_safetensors = False
@@ -77,6 +87,25 @@ elif torch.backends.mps.is_available():
 else:
     device = "cpu" 
 
+# inference config
+current_config = {
+    "device": device,
+    "model": model,
+    "scheduler": scheduler,
+    "variant": variant,
+    "allow_tensorflow": allow_tensorfloat32,
+    "use_safetensors": use_safetensors,
+    "data_type": data_type,
+    "safety_checker": safety_checker,
+    "requires_safety_checker": requires_safety_checker,
+    "manual_seed": manual_seed,
+    "inference_steps": inference_steps,
+    "guidance_scale": guidance_scale,
+    "prompt": prompt,
+    "negative_prompt": negative_prompt,
+}
+config_history = [current_config]
+
 def get_sorted_code():
     
     return '\r\n'.join(value[1] for value in sorted(code.items()))
@@ -90,6 +119,7 @@ def device_change(device):
 
 def models_change(model, scheduler):
         
+    print(model)
     use_safetensors = False
     
     # no model selected (because this is UI init run)
@@ -111,6 +141,7 @@ def models_change(model, scheduler):
     safety_checker_change(safety_checker)
     requires_safety_checker_change(requires_safety_checker)
     
+    print(use_safetensors)
     return get_sorted_code(), use_safetensors, scheduler
 
 def data_type_change(selected_data_type):
@@ -197,7 +228,7 @@ def get_scheduler(scheduler, config):
         return DPMSolverMultistepScheduler.from_config(config)
     
 # pipeline
-def start_pipeline(model,
+def run_inference(model,
                     device, 
                     use_safetensors, 
                     data_type, 
@@ -235,17 +266,22 @@ def start_pipeline(model,
                 
         pipeline.scheduler = get_scheduler(scheduler, pipeline.scheduler.config)
         
-        generator = torch.Generator(device)
+        
+        if manual_seed < 0 or manual_seed is None or manual_seed == '':
+            generator = torch.Generator(device)
+        else:
+            generator = torch.manual_seed(42) 
         
         progress((3,3), desc="Creating the result...")
 
         image = pipeline(
             prompt=prompt,
             negative_prompt=negative_prompt,
-            generator=generator.manual_seed(int(manual_seed)),
+            generator=generator,
             num_inference_steps=int(inference_steps), 
             guidance_scale=float(guidance_scale)).images[0]
-            
+    
+
         return "Done.", image
     
     else:
@@ -260,6 +296,46 @@ 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 = {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 = "{prompt}"'
+code[code_pos_negative_prompt] = f'negative_prompt = "{negative_prompt}"'
+code[code_pos_inference_steps] = f'inference_steps = {inference_steps}'
+code[code_pos_guidance_scale] = f'guidance_scale = {guidance_scale}'
+code[code_pos_run_inference] = f'''image = pipeline(
+    prompt=prompt,
+    negative_prompt=negative_prompt,
+    generator=generator.manual_seed(manual_seed),
+    num_inference_steps=inference_steps, 
+    guidance_scale=guidance_scale).images[0]'''
+    
+def dict_list_to_markdown_table(data):
+    if not data:
+        return ""
+
+    headers = list(data[0].keys())
+    markdown_table = "| action | " + " | ".join(headers) + " |\n"
+    markdown_table += "| ---  | " + " | ".join(["---"] * len(headers)) + " |\n"
+
+    for i, row in enumerate(data):
+        # Encode row's content in base64 for sharing
+        encoded_row = base64.b64encode(str(row).encode()).decode()
+        # Create link to share the row's content
+        share_link = f'<a href="share/{encoded_row}">📎</a>'
+        # Create link to remove the row
+        remove_link = f'<a href="remove/{i}">❌</a>'
+        # Construct the row with links
+        markdown_table += f"| {share_link} &nbsp; {remove_link} | " + " | ".join(str(row.get(key, "")) for key in headers) + " |\n"
+
+    # Wrap the Markdown table in a <div> tag with horizontal scrolling
+    markdown_table = '<div style="overflow-x: auto;">\n\n' + markdown_table + '</div>'
+
+    return markdown_table
+
+@app.route('/remove/<int:index>')
+def remove_row(index):
+    if 0 <= index < len(data):
+        del data[index]
+    return "Row removed successfully"
 
 # interface
 with gr.Blocks() as demo:
@@ -270,25 +346,25 @@ with gr.Blocks() as demo:
                 </small>''')
     gr.Markdown("### Device specific settings")
     with gr.Row():
-        el_devices = gr.Dropdown(label="Device:", value=device, choices=devices, filterable=True, multiselect=False, allow_custom_value=True)
-        rg_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")
-        rg_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 ")
-        rg_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 ")
+        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_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 ")
         
     gr.Markdown("### Model specific settings")
     with gr.Row():
-        dd_models = gr.Dropdown(choices=models, label="Model", )
+        in_models = gr.Dropdown(choices=models, label="Model")
     with gr.Row():
         with gr.Column(scale=1):
-            rg_use_safetensors = gr.Radio(label="Use safe tensors:", choices=["True", "False"], interactive=False)
+            in_use_safetensors = gr.Radio(label="Use safe tensors:", choices=["True", "False"], interactive=False)
         with gr.Column(scale=1):
-            rg_safety_checker = gr.Radio(label="Enable safety checker:", value=safety_checker, choices=[True, False])
-            rg_requires_safety_checker = gr.Radio(label="Requires safety checker:", value=requires_safety_checker, choices=[True, False])
+            in_safety_checker = gr.Radio(label="Enable safety checker:", value=safety_checker, choices=[True, False])
+            in_requires_safety_checker = gr.Radio(label="Requires safety checker:", value=requires_safety_checker, choices=[True, False])
 
     gr.Markdown("### Scheduler")
     with gr.Row():
-        dd_schedulers = gr.Dropdown(choices=schedulers, label="Scheduler", info="see https://huggingface.co/docs/diffusers/using-diffusers/loading#schedulers" )
-        txt_scheduler = gr.Textbox(value="", label="Description")
+        in_schedulers = gr.Dropdown(choices=schedulers, label="Scheduler", info="see https://huggingface.co/docs/diffusers/using-diffusers/loading#schedulers" )
+        out_scheduler_description = gr.Textbox(value="", label="Description")
     
     gr.Markdown("### Adapters")
     with gr.Row():
@@ -296,43 +372,47 @@ with gr.Blocks() as demo:
         
     gr.Markdown("### Inference settings")
     with gr.Row():
-        el_prompt = gr.TextArea(label="Prompt", value=prompt)
-        el_negative_prompt = gr.TextArea(label="Negative prompt", value=negative_prompt)
+        in_prompt = gr.TextArea(label="Prompt", value=prompt)
+        in_negative_prompt = gr.TextArea(label="Negative prompt", value=negative_prompt)
     with gr.Row():
-        el_inference_steps = gr.Textbox(label="Inference steps", value=inference_steps)
-        el_manual_seed = gr.Textbox(label="Manual seed", value=manual_seed)
-        el_guidance_scale = gr.Textbox(label="Guidance Scale", 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.Textbox(label="Inference steps", value=inference_steps)
+        in_manual_seed = gr.Textbox(label="Manual seed", 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")
+        in_guidance_scale = gr.Textbox(label="Guidance Scale", 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.")
         
     gr.Markdown("### Output")
     with gr.Row():
         btn_start_pipeline = gr.Button(value="Run inferencing")
     with gr.Row():
-        tb_result = gr.Textbox(label="Status", value="")
-        el_result = gr.Image()
-        txt_code = gr.Code(get_sorted_code(), label="Code")
+        # out_result = gr.Textbox(label="Status", value="")
+        out_image = gr.Image()
+        out_code = gr.Code(get_sorted_code(), label="Code")
+    with gr.Row():
+        out_current_config = gr.Code(value=str(current_config), label="Current config")
+    with gr.Row():
+        out_config_history = gr.Markdown(dict_list_to_markdown_table(config_history))
     
-    el_devices.change(device_change, inputs=[el_devices], outputs=[txt_code])
-    rg_data_type.change(data_type_change, inputs=[rg_data_type], outputs=[txt_code])
-    rg_allow_tensorfloat32.change(tensorfloat32_change, inputs=[rg_allow_tensorfloat32], outputs=[txt_code])
-    rg_variant.change(variant_change, inputs=[rg_variant], outputs=[txt_code])
-    dd_models.change(models_change, inputs=[dd_models, dd_schedulers], outputs=[txt_code, rg_use_safetensors, dd_schedulers])
-    rg_safety_checker.change(safety_checker_change, inputs=[rg_safety_checker], outputs=[txt_code])
-    rg_requires_safety_checker.change(requires_safety_checker_change, inputs=[rg_requires_safety_checker], outputs=[txt_code])
-    dd_schedulers.change(schedulers_change, inputs=[dd_schedulers], outputs=[txt_code, txt_scheduler])
-    btn_start_pipeline.click(start_pipeline, inputs=[
-        dd_models, 
-        el_devices,
-        rg_use_safetensors,
-        rg_data_type,
-        rg_variant,
-        rg_safety_checker,
-        rg_requires_safety_checker,
-        dd_schedulers,
-        el_prompt,
-        el_negative_prompt,
-        el_inference_steps,
-        el_manual_seed,
-        el_guidance_scale
-        ], outputs=[tb_result, el_result])
+    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])
+    btn_start_pipeline.click(run_inference, inputs=[
+        in_models, 
+        in_devices,
+        in_use_safetensors,
+        in_data_type,
+        in_variant,
+        in_safety_checker,
+        in_requires_safety_checker,
+        in_schedulers,
+        in_prompt,
+        in_negative_prompt,
+        in_inference_steps,
+        in_manual_seed,
+        in_guidance_scale
+        ], outputs=[out_image])
         
 demo.launch()

requirements.txt

@@ -5,4 +5,5 @@ torch==2.2.1
 gunicorn
 urllib3==1.26.6
 transformers
-gradio
+gradio
+stripe>=9.0.0