Upload 2 files

app.py

@@ -75,33 +75,81 @@ try:
         st.warning(f"HuggingFace Hub import issue: {hf_error}")
         hf_hub_download = None
     
-    # Try custom modules with fallback
+    # Try custom modules with fallback - import each module separately for better error handling
+    pose_models = None
+    expression_mapping = None
+    isl_processor = None
+    utils = None
+    
+    # Try importing pose_models
     try:
         from pose_models import create_bodypose_model, create_handpose_model
+        pose_models = True
+        st.success("✅ Pose models imported successfully")
+    except Exception as pose_error:
+        st.warning(f"Pose models import issue: {pose_error}")
+        pose_models = None
+    
+    # Try importing expression_mapping
+    try:
         from expression_mapping import expression_mapping
-        from isl_processor import ISLTranslationModel
-        import pose_utils as utils
-    except Exception as custom_error:
-        st.warning(f"Custom modules import issue: {custom_error}")
+        st.success("✅ Expression mapping imported successfully")
+    except Exception as expr_error:
+        st.warning(f"Expression mapping import issue: {expr_error}")
         # Fallback expression mapping
         expression_mapping = {
             'hello': 0, 'thank_you': 1, 'please': 2, 'sorry': 3, 'help': 4,
             'good': 5, 'bad': 6, 'yes': 7, 'no': 8, 'water': 9,
             'food': 10, 'home': 11, 'work': 12, 'school': 13, 'family': 14
         }
-        utils = None  # Set utils to None if import fails
+    
+    # Try importing ISL processor
+    try:
+        from isl_processor import ISLTranslationModel
+        isl_processor = True
+        st.success("✅ ISL processor imported successfully")
+    except Exception as isl_error:
+        st.warning(f"ISL processor import issue: {isl_error}")
+        isl_processor = None
+    
+    # Try importing pose_utils
+    try:
+        import pose_utils as utils
+        st.success("✅ Pose utils imported successfully")
+    except Exception as utils_error:
+        st.warning(f"Pose utils import issue: {utils_error}")
+        utils = None
     
     st.success("✅ Core dependencies loaded successfully!")
 except ImportError as e:
     st.error(f"❌ Critical import error: {e}")
     st.error("Running in fallback mode with limited functionality.")
 
-# Import pose_utils separately to ensure it's always available
-try:
-    import pose_utils as utils
-except ImportError as utils_error:
-    st.error(f"❌ Failed to import pose_utils: {utils_error}")
-    utils = None
+# Ensure we have utils available globally after the main import block
+if utils is None:
+    try:
+        import pose_utils as utils
+        st.info("ℹ️ Pose utils loaded on secondary attempt")
+    except ImportError as utils_error:
+        st.error(f"❌ Failed to import pose_utils: {utils_error}")
+        utils = None
+
+# Ensure expression_mapping is available and create index-to-label mapping
+if expression_mapping is None:
+    st.warning("⚠️ Using fallback expression mapping")
+    expression_mapping = {
+        0: 'hello', 1: 'thank_you', 2: 'please', 3: 'sorry', 4: 'help',
+        5: 'good', 6: 'bad', 7: 'yes', 8: 'no', 9: 'water',
+        10: 'food', 11: 'home', 12: 'work', 13: 'school', 14: 'family'
+    }
+
+# Create index-to-label mapping function for safe access
+def get_sign_label(index):
+    """Safely get sign label from prediction index"""
+    if isinstance(expression_mapping, dict):
+        return expression_mapping.get(int(index), f'unknown_sign_{index}')
+    else:
+        return f'sign_{index}'
 
 # System information will be shown in About section
 
@@ -251,7 +299,9 @@ def load_translation_model():
             model.add(BatchNormalization())
             model.add(keras.layers.Activation('elu'))
             model.add(Dropout(0.2))
-            model.add(Dense(len(list(expression_mapping.keys())), activation='softmax'))
+            # Determine number of classes - use 167 for the full dataset or fallback size
+            num_classes = len(list(expression_mapping.keys())) if expression_mapping else 167
+            model.add(Dense(num_classes, activation='softmax'))
             
             # Try to load weights
             model.load_weights(model_file)
@@ -836,7 +886,7 @@ elif app_mode == 'Test Video Translation':
                             # Get top predictions
                             top_prediction_idx = np.argmax(prediction_output)
                             top_3_indices = prediction_output.argsort()[-3:][::-1]
-                            top_3_signs = [expression_mapping[i] for i in top_3_indices]
+                            top_3_signs = [get_sign_label(i) for i in top_3_indices]
                             top_3_probabilities = prediction_output[top_3_indices]
                             
                             # Current frame predictions

isl_processor.py

@@ -12,16 +12,41 @@ Institution: Shri Ram Group of Institutions
 """
 
 import keras
-from keras.layers import TorchModuleWrapper
 import numpy as np
 import cv2
 import torch
-from scipy.ndimage.filters import gaussian_filter
+try:
+    from scipy.ndimage.filters import gaussian_filter
+except ImportError:
+    from scipy.ndimage import gaussian_filter
 import math
 import os
 from skimage.measure import label
 import pose_utils as utils
 
+# Simple TorchModuleWrapper replacement for compatibility
+class TorchModuleWrapper:
+    """
+    Simple wrapper to make PyTorch models compatible with Keras-style usage
+    """
+    def __init__(self, torch_model):
+        self.torch_model = torch_model
+        self.trainable = False
+        
+    def __call__(self, x):
+        """Forward pass through the PyTorch model"""
+        return self.torch_model(x)
+        
+    def eval(self):
+        """Set model to evaluation mode"""
+        if hasattr(self.torch_model, 'eval'):
+            self.torch_model.eval()
+            
+    def train(self, mode=True):
+        """Set model to train mode"""
+        if hasattr(self.torch_model, 'train'):
+            self.torch_model.train(mode)
+
 
 class ISLPoseEstimator(keras.Model):
     """