Update app.py

app.py

@@ -5,257 +5,104 @@ from PIL import Image
 import numpy as np
 import os
 
-# Try importing TensorFlow. This is crucial for .h5 models.
+# Check for TensorFlow
 try:
     import tensorflow as tf
     IS_TF_AVAILABLE = True
-    print("TensorFlow is available.")
 except ImportError:
     IS_TF_AVAILABLE = False
-    print("TensorFlow is not available. .h5 models loaded directly with tf.keras.models.load_model will not work.")
 
-
-# --- 1. Load the Model ---
-# IMPORTANT: Replace "ravi86/mood_detector" with your actual model name on Hugging Face Hub,
-# or ensure your local model files are correctly placed in the 'model/' directory.
-
-model_name_or_path = "ravi86/mood_detector" # Default to Hugging Face Hub model
+# --- Load Model ---
 model = None
 processor = None
-is_pytorch_model = True # Flag to track model type (defaults to PyTorch)
+is_pytorch_model = True
+
+model_name_or_path = "ravi86/mood_detector"
+local_h5_path = "./my_model.h5"
 
 try:
-    # 1. Attempt to load as a PyTorch model from Hugging Face Hub (default behavior)
     model = AutoModelForImageClassification.from_pretrained(model_name_or_path)
     processor = AutoImageProcessor.from_pretrained(model_name_or_path)
-    print(f"Model and processor loaded successfully from Hugging Face Hub: {model_name_or_path} (PyTorch)")
-except Exception as e_hub_pt:
-    print(f"Error loading PyTorch model from Hugging Face Hub ({model_name_or_path}): {e_hub_pt}")
-
-    # 2. If PyTorch Hub load fails, attempt to load as a TensorFlow model from Hugging Face Hub
+except:
     if IS_TF_AVAILABLE:
         try:
-            model = AutoModelForImageClassification.from_pretrained(model_name_or_path, from_tf=True)
-            processor = AutoImageProcessor.from_pretrained(model_name_or_path)
-            is_pytorch_model = False # Set flag as it's a TF model
-            print(f"Model and processor loaded successfully from Hugging Face Hub: {model_name_or_path} (TensorFlow)")
-        except Exception as e_hub_tf:
-            print(f"Error loading TensorFlow model from Hugging Face Hub ({model_name_or_path}): {e_hub_tf}")
-
-# 3. If still no model loaded, try local files (both Transformers-saved and raw .h5)
-if model is None:
-    print("Trying to load model from local 'model/' directory...")
-    local_model_dir = "./model"
-    local_h5_path = os.path.join(local_model_dir, "my_model.h5") # <--- UPDATED THIS LINE
-
-    # Attempt to load as a Transformers model (might be PyTorch or TF saved with save_pretrained)
-    try:
-        model = AutoModelForImageClassification.from_pretrained(local_model_dir)
-        processor = AutoImageProcessor.from_pretrained(local_model_dir)
-        # Determine if it's PyTorch or TF based on internal attribute
-        is_pytorch_model = hasattr(model, 'parameters') and callable(getattr(model, 'parameters'))
-        print(f"Model and processor loaded successfully from local '{local_model_dir}' (Transformers format, {'PyTorch' if is_pytorch_model else 'TensorFlow'})!")
-    except Exception as e_local_transformers:
-        print(f"Error loading Transformers model from local '{local_model_dir}': {e_local_transformers}")
-
-        # If it failed as a Transformers model, try loading raw .h5 if TensorFlow is available
-        if IS_TF_AVAILABLE and os.path.exists(local_h5_path):
-            try:
-                model = tf.keras.models.load_model(local_h5_path)
-                # For raw Keras .h5, we assume AutoImageProcessor (or similar preprocessor) is still valid.
-                # If your .h5 model has custom preprocessing, you'll need to define it here.
-                # For now, we'll try to load a processor based on the original model_name_or_path
-                # or a generic one if no preprocessor_config.json is present in ./model.
-                try:
-                    processor = AutoImageProcessor.from_pretrained(local_model_dir)
-                except Exception:
-                    print("Could not load processor from local model directory, trying generic AutoImageProcessor.")
-                    # Fallback if preprocessor_config.json is missing for local .h5
-                    processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224") # Generic image processor example
-                is_pytorch_model = False # It's a Keras TF model
-                print(f"Model loaded successfully from local .h5 file: {local_h5_path} (TensorFlow Keras)")
-            except Exception as e_local_h5:
-                print(f"Error loading .h5 model directly: {e_local_h5}")
+            model = tf.keras.models.load_model(local_h5_path)
+            processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")
+            is_pytorch_model = False
+        except:
+            raise RuntimeError("Could not load .h5 model.")
+    else:
+        raise RuntimeError("Model loading failed. No valid model found.")
 
-# Final check if model loaded successfully
 if model is None or processor is None:
-    raise RuntimeError("Failed to load facial expression model from any source. Please check model path, files, and dependencies.")
+    raise RuntimeError("Model or processor not loaded.")
 
-# Set model to evaluation mode for PyTorch models only
 if is_pytorch_model:
     model.eval()
-else:
-    # Keras models are typically ready for inference by default, no .eval() needed
-    pass
 
-# --- 2. Define Emotion Labels and Spotify Playlist Mapping ---
+# --- Labels and Music Mapping ---
 emotions = ["Angry", "Disgust", "Fear", "Happy", "Sad", "Surprise", "Neutral"]
 
-# IMPORTANT: Replace these with actual Spotify playlist URLs.
-# You can find many public mood-based playlists on Spotify.
-# These are placeholder examples.
 spotify_playlist_mapping = {
-    "Angry": "https://open.spotify.com/playlist/37i9dQZF1DX2LTjeP1y0aR", # Aggressive Rock/Metal
-    "Disgust": "https://open.spotify.com/playlist/37i9dQZF1DXcK3k3gJ6usM", # Something a bit unsettling or chaotic
-    "Fear": "https://open.spotify.com/playlist/37i9dQZF1DX4Qp4Cp4wK2N",  # Dark Ambient/Suspenseful
-    "Happy": "https://open.spotify.com/playlist/37i9dQZF1DXdPec7aLk9C1",  # Happy Hits!
-    "Sad": "https://open.spotify.com/playlist/37i9dQZF1DX7qK8TM4T5pC",   # Sad Indie
-    "Surprise": "https://open.spotify.com/playlist/37i9dQZF1DXdgnL3vj1gWM", # High Energy/Unexpected
-    "Neutral": "https://open.spotify.com/playlist/37i9dQZF1DXasMvN3R0sVw" # Chill Instrumental
+    "Angry": "https://open.spotify.com/playlist/37i9dQZF1DX2LTjeP1y0aR",
+    "Disgust": "https://open.spotify.com/playlist/37i9dQZF1DXcK3k3gJ6usM",
+    "Fear": "https://open.spotify.com/playlist/37i9dQZF1DX4Qp4Cp4wK2N",
+    "Happy": "https://open.spotify.com/playlist/37i9dQZF1DXdPec7aLk9C1",
+    "Sad": "https://open.spotify.com/playlist/37i9dQZF1DX7qK8TM4T5pC",
+    "Surprise": "https://open.spotify.com/playlist/37i9dQZF1DXdgnL3vj1gWM",
+    "Neutral": "https://open.spotify.com/playlist/37i9dQZF1DXasMvN3R0sVw"
 }
 
-# --- 3. Prediction Function ---
-def classify_expression_and_suggest_music(image_input: np.ndarray):
+# --- Predict Function ---
+def classify_expression_and_suggest_music(image_input):
     if image_input is None:
-        return "No webcam input detected. Please allow camera access.", ""
+        return "No webcam input detected.", ""
 
-    # Convert NumPy array to PIL Image (and ensure grayscale)
-    image = Image.fromarray(image_input).convert("L") # Convert to grayscale
-    image = image.resize((48, 48)) # Resize to model's expected input dimensions
+    image = Image.fromarray(image_input).convert("L").resize((48, 48))
 
-    # Prepare image for model inference using the processor
-    # The processor usually returns PyTorch tensors by default
     inputs = processor(images=image, return_tensors="pt")
+    inputs_for_model = inputs['pixel_values']
 
-    # If the model is a TensorFlow Keras model, convert inputs to TensorFlow tensors
-    if not is_pytorch_model:
-        # Assuming the processor outputs a dictionary with 'pixel_values' key for image data
-        # Convert PyTorch tensor to NumPy, then to TensorFlow tensor
-        # Squeeze(0) removes the batch dimension which `from_pretrained` might add
+    if not is_pytorch_model and IS_TF_AVAILABLE:
         pixel_values_np = inputs['pixel_values'].squeeze(0).numpy()
-        pixel_values_tf = tf.convert_to_tensor(pixel_values_np, dtype=tf.float32)
-        # Add batch dimension back for the model if necessary (Keras models expect batch dim)
-        inputs_for_model = tf.expand_dims(pixel_values_tf, axis=0)
-    else:
-        inputs_for_model = inputs['pixel_values'] # For PyTorch, just use the pixel values
-
+        inputs_for_model = tf.expand_dims(tf.convert_to_tensor(pixel_values_np), 0)
 
-    # Perform inference
-    with torch.no_grad(): # This context manager is primarily for PyTorch, does nothing for TF models
+    with torch.no_grad():
         if is_pytorch_model:
             outputs = model(inputs_for_model)
-            logits = outputs.logits # Access logits if model output is an object (common in Transformers models)
+            logits = outputs.logits
         else:
-            # For a raw Keras model, it usually returns raw logits directly
             outputs = model(inputs_for_model)
-            logits = outputs # Assume direct output is logits for a simple Keras model
+            logits = outputs
 
-        # Ensure logits is a torch.Tensor for softmax calculation.
-        # If it's a TensorFlow tensor from a Keras model, convert it.
-        if IS_TF_AVAILABLE and not is_pytorch_model and isinstance(logits, tf.Tensor):
-            logits = torch.from_numpy(logits.numpy()) # Convert TF tensor to PyTorch tensor for softmax
+        if isinstance(logits, tf.Tensor):
+            logits = torch.from_numpy(logits.numpy())
         elif not isinstance(logits, torch.Tensor):
-            # This case handles if logits is a numpy array or other format after TF processing
             logits = torch.from_numpy(np.array(logits))
 
-
         probs = torch.softmax(logits, dim=-1)
 
-    predicted_class_idx = probs.argmax().item()
-    predicted_emotion = emotions[predicted_class_idx]
-    confidence = probs[0, predicted_class_idx].item() * 100
-
-    output_text = f"Detected Emotion: **{predicted_emotion}** (Confidence: {confidence:.2f}%)"
-
-    # Get the Spotify playlist URL for the detected emotion
-    playlist_url = spotify_playlist_mapping.get(predicted_emotion, spotify_playlist_mapping["Neutral"])
+    idx = probs.argmax().item()
+    emotion = emotions[idx]
+    confidence = probs[0, idx].item() * 100
 
-    # Create a clickable markdown link for the Spotify playlist
-    spotify_link_markdown = f"**Listen on Spotify:** <a href='{playlist_url}' target='_blank'>🎧 {predicted_emotion} Vibes</a>"
+    output_text = f"Detected Emotion: **{emotion}** (Confidence: {confidence:.2f}%)"
+    playlist_url = spotify_playlist_mapping.get(emotion, spotify_playlist_mapping["Neutral"])
+    spotify_link = f"**Listen on Spotify:** <a href='{playlist_url}' target='_blank'>🎧 {emotion} Vibes</a>"
 
-    return output_text, spotify_link_markdown
+    return output_text, spotify_link
 
-# --- 4. Gradio Interface ---
-# Define the Gradio Interface
+# --- Gradio UI ---
 iface = gr.Interface(
     fn=classify_expression_and_suggest_music,
-    inputs=gr.Image(
-        type="numpy",
-        source="webcam",
-        streaming=True, # Enable continuous streaming from webcam
-        label="Your Live Webcam Feed (Ensure good lighting and center face!)"
-    ),
+    inputs=gr.Image(type="numpy", source="webcam", streaming=True, label="Live Webcam"),
     outputs=[
         gr.Textbox(label="Emotion Detected"),
-        gr.Markdown(label="Suggested Music") # Use Markdown to display the clickable Spotify link
+        gr.Markdown(label="Suggested Music")
     ],
-    live=True, # Process input continuously as it changes
+    live=True,
     title="🎭 MoodTune: Your Emotional DJ 🎶",
-    description=(
-        "This Hugging Face Space detects your facial expression in real-time "
-        "and suggests a Spotify playlist tailored to your mood! "
-        "**Ensure good lighting and center your face for best results.**"
-        "<br>*(Click the Spotify link below to open the playlist in a new tab.)*"
-    ),
-    css="""
-        .gradio-container {
-            font-family: 'Inter', sans-serif;
-            background-color: #f0f2f5;
-            padding: 20px;
-            border-radius: 12px;
-            box-shadow: 0 4px 15px rgba(0,0,0,0.1);
-        }
-        h1 {
-            color: #2c3e50;
-            text-align: center;
-            font-size: 2.5em;
-            margin-bottom: 20px;
-        }
-        .gr-button {
-            background-color: #3498db !important; /* A nice blue */
-            color: white !important;
-            border-radius: 8px;
-            padding: 10px 20px;
-            font-weight: bold;
-            transition: background-color 0.3s ease;
-        }
-        .gr-button:hover {
-            background-color: #2980b9 !important;
-        }
-        .gr-text {
-            font-size: 1.3em;
-            font-weight: bold;
-            color: #2c3e50;
-            text-align: center;
-            padding: 15px;
-            background-color: #ecf0f1;
-            border-radius: 8px;
-            margin-top: 15px;
-            border: 1px solid #bdc3c7;
-        }
-        .gr-image {
-            border: 3px solid #3498db;
-            border-radius: 12px;
-            box-shadow: 0 2px 10px rgba(0,0,0,0.08);
-            width: 100%; /* Make image responsive */
-            max-width: 600px; /* Max width for image */
-            margin: auto; /* Center the image */
-        }
-        .gr-markdown {
-            text-align: center;
-            margin-top: 20px;
-            font-size: 1.2em;
-        }
-        .gr-markdown a {
-            color: #1DB954; /* Spotify green */
-            text-decoration: none;
-            font-weight: bold;
-        }
-        .gr-markdown a:hover {
-            text-decoration: underline;
-        }
-        /* Responsive adjustments */
-        @media (max-width: 768px) {
-            h1 {
-                font-size: 1.8em;
-            }
-            .gr-text {
-                font-size: 1em;
-            }
-        }
-    """
+    description="Real-time facial expression detector that plays music to match your mood!",
 )
 
-# Launch the Gradio app
-if __name__ == "__main__":
-    iface.launch()
+iface.launch()  # Automatically runs in Hugging Face Spaces