Create app.py

app.py

@@ -0,0 +1,207 @@
+# Install required dependencies
+!pip install -q mediapipe tensorflow opencv-python-headless gradio Pillow numpy
+
+import os
+import numpy as np
+import tensorflow as tf
+import cv2
+import mediapipe as mp
+import gradio as gr
+from PIL import Image
+
+# Hand Tracker class - using the provided implementation
+class handTracker():
+    def __init__(self, mode=False, maxHands=2, modelComplexity=1,
+                 detectionConfidence=0.5, trackConfidence=0.5):
+        self.mode = mode
+        self.maxHands = maxHands
+        self.modelComplexity = modelComplexity
+        self.detectionConfidence = detectionConfidence
+        self.trackConfidence = trackConfidence
+        
+        self.mpHands = mp.solutions.hands
+        self.hands = self.mpHands.Hands(
+            static_image_mode=self.mode,
+            max_num_hands=self.maxHands,
+            model_complexity=self.modelComplexity,
+            min_detection_confidence=self.detectionConfidence,
+            min_tracking_confidence=self.trackConfidence)
+        
+        self.mpDraw = mp.solutions.drawing_utils
+        self.mpDrawStyles = mp.solutions.drawing_styles
+    
+    def findAndDrawHands(self, frame):
+        RGBimage = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        self.results = self.hands.process(RGBimage)
+        
+        if self.results.multi_hand_landmarks:
+            for handLms in self.results.multi_hand_landmarks:
+                self.mpDraw.draw_landmarks(
+                    frame, 
+                    handLms,
+                    self.mpHands.HAND_CONNECTIONS,
+                    self.mpDrawStyles.get_default_hand_landmarks_style(),
+                    self.mpDrawStyles.get_default_hand_connections_style())
+        return frame
+    
+    def findLandmarks(self, frame, handNo=0):
+        landmarkList = []
+        x_list = []
+        y_list = []
+        bbox = []
+        
+        if self.results.multi_hand_landmarks:
+            if handNo < len(self.results.multi_hand_landmarks):
+                myHand = self.results.multi_hand_landmarks[handNo]
+                
+                for id, lm in enumerate(myHand.landmark):
+                    h, w, c = frame.shape
+                    cx, cy = int(lm.x * w), int(lm.y * h)
+                    x_list.append(cx)
+                    y_list.append(cy)
+                    landmarkList.append([id, cx, cy])
+                
+                if x_list and y_list:
+                    xmin, xmax = min(x_list), max(x_list)
+                    ymin, ymax = min(y_list), max(y_list)
+                    
+                    padding = 20
+                    xmin = max(0, xmin - padding)
+                    ymin = max(0, ymin - padding)
+                    boxW = min(w - xmin, xmax - xmin + 2*padding)
+                    boxH = min(h - ymin, ymax - ymin + 2*padding)
+                    
+                    if boxW > boxH:
+                        diff = boxW - boxH
+                        ymin = max(0, ymin - diff//2)
+                        boxH = min(h - ymin, boxW)
+                    elif boxH > boxW:
+                        diff = boxH - boxW
+                        xmin = max(0, xmin - diff//2)
+                        boxW = min(w - xmin, boxH)
+                    
+                    bbox = [xmin, ymin, boxW, boxH]
+        return landmarkList, bbox
+
+# Model loading with compatibility handling
+def load_model_with_compatibility(model_path):
+    try:
+        model = tf.keras.models.load_model(model_path)
+        print("✓ Model loaded successfully")
+        return model
+    except Exception as e:
+        print(f"Standard loading failed: {str(e)}")
+        try:
+            class CustomDepthwiseConv2D(tf.keras.layers.DepthwiseConv2D):
+                def __init__(self, **kwargs):
+                    if 'groups' in kwargs:
+                        del kwargs['groups']
+                    super(CustomDepthwiseConv2D, self).__init__(**kwargs)
+            
+            custom_objects = {'DepthwiseConv2D': CustomDepthwiseConv2D}
+            model = tf.keras.models.load_model(
+                model_path, 
+                custom_objects=custom_objects,
+                compile=False
+            )
+            print("✓ Model loaded in compatibility mode")
+            return model
+        except Exception as e2:
+            print(f"Compatibility loading failed: {str(e2)}")
+            return create_simple_asl_model()
+
+def create_simple_asl_model():
+    labels = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
+             'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
+             'T', 'U', 'V', 'W', 'X', 'Y']
+    
+    print("Creating a new compatible model...")
+    model = tf.keras.Sequential([
+        tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(224, 224, 3)),
+        tf.keras.layers.MaxPooling2D((2, 2)),
+        tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),
+        tf.keras.layers.MaxPooling2D((2, 2)),
+        tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),
+        tf.keras.layers.Flatten(),
+        tf.keras.layers.Dense(128, activation='relu'),
+        tf.keras.layers.Dropout(0.5),
+        tf.keras.layers.Dense(len(labels), activation='softmax')
+    ])
+    model.compile(optimizer='adam',
+                  loss='sparse_categorical_crossentropy', 
+                  metrics=['accuracy'])
+    return model
+
+model_path = "keras_model.h5"
+model = load_model_with_compatibility(model_path)
+model_input_shape = (224, 224, 3)
+labels = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
+         'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
+         'T', 'U', 'V', 'W', 'X', 'Y']
+
+def preprocess_hand_roi(hand_roi, target_shape):
+    if target_shape[2] == 3:
+        if len(hand_roi.shape) == 2 or hand_roi.shape[2] == 1:
+            hand_roi_rgb = cv2.cvtColor(hand_roi, cv2.COLOR_GRAY2RGB)
+        else:
+            hand_roi_rgb = hand_roi.copy()
+        
+        resized = cv2.resize(hand_roi_rgb, (target_shape[0], target_shape[1]))
+        normalized = resized.astype('float32') / 255.0
+    else:
+        if len(hand_roi.shape) > 2 and hand_roi.shape[2] > 1:
+            hand_roi_gray = cv2.cvtColor(hand_roi, cv2.COLOR_BGR2GRAY)
+        else:
+            hand_roi_gray = hand_roi
+            
+        resized = cv2.resize(hand_roi_gray, (target_shape[0], target_shape[1]))
+        normalized = resized.astype('float32') / 255.0
+        if len(normalized.shape) == 2:
+            normalized = normalized[..., np.newaxis]
+    
+    return np.expand_dims(normalized, axis=0), resized
+
+def process_image(input_image):
+    frame = cv2.cvtColor(np.array(input_image), cv2.COLOR_RGB2BGR)
+    tracker = handTracker(detectionConfidence=0.7)
+    frame_with_hands = tracker.findAndDrawHands(frame.copy())
+    landmarks, bbox = tracker.findLandmarks(frame)
+    
+    if not bbox:
+        return "No hand detected", None
+    
+    x, y, w, h = bbox
+    hand_roi = frame[y:y+h, x:x+w]
+    cv2.rectangle(frame_with_hands, (x, y), (x+w, y+h), (0, 255, 0), 2)
+    
+    model_input, _ = preprocess_hand_roi(hand_roi, model_input_shape)
+    
+    try:
+        prediction = model.predict(model_input, verbose=0)[0]
+        predicted_class = np.argmax(prediction)
+        confidence = np.max(prediction)
+        letter = labels[predicted_class] if predicted_class < len(labels) else "Unknown"
+    except:
+        return "Prediction error", None
+    
+    result_text = f"Prediction: {letter} (Confidence: {confidence:.2f})"
+    cv2.putText(frame_with_hands, result_text, (10, 30), 
+                cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2)
+    
+    output_image = cv2.cvtColor(frame_with_hands, cv2.COLOR_BGR2RGB)
+    return result_text, Image.fromarray(output_image)
+
+# Gradio interface
+interface = gr.Interface(
+    fn=process_image,
+    inputs=gr.Image(label="Upload Hand Sign Image", type="pil"),
+    outputs=[
+        gr.Text(label="Prediction Result"),
+        gr.Image(label="Processed Image")
+    ],
+    title="ASL Sign Language Recognition",
+    description="Upload an image of a hand sign to recognize the ASL letter."
+)
+
+if __name__ == "__main__":
+    interface.launch(share=True)