updated with latest changes

app.py

@@ -1,11 +1,14 @@
 from app_settings import AppSettings
 from utils import show_system_info
+from PIL import Image
+from backend.models.lcmdiffusion_setting import DiffusionTask
 import constants
 from argparse import ArgumentParser
-from context import Context
+
 from constants import APP_VERSION, LCM_DEFAULT_MODEL_OPENVINO
 from models.interface_types import InterfaceType
 from constants import DEVICE
+from state import get_settings, get_context
 
 parser = ArgumentParser(description=f"FAST SD CPU {constants.APP_VERSION}")
 parser.add_argument(
@@ -128,10 +131,23 @@ parser.add_argument(
     help="Interactive CLI mode",
 )
 parser.add_argument(
+    "-t",
     "--use_tiny_auto_encoder",
     action="store_true",
     help="Use tiny auto encoder for SD (TAESD)",
 )
+parser.add_argument(
+    "-f",
+    "--file",
+    type=str,
+    help="Input image for img2img mode",
+    default="",
+)
+parser.add_argument(
+    "--img2img",
+    action="store_true",
+    help="img2img mode; requires input file via -f argument",
+)
 args = parser.parse_args()
 
 if args.version:
@@ -141,8 +157,12 @@ if args.version:
 # parser.print_help()
 show_system_info()
 print(f"Using device : {constants.DEVICE}")
-app_settings = AppSettings()
-app_settings.load()
+if args.webui:
+    app_settings = get_settings()
+else:
+    app_settings = get_settings()
+
+print(f"Found {len(app_settings.lcm_models)} LCM models in config/lcm-models.txt")
 print(
     f"Found {len(app_settings.stable_diffsuion_models)} stable diffusion models in config/stable-diffusion-models.txt"
 )
@@ -152,8 +172,76 @@ print(
 print(
     f"Found {len(app_settings.openvino_lcm_models)} OpenVINO LCM models in config/openvino-lcm-models.txt"
 )
+if args.gui:
+    from frontend.gui.ui import start_gui
+
+    print("Starting desktop GUI mode(Qt)")
+    start_gui(
+        [],
+        app_settings,
+    )
+elif args.webui:
+    from frontend.webui.ui import start_webui
+
+    print("Starting web UI mode")
+    start_webui(
+        args.share,
+    )
+elif args.realtime:
+    from frontend.webui.realtime_ui import start_realtime_text_to_image
+
+    print("Starting realtime text to image(EXPERIMENTAL)")
+    start_realtime_text_to_image(args.share)
+else:
+    context = get_context(InterfaceType.CLI)
+    config = app_settings.settings
+
+    if args.use_openvino:
+        config.lcm_diffusion_setting.lcm_model_id = LCM_DEFAULT_MODEL_OPENVINO
+    else:
+        config.lcm_diffusion_setting.lcm_model_id = args.lcm_model_id
+
+    config.lcm_diffusion_setting.prompt = args.prompt
+    config.lcm_diffusion_setting.image_height = args.image_height
+    config.lcm_diffusion_setting.image_width = args.image_width
+    config.lcm_diffusion_setting.guidance_scale = args.guidance_scale
+    config.lcm_diffusion_setting.number_of_images = args.number_of_images
+    config.lcm_diffusion_setting.inference_steps = args.inference_steps
+    config.lcm_diffusion_setting.seed = args.seed
+    config.lcm_diffusion_setting.use_openvino = args.use_openvino
+    config.lcm_diffusion_setting.use_tiny_auto_encoder = args.use_tiny_auto_encoder
+    config.lcm_diffusion_setting.use_lcm_lora = args.use_lcm_lora
+    config.lcm_diffusion_setting.lcm_lora.base_model_id = args.base_model_id
+    config.lcm_diffusion_setting.lcm_lora.lcm_lora_id = args.lcm_lora_id
+    config.lcm_diffusion_setting.diffusion_task = DiffusionTask.text_to_image.value
+
+    if args.img2img and args.file != "" :
+        config.lcm_diffusion_setting.init_image = Image.open(args.file)
+        config.lcm_diffusion_setting.diffusion_task = DiffusionTask.image_to_image.value
+    elif args.img2img and args.file == "":
+        print("You need to specify a file in img2img mode")
+        exit()
+
+    if args.seed > -1:
+        config.lcm_diffusion_setting.use_seed = True
+    else:
+        config.lcm_diffusion_setting.use_seed = False
+    config.lcm_diffusion_setting.use_offline_model = args.use_offline_model
+    config.lcm_diffusion_setting.use_safety_checker = args.use_safety_checker
 
-from frontend.webui.hf_demo import start_demo_text_to_image
+    if args.interactive:
+        while True:
+            user_input = input(">>")
+            if user_input == "exit":
+                break
+            config.lcm_diffusion_setting.prompt = user_input
+            context.generate_text_to_image(
+                settings=config,
+                device=DEVICE,
+            )
 
-print("Starting demo text to image")
-start_demo_text_to_image(False)
+    else:
+        context.generate_text_to_image(
+            settings=config,
+            device=DEVICE,
+        )

app_settings.py

@@ -3,15 +3,30 @@ from os import path, makedirs
 from models.settings import Settings
 from paths import FastStableDiffusionPaths
 from utils import get_models_from_text_file
-from constants import OPENVINO_LCM_MODELS_FILE, LCM_LORA_MODELS_FILE, SD_MODELS_FILE
+from constants import (
+    OPENVINO_LCM_MODELS_FILE,
+    LCM_LORA_MODELS_FILE,
+    SD_MODELS_FILE,
+    LCM_MODELS_FILE,
+)
+from copy import deepcopy
 
 
 class AppSettings:
     def __init__(self):
         self.config_path = FastStableDiffusionPaths().get_app_settings_path()
-        self._stable_diffsuion_models = ["Lykon/dreamshaper-7"]
-        self._lcm_lora_models = ["latent-consistency/lcm-lora-sdv1-5"]
-        self._openvino_lcm_models = ["rupeshs/LCM-dreamshaper-v7-openvino"]
+        self._stable_diffsuion_models = get_models_from_text_file(
+            FastStableDiffusionPaths().get_models_config_path(SD_MODELS_FILE)
+        )
+        self._lcm_lora_models = get_models_from_text_file(
+            FastStableDiffusionPaths().get_models_config_path(LCM_LORA_MODELS_FILE)
+        )
+        self._openvino_lcm_models = get_models_from_text_file(
+            FastStableDiffusionPaths().get_models_config_path(OPENVINO_LCM_MODELS_FILE)
+        )
+        self._lcm_models = get_models_from_text_file(
+            FastStableDiffusionPaths().get_models_config_path(LCM_MODELS_FILE)
+        )
 
     @property
     def settings(self):
@@ -25,36 +40,47 @@ class AppSettings:
     def openvino_lcm_models(self):
         return self._openvino_lcm_models
 
+    @property
+    def lcm_models(self):
+        return self._lcm_models
+
     @property
     def lcm_lora_models(self):
         return self._lcm_lora_models
 
-    def load(self):
-        if not path.exists(self.config_path):
-            base_dir = path.dirname(self.config_path)
-            if not path.exists(base_dir):
-                makedirs(base_dir)
+    def load(self, skip_file=False):
+        if skip_file:
+            print("Skipping config file")
+            settings_dict = self._load_default()
+            self._config = Settings.parse_obj(settings_dict)
+        else:
+            if not path.exists(self.config_path):
+                base_dir = path.dirname(self.config_path)
+                if not path.exists(base_dir):
+                    makedirs(base_dir)
+                try:
+                    print("Settings not found creating default settings")
+                    with open(self.config_path, "w") as file:
+                        yaml.dump(
+                            self._load_default(),
+                            file,
+                        )
+                except Exception as ex:
+                    print(f"Error in creating settings : {ex}")
+                    exit()
             try:
-                print("Settings not found creating default settings")
-                with open(self.config_path, "w") as file:
-                    yaml.dump(
-                        self._load_default(),
-                        file,
-                    )
+                with open(self.config_path) as file:
+                    settings_dict = yaml.safe_load(file)
+                    self._config = Settings.parse_obj(settings_dict)
             except Exception as ex:
-                print(f"Error in creating settings : {ex}")
-                exit()
-        try:
-            with open(self.config_path) as file:
-                settings_dict = yaml.safe_load(file)
-                self._config = Settings.parse_obj(settings_dict)
-        except Exception as ex:
-            print(f"Error in loading settings : {ex}")
+                print(f"Error in loading settings : {ex}")
 
     def save(self):
         try:
             with open(self.config_path, "w") as file:
-                yaml.dump(self._config.dict(), file)
+                tmp_cfg = deepcopy(self._config)
+                tmp_cfg.lcm_diffusion_setting.init_image = None
+                yaml.dump(tmp_cfg.dict(), file)
         except Exception as ex:
             print(f"Error in saving settings : {ex}")
 

backend/image_saver.py

@@ -15,6 +15,7 @@ class ImageSaver:
         lcm_diffusion_setting: LCMDiffusionSetting = None,
     ) -> None:
         gen_id = uuid4()
+
         for index, image in enumerate(images):
             if not path.exists(output_path):
                 mkdir(output_path)
@@ -33,7 +34,7 @@ class ImageSaver:
         if lcm_diffusion_setting:
             with open(path.join(out_path, f"{gen_id}.json"), "w") as json_file:
                 json.dump(
-                    lcm_diffusion_setting.model_dump(),
+                    lcm_diffusion_setting.model_dump(exclude="init_image"),
                     json_file,
                     indent=4,
                 )

backend/lcm_text_to_image.py

@@ -1,52 +1,25 @@
 from typing import Any
-from diffusers import (
-    DiffusionPipeline,
-    AutoencoderTiny,
-    LCMScheduler,
-    UNet2DConditionModel,
-)
-from os import path
+from diffusers import LCMScheduler
 import torch
 from backend.models.lcmdiffusion_setting import LCMDiffusionSetting
 import numpy as np
-from constants import (
-    DEVICE,
-    LCM_DEFAULT_MODEL,
-    TAESD_MODEL,
-    TAESDXL_MODEL,
-    TAESD_MODEL_OPENVINO,
-)
-from huggingface_hub import model_info
+from constants import DEVICE
 from backend.models.lcmdiffusion_setting import LCMLora
 from backend.device import is_openvino_device
-
-if is_openvino_device():
-    from huggingface_hub import snapshot_download
-    from optimum.intel.openvino.modeling_diffusion import OVModelVaeDecoder, OVBaseModel
-
-    # from optimum.intel.openvino.modeling_diffusion import OVStableDiffusionPipeline
-    from backend.lcmdiffusion.pipelines.openvino.lcm_ov_pipeline import (
-        OVStableDiffusionPipeline,
-    )
-    from backend.lcmdiffusion.pipelines.openvino.lcm_scheduler import (
-        LCMScheduler as OpenVinoLCMscheduler,
-    )
-
-    class CustomOVModelVaeDecoder(OVModelVaeDecoder):
-        def __init__(
-            self,
-            model,
-            parent_model,
-            ov_config=None,
-            model_dir=None,
-        ):
-            super(OVModelVaeDecoder, self).__init__(
-                model,
-                parent_model,
-                ov_config,
-                "vae_decoder",
-                model_dir,
-            )
+from backend.openvino.pipelines import (
+    get_ov_text_to_image_pipeline,
+    ov_load_taesd,
+    get_ov_image_to_image_pipeline,
+)
+from backend.pipelines.lcm import (
+    get_lcm_model_pipeline,
+    load_taesd,
+    get_image_to_image_pipeline,
+)
+from backend.pipelines.lcm_lora import get_lcm_lora_pipeline
+from backend.models.lcmdiffusion_setting import DiffusionTask
+from image_ops import resize_pil_image
+from math import ceil
 
 
 class LCMTextToImage:
@@ -60,95 +33,17 @@ class LCMTextToImage:
         self.previous_model_id = None
         self.previous_use_tae_sd = False
         self.previous_use_lcm_lora = False
+        self.previous_ov_model_id = ""
+        self.previous_safety_checker = False
+        self.previous_use_openvino = False
+        self.img_to_img_pipeline = None
+        self.is_openvino_init = False
+        self.task_type = DiffusionTask.text_to_image
         self.torch_data_type = (
             torch.float32 if is_openvino_device() or DEVICE == "mps" else torch.float16
         )
         print(f"Torch datatype : {self.torch_data_type}")
 
-    def _get_lcm_pipeline(
-        self,
-        lcm_model_id: str,
-        base_model_id: str,
-        use_local_model: bool,
-    ):
-        pipeline = None
-        unet = UNet2DConditionModel.from_pretrained(
-            lcm_model_id,
-            torch_dtype=torch.float32,
-            local_files_only=use_local_model
-            # resume_download=True,
-        )
-        pipeline = DiffusionPipeline.from_pretrained(
-            base_model_id,
-            unet=unet,
-            torch_dtype=torch.float32,
-            local_files_only=use_local_model
-            # resume_download=True,
-        )
-        pipeline.scheduler = LCMScheduler.from_config(pipeline.scheduler.config)
-        return pipeline
-
-    def get_tiny_decoder_vae_model(self) -> str:
-        pipeline_class = self.pipeline.__class__.__name__
-        print(f"Pipeline class : {pipeline_class}")
-        if (
-            pipeline_class == "LatentConsistencyModelPipeline"
-            or pipeline_class == "StableDiffusionPipeline"
-        ):
-            return TAESD_MODEL
-        elif pipeline_class == "StableDiffusionXLPipeline":
-            return TAESDXL_MODEL
-        elif pipeline_class == "OVStableDiffusionPipeline":
-            return TAESD_MODEL_OPENVINO
-
-    def _get_lcm_model_pipeline(
-        self,
-        model_id: str,
-        use_local_model,
-    ):
-        pipeline = None
-        if model_id == LCM_DEFAULT_MODEL:
-            pipeline = DiffusionPipeline.from_pretrained(
-                model_id,
-                local_files_only=use_local_model,
-            )
-        elif model_id == "latent-consistency/lcm-sdxl":
-            pipeline = self._get_lcm_pipeline(
-                model_id,
-                "stabilityai/stable-diffusion-xl-base-1.0",
-                use_local_model,
-            )
-
-        elif model_id == "latent-consistency/lcm-ssd-1b":
-            pipeline = self._get_lcm_pipeline(
-                model_id,
-                "segmind/SSD-1B",
-                use_local_model,
-            )
-        return pipeline
-
-    def _get_lcm_lora_pipeline(
-        self,
-        base_model_id: str,
-        lcm_lora_id: str,
-        use_local_model: bool,
-    ):
-        pipeline = DiffusionPipeline.from_pretrained(
-            base_model_id,
-            torch_dtype=self.torch_data_type,
-            local_files_only=use_local_model,
-        )
-        pipeline.load_lora_weights(
-            lcm_lora_id,
-            local_files_only=use_local_model,
-        )
-
-        pipeline.scheduler = LCMScheduler.from_config(pipeline.scheduler.config)
-
-        pipeline.fuse_lora()
-        pipeline.unet.to(memory_format=torch.channels_last)
-        return pipeline
-
     def _pipeline_to_device(self):
         print(f"Pipeline device : {DEVICE}")
         print(f"Pipeline dtype : {self.torch_data_type}")
@@ -159,37 +54,53 @@ class LCMTextToImage:
 
     def _add_freeu(self):
         pipeline_class = self.pipeline.__class__.__name__
-        if pipeline_class == "StableDiffusionPipeline":
-            print("Add FreeU - SD")
-            self.pipeline.enable_freeu(
-                s1=0.9,
-                s2=0.2,
-                b1=1.2,
-                b2=1.4,
-            )
-        elif pipeline_class == "StableDiffusionXLPipeline":
-            print("Add FreeU - SDXL")
-            self.pipeline.enable_freeu(
-                s1=0.6,
-                s2=0.4,
-                b1=1.1,
-                b2=1.2,
+        if isinstance(self.pipeline.scheduler, LCMScheduler):
+            if pipeline_class == "StableDiffusionPipeline":
+                print("Add FreeU - SD")
+                self.pipeline.enable_freeu(
+                    s1=0.9,
+                    s2=0.2,
+                    b1=1.2,
+                    b2=1.4,
+                )
+            elif pipeline_class == "StableDiffusionXLPipeline":
+                print("Add FreeU - SDXL")
+                self.pipeline.enable_freeu(
+                    s1=0.6,
+                    s2=0.4,
+                    b1=1.1,
+                    b2=1.2,
+                )
+
+    def _update_lcm_scheduler_params(self):
+        if isinstance(self.pipeline.scheduler, LCMScheduler):
+            self.pipeline.scheduler = LCMScheduler.from_config(
+                self.pipeline.scheduler.config,
+                beta_start=0.001,
+                beta_end=0.01,
             )
 
     def init(
         self,
-        model_id: str,
-        use_openvino: bool = False,
         device: str = "cpu",
-        use_local_model: bool = False,
-        use_tiny_auto_encoder: bool = False,
-        use_lora: bool = False,
-        lcm_lora: LCMLora = LCMLora(),
+        lcm_diffusion_setting: LCMDiffusionSetting = LCMDiffusionSetting(),
     ) -> None:
         self.device = device
-        self.use_openvino = use_openvino
-        print(f"use_openvino {self.use_openvino}")
-        print(f"is_openvino {is_openvino_device()}")
+        self.use_openvino = lcm_diffusion_setting.use_openvino
+        model_id = lcm_diffusion_setting.lcm_model_id
+        use_local_model = lcm_diffusion_setting.use_offline_model
+        use_tiny_auto_encoder = lcm_diffusion_setting.use_tiny_auto_encoder
+        use_lora = lcm_diffusion_setting.use_lcm_lora
+        lcm_lora: LCMLora = lcm_diffusion_setting.lcm_lora
+        ov_model_id = lcm_diffusion_setting.openvino_lcm_model_id
+
+        if lcm_diffusion_setting.diffusion_task == DiffusionTask.image_to_image.value:
+            lcm_diffusion_setting.init_image = resize_pil_image(
+                lcm_diffusion_setting.init_image,
+                lcm_diffusion_setting.image_width,
+                lcm_diffusion_setting.image_height,
+            )
+
         if (
             self.pipeline is None
             or self.previous_model_id != model_id
@@ -197,77 +108,132 @@ class LCMTextToImage:
             or self.previous_lcm_lora_base_id != lcm_lora.base_model_id
             or self.previous_lcm_lora_id != lcm_lora.lcm_lora_id
             or self.previous_use_lcm_lora != use_lora
+            or self.previous_ov_model_id != ov_model_id
+            or self.previous_safety_checker != lcm_diffusion_setting.use_safety_checker
+            or self.previous_use_openvino != lcm_diffusion_setting.use_openvino
+            or self.previous_task_type != lcm_diffusion_setting.diffusion_task
         ):
             if self.use_openvino and is_openvino_device():
                 if self.pipeline:
                     del self.pipeline
                     self.pipeline = None
-
-                self.pipeline = OVStableDiffusionPipeline.from_pretrained(
-                    model_id,
-                    local_files_only=use_local_model,
-                    ov_config={"CACHE_DIR": ""},
-                    device=DEVICE.upper(),
-                )
-
-                if use_tiny_auto_encoder:
-                    print("Using Tiny Auto Encoder (OpenVINO)")
-                    taesd_dir = snapshot_download(
-                        repo_id=self.get_tiny_decoder_vae_model(),
-                        local_files_only=use_local_model,
+                self.is_openvino_init = True
+                if (
+                    lcm_diffusion_setting.diffusion_task
+                    == DiffusionTask.text_to_image.value
+                ):
+                    print(f"***** Init Text to image (OpenVINO) - {ov_model_id} *****")
+                    self.pipeline = get_ov_text_to_image_pipeline(
+                        ov_model_id,
+                        use_local_model,
                     )
-                    self.pipeline.vae_decoder = CustomOVModelVaeDecoder(
-                        model=OVBaseModel.load_model(
-                            f"{taesd_dir}/vae_decoder/openvino_model.xml"
-                        ),
-                        parent_model=self.pipeline,
-                        model_dir=taesd_dir,
+                elif (
+                    lcm_diffusion_setting.diffusion_task
+                    == DiffusionTask.image_to_image.value
+                ):
+                    print(f"***** Image to image (OpenVINO) - {ov_model_id} *****")
+                    self.pipeline = get_ov_image_to_image_pipeline(
+                        ov_model_id,
+                        use_local_model,
                     )
-
             else:
                 if self.pipeline:
                     del self.pipeline
                     self.pipeline = None
+                if self.img_to_img_pipeline:
+                    del self.img_to_img_pipeline
+                    self.img_to_img_pipeline = None
 
                 if use_lora:
-                    print("Init LCM-LoRA pipeline")
-                    self.pipeline = self._get_lcm_lora_pipeline(
+                    print(
+                        f"***** Init LCM-LoRA pipeline - {lcm_lora.base_model_id} *****"
+                    )
+                    self.pipeline = get_lcm_lora_pipeline(
                         lcm_lora.base_model_id,
                         lcm_lora.lcm_lora_id,
                         use_local_model,
+                        torch_data_type=self.torch_data_type,
                     )
                 else:
-                    print("Init LCM Model pipeline")
-                    self.pipeline = self._get_lcm_model_pipeline(
+                    print(f"***** Init LCM Model pipeline - {model_id} *****")
+                    self.pipeline = get_lcm_model_pipeline(
                         model_id,
                         use_local_model,
                     )
 
-                if use_tiny_auto_encoder:
-                    vae_model = self.get_tiny_decoder_vae_model()
-                    print(f"Using Tiny Auto Encoder {vae_model}")
-                    self.pipeline.vae = AutoencoderTiny.from_pretrained(
-                        vae_model,
-                        torch_dtype=torch.float32,
-                        local_files_only=use_local_model,
+                if (
+                    lcm_diffusion_setting.diffusion_task
+                    == DiffusionTask.image_to_image.value
+                ):
+                    self.img_to_img_pipeline = get_image_to_image_pipeline(
+                        self.pipeline
                     )
-
                 self._pipeline_to_device()
 
+            if use_tiny_auto_encoder:
+                if self.use_openvino and is_openvino_device():
+                    print("Using Tiny Auto Encoder (OpenVINO)")
+                    ov_load_taesd(
+                        self.pipeline,
+                        use_local_model,
+                    )
+                else:
+                    print("Using Tiny Auto Encoder")
+                    if (
+                        lcm_diffusion_setting.diffusion_task
+                        == DiffusionTask.text_to_image.value
+                    ):
+                        load_taesd(
+                            self.pipeline,
+                            use_local_model,
+                            self.torch_data_type,
+                        )
+                    elif (
+                        lcm_diffusion_setting.diffusion_task
+                        == DiffusionTask.image_to_image.value
+                    ):
+                        load_taesd(
+                            self.img_to_img_pipeline,
+                            use_local_model,
+                            self.torch_data_type,
+                        )
+
+            if (
+                lcm_diffusion_setting.diffusion_task
+                == DiffusionTask.image_to_image.value
+                and lcm_diffusion_setting.use_openvino
+            ):
+                self.pipeline.scheduler = LCMScheduler.from_config(
+                    self.pipeline.scheduler.config,
+                )
+            else:
+                self._update_lcm_scheduler_params()
+
+            if use_lora:
+                self._add_freeu()
+
             self.previous_model_id = model_id
+            self.previous_ov_model_id = ov_model_id
             self.previous_use_tae_sd = use_tiny_auto_encoder
             self.previous_lcm_lora_base_id = lcm_lora.base_model_id
             self.previous_lcm_lora_id = lcm_lora.lcm_lora_id
             self.previous_use_lcm_lora = use_lora
-            print(f"Model :{model_id}")
-            print(f"Pipeline : {self.pipeline}")
-            self.pipeline.scheduler = LCMScheduler.from_config(
-                self.pipeline.scheduler.config,
-                beta_start=0.001,
-                beta_end=0.01,
-            )
-            if use_lora:
-                self._add_freeu()
+            self.previous_safety_checker = lcm_diffusion_setting.use_safety_checker
+            self.previous_use_openvino = lcm_diffusion_setting.use_openvino
+            self.previous_task_type = lcm_diffusion_setting.diffusion_task
+            if (
+                lcm_diffusion_setting.diffusion_task
+                == DiffusionTask.text_to_image.value
+            ):
+                print(f"Pipeline : {self.pipeline}")
+            elif (
+                lcm_diffusion_setting.diffusion_task
+                == DiffusionTask.image_to_image.value
+            ):
+                if self.use_openvino and is_openvino_device():
+                    print(f"Pipeline : {self.pipeline}")
+                else:
+                    print(f"Pipeline : {self.img_to_img_pipeline}")
 
     def generate(
         self,
@@ -275,6 +241,19 @@ class LCMTextToImage:
         reshape: bool = False,
     ) -> Any:
         guidance_scale = lcm_diffusion_setting.guidance_scale
+        img_to_img_inference_steps = lcm_diffusion_setting.inference_steps
+        check_step_value = int(
+            lcm_diffusion_setting.inference_steps * lcm_diffusion_setting.strength
+        )
+        if (
+            lcm_diffusion_setting.diffusion_task == DiffusionTask.image_to_image.value
+            and check_step_value < 1
+        ):
+            img_to_img_inference_steps = ceil(1 / lcm_diffusion_setting.strength)
+            print(
+                f"Strength: {lcm_diffusion_setting.strength},{img_to_img_inference_steps}"
+            )
+
         if lcm_diffusion_setting.use_seed:
             cur_seed = lcm_diffusion_setting.seed
             if self.use_openvino:
@@ -282,9 +261,10 @@ class LCMTextToImage:
             else:
                 torch.manual_seed(cur_seed)
 
-        if lcm_diffusion_setting.use_openvino and is_openvino_device():
+        is_openvino_pipe = lcm_diffusion_setting.use_openvino and is_openvino_device()
+        if is_openvino_pipe:
             print("Using OpenVINO")
-            if reshape:
+            if reshape and not self.is_openvino_init:
                 print("Reshape and compile")
                 self.pipeline.reshape(
                     batch_size=-1,
@@ -294,8 +274,17 @@ class LCMTextToImage:
                 )
                 self.pipeline.compile()
 
+            if self.is_openvino_init:
+                self.is_openvino_init = False
+
         if not lcm_diffusion_setting.use_safety_checker:
             self.pipeline.safety_checker = None
+            if (
+                lcm_diffusion_setting.diffusion_task
+                == DiffusionTask.image_to_image.value
+                and not is_openvino_pipe
+            ):
+                self.img_to_img_pipeline.safety_checker = None
 
         if (
             not lcm_diffusion_setting.use_lcm_lora
@@ -306,24 +295,61 @@ class LCMTextToImage:
             guidance_scale = 1.0
 
         if lcm_diffusion_setting.use_openvino:
-            result_images = self.pipeline(
-                prompt=lcm_diffusion_setting.prompt,
-                negative_prompt=lcm_diffusion_setting.negative_prompt,
-                num_inference_steps=lcm_diffusion_setting.inference_steps,
-                guidance_scale=guidance_scale,
-                width=lcm_diffusion_setting.image_width,
-                height=lcm_diffusion_setting.image_height,
-                num_images_per_prompt=lcm_diffusion_setting.number_of_images,
-            ).images
+            if (
+                lcm_diffusion_setting.diffusion_task
+                == DiffusionTask.text_to_image.value
+            ):
+                result_images = self.pipeline(
+                    prompt=lcm_diffusion_setting.prompt,
+                    negative_prompt=lcm_diffusion_setting.negative_prompt,
+                    num_inference_steps=lcm_diffusion_setting.inference_steps,
+                    guidance_scale=guidance_scale,
+                    width=lcm_diffusion_setting.image_width,
+                    height=lcm_diffusion_setting.image_height,
+                    num_images_per_prompt=lcm_diffusion_setting.number_of_images,
+                ).images
+            elif (
+                lcm_diffusion_setting.diffusion_task
+                == DiffusionTask.image_to_image.value
+            ):
+                result_images = self.pipeline(
+                    image=lcm_diffusion_setting.init_image,
+                    strength=lcm_diffusion_setting.strength,
+                    prompt=lcm_diffusion_setting.prompt,
+                    negative_prompt=lcm_diffusion_setting.negative_prompt,
+                    num_inference_steps=img_to_img_inference_steps * 3,
+                    guidance_scale=guidance_scale,
+                    num_images_per_prompt=lcm_diffusion_setting.number_of_images,
+                ).images
+
         else:
-            result_images = self.pipeline(
-                prompt=lcm_diffusion_setting.prompt,
-                negative_prompt=lcm_diffusion_setting.negative_prompt,
-                num_inference_steps=lcm_diffusion_setting.inference_steps,
-                guidance_scale=guidance_scale,
-                width=lcm_diffusion_setting.image_width,
-                height=lcm_diffusion_setting.image_height,
-                num_images_per_prompt=lcm_diffusion_setting.number_of_images,
-            ).images
+            if (
+                lcm_diffusion_setting.diffusion_task
+                == DiffusionTask.text_to_image.value
+            ):
+                result_images = self.pipeline(
+                    prompt=lcm_diffusion_setting.prompt,
+                    negative_prompt=lcm_diffusion_setting.negative_prompt,
+                    num_inference_steps=lcm_diffusion_setting.inference_steps,
+                    guidance_scale=guidance_scale,
+                    width=lcm_diffusion_setting.image_width,
+                    height=lcm_diffusion_setting.image_height,
+                    num_images_per_prompt=lcm_diffusion_setting.number_of_images,
+                ).images
+            elif (
+                lcm_diffusion_setting.diffusion_task
+                == DiffusionTask.image_to_image.value
+            ):
+                result_images = self.img_to_img_pipeline(
+                    image=lcm_diffusion_setting.init_image,
+                    strength=lcm_diffusion_setting.strength,
+                    prompt=lcm_diffusion_setting.prompt,
+                    negative_prompt=lcm_diffusion_setting.negative_prompt,
+                    num_inference_steps=img_to_img_inference_steps,
+                    guidance_scale=guidance_scale,
+                    width=lcm_diffusion_setting.image_width,
+                    height=lcm_diffusion_setting.image_height,
+                    num_images_per_prompt=lcm_diffusion_setting.number_of_images,
+                ).images
 
         return result_images

backend/models/lcmdiffusion_setting.py

@@ -1,12 +1,19 @@
-from typing import Optional
-
+from typing import Optional, Any
+from enum import Enum
 from pydantic import BaseModel
 from constants import LCM_DEFAULT_MODEL, LCM_DEFAULT_MODEL_OPENVINO
 
 
 class LCMLora(BaseModel):
-    base_model_id: str = ""
-    lcm_lora_id: str = ""
+    base_model_id: str = "Lykon/dreamshaper-8"
+    lcm_lora_id: str = "latent-consistency/lcm-lora-sdv1-5"
+
+
+class DiffusionTask(str, Enum):
+    """Diffusion task types"""
+
+    text_to_image = "text_to_image"
+    image_to_image = "image_to_image"
 
 
 class LCMDiffusionSetting(BaseModel):
@@ -19,11 +26,14 @@ class LCMDiffusionSetting(BaseModel):
     use_openvino: bool = False
     prompt: str = ""
     negative_prompt: str = ""
+    init_image: Any = None
+    strength: Optional[float] = 0.6
     image_height: Optional[int] = 512
     image_width: Optional[int] = 512
-    inference_steps: Optional[int] = 4
+    inference_steps: Optional[int] = 1
     guidance_scale: Optional[float] = 1
     number_of_images: Optional[int] = 1
-    seed: Optional[int] = -1
+    seed: Optional[int] = 123123
     use_seed: bool = False
     use_safety_checker: bool = False
+    diffusion_task: str = DiffusionTask.text_to_image.value

configs/openvino-lcm-models.txt

@@ -1,2 +1,4 @@
+rupeshs/sd-turbo-openvino
+rupeshs/sdxl-turbo-openvino-int8
 rupeshs/LCM-dreamshaper-v7-openvino
 Disty0/LCM_SoteMix

constants.py

@@ -1,8 +1,8 @@
 from os import environ
 
-APP_VERSION = "v1.0.0 beta 16"
-LCM_DEFAULT_MODEL = "SimianLuo/LCM_Dreamshaper_v7"
-LCM_DEFAULT_MODEL_OPENVINO = "rupeshs/LCM-dreamshaper-v7-openvino"
+APP_VERSION = "v1.0.0 beta 23"
+LCM_DEFAULT_MODEL = "stabilityai/sd-turbo"
+LCM_DEFAULT_MODEL_OPENVINO = "rupeshs/sd-turbo-openvino"
 APP_NAME = "FastSD CPU"
 APP_SETTINGS_FILE = "settings.yaml"
 RESULTS_DIRECTORY = "results"
@@ -14,3 +14,5 @@ OPENVINO_LCM_MODELS_FILE = "openvino-lcm-models.txt"
 TAESD_MODEL = "madebyollin/taesd"
 TAESDXL_MODEL = "madebyollin/taesdxl"
 TAESD_MODEL_OPENVINO = "deinferno/taesd-openvino"
+LCM_MODELS_FILE = "lcm-models.txt"
+TAESDXL_MODEL_OPENVINO = "rupeshs/taesdxl-openvino"

context.py

@@ -23,17 +23,15 @@ class Context:
         device: str = "cpu",
     ) -> Any:
         tick = perf_counter()
+        from state import get_settings
+
+        get_settings().save()
         pprint(settings.lcm_diffusion_setting.model_dump())
         if not settings.lcm_diffusion_setting.lcm_lora:
             return None
         self.lcm_text_to_image.init(
-            settings.lcm_diffusion_setting.lcm_model_id,
-            settings.lcm_diffusion_setting.use_openvino,
             device,
-            settings.lcm_diffusion_setting.use_offline_model,
-            settings.lcm_diffusion_setting.use_tiny_auto_encoder,
-            settings.lcm_diffusion_setting.use_lcm_lora,
-            settings.lcm_diffusion_setting.lcm_lora,
+            settings.lcm_diffusion_setting,
         )
         images = self.lcm_text_to_image.generate(
             settings.lcm_diffusion_setting,
@@ -45,5 +43,5 @@ class Context:
             images=images,
             lcm_diffusion_setting=settings.lcm_diffusion_setting,
         )
-        print(f"Elapsed time : {elapsed:.2f} seconds")
+        print(f"Latency : {elapsed:.2f} seconds")
         return images

frontend/gui/app_window.py

@@ -35,7 +35,7 @@ from context import Context
 from models.interface_types import InterfaceType
 from constants import DEVICE
 from frontend.utils import enable_openvino_controls, get_valid_model_id
-from backend.lcm_models import get_available_models
+from backend.models.lcmdiffusion_setting import DiffusionTask
 
 # DPI scale fix
 QtWidgets.QApplication.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling, True)
@@ -100,6 +100,13 @@ class MainWindow(QMainWindow):
         self.use_lcm_lora.setChecked(
             self.config.settings.lcm_diffusion_setting.use_lcm_lora
         )
+        self.lcm_model.setCurrentText(
+            get_valid_model_id(
+                self.config.lcm_models,
+                self.config.settings.lcm_diffusion_setting.lcm_model_id,
+                LCM_DEFAULT_MODEL,
+            )
+        )
         self.base_model_id.setCurrentText(
             get_valid_model_id(
                 self.config.stable_diffsuion_models,
@@ -116,6 +123,7 @@ class MainWindow(QMainWindow):
             get_valid_model_id(
                 self.config.openvino_lcm_models,
                 self.config.settings.lcm_diffusion_setting.openvino_lcm_model_id,
+                LCM_DEFAULT_MODEL_OPENVINO,
             )
         )
         self.neg_prompt.setEnabled(
@@ -193,10 +201,9 @@ class MainWindow(QMainWindow):
     def create_settings_tab(self):
         self.lcm_model_label = QLabel("Latent Consistency Model:")
         # self.lcm_model = QLineEdit(LCM_DEFAULT_MODEL)
-        lcm_models = get_available_models()
         self.lcm_model = QComboBox(self)
-        for model in lcm_models:
-            self.lcm_model.addItem(model)
+        self.lcm_model.addItems(self.config.lcm_models)
+        self.lcm_model.currentIndexChanged.connect(self.on_lcm_model_changed)
 
         self.use_lcm_lora = QCheckBox("Use LCM LoRA")
         self.use_lcm_lora.setChecked(False)
@@ -303,6 +310,7 @@ class MainWindow(QMainWindow):
         vlayout = QVBoxLayout()
         vspacer = QSpacerItem(20, 20, QSizePolicy.Minimum, QSizePolicy.Expanding)
         vlayout.addItem(hspacer)
+        vlayout.setSpacing(3)
         vlayout.addWidget(self.lcm_model_label)
         vlayout.addWidget(self.lcm_model)
         vlayout.addWidget(self.use_local_model_folder)
@@ -415,6 +423,10 @@ class MainWindow(QMainWindow):
         height_txt = self.height.itemText(index)
         self.config.settings.lcm_diffusion_setting.image_height = int(height_txt)
 
+    def on_lcm_model_changed(self, index):
+        model_id = self.lcm_model.itemText(index)
+        self.config.settings.lcm_diffusion_setting.lcm_model_id = model_id
+
     def on_base_model_id_changed(self, index):
         model_id = self.base_model_id.itemText(index)
         self.config.settings.lcm_diffusion_setting.lcm_lora.base_model_id = model_id
@@ -536,7 +548,9 @@ class MainWindow(QMainWindow):
                 self.previous_num_of_images,
                 self.config.settings.lcm_diffusion_setting.number_of_images,
             )
-
+        self.config.settings.lcm_diffusion_setting.diffusion_task = (
+            DiffusionTask.text_to_image.value
+        )
         images = self.context.generate_text_to_image(
             self.config.settings,
             reshape_required,

frontend/utils.py

@@ -34,12 +34,16 @@ def enable_openvino_controls() -> bool:
 def get_valid_model_id(
     models: List,
     model_id: str,
+    default_model: str = "",
 ) -> str:
     if len(models) == 0:
         print("Error: model configuration file is empty,please add some models.")
         return ""
     if model_id == "":
-        return models[0]
+        if default_model:
+            return default_model
+        else:
+            return models[0]
 
     if model_id in models:
         return model_id

frontend/webui/css/style.css

@@ -5,10 +5,8 @@ footer {
 #generate_button {
     color: white;
     border-color: #007bff;
-    background: #007bff;
-    width: 150px;
-    margin-top: 38px;
-    height: 80px;
+    background: #2563eb;
+
 }
 
 #save_button {

frontend/webui/hf_demo.py

@@ -122,7 +122,7 @@ with gr.Blocks(css=css) as demo:
         with gr.Accordion("Advanced options", open=False):
             steps = gr.Slider(
                 label="Steps",
-                value=3 if is_openvino_device() else 3,
+                value=1,
                 minimum=1,
                 maximum=4,
                 step=1,

frontend/webui/realtime_ui.py

@@ -12,7 +12,7 @@ from backend.device import is_openvino_device
 
 lcm_text_to_image = LCMTextToImage()
 lcm_lora = LCMLora(
-    base_model_id="Lykon/dreamshaper-7",
+    base_model_id="Lykon/dreamshaper-8",
     lcm_lora_id="latent-consistency/lcm-lora-sdv1-5",
 )
 
@@ -35,14 +35,8 @@ def predict(
     steps,
     seed,
 ):
-    lcm_text_to_image.init(
-        model_id=LCM_DEFAULT_MODEL_OPENVINO,
-        use_lora=True,
-        lcm_lora=lcm_lora,
-        use_openvino=True if is_openvino_device() else False,
-    )
-
     lcm_diffusion_setting = LCMDiffusionSetting()
+    lcm_diffusion_setting.openvino_lcm_model_id = "rupeshs/LCM-dreamshaper-v7-openvino"
     lcm_diffusion_setting.prompt = prompt
     lcm_diffusion_setting.guidance_scale = 1.0
     lcm_diffusion_setting.inference_steps = steps
@@ -51,7 +45,12 @@ def predict(
     lcm_diffusion_setting.image_width = 256 if is_openvino_device() else 512
     lcm_diffusion_setting.image_height = 256 if is_openvino_device() else 512
     lcm_diffusion_setting.use_openvino = True if is_openvino_device() else False
+    lcm_text_to_image.init(
+        DEVICE,
+        lcm_diffusion_setting,
+    )
     start = perf_counter()
+
     images = lcm_text_to_image.generate(lcm_diffusion_setting)
     latency = perf_counter() - start
     print(f"Latency: {latency:.2f} seconds")

frontend/webui/text_to_image_ui.py

@@ -1,19 +1,15 @@
-from typing import Any
 import gradio as gr
-
-from backend.models.lcmdiffusion_setting import LCMDiffusionSetting
-from context import Context
+from typing import Any
+from backend.models.lcmdiffusion_setting import DiffusionTask
 from models.interface_types import InterfaceType
-from app_settings import Settings
-from constants import LCM_DEFAULT_MODEL, LCM_DEFAULT_MODEL_OPENVINO
-from frontend.utils import is_reshape_required
-from app_settings import AppSettings
 from constants import DEVICE
-from frontend.utils import enable_openvino_controls
-
-random_enabled = True
+from state import get_settings, get_context
+from frontend.utils import is_reshape_required
+from concurrent.futures import ThreadPoolExecutor
+from pprint import pprint
 
-context = Context(InterfaceType.WEBUI)
+app_settings = get_settings()
+context = get_context(InterfaceType.WEBUI)
 previous_width = 0
 previous_height = 0
 previous_model_id = ""
@@ -22,42 +18,20 @@ previous_num_of_images = 0
 
 def generate_text_to_image(
     prompt,
-    image_height,
-    image_width,
-    inference_steps,
-    guidance_scale,
-    num_images,
-    seed,
-    use_openvino,
-    use_safety_checker,
-    tiny_auto_encoder_checkbox,
+    neg_prompt,
 ) -> Any:
-    global previous_height, previous_width, previous_model_id, previous_num_of_images
-    model_id = LCM_DEFAULT_MODEL
-    if use_openvino:
-        model_id = LCM_DEFAULT_MODEL_OPENVINO
-
-    use_seed = True if seed != -1 else False
-
-    lcm_diffusion_settings = LCMDiffusionSetting(
-        lcm_model_id=model_id,
-        prompt=prompt,
-        image_height=image_height,
-        image_width=image_width,
-        inference_steps=inference_steps,
-        guidance_scale=guidance_scale,
-        number_of_images=num_images,
-        seed=seed,
-        use_openvino=use_openvino,
-        use_safety_checker=use_safety_checker,
-        use_seed=use_seed,
-        use_tiny_auto_encoder=tiny_auto_encoder_checkbox,
-    )
-    settings = Settings(
-        lcm_diffusion_setting=lcm_diffusion_settings,
+    global previous_height, previous_width, previous_model_id, previous_num_of_images, app_settings
+    app_settings.settings.lcm_diffusion_setting.prompt = prompt
+    app_settings.settings.lcm_diffusion_setting.negative_prompt = neg_prompt
+    app_settings.settings.lcm_diffusion_setting.diffusion_task = (
+        DiffusionTask.text_to_image.value
     )
+    model_id = app_settings.settings.lcm_diffusion_setting.openvino_lcm_model_id
     reshape = False
-    if use_openvino:
+    image_width = app_settings.settings.lcm_diffusion_setting.image_width
+    image_height = app_settings.settings.lcm_diffusion_setting.image_height
+    num_images = app_settings.settings.lcm_diffusion_setting.number_of_images
+    if app_settings.settings.lcm_diffusion_setting.use_openvino:
         reshape = is_reshape_required(
             previous_width,
             image_width,
@@ -68,39 +42,37 @@ def generate_text_to_image(
             previous_num_of_images,
             num_images,
         )
-    images = context.generate_text_to_image(
-        settings,
-        reshape,
-        DEVICE,
-    )
+
+    with ThreadPoolExecutor(max_workers=1) as executor:
+        future = executor.submit(
+            context.generate_text_to_image,
+            app_settings.settings,
+            reshape,
+            DEVICE,
+        )
+        images = future.result()
+    # images = context.generate_text_to_image(
+    #     app_settings.settings,
+    #     reshape,
+    #     DEVICE,
+    # )
     previous_width = image_width
     previous_height = image_height
     previous_model_id = model_id
     previous_num_of_images = num_images
-
     return images
 
 
-def get_text_to_image_ui(app_settings: AppSettings) -> None:
+def get_text_to_image_ui() -> None:
     with gr.Blocks():
         with gr.Row():
             with gr.Column():
-
-                def random_seed():
-                    global random_enabled
-                    random_enabled = not random_enabled
-                    seed_val = -1
-                    if not random_enabled:
-                        seed_val = 42
-                    return gr.Number.update(
-                        interactive=not random_enabled, value=seed_val
-                    )
-
                 with gr.Row():
                     prompt = gr.Textbox(
-                        label="Describe the image you'd like to see",
+                        show_label=False,
                         lines=3,
                         placeholder="A fantasy landscape",
+                        container=False,
                     )
 
                     generate_btn = gr.Button(
@@ -108,68 +80,13 @@ def get_text_to_image_ui(app_settings: AppSettings) -> None:
                         elem_id="generate_button",
                         scale=0,
                     )
-                num_inference_steps = gr.Slider(
-                    1, 25, value=4, step=1, label="Inference Steps"
-                )
-                image_height = gr.Slider(
-                    256, 768, value=512, step=256, label="Image Height"
-                )
-                image_width = gr.Slider(
-                    256, 768, value=512, step=256, label="Image Width"
-                )
-                num_images = gr.Slider(
-                    1,
-                    50,
-                    value=1,
-                    step=1,
-                    label="Number of images to generate",
+                negative_prompt = gr.Textbox(
+                    label="Negative prompt (Works in LCM-LoRA mode, set guidance > 1.0) :",
+                    lines=1,
+                    placeholder="",
                 )
-                with gr.Accordion("Advanced options", open=False):
-                    guidance_scale = gr.Slider(
-                        1.0, 2.0, value=1.0, step=0.5, label="Guidance Scale"
-                    )
-
-                    seed = gr.Number(
-                        label="Seed",
-                        value=-1,
-                        precision=0,
-                        interactive=False,
-                    )
-                    seed_checkbox = gr.Checkbox(
-                        label="Use random seed",
-                        value=True,
-                        interactive=True,
-                    )
 
-                    openvino_checkbox = gr.Checkbox(
-                        label="Use OpenVINO",
-                        value=False,
-                        interactive=enable_openvino_controls(),
-                    )
-
-                    safety_checker_checkbox = gr.Checkbox(
-                        label="Use Safety Checker",
-                        value=True,
-                        interactive=True,
-                    )
-                    tiny_auto_encoder_checkbox = gr.Checkbox(
-                        label="Use tiny auto encoder for SD",
-                        value=False,
-                        interactive=True,
-                    )
-
-                    input_params = [
-                        prompt,
-                        image_height,
-                        image_width,
-                        num_inference_steps,
-                        guidance_scale,
-                        num_images,
-                        seed,
-                        openvino_checkbox,
-                        safety_checker_checkbox,
-                        tiny_auto_encoder_checkbox,
-                    ]
+                input_params = [prompt, negative_prompt]
 
             with gr.Column():
                 output = gr.Gallery(
@@ -177,9 +94,8 @@ def get_text_to_image_ui(app_settings: AppSettings) -> None:
                     show_label=True,
                     elem_id="gallery",
                     columns=2,
+                    height=512,
                 )
-
-    seed_checkbox.change(fn=random_seed, outputs=seed)
     generate_btn.click(
         fn=generate_text_to_image,
         inputs=input_params,

frontend/webui/ui.py

@@ -1,8 +1,14 @@
 import gradio as gr
 from constants import APP_VERSION
 from frontend.webui.text_to_image_ui import get_text_to_image_ui
+from frontend.webui.image_to_image_ui import get_image_to_image_ui
+from frontend.webui.generation_settings_ui import get_generation_settings_ui
+from frontend.webui.models_ui import get_models_ui
+from frontend.webui.image_variations_ui import get_image_variations_ui
 from paths import FastStableDiffusionPaths
-from app_settings import AppSettings
+from state import get_settings
+
+app_settings = get_settings()
 
 
 def _get_footer_message() -> str:
@@ -14,23 +20,54 @@ def _get_footer_message() -> str:
     return footer_msg
 
 
-def get_web_ui(app_settings: AppSettings) -> gr.Blocks:
+def get_web_ui() -> gr.Blocks:
+    def change_mode(mode):
+        global app_settings
+        app_settings.settings.lcm_diffusion_setting.use_lcm_lora = False
+        app_settings.settings.lcm_diffusion_setting.use_openvino = False
+        if mode == "LCM-LoRA":
+            app_settings.settings.lcm_diffusion_setting.use_lcm_lora = True
+        elif mode == "LCM-OpenVINO":
+            app_settings.settings.lcm_diffusion_setting.use_openvino = True
+
     with gr.Blocks(
         css=FastStableDiffusionPaths.get_css_path(),
         title="FastSD CPU",
     ) as fastsd_web_ui:
         gr.HTML("<center><H1>FastSD CPU</H1></center>")
+        current_mode = "LCM"
+        if app_settings.settings.lcm_diffusion_setting.use_openvino:
+            current_mode = "LCM-OpenVINO"
+        elif app_settings.settings.lcm_diffusion_setting.use_lcm_lora:
+            current_mode = "LCM-LoRA"
+
+        mode = gr.Radio(
+            ["LCM", "LCM-LoRA", "LCM-OpenVINO"],
+            label="Mode",
+            info="Current working mode",
+            value=current_mode,
+        )
+        mode.change(change_mode, inputs=mode)
+
         with gr.Tabs():
             with gr.TabItem("Text to Image"):
-                get_text_to_image_ui(app_settings)
+                get_text_to_image_ui()
+            with gr.TabItem("Image to Image"):
+                get_image_to_image_ui()
+            with gr.TabItem("Image Variations"):
+                get_image_variations_ui()
+            with gr.TabItem("Generation Settings"):
+                get_generation_settings_ui()
+            with gr.TabItem("Models"):
+                get_models_ui()
+
         gr.HTML(_get_footer_message())
 
     return fastsd_web_ui
 
 
 def start_webui(
-    app_settings: AppSettings,
     share: bool = False,
 ):
-    webui = get_web_ui(app_settings)
+    webui = get_web_ui()
     webui.launch(share=share)

paths.py

@@ -55,3 +55,7 @@ class FastStableDiffusionPaths:
             model_config_file,
         )
         return models_path
+
+
+def get_base_folder_name(path: str) -> str:
+    return os.path.basename(path)