Update app.py

app.py

@@ -15,7 +15,6 @@ class EmotionCNN(nn.Module):
     def __init__(self):
         super(EmotionCNN, self).__init__()
         self.conv_layers = nn.Sequential(
-            # Premier bloc
             nn.Conv2d(1, 32, 3, padding=1),
             nn.BatchNorm2d(32),
             nn.ReLU(),
@@ -24,8 +23,6 @@ class EmotionCNN(nn.Module):
             nn.ReLU(),
             nn.MaxPool2d(2),
             nn.Dropout2d(0.25),
-            
-            # Deuxième bloc
             nn.Conv2d(32, 64, 3, padding=1),
             nn.BatchNorm2d(64),
             nn.ReLU(),
@@ -34,8 +31,6 @@ class EmotionCNN(nn.Module):
             nn.ReLU(),
             nn.MaxPool2d(2),
             nn.Dropout2d(0.25),
-            
-            # Troisième bloc
             nn.Conv2d(64, 128, 3, padding=1),
             nn.BatchNorm2d(128),
             nn.ReLU(),
@@ -45,7 +40,6 @@ class EmotionCNN(nn.Module):
             nn.MaxPool2d(2),
             nn.Dropout2d(0.25)
         )
-        
         self.fc_layers = nn.Sequential(
             nn.Linear(128 * 6 * 6, 512),
             nn.ReLU(),
@@ -62,7 +56,7 @@ class EmotionCNN(nn.Module):
         x = self.fc_layers(x)
         return x
 
-# Dictionnaire des émotions et leurs messages associés
+# Dictionnaire des émotions
 emotion_dict = {
     0: {"name": "Colère", "message": "Respirez profondément et prenez un moment pour vous calmer."},
     1: {"name": "Mépris", "message": "Essayez de voir les choses d'un autre point de vue."},
@@ -129,8 +123,12 @@ st.title("🎭 Détecteur d'Émotions en Temps Réel")
 def load_model():
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     model = EmotionCNN().to(device)
-    model.load_state_dict(torch.load("cnn_emotion_model.pth", map_location=device))
-    model.eval()
+    try:
+        model.load_state_dict(torch.load("cnn_emotion_model.pth", map_location=device))
+        model.eval()
+    except Exception as e:
+        st.error(f"Erreur lors du chargement du modèle : {str(e)}")
+        st.stop()
     return model, device
 
 # Chargement du modèle
@@ -146,15 +144,31 @@ transform = transforms.Compose([
 
 # Chargement du classificateur Haar pour la détection de visage
 face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+if face_cascade.empty():
+    st.error("Erreur : Impossible de charger le classificateur Haar pour la détection de visage.")
+    st.stop()
 
 def detect_faces(frame):
     gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
     faces = face_cascade.detectMultiScale(gray, 1.1, 4)
     return faces
 
-# Configuration RTC pour WebRTC (utile pour Hugging Face Spaces)
+# Configuration RTC avec plusieurs STUN et TURN
 RTC_CONFIGURATION = RTCConfiguration({
-    "iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]
+    "iceServers": [
+        {"urls": "stun:stun.l.google.com:19302"},
+        {"urls": "stun:stun1.l.google.com:19302"},
+        {"urls": "stun:stun2.l.google.com:19302"},
+        {"urls": "stun:stun3.l.google.com:19302"},
+        {"urls": "stun:stun4.l.google.com:19302"},
+        {"urls": "stun:stun.stunprotocol.org:3478"},
+        # Exemple de configuration TURN (remplacez par vos propres identifiants si disponible)
+        {
+            "urls": "turn:your-turn-server.example.com:3478",
+            "username": "your-username",
+            "credential": "your-password"
+        }
+    ]
 })
 
 # Classe pour traiter les frames vidéo
@@ -169,55 +183,61 @@ class VideoProcessor(VideoProcessorBase):
         self.message_placeholder = st.session_state.get('message_placeholder')
 
     def recv(self, frame):
-        img = frame.to_ndarray(format="bgr24")
-        faces = detect_faces(img)
-        
-        for (x, y, w, h) in faces:
-            cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2)
-            face_img = img[y:y+h, x:x+w]
-            pil_img = Image.fromarray(cv2.cvtColor(face_img, cv2.COLOR_BGR2RGB))
-            img_tensor = self.transform(pil_img).unsqueeze(0).to(self.device)
-            with torch.no_grad():
-                output = self.model(img_tensor)
-                _, predicted = torch.max(output, 1)
-                emotion_idx = predicted.item()
-            emotion_name = self.emotion_dict[emotion_idx]["name"]
-            cv2.putText(img, emotion_name, (x, y-10),
-                        cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
-            
-            # Mettre à jour les placeholders (utiliser st.session_state pour partager)
-            if self.emotion_placeholder:
-                self.emotion_placeholder.markdown(f"""
-                <div class="emotion-box">
-                    <div class="emotion-title">{emotion_name}</div>
-                </div>
-                """, unsafe_allow_html=True)
+        try:
+            img = frame.to_ndarray(format="bgr24")
+            faces = detect_faces(img)
             
-            if self.message_placeholder:
-                self.message_placeholder.markdown(f"""
-                <div class="emotion-box">
-                    <div class="emotion-message">{self.emotion_dict[emotion_idx]["message"]}</div>
-                </div>
-                """, unsafe_allow_html=True)
-
-        return av.VideoFrame.from_ndarray(img, format="bgr24")
+            for (x, y, w, h) in faces:
+                cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2)
+                face_img = img[y:y+h, x:x+w]
+                pil_img = Image.fromarray(cv2.cvtColor(face_img, cv2.COLOR_BGR2RGB))
+                img_tensor = self.transform(pil_img).unsqueeze(0).to(self.device)
+                with torch.no_grad():
+                    output = self.model(img_tensor)
+                    _, predicted = torch.max(output, 1)
+                    emotion_idx = predicted.item()
+                emotion_name = self.emotion_dict[emotion_idx]["name"]
+                cv2.putText(img, emotion_name, (x, y-10),
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
+                
+                # Mettre à jour les placeholders
+                if self.emotion_placeholder:
+                    self.emotion_placeholder.markdown(f"""
+                    <div class="emotion-box">
+                        <div class="emotion-title">{emotion_name}</div>
+                    </div>
+                    """, unsafe_allow_html=True)
+                
+                if self.message_placeholder:
+                    self.message_placeholder.markdown(f"""
+                    <div class="emotion-box">
+                        <div class="emotion-message">{self.emotion_dict[emotion_idx]["message"]}</div>
+                    </div>
+                    """, unsafe_allow_html=True)
+            return av.VideoFrame.from_ndarray(img, format="bgr24")
+        except Exception as e:
+            st.error(f"Erreur lors du traitement de la frame : {str(e)}")
+            return frame
 
-# Configuration de la webcam avec streamlit-webrtc
+# Configuration de l'interface
 col1, col2 = st.columns([2, 1])
 
 with col1:
     st.markdown("### 📹 Flux Vidéo")
-    # Lancer le flux webcam
-    webrtc_ctx = webrtc_streamer(
-        key="emotion-detection",
-        rtc_configuration=RTC_CONFIGURATION,
-        video_processor_factory=VideoProcessor,
-        media_stream_constraints={"video": True, "audio": False},
-    )
+    try:
+        webrtc_ctx = webrtc_streamer(
+            key="emotion-detection",
+            rtc_configuration=RTC_CONFIGURATION,
+            video_processor_factory=VideoProcessor,
+            media_stream_constraints={"video": True, "audio": False},
+            async_processing=True
+        )
+    except Exception as e:
+        st.error(f"Erreur lors de l'initialisation de WebRTC : {str(e)}")
+        st.warning("Vérifiez votre connexion réseau ou les paramètres STUN/TURN.")
 
 with col2:
     st.markdown("### 😊 Émotion Détectée")
-    # Utiliser session_state pour partager les placeholders avec VideoProcessor
     if 'emotion_placeholder' not in st.session_state:
         st.session_state.emotion_placeholder = st.empty()
     if 'message_placeholder' not in st.session_state:
@@ -226,4 +246,40 @@ with col2:
     emotion_placeholder = st.session_state.emotion_placeholder
     message_placeholder = st.session_state.message_placeholder
 
-st.info("👆 Autorisez l'accès à la webcam dans votre navigateur pour démarrer la détection d'émotions.")
+st.info("👆 Autorisez l'accès à la webcam dans votre navigateur pour démarrer la détection d'émotions.")
+st.warning("Si la connexion échoue, vérifiez votre réseau ou configurez un serveur TURN pour WebRTC.")
+
+# Option de téléchargement d'image comme solution de secours
+st.markdown("### 📷 Ou téléchargez une image")
+uploaded_file = st.file_uploader("Choisissez une image...", type=["jpg", "jpeg", "png"])
+if uploaded_file is not None:
+    image = Image.open(uploaded_file)
+    frame = np.array(image)
+    faces = detect_faces(frame)
+    
+    for (x, y, w, h) in faces:
+        cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)
+        face_img = frame[y:y+h, x:x+w]
+        pil_img = Image.fromarray(cv2.cvtColor(face_img, cv2.COLOR_BGR2RGB))
+        img_tensor = transform(pil_img).unsqueeze(0).to(device)
+        with torch.no_grad():
+            output = model(img_tensor)
+            _, predicted = torch.max(output, 1)
+            emotion_idx = predicted.item()
+        emotion_name = emotion_dict[emotion_idx]["name"]
+        cv2.putText(frame, emotion_name, (x, y-10),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
+        
+        emotion_placeholder.markdown(f"""
+        <div class="emotion-box">
+            <div class="emotion-title">{emotion_name}</div>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        message_placeholder.markdown(f"""
+        <div class="emotion-box">
+            <div class="emotion-message">{emotion_dict[emotion_idx]["message"]}</div>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    st.image(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))