Update app.py

app.py

@@ -1,12 +1,12 @@
 # -*- coding: utf-8 -*-
 """
-Hugging Face Spaces Script for Basic Stable Diffusion 1.5 Gradio App
-Adapted from user's local script and HF Spaces template.
-Supports Hub models and CPU/GPU selection based on available hardware.
+CipherCore SD1.5 Image Generator, FAST CPU INFERENCE
+Raxephion @2025
+
 """
 
 import gradio as gr
-import numpy as np
+import numpy as np # <-- Needed for np.iinfo
 import random
 import torch
 from diffusers import StableDiffusionPipeline
@@ -45,6 +45,12 @@ DEFAULT_HUB_MODELS = [
     # Add other diffusers-compatible SD1.5 models here
 ]
 
+# --- Constants for Gradio UI / Generation ---
+MAX_SEED = np.iinfo(np.int32).max # <-- Added this line back! Defines the maximum seed value
+# MAX_IMAGE_SIZE = 1024 # This was in the template but not strictly used in the logic outside the slider max, keeping it defined is harmless but maybe not needed
+# However, let's add MAX_IMAGE_SIZE as it was related to the sliders in the template
+MAX_IMAGE_SIZE_SLIDER = 1024 # Renamed to avoid confusion, used only for slider max
+
 # --- Determine available devices and set up options ---
 # This logic is from the user's script and works well for Spaces
 AVAILABLE_DEVICES = ["CPU"]
@@ -92,6 +98,7 @@ INITIAL_MODEL_ID = DEFAULT_HUB_MODELS[0] if DEFAULT_HUB_MODELS else None
 if INITIAL_MODEL_ID:
     print(f"\nLoading initial model '{INITIAL_MODEL_ID}' on startup...")
     try:
+        # Load the pipeline onto the initial device and dtype
         current_pipeline = StableDiffusionPipeline.from_pretrained(
             INITIAL_MODEL_ID,
             torch_dtype=initial_dtype_to_use,
@@ -146,131 +153,106 @@ def infer(
     progress=gr.Progress(track_tqdm=True), # Added progress argument from template
 ):
     """Generates an image using the selected model and parameters on the chosen device."""
-    global current_pipeline, current_model_id, current_device_loaded, SCHEDULER_MAP
-
-    # Check if initial load failed
-    if current_pipeline is None and model_identifier != INITIAL_MODEL_ID:
-         # Try loading the selected model if initial load failed or model is different
-         pass # Logic below handles loading
-
-    if not model_identifier or model_identifier == "No models found":
-        raise gr.Error(f"No model selected or available. Please select a model from the list.")
-    if not prompt:
-        raise gr.Error("Please enter a prompt.")
-
-    # Map selected device string to PyTorch device string
-    device_to_use = "cuda" if selected_device_str == "GPU" and "GPU" in AVAILABLE_DEVICES else "cpu"
-    # If GPU was selected but not available, raise an error specific to this condition
-    if selected_device_str == "GPU" and device_to_use == "cpu":
-         raise gr.Error("GPU selected but CUDA is not available to PyTorch on this Space. Please select CPU or ensure the Space is configured with a GPU and the CUDA version of PyTorch is installed.")
-
-    # Determine dtype based on the actual device being used
-    dtype_to_use = torch.float32 # Default
-    if device_to_use == "cuda":
-        if torch.cuda.is_available() and torch.cuda.get_device_capability(0)[0] >= 7:
-             dtype_to_use = torch.float16
-        else:
-             dtype_to_use = torch.float32
-    else:
-         dtype_to_use = torch.float32
-
-
-    print(f"Attempting generation on device: {device_to_use}, using dtype: {dtype_to_use}")
+    global current_pipeline, current_model_id, current_device_loaded, SCHEDULER_MAP, MAX_SEED # <-- Make MAX_SEED global
 
-    # 1. Load/Switch Model if necessary
-    # Check if the requested model identifier OR the requested device has changed
-    # Use string comparison for current_device_loaded as it's a torch.device object
+    # Check if initial load failed or model is different
     if current_pipeline is None or current_model_id != model_identifier or (current_device_loaded is not None and str(current_device_loaded) != device_to_use):
-        print(f"Loading model: {model_identifier} onto {device_to_use}...")
-        # Clear previous pipeline to potentially free memory *before* loading the new one
-        if current_pipeline is not None:
-             print(f"Unloading previous model '{current_model_id}' from {current_device_loaded}...")
-             # Move pipeline to CPU before deleting if it was on GPU, might help with freeing VRAM
-             if str(current_device_loaded) == "cuda":
+         # This check is done before parameter parsing so we can determine device/dtype for loading
+         # Need to redo some parameter parsing here to get device_to_use early
+         temp_device_to_use = "cuda" if selected_device_str == "GPU" and "GPU" in AVAILABLE_DEVICES else "cpu"
+         temp_dtype_to_use = torch.float32
+         if temp_device_to_use == "cuda":
+             if torch.cuda.is_available() and torch.cuda.get_device_capability(0)[0] >= 7:
+                  temp_dtype_to_use = torch.float16
+             else:
+                  temp_dtype_to_use = torch.float32
+         else:
+              temp_dtype_to_use = torch.float32
+
+         # Now proceed with actual model loading based on parsed device/dtype
+         print(f"Loading model: {model_identifier} onto {temp_device_to_use} with dtype {temp_dtype_to_use}...")
+         # Clear previous pipeline to potentially free memory *before* loading the new one
+         if current_pipeline is not None:
+              print(f"Unloading previous model '{current_model_id}' from {current_device_loaded}...")
+              if str(current_device_loaded) == "cuda":
+                   try:
+                       current_pipeline.to("cpu")
+                       print("Moved previous pipeline to CPU.")
+                   except Exception as move_e:
+                       print(f"Warning: Failed to move previous pipeline to CPU: {move_e}")
+              del current_pipeline
+              current_pipeline = None # Set to None immediately
+              if str(current_device_loaded) == "cuda":
                   try:
-                      current_pipeline.to("cpu")
-                      print("Moved previous pipeline to CPU.")
-                  except Exception as move_e:
-                      print(f"Warning: Failed to move previous pipeline to CPU: {move_e}")
-
-             del current_pipeline
-             current_pipeline = None # Set to None immediately
-             # Attempt to clear CUDA cache if using GPU (from the previous device)
-             if str(current_device_loaded) == "cuda":
-                 try:
-                     torch.cuda.empty_cache()
-                     print("Cleared CUDA cache.")
-                 except Exception as cache_e:
-                     print(f"Warning: Error clearing CUDA cache: {cache_e}")
-
-        # Ensure the device is actually available if not CPU (redundant with earlier check but safe)
-        if device_to_use == "cuda":
-             if not torch.cuda.is_available():
-                  raise gr.Error("CUDA selected but not available. Please select CPU.")
-
-        try:
-            # For Spaces, assume model_identifier is a Hub ID or a path *within the repo*
-            # from_pretrained can handle both.
-            print(f"Attempting to load model from: {model_identifier}")
-            pipeline = StableDiffusionPipeline.from_pretrained(
-                model_identifier,
-                torch_dtype=dtype_to_use,
-                safety_checker=None, # <<< SAFETY CHECKER DISABLED <<<
-                # Add `vae=AutoencoderKL.from_pretrained(...)` if needed for specific models
-            )
-
-            pipeline = pipeline.to(device_to_use) # Move to the selected device
-
-            current_pipeline = pipeline
-            current_model_id = model_identifier
-            current_device_loaded = torch.device(device_to_use)
-
-            # Basic check for SD1.x architecture (cross_attention_dim = 768)
-            unet_config = getattr(pipeline, 'unet', None)
-            if unet_config and hasattr(unet_config, 'config') and hasattr(unet_config.config, 'cross_attention_dim'):
-                 cross_attn_dim = unet_config.config.cross_attention_dim
-                 if cross_attn_dim != 768:
-                     warning_msg = (f"Warning: Loaded model '{model_identifier}' might not be a standard SD 1.x model "
-                                    f"(expected UNet cross_attention_dim 768, found {cross_attn_dim}). "
-                                    "Results may be unexpected or generation might fail.")
-                     print(warning_msg)
-                     gr.Warning(warning_msg)
-                 else:
-                     print("UNet cross_attention_dim is 768, consistent with SD 1.x.")
-            else:
-                 print("Could not check UNet cross_attention_dim.")
-
-
-            print(f"Model '{model_identifier}' loaded successfully on {current_device_loaded} with dtype {dtype_to_use}.")
+                      torch.cuda.empty_cache()
+                      print("Cleared CUDA cache.")
+                  except Exception as cache_e:
+                      print(f"Warning: Error clearing CUDA cache: {cache_e}")
+
+         # Ensure the device is actually available if not CPU (redundant with earlier check but safe)
+         if temp_device_to_use == "cuda":
+              if not torch.cuda.is_available():
+                   raise gr.Error("CUDA selected but not available to PyTorch on this Space. Please select CPU or ensure the Space is configured with a GPU and the CUDA version of PyTorch is installed.")
+
+         try:
+             pipeline = StableDiffusionPipeline.from_pretrained(
+                 model_identifier,
+                 torch_dtype=temp_dtype_to_use, # Use the determined dtype for loading
+                 safety_checker=None,
+             )
+             pipeline = pipeline.to(temp_device_to_use) # Use the determined device
+
+             current_pipeline = pipeline
+             current_model_id = model_identifier
+             current_device_loaded = torch.device(temp_device_to_use) # Store the actual device object
+
+             # Basic check for SD1.x architecture
+             unet_config = getattr(pipeline, 'unet', None)
+             if unet_config and hasattr(unet_config, 'config') and hasattr(unet_config.config, 'cross_attention_dim'):
+                  cross_attn_dim = unet_config.config.cross_attention_dim
+                  if cross_attn_dim != 768:
+                      warning_msg = (f"Warning: Loaded model '{model_identifier}' might not be a standard SD 1.x model "
+                                     f"(expected UNet cross_attention_dim 768, found {cross_attn_dim}). "
+                                     "Results may be unexpected or generation might fail.")
+                      print(warning_msg)
+                      gr.Warning(warning_msg)
+                  else:
+                      print("UNet cross_attention_dim is 768, consistent with SD 1.x.")
+             else:
+                  print("Could not check UNet cross_attention_dim.")
+
+             print(f"Model '{model_identifier}' loaded successfully on {current_device_loaded} with dtype {temp_dtype_to_use}.")
+
+         except Exception as e:
+             current_pipeline = None
+             current_model_id = None
+             current_device_loaded = None
+             print(f"Error loading model '{model_identifier}': {e}")
+             error_message_lower = str(e).lower()
+             if "cannot find requested files" in error_message_lower or "404 client error" in error_message_lower or "no such file or directory" in error_message_lower:
+                  raise gr.Error(f"Model '{model_identifier}' not found on Hugging Face Hub or in repo files. Check ID/path or internet connection. Error: {e}")
+             elif "checkpointsnotfounderror" in error_message_lower or "valueerror: could not find a valid model structure" in error_message_lower:
+                  raise gr.Error(f"No valid diffusers model at '{model_identifier}'. Ensure it's a diffusers format ID/path. Error: {e}")
+             elif "out of memory" in error_message_lower:
+                  raise gr.Error(f"Out of Memory (OOM) loading model. This Space might not have enough RAM/VRAM for this model. Try a lighter model or select CPU (if available). Error: {e}")
+             elif "cusolver64" in error_message_lower or "cuda driver version" in error_message_lower or "cuda error" in error_message_lower:
+                  raise gr.Error(f"CUDA/GPU Driver/Installation Error on Space: {e}. Check Space hardware or select CPU.")
+             elif "safetensors_rust.safetensorserror" in error_message_lower or "oserror: cannot load" in error_message_lower or "filenotfounderror" in error_message_lower:
+                  raise gr.Error(f"Model file error for '{model_identifier}': {e}. Files might be corrupt or incomplete on the Hub/in repo.")
+             elif "could not import" in error_message_lower or "module not found" in error_message_lower:
+                  raise gr.Error(f"Dependency error: {e}. Ensure required libraries are in requirements.txt.")
+             else:
+                 raise gr.Error(f"Failed to load model '{model_identifier}': {e}")
 
-        except Exception as e:
-            # Reset global state on load failure
-            current_pipeline = None
-            current_model_id = None
-            current_device_loaded = None
-            print(f"Error loading model '{model_identifier}': {e}")
-            error_message_lower = str(e).lower()
-            # Provide more specific error messages based on common exceptions
-            if "cannot find requested files" in error_message_lower or "404 client error" in error_message_lower or "no such file or directory" in error_message_lower:
-                 raise gr.Error(f"Model '{model_identifier}' not found on Hugging Face Hub or in repo files. Check ID/path or internet connection. Error: {e}")
-            elif "checkpointsnotfounderror" in error_message_lower or "valueerror: could not find a valid model structure" in error_message_lower:
-                 raise gr.Error(f"No valid diffusers model at '{model_identifier}'. Ensure it's a diffusers format ID/path. Error: {e}")
-            elif "out of memory" in error_message_lower:
-                 raise gr.Error(f"Out of Memory (OOM) loading model. This Space might not have enough RAM/VRAM for this model. Try a lighter model or select CPU (if available). Error: {e}")
-            elif "cusolver64" in error_message_lower or "cuda driver version" in error_message_lower or "cuda error" in error_message_lower:
-                 raise gr.Error(f"CUDA/GPU Driver/Installation Error on Space: {e}. Check Space hardware or select CPU.")
-            elif "safetensors_rust.safetensorserror" in error_message_lower or "oserror: cannot load" in error_message_lower or "filenotfounderror" in error_message_lower:
-                 raise gr.Error(f"Model file error for '{model_identifier}': {e}. Files might be corrupt or incomplete on the Hub/in repo.")
-            elif "could not import" in error_message_lower or "module not found" in error_message_lower:
-                 raise gr.Error(f"Dependency error: {e}. Ensure required libraries are in requirements.txt.")
-            else:
-                raise gr.Error(f"Failed to load model '{model_identifier}': {e}")
+    # Re-determine device_to_use and dtype_to_use *after* ensuring pipeline is loaded
+    # They should match current_device_loaded and the pipeline's dtype
+    device_to_use = str(current_pipeline.device) if current_pipeline else ("cuda" if selected_device_str == "GPU" and "GPU" in AVAILABLE_DEVICES else "cpu")
+    dtype_to_use = current_pipeline.dtype if current_pipeline else torch.float32 # Fallback if somehow pipeline is still None
 
     # Check if pipeline is successfully loaded before proceeding
     if current_pipeline is None:
          raise gr.Error("Model failed to load. Cannot generate image.")
 
-
     # 2. Configure Scheduler
     selected_scheduler_class = SCHEDULER_MAP.get(scheduler_name)
     if selected_scheduler_class is None:
@@ -322,26 +304,41 @@ def infer(
 
 
     # 4. Set Seed Generator
-    generator = None
     # The generator device needs to match the pipeline device
     generator_device = current_pipeline.device # Must match the pipeline device
 
     if randomize_seed: # Use the randomize_seed checkbox
-        seed = random.randint(0, MAX_SEED) # Re-randomize seed
+        seed = random.randint(0, MAX_SEED) # Re-randomize seed using MAX_SEED
         print(f"Randomizing seed to: {seed}")
     else:
         # Use provided seed if not randomizing (-1 will still use it)
+        # If seed is -1 but randomize_seed is False, we should still use a random seed,
+        # but make it deterministic based on system time or similar if possible, or just MAX_SEED based random.
+        # Given the UI has a 'randomize_seed' checkbox, let's treat seed=-1 as a specific "use system random" signal IF randomize_seed is also False.
+        # Or, more simply, if randomize_seed is False, always use the value in the seed input.
+        # Let's stick to the simpler interpretation: if randomize_seed is True, override seed input. If False, use seed input value.
         print(f"Using provided seed: {int(seed)}")
 
 
     try:
+        # Ensure seed is an integer for the generator
+        seed_int = int(seed)
         # Explicitly move generator to the desired device
-        generator = torch.Generator(device=generator_device).manual_seed(int(seed))
-        print(f"Generator set with seed {int(seed)} on device: {generator_device}")
+        generator = torch.Generator(device=generator_device).manual_seed(seed_int)
+        print(f"Generator set with seed {seed_int} on device: {generator_device}")
     except Exception as e:
-         print(f"Warning: Error setting seed generator on device {generator_device}: {e}. Generation might still proceed with a default generator (potentially on CPU).")
-         gr.Warning(f"Failed to set seed generator on device {generator_device}. Generation might use a random seed on a different device. Error: {e}")
+         # Handle potential issues like non-integer seed input
+         print(f"Warning: Error setting seed generator with seed {seed} on device {generator_device}: {e}. Falling back to default generator (potentially on CPU) and using a potentially different seed.")
+         gr.Warning(f"Failed to set seed generator with seed {seed}. Using random seed. Error: {e}")
          generator = None # Let pipeline handle random seed if generator creation fails or device mismatch
+         # If generator creation failed, the actual seed used might be different. How to report it?
+         # The simplest is to let the pipeline run and report the seed *we attempted to use*.
+         # Or, if we know pipeline will use a random seed on failure, report that.
+         # For simplicity, let's report the seed_int we derived UNLESS randomize_seed was True, then report the generated random seed.
+         # No, the most accurate is to let the pipeline generate, and some diffusers versions return the generator state/seed.
+         # However, the standard pipeline output doesn't return the seed.
+         # Let's just report the seed we *tried* to use. If randomize_seed was True, it's the random one. If False, it's the user input one.
+         pass # Keep the last calculated seed_int or seed value
 
     # 5. Generate Image
     # Ensure required parameters are integers/floats
@@ -354,7 +351,7 @@ def infer(
     if width <= 0 or height <= 0:
          raise ValueError("Image width and height must be positive.")
 
-    print(f"Generating: Prompt='{prompt[:80]}{'...' if len(prompt) > 80 else ''}', NegPrompt='{negative_prompt[:80]}{'...' if len(negative_prompt) > 80 else ''}', Steps={num_inference_steps_int}, CFG={guidance_scale_float}, Size={width}x{height}, Scheduler={scheduler_name}, Seed={int(seed)}, Device={device_to_use}, Dtype={dtype_to_use}")
+    print(f"Generating: Prompt='{prompt[:80]}{'...' if len(prompt) > 80 else ''}', NegPrompt='{negative_prompt[:80]}{'...' if len(negative_prompt) > 80 else ''}', Steps={num_inference_steps_int}, CFG={guidance_scale_float}, Size={width}x{height}, Scheduler={scheduler_name}, Seed={seed_int if generator else 'Random (Generator Failed)'}, Device={device_to_use}, Dtype={dtype_to_use}")
     start_time = time.time()
 
     try:
@@ -366,7 +363,7 @@ def infer(
             guidance_scale=guidance_scale_float,
             width=width,
             height=height,
-            generator=generator,
+            generator=generator, # Pass the generator (which might be None)
             # Pass progress object for tqdm tracking in Gradio
             callback_steps=max(1, num_inference_steps_int // 20), # Update progress bar periodically
             callback=lambda step, timestep, latents: progress((step / num_inference_steps_int, f"Step {step}/{num_inference_steps_int}")),
@@ -381,8 +378,11 @@ def infer(
         print(f"Generation finished in {end_time - start_time:.2f} seconds.")
         generated_image = output.images[0]
 
+        # Determine the seed to return: the one we attempted to use
+        actual_seed_used = seed_int if generator else -1 # Return -1 or the input seed if generator failed
+
         # Return both the image and the seed (potentially randomized)
-        return generated_image, seed
+        return generated_image, actual_seed_used
 
     except gr.Error as e:
          # Re-raise Gradio errors directly
@@ -423,8 +423,16 @@ else:
     initial_model_choices = model_choices
     # Set a reasonable default if available
     initial_default_model = INITIAL_MODEL_ID if INITIAL_MODEL_ID else "No models found"
-    model_dropdown_interactive = True if INITIAL_MODEL_ID else False
+    model_dropdown_interactive = True # Make it interactive if there's *any* model choice
 
+# Ensure the initial default model is actually in the choices list if possible
+if initial_default_model != "No models found" and initial_default_model not in initial_model_choices:
+     print(f"Warning: Initial default model '{initial_default_model}' is not in the model_choices list.")
+     if initial_model_choices and initial_model_choices[0] != "No models found":
+          initial_default_model = initial_model_choices[0]
+          print(f"Setting default model to first available choice: {initial_default_model}")
+     else:
+          initial_default_model = "No models found" # Fallback if no choices
 
 scheduler_choices = list(SCHEDULER_MAP.keys())
 
@@ -449,8 +457,10 @@ with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo: # Added Soft theme from
     # Add a note about model loading time
     if INITIAL_MODEL_ID:
          gr.Markdown(f"*(Note: The initial model '{INITIAL_MODEL_ID}' is loading... First generation might take longer.)*")
+    elif initial_default_model != "No models found":
+         gr.Markdown(f"*(Note: Loading model '{initial_default_model}' on first generation... This might take some time.)*")
     else:
-         gr.Markdown(f"*(Note: No initial model configured or loaded. Select a model from the dropdown to start.)*")
+         gr.Markdown(f"*(Note: No models available. Add Hub IDs to DEFAULT_HUB_MODELS in the script.)*")
 
 
     with gr.Row():
@@ -487,8 +497,9 @@ with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo: # Added Soft theme from
                     )
                 # Combine seed input and randomize checkbox
                 with gr.Row():
-                     seed_input = gr.Number(label="Seed", value=0, precision=0, interactive=True) # Use 0 as default, interactive initially
-                     randomize_seed_checkbox = gr.Checkbox(label="Randomize seed (-1 equivalent)", value=True)
+                     # Use MAX_SEED for slider max
+                     seed_input = gr.Slider(label="Seed", minimum=0, maximum=MAX_SEED, step=1, value=0, precision=0, interactive=True) # Use 0 as default, interactive initially
+                     randomize_seed_checkbox = gr.Checkbox(label="Randomize seed", value=True) # Simplified label
 
 
             generate_button = gr.Button("✨ Generate Image ✨", variant="primary", scale=1) # Added emojis
@@ -529,25 +540,14 @@ with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo: # Added Soft theme from
     )
 
     # Add examples from template
-    # Ensure examples match the input types and order of the infer function
-    # Examples inputs: [prompt, neg_prompt, seed, randomize_seed, width, height, cfg_scale, steps]
-    # Note: Size and Scheduler are not easily handled in standard examples, they'll use defaults.
-    # Let's adjust the example inputs to match the infer function's first few parameters
-    example_prompts = [
-        ["Astronaut in a jungle, cold color palette, muted colors, detailed, 8k", None, 0, True, "512x512", "Euler", 7.5, 30],
-        ["An astronaut riding a green horse", None, 0, True, "512x512", "Euler", 7.5, 30],
-        ["A delicious ceviche cheesecake slice", None, 0, True, "512x512", "Euler", 7.5, 30],
-    ]
-    # Update example inputs to match the infer function parameters
-    # [model_identifier, selected_device_str, prompt, negative_prompt, steps, cfg_scale, scheduler_name, size, seed, randomize_seed]
-    # Need to add dummy values for model, device, steps, cfg, scheduler, size for examples
-    # Let's simplify examples to just prompt/neg_prompt for typical template usage
+    # Ensure examples map to the correct input component indices
     template_examples = [
         "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k",
         "An astronaut riding a green horse",
         "A delicious ceviche cheesecake slice",
     ]
-    # Map template examples to the input components: [prompt_input]
+    # Examples will only populate the first input they match.
+    # In this case, passing just a list of strings populates the first Textbox: prompt_input.
     gr.Examples(examples=template_examples, inputs=[prompt_input])
 
 
@@ -559,7 +559,7 @@ with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo: # Added Soft theme from
         1. Select a model from the dropdown (Hugging Face Hub ID). Models are downloaded and cached on the Space.
         2. Choose your processing device (GPU recommended if available).
         3. Enter your positive and optional negative prompts.
-        4. Adjust advanced settings (Steps, CFG Scale, Scheduler, Size, Seed) if needed. Seed -1 or the "Randomize seed" checkbox will use a random seed.
+        4. Adjust advanced settings (Steps, CFG Scale, Scheduler, Size, Seed) if needed. The "Randomize seed" checkbox will override the seed value in the input box.
         5. Click "Generate Image".
         The first generation with a new model/device might take some time to load.
         """ # Removed notes about local models and batch files
@@ -576,7 +576,7 @@ if __name__ == "__main__":
     print(f"Available devices detected by PyTorch: {', '.join(AVAILABLE_DEVICES)}")
     print(f"Default device selected by app: {DEFAULT_DEVICE}")
     if current_pipeline:
-         print(f"Initial model '{current_model_id}' loaded successfully.")
+         print(f"Initial model '{current_model_id}' loaded successfully on {current_device_loaded}.")
     else:
          print("No initial model loaded. Check model list and network connectivity.")