Pbars

app.py

@@ -16,6 +16,9 @@ class Demo:
 
     def __init__(self) -> None:
 
+        self.training = False
+        self.generating = False
+
         with gr.Blocks() as demo:
             self.layout()
             demo.queue(concurrency_count=10).launch()
@@ -56,9 +59,10 @@ class Demo:
                     label="Learning Rate",
                     info='Learning rate used to train'
                 )
+                self.progress_bar = gr.Text(interactive=False, label="Training Progress")
+
                 self.train_button = gr.Button(
                     value="Train",
-                    
                 )
                 
                 
@@ -107,11 +111,16 @@ class Demo:
                         self.iterations_input,
                         self.lr_input
                     ],
-                    outputs=[self.train_button, self.infr_button]
+                    outputs=[self.train_button, self.infr_button, self.progress_bar]
                 )
 
     def train(self, prompt, train_method, neg_guidance, iterations, lr, pbar = gr.Progress(track_tqdm=True)):
 
+        if self.training:
+            return [None, None, None]
+        else:
+            self.training = True
+
         model_orig, model_edited = train_esd(prompt,
                 train_method,
                 3,
@@ -132,7 +141,7 @@ class Demo:
 
         self.init_inference(model_edited_sd, model_orig_sd, unet_config)
 
-        return [gr.update(interactive=True), gr.update(interactive=True)]
+        return [gr.update(interactive=True), gr.update(interactive=True), None]
 
     def init_inference(self, model_edited_sd, model_orig_sd, unet_config):
 
@@ -144,9 +153,16 @@ class Demo:
         self.diffuser.unet = UNet2DConditionModel(**unet_config)
         self.diffuser.to('cuda')
 
+        self.training = False
+
 
     def inference(self, prompt):
 
+        if self.generating:
+            return [None, None]
+        else:
+            self.generating = True
+
         self.diffuser.unet.load_state_dict(self.model_orig_sd)
 
         images = self.diffuser(
@@ -167,6 +183,8 @@ class Demo:
 
         edited_image = images[0][0]
 
+        self.generating = False
+
         return edited_image, orig_image
 
 

test.py

@@ -1,32 +1,39 @@
-import sys
-sys.path.insert(0,'stable_diffusion')
-from train_esd import train_esd
-import torch
-ckpt_path = "stable_diffusion/models/ldm/sd-v1-4-full-ema.ckpt"
-config_path = "stable_diffusion/configs/stable-diffusion/v1-inference.yaml"
-diffusers_config_path = "stable_diffusion/config.json"
-
-orig, newm = train_esd("England",
-              'xattn',
-              3,
-              1,
-              2,
-              .003,
-              config_path,
-              ckpt_path, 
-              diffusers_config_path,
-              ['cuda', 'cuda'],
-              None
-              )
-
-
-from convertModels import convert_ldm_unet_checkpoint, create_unet_diffusers_config
-from diffusers import UNet2DConditionModel, AutoencoderKL, LMSDiscreteScheduler
-from omegaconf import OmegaConf
-from transformers import CLIPTextModel, CLIPTokenizer
-original_config = OmegaConf.load(config_path)
-original_config["model"]["params"]["unet_config"]["params"]["in_channels"] = 4
-unet_config = create_unet_diffusers_config(original_config, image_size=512)
-converted_unet_checkpoint = convert_ldm_unet_checkpoint(newm.state_dict(), unet_config)
-unet = UNet2DConditionModel(**unet_config)
-unet.load_state_dict(converted_unet_checkpoint)
+import gradio as gr
+
+
+import gradio as gr
+import time
+
+def slowly_reverse(word, progress=gr.Progress()):
+    progress(0, desc="Starting")
+    time.sleep(1)
+    progress(0.05)
+    new_string = ""
+    for letter in progress.tqdm(word, desc="Reversing"):
+        time.sleep(0.25)
+        new_string = letter + new_string
+    return new_string, None
+
+with gr.Blocks() as demo:
+
+    with gr.Row(elem_id=123) as row:
+
+        t1 = gr.Text()
+        t2 = gr.Text()
+
+        b = gr.Button("Test")
+
+        
+    with gr.Row():
+
+        sl = gr.Text(interactive=False)
+
+
+        b.click(slowly_reverse,
+            inputs = [t1],
+            outputs= [t2, sl],
+            show_progress=True
+            )
+
+
+    demo.queue(concurrency_count=10).launch()