Upload folder using huggingface_hub

infrerence_examples/keras_inference_example.py

@@ -0,0 +1,63 @@
+import tensorflow as tf
+import pickle
+import numpy as np
+import pandas as pd
+
+def load_model_and_processor():
+    """Load the trained model and processor."""
+    # Load the complete model
+    model = tf.keras.models.load_model('model.h5')
+    
+    # Load the processor
+    with open('processor.pkl', 'rb') as f:
+        processor = pickle.load(f)
+    
+    return model, processor
+
+def predict_sign(model, processor, landmark_data):
+    """
+    Predict sign from landmark data.
+    
+    Args:
+        model: Loaded Keras model
+        processor: SignLanguageProcessor instance
+        landmark_data: DataFrame with columns ['frame', 'row_id', 'x', 'y', 'z']
+    
+    Returns:
+        predicted_class: Predicted sign class
+        confidence: Prediction confidence
+    """
+    # Process the landmark data
+    X, _ = processor.process_dataset(landmark_data)
+    
+    if len(X) == 0:
+        return None, 0.0
+    
+    # Make prediction
+    predictions = model.predict(X)
+    predicted_class = np.argmax(predictions, axis=1)[0]
+    confidence = np.max(predictions, axis=1)[0]
+    
+    # Convert back to sign name if mapping exists
+    if hasattr(processor, 'index_to_sign'):
+        sign_name = processor.index_to_sign[predicted_class]
+        return sign_name, confidence
+    
+    return predicted_class, confidence
+
+# Example usage
+if __name__ == "__main__":
+    # Load model and processor
+    model, processor = load_model_and_processor()
+    
+    # Example landmark data (replace with your actual data)
+    # landmark_data = pd.read_csv('your_landmark_data.csv')
+    
+    # Make prediction
+    # predicted_sign, confidence = predict_sign(model, processor, landmark_data)
+    # print(f"Predicted sign: {predicted_sign}, Confidence: {confidence:.3f}")
+    
+    print("Model and processor loaded successfully!")
+    print(f"Model input shape: {model.input_shape}")
+    print(f"Model output shape: {model.output_shape}")
+    print(f"Number of classes: {processor.sign_count}")

infrerence_examples/tflite_inference_example.py

@@ -0,0 +1,125 @@
+import tensorflow as tf
+import numpy as np
+import pickle
+
+class TFLiteSignLanguagePredictor:
+    """TensorFlow Lite predictor for sign language recognition."""
+    
+    def __init__(self, tflite_model_path, processor_path):
+        """
+        Initialize the TFLite predictor.
+        
+        Args:
+            tflite_model_path: Path to .tflite model file
+            processor_path: Path to processor.pkl file
+        """
+        # Load TFLite model
+        self.interpreter = tf.lite.Interpreter(model_path=tflite_model_path)
+        self.interpreter.allocate_tensors()
+        
+        # Get input and output details
+        self.input_details = self.interpreter.get_input_details()
+        self.output_details = self.interpreter.get_output_details()
+        
+        # Load processor
+        with open(processor_path, 'rb') as f:
+            self.processor = pickle.load(f)
+        
+        print(f"TFLite model loaded successfully!")
+        print(f"Input shape: {self.input_details[0]['shape']}")
+        print(f"Output shape: {self.output_details[0]['shape']}")
+    
+    def predict(self, landmark_data):
+        """
+        Predict sign from landmark data.
+        
+        Args:
+            landmark_data: DataFrame with landmark data or preprocessed array
+        
+        Returns:
+            tuple: (predicted_class, confidence, all_probabilities)
+        """
+        # Preprocess data if it's raw landmark data
+        if hasattr(landmark_data, 'columns'):  # It's a DataFrame
+            X, _ = self.processor.process_dataset(landmark_data)
+            if len(X) == 0:
+                return None, 0.0, None
+            input_data = X[0:1].astype(np.float32)
+        else:  # It's already preprocessed
+            input_data = landmark_data.astype(np.float32)
+            if len(input_data.shape) == 2:  # Add batch dimension if needed
+                input_data = np.expand_dims(input_data, 0)
+        
+        # Run inference
+        self.interpreter.set_tensor(self.input_details[0]['index'], input_data)
+        self.interpreter.invoke()
+        output_data = self.interpreter.get_tensor(self.output_details[0]['index'])
+        
+        # Process results
+        probabilities = tf.nn.softmax(output_data[0]).numpy()
+        predicted_class = np.argmax(probabilities)
+        confidence = probabilities[predicted_class]
+        
+        # Convert to sign name if mapping exists
+        if hasattr(self.processor, 'index_to_sign'):
+            sign_name = self.processor.index_to_sign[predicted_class]
+            return sign_name, confidence, probabilities
+        
+        return predicted_class, confidence, probabilities
+    
+    def predict_batch(self, batch_data):
+        """Predict multiple samples (if model supports batch inference)."""
+        # Note: Some TFLite models may only support single inference
+        # This is a template for batch processing
+        results = []
+        for i in range(len(batch_data)):
+            result = self.predict(batch_data[i:i+1])
+            results.append(result)
+        return results
+
+# Example usage
+if __name__ == "__main__":
+    # Initialize predictor
+    predictor = TFLiteSignLanguagePredictor(
+        tflite_model_path="model_optimized.tflite",  # or model.tflite, model_quantized.tflite
+        processor_path="processor.pkl"
+    )
+    
+    # Example prediction (replace with your actual data)
+    # landmark_data = pd.read_csv("your_landmark_data.csv")
+    # predicted_sign, confidence, probabilities = predictor.predict(landmark_data)
+    # print(f"Predicted: {predicted_sign}, Confidence: {confidence:.3f}")
+    
+    print("TFLite predictor ready for inference!")
+
+# Performance comparison function
+def compare_model_performance(keras_model, tflite_paths, test_data):
+    """Compare performance between Keras and TFLite models."""
+    import time
+    
+    print("\\n🏃 Performance Comparison:")
+    print("-" * 50)
+    
+    # Test Keras model
+    start_time = time.time()
+    keras_pred = keras_model.predict(test_data)
+    keras_time = time.time() - start_time
+    print(f"Keras Model: {keras_time:.4f}s for {len(test_data)} samples")
+    
+    # Test TFLite models
+    for name, path in tflite_paths.items():
+        interpreter = tf.lite.Interpreter(model_path=path)
+        interpreter.allocate_tensors()
+        input_details = interpreter.get_input_details()
+        output_details = interpreter.get_output_details()
+        
+        start_time = time.time()
+        for i in range(len(test_data)):
+            test_input = test_data[i:i+1].astype(np.float32)
+            interpreter.set_tensor(input_details[0]['index'], test_input)
+            interpreter.invoke()
+            _ = interpreter.get_tensor(output_details[0]['index'])
+        tflite_time = time.time() - start_time
+        
+        speedup = keras_time / tflite_time if tflite_time > 0 else 0
+        print(f"TFLite {name}: {tflite_time:.4f}s ({speedup:.1f}x {'faster' if speedup > 1 else 'slower'})")

keras_models/config.json

@@ -0,0 +1,85 @@
+{
+  "model_type": "sign_language_recognition",
+  "framework": "tensorflow",
+  "max_len": 384,
+  "dim": 192,
+  "num_classes": 60,
+  "dropout_start_epoch": 15,
+  "batch_size": 32,
+  "learning_rate": 0.0005,
+  "weight_decay": 0.1,
+  "epochs_trained": 200,
+  "input_shape": [
+    null,
+    384,
+    708
+  ],
+  "output_shape": [
+    null,
+    60
+  ],
+  "total_params": 1763418,
+  "sign_classes": {
+    "go": 0,
+    "hot": 1,
+    "dad": 2,
+    "yes": 3,
+    "no": 4,
+    "sick": 5,
+    "mom": 6,
+    "cut": 7,
+    "stuck": 8,
+    "outside": 9,
+    "talk": 10,
+    "arm": 11,
+    "up": 12,
+    "person": 13,
+    "can": 14,
+    "close": 15,
+    "face": 16,
+    "head": 17,
+    "mad": 18,
+    "wait": 19,
+    "eye": 20,
+    "hide": 21,
+    "home": 22,
+    "why": 23,
+    "quiet": 24,
+    "will": 25,
+    "glasswindow": 26,
+    "not": 27,
+    "fireman": 28,
+    "down": 29,
+    "child": 30,
+    "hesheit": 31,
+    "find": 32,
+    "jump": 33,
+    "where": 34,
+    "room": 35,
+    "look": 36,
+    "high": 37,
+    "hear": 38,
+    "now": 39,
+    "time": 40,
+    "open": 41,
+    "fall": 42,
+    "owie": 43,
+    "drop": 44,
+    "man": 45,
+    "give": 46,
+    "car": 47,
+    "fast": 48,
+    "bad": 49,
+    "have": 50,
+    "stairs": 51,
+    "who": 52,
+    "cry": 53,
+    "loud": 54,
+    "haveto": 55,
+    "water": 56,
+    "see": 57,
+    "police": 58,
+    "touch": 59
+  },
+  "created_at": "2025-07-10T07:14:08.417702"
+}

keras_models/model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:efe7b6664db32251bbcef3851cb32d154538b78f4aa2287695bf94affb4f547b
+size 21418472

keras_models/model.weights.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4015ffa390b55f42901ba7df9be1d585770251e10b8f3112fab9bc8faee1d4c1
+size 21399464

tflite_models/model.tflite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6058819febc08655877b6c6c5487fc69440c7d5ad60a6953fe26a462b250dfdc
+size 7068388

tflite_models/model_optimized.tflite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b47c15a4a6c98e456f500ce06ab8ce5e3662ba99356d48d76fd6b4f04ea283e8
+size 1938536

tflite_models/model_quantized.tflite

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:05508b611536d6de90b3973d5687a1e88feb6ff92a70629fe2196e6f13c71f0c
+size 2020008

tflite_models/tflite_metadata.json

@@ -0,0 +1,34 @@
+{
+  "model_type": "sign_language_recognition",
+  "framework": "tensorflow_lite",
+  "input_shape": [
+    null,
+    384,
+    708
+  ],
+  "output_shape": [
+    null,
+    60
+  ],
+  "num_classes": 60,
+  "models": {
+    "basic": {
+      "filename": "model.tflite",
+      "size_bytes": 7068388,
+      "size_mb": 6.740940093994141,
+      "description": "Basic TFLite model with no optimizations. Best accuracy, larger size."
+    },
+    "optimized": {
+      "filename": "model_optimized.tflite",
+      "size_bytes": 1938536,
+      "size_mb": 1.8487319946289062,
+      "description": "Optimized with dynamic range quantization. Good balance of size and accuracy."
+    },
+    "quantized": {
+      "filename": "model_quantized.tflite",
+      "size_bytes": 2020008,
+      "size_mb": 1.9264297485351562,
+      "description": "Integer quantized model. Smallest size, may have slight accuracy loss."
+    }
+  }
+}