Update UI

README.md

@@ -5,7 +5,7 @@ colorFrom: yellow
 colorTo: blue
 sdk: gradio
 sdk_version: 6.16.0
-python_version: '3.13'
+python_version: '3.12'
 app_file: app.py
 pinned: false
 short_description: A space to play with SLM models without Inference Endpoint

app.py

@@ -9,60 +9,104 @@ import torch
 import psutil
 import time
 
-# Define path for HF cache to clean
 HF_CACHE_DIR = os.path.expanduser("~/.cache/huggingface/hub")
+DEFAULT_MODEL = "HuggingFaceTB/SmolLM2-135M-Instruct"
 
-# List of models for autocomplete
 MODELS = [
-    'HuggingFaceTB/SmolLM2-135M', 'AxiomicLabs/GPT-X2-125M', 'Qwen/Qwen3-0.6B',
-    'facebook/MobileLLM-R1-140M-base', 'SupraLabs/Supra-50M-Base', 'CompactAI-O/Shard-1',
-    'SupraLabs/Supra-50M-Instruct', 'HuggingFaceTB/SmolLM-135M', 'facebook/opt-125m',
-    'AxiomicLabs/GPT-S-5M', 'openai-community/gpt2', 'LH-Tech-AI/Spark-5M-Base-v4',
-    'SupraLabs/Supra-Mini-v5-8M', 'EleutherAI/pythia-70m', 'SupraLabs/Supra-Mini-v4-2M',
-    'EleutherAI/pythia-31m', 'StentorLabs/Stentor3-50M', 'StentorLabs/Stentor3-20M',
-    'StentorLabs/Portimbria-150M', 'HuggingFaceTB/nanowhale-100m-base', 'EleutherAI/pythia-14m',
-    'Harley-ml/Tenete-8M', 'Harley-ml/Dillion-1.2M', 'MihaiPopa-1/CinnabarLM-1.4M-Base',
-    'MihaiPopa-1/CinnabarLM-4M-Base', 'MihaiPopa-1/PotentSulfurLM-500K-Base',
-    'MihaiPopa-1/CinnabarLM-1.5M-Base', 'Harley-ml/Dillionv2-1.3M', 'Eclipse-Senpai/KeyLM-75M',
-    'SupraLabs/Supra-Mini-v6-1M', 'AxiomicLabs/GPT-S-1.4M', 'GODELEV/Archaea-74M',
-    'Sandroeth/cali-0.1B', 'veyra-ai/veyra3-5m-base', 'veyra-ai/veyra-30m-base-5b-tokens',
-    'ThingAI/Quark-50m', 'ThingAI/Quark-135m', 'HuggingFaceTB/SmolLM2-135M-Instruct', 
-    'Aravindan/awesome-gpt-2-coder', 'Qwen/Qwen2.5-Coder-0.5B', 'SupraLabs/Supra-50M-Reasoning'
+    "HuggingFaceTB/SmolLM2-135M-Instruct",
+    "HuggingFaceTB/SmolLM2-135M",
+    "HuggingFaceTB/SmolLM2-360M-Instruct",
+    "HuggingFaceTB/SmolLM2-1.7B-Instruct",
+    "HuggingFaceTB/SmolLM-135M",
+    "Qwen/Qwen3-0.6B",
+    "Qwen/Qwen2.5-Coder-0.5B",
+    "Qwen/Qwen2.5-0.5B",
+    "Qwen/Qwen2.5-1.5B",
+    "Qwen/Qwen2.5-3B",
+    "Qwen/Qwen3-1.7B",
+    "facebook/MobileLLM-R1-140M-base",
+    "facebook/opt-125m",
+    "facebook/opt-350m",
+    "microsoft/phi-2",
+    "microsoft/Phi-3.5-mini-instruct",
+    "microsoft/Phi-3-mini-4k-instruct",
+    "openai-community/gpt2",
+    "openai-community/gpt2-medium",
+    "openai-community/gpt2-large",
+    "EleutherAI/pythia-70m",
+    "EleutherAI/pythia-160m",
+    "EleutherAI/pythia-410m",
+    "EleutherAI/gpt-neo-125M",
+    "EleutherAI/gpt-neo-1.3B",
+    "TinyLlama/TinyLlama-1.1B-Chat-v1.0",
+    "stabilityai/StableLM-3b-4e1t",
+    "stabilityai/StableLM-Zephyr-3B",
+    "NousResearch/Hermes-3-Llama-3.1-8B",
+    "meta-llama/Llama-3.2-1B",
+    "meta-llama/Llama-3.2-3B",
+    "THUDM/glm-4-1b-flash",
+    "2Butch/MiniCPM-1B-sft-bf16",
+    "SupraLabs/Supra-50M-Base",
+    "SupraLabs/Supra-50M-Instruct",
+    "SupraLabs/Supra-50M-Reasoning",
+    "GODELEV/Archaea-74M",
+    "Sandroeth/cali-0.1B",
+    "ThingAI/Quark-50m",
+    "ThingAI/Quark-135m",
+    "Aravindan/awesome-gpt-2-coder",
+    "LiquidAI/LFM2-1.2B",
+    "LiquidAI/LFM2-2.6B",
+    "LiquidAI/LFM-350M",
+    "LiquidAI/LFM-700M",
+    "LiquidAI/LFM2.5-230M",
+    "LiquidAI/LFM2.5-350M",
+    "LiquidAI/LFM2.5-1.2B-Instruct",
+    "LiquidAI/LFM2.5-1.2B-Thinking",
+    "LiquidAI/LFM2.5-8B-A1B",
+]
+
+TASK_MODES = ["Completion", "Chat", "Q&A", "Translation"]
+
+LANGUAGES = [
+    "English", "Spanish", "French", "German", "Italian", "Portuguese",
+    "Chinese", "Japanese", "Korean", "Arabic", "Russian", "Hindi",
+    "Dutch", "Turkish", "Polish", "Czech", "Romanian", "Greek",
+    "Thai", "Vietnamese", "Indonesian", "Malay", "Finnish", "Swedish",
+    "Norwegian", "Danish"
 ]
 
 ACTIVE_SESSIONS = {}
 SESSION_TIMEOUT = 60
 
+
 def live_count(request: gr.Request):
     current_time = time.time()
     if request:
         ACTIVE_SESSIONS[request.session_hash] = current_time
-        
-    # Prune
     expired = [s for s, t in ACTIVE_SESSIONS.items() if current_time - t > SESSION_TIMEOUT]
     for s in expired:
         ACTIVE_SESSIONS.pop(s, None)
-        
     return len(ACTIVE_SESSIONS)
 
-# Global class to safely manage the loaded model and tokenizer in memory
+
 class ModelManager:
     def __init__(self):
         self.model = None
         self.tokenizer = None
         self.model_id = None
-        self.stop_generation = False # Added flag to instantly kill generation
+        self.stop_generation = False
         self.device = "cuda" if torch.cuda.is_available() else "cpu"
 
+
 model_manager = ModelManager()
 
-# Custom stopping criteria to halt the generation thread when loading a new model
+
 class StopOnFlag(StoppingCriteria):
     def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
         return model_manager.stop_generation
 
+
 def get_system_stats(request: gr.Request = None):
-    """Returns a dictionary of current system metrics with formatted strings."""
     mem = psutil.virtual_memory()
     disk = psutil.disk_usage('/')
     return (
@@ -72,12 +116,9 @@ def get_system_stats(request: gr.Request = None):
         f"Active\t: \t{len(ACTIVE_SESSIONS) if request is None else live_count(request)} session(s)"
     )
 
+
 def load_new_model(model_id):
-    """Loads the model and tokenizer dynamically into the global manager."""
-    # Stop any ongoing generation immediately
     model_manager.stop_generation = True
-    
-    # Clear old model from memory
     model_manager.model = None
     model_manager.tokenizer = None
     model_manager.model_id = None
@@ -85,90 +126,137 @@ def load_new_model(model_id):
     gc.collect()
     if torch.cuda.is_available():
         torch.cuda.empty_cache()
-    
     try:
-        # Load explicitly for streaming purposes instead of pipeline
         tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
-        model = AutoModelForCausalLM.from_pretrained(model_id, trust_remote_code=True)
-        
+        model = AutoModelForCausalLM.from_pretrained(
+            model_id, trust_remote_code=True, dtype=torch.float16
+        )
         model_manager.tokenizer = tokenizer
         model_manager.model = model
         model_manager.model_id = model_id
-        
-        yield f"Successfully loaded {model_id} on {model_manager.device.upper()}"
+        yield f"Loaded **{model_id}** on {model_manager.device.upper()}"
     except Exception as e:
         yield f"Error loading model: {str(e)}"
 
 
-def run_inference(user_prompt, max_tokens, temperature, top_k, top_p, rep_penalty, ngram_size, do_sample, gpu):
+def update_mode_ui(mode):
+    show_sys = mode == "Chat"
+    show_ctx = mode == "Q&A"
+    show_src = mode == "Translation"
+    show_tgt = mode == "Translation"
+
+    if mode == "Chat":
+        prompt_label = "User Message"
+        prompt_placeholder = "Type your message..."
+    elif mode == "Q&A":
+        prompt_label = "Question"
+        prompt_placeholder = "Enter your question..."
+    elif mode == "Translation":
+        prompt_label = "Text to Translate"
+        prompt_placeholder = "Enter text to translate..."
+    else:
+        prompt_label = "Prompt"
+        prompt_placeholder = "Enter your prompt here..."
+
+    return (
+        gr.update(visible=show_sys),
+        gr.update(label=prompt_label, placeholder=prompt_placeholder),
+        gr.update(visible=show_ctx),
+        gr.update(visible=show_src),
+        gr.update(visible=show_tgt),
+    )
+
+
+def format_prompt(mode, prompt, system_prompt="", context="", src_lang="", tgt_lang=""):
+    if mode == "Completion":
+        return prompt
+
+    elif mode == "Chat":
+        if model_manager.tokenizer and hasattr(model_manager.tokenizer, "apply_chat_template"):
+            try:
+                messages = []
+                if system_prompt:
+                    messages.append({"role": "system", "content": system_prompt})
+                messages.append({"role": "user", "content": prompt})
+                return model_manager.tokenizer.apply_chat_template(
+                    messages, tokenize=False, add_generation_prompt=True
+                )
+            except Exception:
+                pass
+        parts = []
+        if system_prompt:
+            parts.append(f"[SYSTEM]: {system_prompt}")
+        parts.append(f"[USER]: {prompt}")
+        parts.append("[ASSISTANT]:")
+        return "\n\n".join(parts)
+
+    elif mode == "Q&A":
+        if context and context.strip():
+            return f"Context:\n{context.strip()}\n\nQuestion: {prompt.strip()}\n\nAnswer:"
+        return f"Question: {prompt.strip()}\n\nAnswer:"
+
+    elif mode == "Translation":
+        src = src_lang or "English"
+        tgt = tgt_lang or "Spanish"
+        return f"Translate the following text from {src} to {tgt}:\n\n{prompt.strip()}\n\nTranslation:"
+
+    return prompt
+
+
+def estimate_duration(user_prompt, max_tokens, temperature, top_k, top_p, rep_penalty, ngram_size, do_sample):
+    return min(max(int(max_tokens) // 20, 15), 60)
+
+
+def run_inference(mode, prompt, system_prompt, context, src_lang, tgt_lang,
+                  max_tokens, temperature, top_k, top_p, rep_penalty,
+                  ngram_size, do_sample, gpu):
+    formatted = format_prompt(mode, prompt, system_prompt, context, src_lang, tgt_lang)
     if gpu:
-        yield from run_inference_gpu(user_prompt, max_tokens, temperature, top_k, top_p, rep_penalty, ngram_size, do_sample)
+        try:
+            yield from run_inference_gpu(formatted, max_tokens, temperature, top_k, top_p, rep_penalty, ngram_size, do_sample)
+        except Exception as e:
+            yield f"GPU error: {e}\n\nClick **Generate** to retry.", "GPU Unavailable"
     else:
-        yield from run_inference_raw(user_prompt, max_tokens, temperature, top_k, top_p, rep_penalty, ngram_size, do_sample)
+        yield from run_inference_raw(formatted, max_tokens, temperature, top_k, top_p, rep_penalty, ngram_size, do_sample)
 
 
-@spaces.GPU
+@spaces.GPU(duration=estimate_duration)
 def run_inference_gpu(user_prompt, max_tokens, temperature, top_k, top_p, rep_penalty, ngram_size, do_sample):
-    max_retries = 5
-    for attempt in range(max_retries):
-        try:
-            if model_manager.model is not None:
-                model_manager.model = model_manager.model.to("cuda")
-            break
-        except RuntimeError as e:
-            if "CUDA" in str(e) and attempt < max_retries - 1:
-                yield f"Waiting for Hugging Face ZeroGPU allocation (Attempt {attempt+1}/{max_retries})...", "Queueing..."
-                time.sleep(2)
-            else:
-                yield f"ZeroGPU initialization failed: {str(e)}. Try clicking Generate again.", "GPU Unavailable"
-                return
+    if model_manager.model is not None:
+        model_manager.model = model_manager.model.to("cuda")
 
     yield from run_inference_raw(user_prompt, max_tokens, temperature, top_k, top_p, rep_penalty, ngram_size, do_sample, use_cuda=True)
 
+
 def run_inference_raw(user_prompt, max_tokens, temperature, top_k, top_p, rep_penalty, ngram_size, do_sample, use_cuda=False):
-    """Generates text via streaming generator."""
     if model_manager.model is None or model_manager.tokenizer is None:
         yield "Please load a model first.", "Model not loaded"
         return
-        
-    # Reset the stop flag for the new generation run
+
     model_manager.stop_generation = False
-    
+
     tokenizer = model_manager.tokenizer
     model = model_manager.model
     model_id = model_manager.model_id
-    
+
     is_supra_reasoning = "Supra-50M-Reasoning" in model_id if model_id else False
-    
-    if is_supra_reasoning:
-        SYSTEM_PROMPT = "Your role as an assistant involves thoroughly exploring questions through a systematic long thinking process before providing the final precise and accurate solutions."
-        prompt_to_encode = (
-            f"[SYSTEM]: {SYSTEM_PROMPT}\n\n"
-            f"[USER]: {user_prompt}\n\n"
-            f"[ASSISTANT]: <|begin_of_thought|>\n"
-        )
-        skip_special = False
-    else:
-        prompt_to_encode = user_prompt
-        skip_special = True
 
-    # Tokenize input
-    inputs = tokenizer([prompt_to_encode], return_tensors="pt")
-    
+    if is_supra_reasoning and "<|begin_of_thought|>" not in user_prompt:
+        user_prompt += "<|begin_of_thought|>\n"
+
+    inputs = tokenizer([user_prompt], return_tensors="pt")
+
     if use_cuda:
         inputs = {k: v.to("cuda") for k, v in inputs.items()}
     else:
         model = model.to("cpu")
         inputs = {k: v.to("cpu") for k, v in inputs.items()}
-    
-    # Set up the streamer
-    streamer = TextIteratorStreamer(tokenizer, timeout=60.0, skip_prompt=True, skip_special_tokens=skip_special)
-    
-    # Adjust variables based on the do_sample logic
+
+    streamer = TextIteratorStreamer(tokenizer, timeout=60.0, skip_prompt=True, skip_special_tokens=True)
+
     if not do_sample:
-        temperature = 1.0 # Temperature is ignored if do_sample=False, but setting it > 0 avoids config errors
+        temperature = 1.0
 
-    # Generation arguments
     generate_kwargs = dict(
         **inputs,
         streamer=streamer,
@@ -179,50 +267,46 @@ def run_inference_raw(user_prompt, max_tokens, temperature, top_k, top_p, rep_pe
         repetition_penalty=float(rep_penalty),
         no_repeat_ngram_size=int(ngram_size),
         do_sample=do_sample,
-        pad_token_id=tokenizer.eos_token_id, # Prevents padding warnings
-        stopping_criteria=StoppingCriteriaList([StopOnFlag()]) # Attach the stopping criteria
+        pad_token_id=tokenizer.eos_token_id,
+        stopping_criteria=StoppingCriteriaList([StopOnFlag()])
     )
 
     start_time = time.time()
-    # Start generation in a separate background thread
     thread = Thread(target=model.generate, kwargs=generate_kwargs)
     thread.start()
-    
+
     if is_supra_reasoning:
-        # Use plain text formatting rather than markdown symbols inside gr.Textbox
-        base_display = f"Prompt: {user_prompt}\n\n----------------------------------------\n\n"
+        base_display = f"Prompt: {user_prompt}\n\n{'─' * 40}\n\n"
         generated_text = ""
     else:
         base_display = ""
-        generated_text = user_prompt
+        generated_text = ""
 
-    # Yield output iteratively for the streaming effect
     token_count = 0
     for new_text in streamer:
-        # Immediately break out of the UI update loop if a new model is loaded
         if model_manager.stop_generation:
             break
-            
+
         generated_text += new_text
         token_count += 1
         duration = time.time() - start_time
         tps = token_count / duration if duration > 0 else 0
-        
+
         display_text = generated_text
-        
+
         if is_supra_reasoning:
             display_text = display_text.replace("<s>", "").replace("</s>", "")
-            if not display_text.startswith("🧠 Thinking Process:"):
-                display_text = "🧠 Thinking Process:\n" + display_text
-                
-            display_text = display_text.replace("<|begin_of_thought|>", "🧠 Thinking Process:\n")
+            if not display_text.startswith("Thinking Process:"):
+                display_text = "Thinking Process:\n" + display_text
+            display_text = display_text.replace("<|begin_of_thought|>", "Thinking Process:\n")
             display_text = display_text.replace("<|end_of_thought|>", "\n\n")
-            display_text = display_text.replace("<|begin_of_solution|>", "✅ Final Answer:\n\n")
+            display_text = display_text.replace("<|begin_of_solution|>", "Final Answer:\n\n")
             display_text = display_text.replace("<|end_of_solution|>", "")
 
         device_label = "CUDA" if use_cuda else "CPU"
         yield base_display + display_text, f"Speed: {tps:.2f} tokens/sec ({device_label})"
 
+
 def clean_cache():
     if os.path.exists(HF_CACHE_DIR):
         shutil.rmtree(HF_CACHE_DIR)
@@ -230,74 +314,109 @@ def clean_cache():
         return "Cache cleaned successfully!"
     return "Cache directory not found."
 
-# Gradio Interface
-with gr.Blocks(title="Small MF Model Tester", theme=gr.themes.Soft()) as app:
-    
-    gr.Markdown("# 🚀 Small Model Evaluation Hub with Streaming")
+
+with gr.Blocks(title="SLM Model Tester") as app:
+
+    gr.Markdown("# SLM Model Evaluation Hub")
 
     with gr.Row():
-        # Left column: Settings & Monitoring
-        with gr.Column(scale=1):
-            
-            with gr.Accordion("System Monitoring", open=True):
-                stats_output = gr.Textbox(label="Live System Stats", show_label=False)
+        with gr.Column(scale=1, min_width=300):
+
+            with gr.Accordion("System", open=False):
+                stats_output = gr.Textbox(label="Stats", show_label=False, max_lines=5)
                 gr.Timer(2).tick(get_system_stats, None, stats_output)
 
             with gr.Group():
-                gr.Markdown("### Select or Paste custom model id here")
+                model_id_input = gr.Dropdown(
+                    choices=MODELS, label="Model", allow_custom_value=True,
+                    value=DEFAULT_MODEL
+                )
                 with gr.Row():
-                    model_id_input = gr.Dropdown(choices=MODELS, label="Model", allow_custom_value=True, show_label=False, scale=3)
-                    load_btn = gr.Button("Load", variant="secondary", scale=1)
-                use_gpu = gr.Checkbox(label="Use GPU?", value=False)
-                clean_btn = gr.Button("Clean HF Cache", variant="stop", size="sm")
-
-            with gr.Accordion("Generation Configuration", open=False):
-                do_sample_input = gr.Checkbox(label="Enable Sampling (do_sample)", value=True, info="Uncheck for greedy decoding")
-                max_tokens_input = gr.Slider(minimum=10, maximum=2048, value=256, step=1, label="Max Output Tokens")
-                temperature_input = gr.Slider(minimum=0.1, maximum=2.0, value=0.7, step=0.1, label="Temperature", info="Higher = more creative")
-                
-                top_k_input = gr.Slider(minimum=0, maximum=100, value=50, step=1, label="Top-K", info="0 = disabled")
-                top_p_input = gr.Slider(minimum=0.1, maximum=1.0, value=0.9, step=0.05, label="Top-P (Nucleus)", info="1.0 = disabled")
-                rep_penalty_input = gr.Slider(minimum=1.0, maximum=2.0, value=1.1, step=0.05, label="Repetition Penalty", info="1.0 = disabled")
-                ngram_size_input = gr.Slider(minimum=0, maximum=10, value=0, step=1, label="No Repeat N-Gram Size", info="0 = disabled")
-
-        # Right column: Interaction
-        with gr.Column(scale=2):
+                    load_btn = gr.Button("Load Model", variant="primary", scale=2)
+                    clean_btn = gr.Button("Clear Cache", variant="stop", scale=1)
+
+            with gr.Group():
+                mode_input = gr.Dropdown(
+                    choices=TASK_MODES, value="Completion", label="Mode"
+                )
+                use_gpu = gr.Checkbox(label="Use GPU", value=True)
+
+            with gr.Accordion("Parameters", open=False):
+                do_sample_input = gr.Checkbox(label="Sampling", value=True, info="Uncheck for greedy")
+                max_tokens_input = gr.Slider(minimum=10, maximum=2048, value=256, step=1, label="Max Tokens")
+                temperature_input = gr.Slider(minimum=0.1, maximum=2.0, value=0.7, step=0.1, label="Temperature")
+                top_k_input = gr.Slider(minimum=0, maximum=100, value=50, step=1, label="Top-K")
+                top_p_input = gr.Slider(minimum=0.1, maximum=1.0, value=0.9, step=0.05, label="Top-P")
+                rep_penalty_input = gr.Slider(minimum=1.0, maximum=2.0, value=1.1, step=0.05, label="Rep. Penalty")
+                ngram_size_input = gr.Slider(minimum=0, maximum=10, value=0, step=1, label="N-Gram Size")
+
+        with gr.Column(scale=3):
+            system_prompt_input = gr.Textbox(
+                label="System Prompt", value="You are a helpful assistant.",
+                lines=2, visible=False
+            )
+
             user_prompt = gr.Textbox(
-                label="Prompt", 
-                value="Once upon a time in a digital kingdom,", 
-                placeholder="Enter your prompt here...", 
-                lines=5
+                label="Prompt",
+                value="Once upon a time in a digital kingdom,",
+                placeholder="Enter your prompt here...",
+                lines=8
+            )
+
+            context_input = gr.Textbox(
+                label="Context", placeholder="Paste reference context here...",
+                lines=5, visible=False
+            )
+
+            src_lang_input = gr.Dropdown(
+                choices=LANGUAGES, value="English", label="Translate from",
+                visible=False
             )
-            run_btn = gr.Button("Generate text", variant="primary", size="lg")
-            status_output = gr.Markdown("Status: *Waiting to load model...*")
-            output_text = gr.Textbox(label="Result", lines=15, buttons=["copy"], autoscroll=True)
-    
-    # Events
+            tgt_lang_input = gr.Dropdown(
+                choices=LANGUAGES, value="Spanish", label="Translate to",
+                visible=False
+            )
+
+            run_btn = gr.Button("Generate", variant="primary", size="lg")
+            status_output = gr.Markdown("*Ready*")
+            output_text = gr.Textbox(
+                label="Output", lines=15, buttons=["copy"], autoscroll=True
+            )
+
     load_btn.click(
-        fn=load_new_model, 
-        inputs=[model_id_input], 
+        fn=load_new_model,
+        inputs=[model_id_input],
         outputs=[status_output]
     )
-    
-    # We use `.click` targeting a generator function, which Gradio naturally treats as a streaming output
+
+    mode_input.change(
+        fn=update_mode_ui,
+        inputs=[mode_input],
+        outputs=[system_prompt_input, user_prompt, context_input, src_lang_input, tgt_lang_input]
+    )
+
     run_btn.click(
         fn=run_inference,
         inputs=[
-            user_prompt, 
-            max_tokens_input, 
-            temperature_input, 
-            top_k_input, 
-            top_p_input, 
-            rep_penalty_input, 
+            mode_input,
+            user_prompt,
+            system_prompt_input,
+            context_input,
+            src_lang_input,
+            tgt_lang_input,
+            max_tokens_input,
+            temperature_input,
+            top_k_input,
+            top_p_input,
+            rep_penalty_input,
             ngram_size_input,
             do_sample_input,
             use_gpu
         ],
         outputs=[output_text, status_output]
     )
-    
+
     clean_btn.click(fn=clean_cache, outputs=[status_output])
 
 if __name__ == "__main__":
-    app.launch()
+    app.launch(theme=gr.themes.Soft())