Upload 30 files

.gitignore

@@ -0,0 +1,47 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Streamlit
+.streamlit/
+
+# Model files
+*.h5
+*.tflite
+*.pb
+
+# Misc
+.DS_Store
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local

.python-version

@@ -0,0 +1 @@
+3.10.13

Dockerfile

@@ -1,21 +1,17 @@
-FROM python:3.9-slim
+FROM python:3.10-slim
 
-WORKDIR /app
+WORKDIR /code
 
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    software-properties-common \
-    git \
-    && rm -rf /var/lib/apt/lists/*
+# Install system dependencies for OpenCV and MediaPipe
+RUN apt-get update && apt-get install -y libgl1 ffmpeg
 
-COPY requirements.txt ./
-COPY src/ ./src/
+# Copy all project files into the container
+COPY . .
 
-RUN pip3 install -r requirements.txt
+# Install Python dependencies
+RUN pip install --upgrade pip
+RUN pip install -r requirements.txt
 
-EXPOSE 8501
+EXPOSE 7860
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
-
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+CMD ["streamlit", "run", "simple_sign_interpreter.py", "--server.port=7860", "--server.headless=true", "--server.enableCORS=false"]

INSTALLATION.md

@@ -0,0 +1,215 @@
+# 📦 Installation Guide - Sign Language Interpreter
+
+This guide provides detailed installation instructions for the Sign Language Interpreter system.
+
+## 🔧 System Requirements
+
+- **Python**: 3.8 - 3.11 (recommended: 3.9 or 3.10)
+- **Operating System**: Windows 10/11, macOS 10.14+, or Linux
+- **Hardware**: 
+  - Webcam (built-in or external)
+  - 4GB RAM minimum (8GB recommended)
+  - 2GB free disk space
+- **Internet**: Required for initial setup and package installation
+
+## 🚀 Quick Installation
+
+### Option 1: Automated Setup (Recommended)
+
+1. **Download and Extract**
+   ```bash
+   # If using git
+   git clone https://github.com/yourusername/sign-language-interpreter.git
+   cd sign-language-interpreter
+   
+   # Or download and extract ZIP file
+   ```
+
+2. **Run Setup Script**
+   ```bash
+   python setup.py
+   ```
+   
+   This will:
+   - Create necessary directories
+   - Install required packages
+   - Create a sample model
+   - Verify installation
+
+### Option 2: Manual Installation
+
+1. **Create Virtual Environment**
+   ```bash
+   python -m venv venv
+   
+   # Activate virtual environment
+   # Windows:
+   venv\Scripts\activate
+   # macOS/Linux:
+   source venv/bin/activate
+   ```
+
+2. **Install Dependencies**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. **Create Directories**
+   ```bash
+   mkdir models dataset logs examples
+   ```
+
+4. **Create Sample Model**
+   ```bash
+   python create_simple_model.py
+   ```
+
+## 🔍 Verification
+
+Run the system test to verify everything is working:
+
+```bash
+python test_system.py
+```
+
+Expected output:
+```
+🤟 Sign Language Interpreter - System Test
+==================================================
+
+Dependencies:
+✅ All dependencies installed
+
+Camera:
+✅ Camera working
+
+MediaPipe:
+✅ MediaPipe working
+
+Model Files:
+✅ Model files found
+
+Predictor:
+✅ Predictor working - Sample prediction: hello (0.85)
+
+==================================================
+Test Results: 5/5 tests passed
+🎉 All tests passed! System is ready to use.
+```
+
+## 🚀 Running the Application
+
+### Web Interface (Recommended)
+```bash
+streamlit run app.py
+```
+
+### Command Line Interface
+```bash
+python examples/basic_usage.py
+```
+
+## 🛠️ Troubleshooting
+
+### Common Issues
+
+1. **Python Version Error**
+   ```
+   Error: This package requires Python 3.8-3.11
+   ```
+   **Solution**: Install a compatible Python version
+
+2. **Camera Access Error**
+   ```
+   Error: Camera not accessible
+   ```
+   **Solutions**:
+   - Close other applications using the camera
+   - Check camera permissions
+   - Try a different camera index
+
+3. **Package Installation Error**
+   ```
+   Error: Could not find a version that satisfies the requirement
+   ```
+   **Solutions**:
+   - Update pip: `python -m pip install --upgrade pip`
+   - Try installing packages individually
+   - Check Python version compatibility
+
+4. **TensorFlow Installation Issues**
+   ```
+   Error: No matching distribution found for tensorflow
+   ```
+   **Solutions**:
+   - Use Python 3.8-3.11
+   - Install TensorFlow separately: `pip install tensorflow`
+   - Use CPU-only version: `pip install tensorflow-cpu`
+
+### Platform-Specific Issues
+
+#### Windows
+- **Visual C++ Error**: Install Microsoft Visual C++ Redistributable
+- **Long Path Error**: Enable long path support in Windows settings
+
+#### macOS
+- **Permission Error**: Grant camera access in System Preferences
+- **Homebrew Issues**: Update Homebrew and Python
+
+#### Linux
+- **Camera Error**: Install v4l-utils: `sudo apt install v4l-utils`
+- **Permission Error**: Add user to video group: `sudo usermod -a -G video $USER`
+
+## 🔄 Updates
+
+To update the system:
+
+1. **Update Code**
+   ```bash
+   git pull  # If using git
+   ```
+
+2. **Update Dependencies**
+   ```bash
+   pip install -r requirements.txt --upgrade
+   ```
+
+3. **Test System**
+   ```bash
+   python test_system.py
+   ```
+
+## 🆘 Getting Help
+
+If you encounter issues:
+
+1. **Check Documentation**
+   - Read `README.md` for overview
+   - Check `QUICKSTART.md` for basic usage
+   - Review this installation guide
+
+2. **Run Diagnostics**
+   ```bash
+   python test_system.py --verbose
+   ```
+
+3. **Community Support**
+   - GitHub Issues: Report bugs and feature requests
+   - Discord: Join our community chat
+   - Email: support@signlanguage.ai
+
+## 📋 Next Steps
+
+After successful installation:
+
+1. **Try the Demo**: `streamlit run app.py`
+2. **Collect Data**: `python data_collection.py`
+3. **Train Model**: `python train_model.py`
+4. **Read Documentation**: Check `docs/` folder for guides
+
+## 🔐 Security Notes
+
+- The application only accesses your camera locally
+- No data is sent to external servers
+- All processing happens on your device
+- You can review the source code for transparency

QUICKSTART.md

@@ -0,0 +1,108 @@
+# 🚀 Quick Start Guide - Sign Language Interpreter
+
+This guide will help you get started with the Sign Language Interpreter system quickly.
+
+## 📋 Prerequisites
+
+- Python 3.8 or higher
+- Webcam
+- Git (optional)
+
+## 🛠️ Installation
+
+1. **Setup Environment**
+```bash
+# Clone repository (if using git)
+git clone https://github.com/yourusername/sign-language-interpreter.git
+cd sign-language-interpreter
+
+# Create virtual environment
+python -m venv venv
+
+# Activate virtual environment
+# On Windows:
+venv\Scripts\activate
+# On macOS/Linux:
+source venv/bin/activate
+
+# Run setup script
+python setup.py
+```
+
+## 🎯 Using the Application
+
+### 1. Quick Demo
+To try the system with a pre-trained model:
+```bash
+streamlit run app.py
+```
+This will launch the web interface where you can:
+- Adjust confidence threshold
+- Toggle hand landmark visualization
+- See real-time sign language interpretation
+
+### 2. Collect Your Own Data
+To create a custom dataset:
+```bash
+python data_collection.py
+```
+Follow the on-screen instructions to:
+- Choose signs to collect
+- Record sequences of hand gestures
+- Save data for training
+
+### 3. Train Custom Model
+To train a model on your collected data:
+```bash
+python train_model.py
+```
+This will:
+- Load your collected dataset
+- Train a new model
+- Save the trained model
+- Generate performance metrics
+
+## 🔍 Troubleshooting
+
+1. **Camera not working?**
+   - Check if another application is using the camera
+   - Ensure camera permissions are granted
+   - Try closing and reopening the application
+
+2. **Poor recognition?**
+   - Ensure good lighting
+   - Keep hands within camera frame
+   - Try adjusting the confidence threshold
+   - Collect more training data
+
+3. **Installation issues?**
+   - Check Python version: `python --version`
+   - Update pip: `python -m pip install --upgrade pip`
+   - Install requirements manually: `pip install -r requirements.txt`
+
+## 📚 Additional Resources
+
+- Check `README.md` for detailed documentation
+- View example signs in `examples/` directory
+- See training tips in `docs/training_guide.md`
+
+## 🆘 Need Help?
+
+- Check the issues section on GitHub
+- Join our Discord community
+- Email support at: support@signlanguage.ai
+
+## 🔄 Updates
+
+To update the application:
+```bash
+git pull  # If using git
+pip install -r requirements.txt  # Update dependencies
+```
+
+## 📝 Notes
+
+- The system works best in well-lit environments
+- Position yourself 2-3 feet from the camera
+- Keep your hand gestures clear and deliberate
+- Practice with the sample signs first

README.md

@@ -1,20 +1,126 @@
----
-title: Sign Intrepreter
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Streamlit template space
-license: apache-2.0
----
-
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+# 🤟  Sign Language Interpreter
+
+A real-time sign language recognition system built with Python, MediaPipe, TensorFlow, and Streamlit. This application can detect and interpret sign language gestures in real-time using computer vision and machine learning.
+
+## 🌟 Features
+
+- **Real-time Hand Detection**: Uses MediaPipe for accurate hand landmark detection
+- **Sign Language Recognition**: Supports 29 gestures including:
+  - Numbers: 1, 2, 4, 5, 6, 7, 8
+  - Letters: A-X (excluding E)
+- **Live Webcam Processing**: Real-time gesture recognition through webcam
+- **Interactive Web Interface**: Built with Streamlit for easy use
+- **Adjustable Confidence**: Configurable detection confidence threshold
+- **Optimized Performance**: Fast response with temporal prediction smoothing
+
+## 🚀 Quick Start
+
+### Prerequisites
+- Python 3.8+
+- Webcam
+- Git
+
+### Installation
+
+1. **Clone the repository**
+```bash
+git clone https://github.com/yourusername/ai-sign-language-interpreter.git
+cd ai-sign-language-interpreter
+```
+
+2. **Install dependencies**
+```bash
+pip install -r requirements.txt
+```
+
+3. **Run the application**
+```bash
+streamlit run simple_sign_interpreter.py
+```
+
+4. **Open your browser** and navigate to `http://localhost:8501`
+
+## 🎯 Usage
+
+1. **Start the application** using the command above
+2. **Allow camera access** when prompted by your browser
+3. **Click "START"** to begin webcam capture
+4. **Show hand gestures** to the camera
+5. **Adjust confidence threshold** using the sidebar slider for better detection
+6. **View real-time predictions** in the "Current Sign" panel
+
+## 📁 Project Structure
+
+```
+ai-sign-language-interpreter/
+├── simple_sign_interpreter.py    # Main Streamlit application
+├── sign_utils.py                 # Core prediction and landmark detection
+├── models/
+│   ├── sign_model.tflite        # Trained TensorFlow Lite model
+│   └── labels.txt               # Class labels for gestures
+├── requirements.txt             # Python dependencies
+├── .gitignore                  # Git ignore file
+└── README.md                   # Project documentation
+```
+
+## 🔧 Technical Details
+
+### Architecture
+- **Frontend**: Streamlit web interface
+- **Computer Vision**: MediaPipe for hand landmark detection
+- **Machine Learning**: TensorFlow Lite for gesture classification
+- **Real-time Processing**: Optimized prediction pipeline with temporal smoothing
+
+### Model Information
+- **Input**: 63-dimensional hand landmark features (21 landmarks × 3 coordinates)
+- **Output**: 29 sign language gesture classes
+- **Format**: TensorFlow Lite (.tflite) for optimized inference
+- **Performance**: Real-time processing at 30+ FPS
+
+### Key Components
+
+1. **MediaPipeLandmarksModel**: Handles hand detection and landmark extraction
+2. **SignLanguagePredictor**: Manages model inference and prediction smoothing
+3. **Streamlit Interface**: Provides user-friendly web interface
+
+## 🎛️ Configuration
+
+### Adjustable Parameters
+- **Detection Confidence**: Minimum confidence for hand detection (default: 0.5)
+- **Tracking Confidence**: Minimum confidence for hand tracking (default: 0.5)
+- **Prediction Threshold**: Minimum confidence for gesture prediction (default: 0.5)
+- **Buffer Size**: Number of frames for prediction smoothing (default: 8)
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## 📝 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- **MediaPipe** for hand landmark detection
+- **TensorFlow** for machine learning framework
+- **Streamlit** for the web interface
+- **OpenCV** for computer vision utilities
+
+## 📞 Support
+
+If you encounter any issues or have questions:
+1. Check the [Issues](https://github.com/kris07hna/SIGN-LANG-INTREPRETOR/issues) page
+2. Create a new issue with detailed description
+3. Include system information and error messages
+
+## 🔮 Future Enhancements
+
+- [ ] Support for more sign language gestures
+- [ ] Multi-hand gesture recognition
+- [ ] Sign language sentence formation
+- [ ] Mobile app version
+- [ ] Real-time translation to multiple languages

README_NEW.md

@@ -0,0 +1,113 @@
+# 🤟 AI Sign Language Interpreter
+
+A comprehensive, real-time sign language interpretation system powered by AI. This application uses computer vision and machine learning to recognize and interpret sign language gestures, providing instant translations with natural language understanding through Google's Gemini AI.
+
+## ✨ Features
+
+- 🎯 Real-time sign language recognition
+- 🤖 AI-powered gesture interpretation
+- 📹 Live webcam processing
+- 🔤 Support for letters (A-X) and numbers (1-8)
+- 💡 Natural language interpretation using Gemini AI
+- 🎨 Beautiful, responsive user interface
+- 📱 Mobile-friendly design
+
+## 🚀 Quick Start
+
+1. **Install Dependencies**
+   ```bash
+   pip install -r requirements_new.txt
+   ```
+
+2. **Set Up Gemini API**
+   - Create `.streamlit/secrets.toml` if not exists
+   - Add your Gemini API key:
+     ```toml
+     GEMINI_API_KEY = "your-api-key-here"
+     ```
+
+3. **Run the Application**
+   ```bash
+   python run_app.py
+   ```
+   This will start both the landing page and the Streamlit application.
+   - Landing page: http://localhost:5000
+   - Streamlit app: http://localhost:8501
+
+## 📖 Usage
+
+1. Visit the landing page at http://localhost:5000
+2. Click "Try it Out" to launch the interpreter
+3. Allow camera access when prompted
+4. Position your hand clearly in the camera view
+5. Make sign language gestures
+6. View real-time interpretations and AI-enhanced understanding
+
+## 🎯 Supported Gestures
+
+### Numbers
+- 1, 2, 4, 5, 6, 7, 8
+
+### Letters
+- A through X (except E)
+
+## 💡 Tips for Best Results
+
+- Ensure good lighting conditions
+- Keep your hand centered in the frame
+- Make clear, distinct gestures
+- Hold gestures steady for 1-2 seconds
+- Maintain consistent hand orientation
+- Avoid cluttered backgrounds
+
+## 🛠️ Technical Details
+
+### Components
+
+- **Frontend**
+  - Landing page: HTML/CSS with Tailwind CSS
+  - Application UI: Streamlit
+  - Real-time video: streamlit-webrtc
+
+- **Backend**
+  - Web Server: Flask
+  - ML Framework: TensorFlow Lite
+  - Hand Tracking: MediaPipe
+  - AI Interpretation: Google Gemini
+
+### Model Architecture
+
+- Custom TensorFlow model trained on hand gesture dataset
+- MediaPipe hand landmark detection
+- 63-dimensional feature vector for gesture recognition
+- Real-time processing optimizations
+
+## 📊 Performance
+
+- Real-time processing at 30+ FPS
+- Low latency gesture recognition
+- High accuracy on supported gestures
+- Efficient memory usage
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit pull requests.
+
+## 📝 License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## 🙏 Acknowledgments
+
+- MediaPipe team for hand tracking technology
+- Google for Gemini AI API
+- Streamlit team for the amazing framework
+- Open source community for various tools and libraries
+
+## 📞 Support
+
+For issues, questions, or contributions, please open an issue on GitHub.
+
+---
+
+Made with ❤️ for breaking communication barriers

app.py

@@ -0,0 +1,163 @@
+import streamlit as st
+from streamlit_webrtc import webrtc_streamer, VideoTransformerBase
+import cv2
+import numpy as np
+from av import VideoFrame
+import os
+from sign_utils import SignLanguagePredictor, MediaPipeLandmarksModel
+
+# Page config
+st.set_page_config(
+    page_title="Sign Language Digits Interpreter",
+    page_icon="🔢",
+    layout="wide"
+)
+
+# Sidebar
+st.sidebar.title("🔢 Controls")
+confidence_threshold = st.sidebar.slider("Confidence Threshold", 0.0, 1.0, 0.5)
+show_landmarks = st.sidebar.checkbox("Show Hand Landmarks", True)
+
+# Main content
+st.title("Sign Language Digits Interpreter")
+st.markdown("""
+This app recognizes hand signs for digits (0-9) in real-time. 
+Show your hand signs to the camera and see the interpretations!
+
+Instructions:
+1. Allow camera access when prompted
+2. Show your hand sign for a digit (0-9)
+3. Hold the sign steady for best results
+4. Adjust the confidence threshold if needed
+""")
+
+# Initialize models
+@st.cache_resource
+def load_models():
+    try:
+        predictor = SignLanguagePredictor(
+            model_path="models/model.tflite",
+            labels_path="models/labels.txt"
+        )
+        return predictor
+    except Exception as e:
+        st.error(f"Error loading models: {str(e)}")
+        return None
+
+predictor = load_models()
+
+class DigitInterpreter(VideoTransformerBase):
+    def __init__(self):
+        self.predictor = predictor
+        self.landmark_model = MediaPipeLandmarksModel()
+        self.result_text = "Show your hand sign"
+        self.confidence = 0.0
+        self.landmarks = None
+        self.frame_count = 0
+        self.last_prediction = None
+        self.prediction_counter = {}
+
+    def recv(self, frame: VideoFrame) -> VideoFrame:
+        image = frame.to_ndarray(format="bgr24")
+        self.frame_count += 1
+        
+        if self.predictor:
+            # Get landmarks
+            self.landmarks = self.landmark_model.predict_landmarks(image)
+            
+            # Get prediction
+            if self.landmarks:
+                try:
+                    # Use static prediction mode
+                    prediction, self.confidence = self.predictor.predict_static(image)
+                    
+                    # Only update prediction if confidence is above threshold
+                    if self.confidence > confidence_threshold:
+                        # Count predictions to reduce flickering
+                        if prediction not in self.prediction_counter:
+                            self.prediction_counter = {prediction: 1}
+                        else:
+                            self.prediction_counter[prediction] += 1
+                        
+                        # Update result if we have consistent predictions
+                        max_pred = max(self.prediction_counter.items(), key=lambda x: x[1])
+                        if max_pred[1] >= 3:  # Require 3 consistent predictions
+                            self.result_text = f"Digit: {prediction}"
+                            self.last_prediction = prediction
+                    else:
+                        self.result_text = "Show your hand sign"
+                        self.prediction_counter = {}
+                except Exception as e:
+                    self.result_text = "Processing..."
+                    self.confidence = 0.0
+                    self.prediction_counter = {}
+            else:
+                self.result_text = "No hand detected"
+                self.confidence = 0.0
+                self.prediction_counter = {}
+            
+            # Draw landmarks if enabled
+            if show_landmarks and self.landmarks:
+                image = self.landmark_model.draw_landmarks(image, self.landmarks)
+            
+            # Add text overlay
+            cv2.putText(
+                image,
+                f"{self.result_text} ({self.confidence:.2f})",
+                (20, 40),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                1.0,
+                (0, 255, 0) if self.confidence > confidence_threshold else (0, 0, 255),
+                2
+            )
+        
+        return VideoFrame.from_ndarray(image, format="bgr24")
+
+# Create two columns
+col1, col2 = st.columns([2, 1])
+
+with col1:
+    # Webcam component
+    ctx = webrtc_streamer(
+        key="digit_recognition",
+        video_processor_factory=DigitInterpreter,
+        media_stream_constraints={"video": True, "audio": False},
+        async_processing=True,
+    )
+
+with col2:
+    # Interpretation display
+    st.markdown("### 🔢 Current Digit")
+    if ctx.video_transformer:
+        # Large digit display
+        digit_display = st.empty()
+        confidence_meter = st.progress(0)
+        
+        # Update interpretation and confidence
+        if ctx.video_transformer.last_prediction is not None and ctx.video_transformer.confidence > confidence_threshold:
+            digit_display.markdown(f"# {ctx.video_transformer.last_prediction}")
+        else:
+            digit_display.markdown("# -")
+        confidence_meter.progress(int(ctx.video_transformer.confidence * 100))
+        
+        # Show confidence value
+        st.text(f"Confidence: {ctx.video_transformer.confidence:.2f}")
+    else:
+        st.warning("📷 Turn on your webcam to start!")
+
+# Instructions
+st.markdown("---")
+st.markdown("""
+### How to Use
+1. Make sure you're in a well-lit environment
+2. Position your hand clearly in the camera view
+3. Make hand signs for digits 0-9
+4. Hold each sign steady for accurate recognition
+5. Adjust the confidence threshold if needed:
+   - Higher threshold = more accurate but less sensitive
+   - Lower threshold = more sensitive but may have false positives
+""")
+
+# Footer
+st.markdown("---")
+st.markdown("Made with ❤️ using MediaPipe, TensorFlow, and Streamlit")

app_enhanced.py

@@ -0,0 +1,473 @@
+import streamlit as st
+import cv2
+import numpy as np
+import tensorflow as tf
+from streamlit_webrtc import webrtc_streamer, VideoTransformerBase, RTCConfiguration
+import av
+import mediapipe as mp
+import google.generativeai as genai
+from collections import deque
+import time
+import json
+
+# Configure page
+st.set_page_config(
+    page_title="🤟 AI Sign Language Interpreter",
+    page_icon="🤟",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Load custom CSS
+st.markdown("""
+<style>
+    .main-header {
+        background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+        padding: 2rem;
+        border-radius: 10px;
+        color: white;
+        text-align: center;
+        margin-bottom: 2rem;
+    }
+    .feature-card {
+        background: #ffffff;
+        border: 1px solid #e0e0e0;
+        padding: 1.5rem;
+        border-radius: 10px;
+        border-left: 4px solid #667eea;
+        margin: 1rem 0;
+        color: #1a1a1a;
+        font-weight: 600;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+    .prediction-box {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        padding: 1.5rem;
+        border-radius: 10px;
+        text-align: center;
+        font-size: 1.2rem;
+        margin: 1rem 0;
+    }
+    .confidence-meter {
+        background: #e9ecef;
+        border-radius: 10px;
+        padding: 0.5rem;
+        margin: 0.5rem 0;
+    }
+    .sentence-builder {
+        background: #ffffff;
+        border: 2px solid #e0e0e0;
+        border-radius: 10px;
+        padding: 1rem;
+        margin: 1rem 0;
+        min-height: 100px;
+        color: #1a1a1a;
+        font-weight: 600;
+        font-size: 1.1rem;
+    }
+    .control-panel {
+        background: #ffffff;
+        border: 2px solid #dee2e6;
+        border-radius: 10px;
+        padding: 1rem;
+        margin: 1rem 0;
+        color: #1a1a1a;
+        font-weight: 600;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Initialize Gemini AI
+@st.cache_resource
+def initialize_gemini():
+    try:
+        genai.configure(api_key=st.secrets["GEMINI_API_KEY"])
+        model = genai.GenerativeModel('gemini-pro')
+        return model
+    except Exception as e:
+        st.error(f"Failed to initialize Gemini AI: {e}")
+        return None
+
+# Load model and labels
+@st.cache_resource
+def load_model_and_labels():
+    try:
+        interpreter = tf.lite.Interpreter(model_path="models/model.tflite")
+        interpreter.allocate_tensors()
+        
+        with open("models/labels.txt", "r") as f:
+            labels = [line.strip() for line in f.readlines()]
+        
+        return interpreter, labels
+    except Exception as e:
+        st.error(f"Error loading model: {e}")
+        return None, []
+
+# Initialize MediaPipe
+@st.cache_resource
+def initialize_mediapipe():
+    mp_hands = mp.solutions.hands
+    hands = mp_hands.Hands(
+        static_image_mode=False,
+        max_num_hands=2,
+        min_detection_confidence=0.7,
+        min_tracking_confidence=0.5
+    )
+    mp_drawing = mp.solutions.drawing_utils
+    return hands, mp_drawing, mp_hands
+
+class EnhancedSignInterpreter(VideoTransformerBase):
+    def __init__(self, confidence_threshold=0.7, sequence_length=10):
+        self.interpreter, self.labels = load_model_and_labels()
+        self.hands, self.mp_drawing, self.mp_hands = initialize_mediapipe()
+        self.gemini_model = initialize_gemini()
+        
+        # Enhanced features
+        self.confidence_threshold = confidence_threshold
+        self.sequence_length = sequence_length
+        self.gesture_sequence = deque(maxlen=sequence_length)
+        self.last_prediction = ""
+        self.last_confidence = 0.0
+        self.sentence_builder = []
+        self.last_gesture_time = time.time()
+        self.gesture_hold_time = 1.5  # seconds to hold gesture for confirmation
+        
+        # Prediction smoothing
+        self.prediction_buffer = deque(maxlen=5)
+        
+    def extract_landmarks(self, image):
+        """Extract hand landmarks using MediaPipe"""
+        image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        results = self.hands.process(image_rgb)
+        
+        if results.multi_hand_landmarks:
+            landmarks = []
+            for hand_landmarks in results.multi_hand_landmarks:
+                for landmark in hand_landmarks.landmark:
+                    landmarks.extend([landmark.x, landmark.y, landmark.z])
+            
+            # Pad or truncate to 63 features (21 landmarks * 3 coordinates)
+            if len(landmarks) < 63:
+                landmarks.extend([0.0] * (63 - len(landmarks)))
+            else:
+                landmarks = landmarks[:63]
+            
+            return np.array(landmarks, dtype=np.float32)
+        return None
+    
+    def predict_gesture(self, landmarks):
+        """Predict gesture from landmarks"""
+        if self.interpreter is None or landmarks is None:
+            return "No gesture", 0.0
+        
+        try:
+            input_details = self.interpreter.get_input_details()
+            output_details = self.interpreter.get_output_details()
+            
+            # Reshape landmarks for model input
+            input_data = landmarks.reshape(1, -1)
+            
+            self.interpreter.set_tensor(input_details[0]['index'], input_data)
+            self.interpreter.invoke()
+            
+            output_data = self.interpreter.get_tensor(output_details[0]['index'])
+            predicted_class = np.argmax(output_data)
+            confidence = float(np.max(output_data))
+            
+            if predicted_class < len(self.labels):
+                return self.labels[predicted_class], confidence
+            else:
+                return "Unknown", confidence
+                
+        except Exception as e:
+            return f"Error: {str(e)}", 0.0
+    
+    def smooth_prediction(self, prediction, confidence):
+        """Smooth predictions using buffer"""
+        self.prediction_buffer.append((prediction, confidence))
+        
+        # Get most common prediction in buffer
+        predictions = [p[0] for p in self.prediction_buffer]
+        confidences = [p[1] for p in self.prediction_buffer]
+        
+        # Find most frequent prediction
+        unique_predictions = list(set(predictions))
+        if unique_predictions:
+            most_common = max(unique_predictions, key=predictions.count)
+            avg_confidence = np.mean([c for p, c in self.prediction_buffer if p == most_common])
+            return most_common, avg_confidence
+        
+        return prediction, confidence
+    
+    def update_sentence_builder(self, gesture, confidence):
+        """Update sentence builder with confirmed gestures"""
+        current_time = time.time()
+        cooldown_period = 0.5  # Time to wait before accepting new gestures
+        
+        # Check if the gesture is valid and meets confidence threshold
+        is_valid_gesture = (gesture not in ["No gesture", "Unknown"] and 
+                          confidence > self.confidence_threshold)
+        
+        # Time elapsed since last gesture
+        time_elapsed = current_time - self.last_gesture_time
+        
+        if is_valid_gesture:
+            # Case 1: New gesture detected
+            if gesture != self.last_prediction:
+                self.last_prediction = gesture
+                self.last_confidence = confidence
+                self.last_gesture_time = current_time
+                
+            # Case 2: Gesture held long enough and cooldown period passed
+            elif (time_elapsed > self.gesture_hold_time and 
+                  (not self.sentence_builder or 
+                   time_elapsed > self.gesture_hold_time + cooldown_period)):
+                if not self.sentence_builder or self.sentence_builder[-1] != gesture:
+                    self.sentence_builder.append(gesture)
+                    self.last_gesture_time = current_time
+                    self.last_prediction = ""  # Reset prediction to allow new gestures
+        else:
+            # Reset prediction if gesture is invalid or confidence is low
+            if time_elapsed > cooldown_period:
+                self.last_prediction = ""
+    
+    def generate_ai_interpretation(self, gestures):
+        """Generate AI interpretation using Gemini"""
+        if not gestures or not self.gemini_model:
+            return "No interpretation available"
+        
+        try:
+            gesture_text = " ".join(gestures)
+            prompt = f"""
+            Convert these sign language gestures into a natural, meaningful sentence: {gesture_text}
+            
+            Guidelines:
+            - Form complete, grammatically correct sentences
+            - Add appropriate articles, prepositions, and conjunctions
+            - Consider context and common sign language patterns
+            - If it's a sequence of letters, try to form words
+            - If it's numbers, consider if they represent quantities, dates, or codes
+            - Make the output conversational and natural
+            
+            Gestures: {gesture_text}
+            
+            Natural interpretation:
+            """
+            
+            response = self.gemini_model.generate_content(prompt)
+            return response.text.strip()
+        except Exception as e:
+            return f"AI interpretation error: {str(e)}"
+    
+    def recv(self, frame):
+        image = frame.to_ndarray(format="bgr24")
+        
+        # Extract landmarks
+        landmarks = self.extract_landmarks(image)
+        
+        if landmarks is not None:
+            # Predict gesture
+            gesture, confidence = self.predict_gesture(landmarks)
+            
+            # Smooth prediction
+            gesture, confidence = self.smooth_prediction(gesture, confidence)
+            
+            # Update sentence builder
+            self.update_sentence_builder(gesture, confidence)
+            
+            # Draw hand landmarks
+            image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            results = self.hands.process(image_rgb)
+            
+            if results.multi_hand_landmarks:
+                for hand_landmarks in results.multi_hand_landmarks:
+                    self.mp_drawing.draw_landmarks(
+                        image, hand_landmarks, self.mp_hands.HAND_CONNECTIONS)
+            
+            # Draw prediction info
+            color = (0, 255, 0) if confidence > self.confidence_threshold else (0, 165, 255)
+            cv2.putText(image, f"{gesture} ({confidence:.2f})", 
+                       (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, color, 2)
+            
+            # Store current prediction for UI
+            st.session_state.current_gesture = gesture
+            st.session_state.current_confidence = confidence
+            st.session_state.sentence_builder = self.sentence_builder.copy()
+        else:
+            st.session_state.current_gesture = "No hand detected"
+            st.session_state.current_confidence = 0.0
+        
+        return av.VideoFrame.from_ndarray(image, format="bgr24")
+
+def main():
+    # Header
+    st.markdown("""
+    <div class="main-header">
+        <h1>🤟 Enhanced AI Sign Language Interpreter</h1>
+        <p>Advanced real-time interpretation with AI-powered sentence formation</p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Initialize session state
+    if 'current_gesture' not in st.session_state:
+        st.session_state.current_gesture = "Ready to start"
+        st.session_state.current_confidence = 0.0
+        st.session_state.sentence_builder = []
+        st.session_state.ai_interpretation = ""
+    
+    # Sidebar controls
+    with st.sidebar:
+        st.markdown("### 🎛️ Control Panel")
+        
+        confidence_threshold = st.slider(
+            "Confidence Threshold", 
+            min_value=0.1, 
+            max_value=1.0, 
+            value=0.7, 
+            step=0.1,
+            help="Minimum confidence required for gesture recognition"
+        )
+        
+        sequence_length = st.slider(
+            "Sequence Memory", 
+            min_value=5, 
+            max_value=20, 
+            value=10,
+            help="Number of gestures to remember for sentence building"
+        )
+        
+        gesture_hold_time = st.slider(
+            "Gesture Hold Time (seconds)", 
+            min_value=0.5, 
+            max_value=3.0, 
+            value=1.5, 
+            step=0.1,
+            help="Time to hold gesture for confirmation"
+        )
+        
+        st.markdown("### 🎯 Quick Actions")
+        if st.button("🗑️ Clear Sentence", use_container_width=True):
+            st.session_state.sentence_builder = []
+            st.session_state.ai_interpretation = ""
+        
+        if st.button("🤖 Generate AI Interpretation", use_container_width=True):
+            if st.session_state.sentence_builder:
+                interpreter = EnhancedSignInterpreter()
+                st.session_state.ai_interpretation = interpreter.generate_ai_interpretation(
+                    st.session_state.sentence_builder
+                )
+        
+        # Display supported gestures
+        st.markdown("### 📋 Supported Gestures")
+        st.markdown("**Numbers:** 1, 2, 4, 5, 6, 7, 8")
+        st.markdown("**Letters:** A-X (except E)")
+    
+    # Main content
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        st.markdown("### 📹 Live Camera Feed")
+        
+        # WebRTC configuration
+        rtc_configuration = RTCConfiguration({
+            "iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]
+        })
+        
+        # Video streamer
+        webrtc_ctx = webrtc_streamer(
+            key="enhanced-sign-interpreter",
+            video_transformer_factory=lambda: EnhancedSignInterpreter(
+                confidence_threshold=confidence_threshold,
+                sequence_length=sequence_length
+            ),
+            rtc_configuration=rtc_configuration,
+            media_stream_constraints={"video": True, "audio": False},
+            async_processing=True,
+        )
+    
+    with col2:
+        st.markdown("### 🎯 Recognition Results")
+        
+        # Current prediction
+        st.markdown(f"""
+        <div class="prediction-box">
+            <h3>{st.session_state.current_gesture}</h3>
+            <div class="confidence-meter">
+                <div style="background: {'#28a745' if st.session_state.current_confidence > confidence_threshold else '#ffc107'}; 
+                           width: {st.session_state.current_confidence * 100}%; 
+                           height: 20px; 
+                           border-radius: 10px; 
+                           transition: all 0.3s ease;">
+                </div>
+                <small>Confidence: {st.session_state.current_confidence:.1%}</small>
+            </div>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        # Sentence builder
+        st.markdown("### 📝 Sentence Builder")
+        sentence_text = " → ".join(st.session_state.sentence_builder) if st.session_state.sentence_builder else "Start making gestures..."
+        
+        st.markdown(f"""
+        <div class="sentence-builder">
+            <strong>Gestures:</strong><br>
+            {sentence_text}
+        </div>
+        """, unsafe_allow_html=True)
+        
+        # AI Interpretation
+        if st.session_state.ai_interpretation:
+            st.markdown("### 🤖 AI Interpretation")
+            st.markdown(f"""
+            <div class="feature-card">
+                <strong>Natural Language:</strong><br>
+                {st.session_state.ai_interpretation}
+            </div>
+            """, unsafe_allow_html=True)
+    
+    # Statistics and tips
+    st.markdown("---")
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.markdown("""
+        <div class="feature-card">
+            <h4>💡 Tips for Better Recognition</h4>
+            <ul>
+                <li>Ensure good lighting</li>
+                <li>Keep hand centered in frame</li>
+                <li>Hold gestures steady</li>
+                <li>Avoid cluttered backgrounds</li>
+            </ul>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with col2:
+        st.markdown(f"""
+        <div class="feature-card">
+            <h4>📊 Session Statistics</h4>
+            <ul>
+                <li>Gestures Captured: {len(st.session_state.sentence_builder)}</li>
+                <li>Current Confidence: {st.session_state.current_confidence:.1%}</li>
+                <li>Threshold: {confidence_threshold:.1%}</li>
+            </ul>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with col3:
+        st.markdown("""
+        <div class="feature-card">
+            <h4>🚀 Enhanced Features</h4>
+            <ul>
+                <li>Confidence threshold control</li>
+                <li>Gesture sequence memory</li>
+                <li>AI sentence formation</li>
+                <li>Real-time smoothing</li>
+            </ul>
+        </div>
+        """, unsafe_allow_html=True)
+
+if __name__ == "__main__":
+    main()

app_new.py

@@ -0,0 +1,357 @@
+import streamlit as st
+from streamlit_webrtc import webrtc_streamer, VideoTransformerBase, RTCConfiguration
+import cv2
+import numpy as np
+import mediapipe as mp
+import tensorflow as tf
+import threading
+import time
+import google.generativeai as genai
+from av import VideoFrame
+
+# Page config
+st.set_page_config(
+    page_title="AI Sign Language Interpreter",
+    page_icon="🤟",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS
+st.markdown("""
+<style>
+    .main {
+        background-color: #f8f9fa;
+    }
+    .stApp {
+        max-width: 1200px;
+        margin: 0 auto;
+    }
+    .prediction-box {
+        background-color: white;
+        padding: 2rem;
+        border-radius: 10px;
+        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        margin-bottom: 1rem;
+    }
+    .interpretation-box {
+        background-color: #f0f7ff;
+        padding: 2rem;
+        border-radius: 10px;
+        border: 1px solid #cce5ff;
+        margin-bottom: 1rem;
+    }
+    .stButton>button {
+        background-color: #4c51bf;
+        color: white;
+        font-weight: bold;
+    }
+    .stButton>button:hover {
+        background-color: #434190;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Initialize Gemini AI
+@st.cache_resource
+def initialize_gemini():
+    try:
+        genai.configure(api_key=st.secrets["GEMINI_API_KEY"])
+        model = genai.GenerativeModel('gemini-pro')
+        return model
+    except Exception as e:
+        st.error(f"Error initializing Gemini AI: {e}")
+        return None
+
+# RTC Configuration
+RTC_CONFIGURATION = RTCConfiguration({
+    "iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]
+})
+
+# Global variables for thread-safe prediction sharing
+prediction_lock = threading.Lock()
+current_prediction = {
+    "gesture": "Show your hand",
+    "confidence": 0.0,
+    "interpretation": ""
+}
+
+# Load model and labels
+@st.cache_resource
+def load_model():
+    try:
+        interpreter = tf.lite.Interpreter(model_path="models/model.tflite")
+        interpreter.allocate_tensors()
+        
+        with open("models/labels.txt", 'r') as f:
+            labels = [line.strip() for line in f.readlines()]
+        
+        return interpreter, labels
+    except Exception as e:
+        st.error(f"Error loading model: {e}")
+        return None, []
+
+interpreter, labels = load_model()
+gemini_model = initialize_gemini()
+
+# MediaPipe setup
+@st.cache_resource
+def get_mediapipe_hands():
+    mp_hands = mp.solutions.hands
+    mp_drawing = mp.solutions.drawing_utils
+    hands = mp_hands.Hands(
+        static_image_mode=False,
+        max_num_hands=1,
+        min_detection_confidence=0.7,
+        min_tracking_confidence=0.5
+    )
+    return mp_hands, mp_drawing, hands
+
+mp_hands, mp_drawing, hands = get_mediapipe_hands()
+
+def extract_hand_features(landmarks):
+    """Extract features from hand landmarks."""
+    try:
+        landmarks_array = np.array([(lm.x, lm.y, lm.z) for lm in landmarks.landmark])
+        if len(landmarks_array) != 21:
+            return np.zeros(63)
+        
+        wrist = landmarks_array[0]
+        normalized = landmarks_array - wrist
+        hand_size = np.linalg.norm(landmarks_array[12] - wrist)
+        
+        if hand_size > 0:
+            normalized = normalized / hand_size
+        
+        features = normalized.flatten()
+        if len(features) != 63:
+            features = np.pad(features, (0, max(0, 63 - len(features))))[:63]
+        
+        return features
+    except Exception as e:
+        print(f"Error extracting features: {e}")
+        return np.zeros(63)
+
+def predict_gesture(features):
+    """Predict gesture from features."""
+    if interpreter is None:
+        return "Model not loaded", 0.0
+    
+    try:
+        input_data = np.expand_dims(features, axis=0).astype(np.float32)
+        input_details = interpreter.get_input_details()
+        output_details = interpreter.get_output_details()
+        
+        interpreter.set_tensor(input_details[0]['index'], input_data)
+        interpreter.invoke()
+        
+        output = interpreter.get_tensor(output_details[0]['index'])
+        predicted_class = np.argmax(output[0])
+        
+        exp_output = np.exp(output[0] - np.max(output[0]))
+        softmax_output = exp_output / np.sum(exp_output)
+        confidence = float(softmax_output[predicted_class])
+        
+        gesture = labels[predicted_class] if predicted_class < len(labels) else str(predicted_class)
+        return gesture, confidence
+    except Exception as e:
+        print(f"Prediction error: {e}")
+        return "Error", 0.0
+
+def get_gesture_interpretation(gesture_sequence):
+    """Get interpretation from Gemini AI."""
+    if not gemini_model or not gesture_sequence:
+        return ""
+    
+    try:
+        prompt = f"""
+        As a sign language interpreter, analyze this sequence of gestures and provide a natural interpretation:
+        Gestures detected: {', '.join(gesture_sequence)}
+        
+        Provide a clear and concise interpretation. If the gestures form a word or phrase, explain its meaning.
+        If they're individual letters/numbers, format them clearly.
+        """
+        
+        response = gemini_model.generate_content(prompt)
+        return response.text
+    except Exception as e:
+        print(f"Gemini AI error: {e}")
+        return ""
+
+class GestureRecognizer(VideoTransformerBase):
+    def __init__(self):
+        self.frame_count = 0
+        self.last_prediction_time = 0
+        self.prediction_interval = 0.2
+        self.gesture_history = []
+        self.last_interpretation_time = 0
+        self.interpretation_interval = 2.0
+
+    def recv(self, frame: VideoFrame) -> VideoFrame:
+        image = frame.to_ndarray(format="bgr24")
+        self.frame_count += 1
+        current_time = time.time()
+        
+        if current_time - self.last_prediction_time > self.prediction_interval:
+            self.last_prediction_time = current_time
+            
+            try:
+                rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+                results = hands.process(rgb_image)
+                
+                if results.multi_hand_landmarks:
+                    hand_landmarks = results.multi_hand_landmarks[0]
+                    
+                    mp_drawing.draw_landmarks(
+                        image, hand_landmarks, mp_hands.HAND_CONNECTIONS,
+                        mp_drawing.DrawingSpec(color=(0, 0, 255), thickness=2, circle_radius=2),
+                        mp_drawing.DrawingSpec(color=(0, 255, 0), thickness=2)
+                    )
+                    
+                    features = extract_hand_features(hand_landmarks)
+                    gesture, confidence = predict_gesture(features)
+                    
+                    if confidence > 0.5:
+                        self.gesture_history.append(gesture)
+                        self.gesture_history = self.gesture_history[-10:]  # Keep last 10 gestures
+                    
+                    with prediction_lock:
+                        current_prediction["gesture"] = gesture
+                        current_prediction["confidence"] = confidence
+                        
+                        # Update interpretation periodically
+                        if current_time - self.last_interpretation_time > self.interpretation_interval:
+                            self.last_interpretation_time = current_time
+                            interpretation = get_gesture_interpretation(self.gesture_history)
+                            if interpretation:
+                                current_prediction["interpretation"] = interpretation
+                else:
+                    with prediction_lock:
+                        current_prediction["gesture"] = "No hand detected"
+                        current_prediction["confidence"] = 0.0
+            except Exception as e:
+                print(f"Processing error: {e}")
+                with prediction_lock:
+                    current_prediction["gesture"] = "Processing error"
+                    current_prediction["confidence"] = 0.0
+        
+        # Add text overlay
+        with prediction_lock:
+            display_text = current_prediction["gesture"]
+            confidence = current_prediction["confidence"]
+        
+        color = (0, 255, 0) if confidence > 0.5 else (0, 0, 255)
+        cv2.putText(
+            image,
+            f"{display_text} ({confidence:.2f})",
+            (20, 40),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            1.0,
+            color,
+            2
+        )
+        
+        return VideoFrame.from_ndarray(image, format="bgr24")
+
+def main():
+    st.title("🤟 AI Sign Language Interpreter")
+    st.markdown("Transform sign language into text with real-time AI interpretation")
+    
+    # Create columns for layout
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        st.markdown("### 📹 Live Camera Feed")
+        ctx = webrtc_streamer(
+            key="gesture_recognition",
+            video_processor_factory=GestureRecognizer,
+            rtc_configuration=RTC_CONFIGURATION,
+            media_stream_constraints={"video": True, "audio": False},
+            async_processing=True,
+        )
+    
+    with col2:
+        st.markdown("### 🎯 Recognition Results")
+        
+        # Create placeholders for dynamic updates
+        prediction_placeholder = st.empty()
+        confidence_bar = st.empty()
+        interpretation_placeholder = st.empty()
+        
+        if ctx.state.playing:
+            while ctx.state.playing:
+                with prediction_lock:
+                    gesture = current_prediction["gesture"]
+                    confidence = current_prediction["confidence"]
+                    interpretation = current_prediction["interpretation"]
+                
+                # Display current gesture
+                with prediction_placeholder.container():
+                    st.markdown("""
+                    <div class="prediction-box">
+                        <h3 style="font-size: 1.5rem; margin-bottom: 0.5rem;">Current Gesture</h3>
+                        <p style="font-size: 2rem; font-weight: bold; color: #4c51bf;">{}</p>
+                    </div>
+                    """.format(gesture), unsafe_allow_html=True)
+                
+                # Display confidence bar
+                if confidence > 0.5 and gesture not in ["No hand detected", "Processing error", "Error"]:
+                    confidence_bar.progress(confidence)
+                    
+                    # Display interpretation
+                    if interpretation:
+                        with interpretation_placeholder.container():
+                            st.markdown("""
+                            <div class="interpretation-box">
+                                <h3 style="font-size: 1.5rem; margin-bottom: 0.5rem;">AI Interpretation</h3>
+                                <p style="font-size: 1.2rem;">{}</p>
+                            </div>
+                            """.format(interpretation), unsafe_allow_html=True)
+                else:
+                    confidence_bar.progress(0)
+                    if gesture == "No hand detected":
+                        interpretation_placeholder.info("Show your hand to begin")
+                    else:
+                        interpretation_placeholder.warning("Gesture not recognized clearly")
+                
+                time.sleep(0.1)
+        else:
+            st.warning("📷 Turn on your webcam to start!")
+    
+    # Instructions and supported gestures
+    st.markdown("---")
+    
+    # Display supported gestures in an organized grid
+    st.markdown("### 🎯 Supported Gestures")
+    
+    # Numbers
+    st.markdown("#### 🔢 Numbers")
+    number_labels = [label for label in labels if label.isdigit()]
+    if number_labels:
+        cols = st.columns(len(number_labels))
+        for i, label in enumerate(number_labels):
+            with cols[i]:
+                st.markdown(f"""
+                <div style="text-align: center; padding: 1rem; background-color: white; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
+                    <h3 style="font-size: 1.5rem; color: #4c51bf;">{label}</h3>
+                </div>
+                """, unsafe_allow_html=True)
+    
+    # Letters
+    st.markdown("#### 🔤 Letters")
+    letter_labels = [label for label in labels if label.isalpha()]
+    if letter_labels:
+        # Display letters in rows of 8
+        for i in range(0, len(letter_labels), 8):
+            row_labels = letter_labels[i:i+8]
+            cols = st.columns(len(row_labels))
+            for j, label in enumerate(row_labels):
+                with cols[j]:
+                    st.markdown(f"""
+                    <div style="text-align: center; padding: 1rem; background-color: white; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1);">
+                        <h3 style="font-size: 1.5rem; color: #4c51bf;">{label}</h3>
+                    </div>
+                    """, unsafe_allow_html=True)
+
+if __name__ == "__main__":
+    main()

create_sample_model.py

@@ -0,0 +1,52 @@
+import tensorflow as tf
+import numpy as np
+from utils.model_utils import create_model, convert_to_tflite
+
+def create_sample_model():
+    """Create a sample model for demonstration purposes."""
+    print("Creating sample sign language model...")
+    
+    # Model parameters
+    num_classes = 10  # Number of signs in labels.txt
+    sequence_length = 30
+    num_features = 126  # 63 landmarks + 63 velocity features
+    
+    # Create model
+    model = create_model(num_classes, sequence_length, num_features)
+    
+    # Generate dummy training data
+    X_train = np.random.random((1000, sequence_length, num_features)).astype(np.float32)
+    y_train = np.random.randint(0, num_classes, (1000,))
+    
+    # Generate dummy validation data
+    X_val = np.random.random((200, sequence_length, num_features)).astype(np.float32)
+    y_val = np.random.randint(0, num_classes, (200,))
+    
+    print("Training sample model...")
+    # Train for a few epochs
+    history = model.fit(
+        X_train, y_train,
+        validation_data=(X_val, y_val),
+        epochs=5,
+        batch_size=32,
+        verbose=1
+    )
+    
+    # Save the model
+    model.save('models/sign_language_model.h5')
+    print("Model saved as 'models/sign_language_model.h5'")
+    
+    # Convert to TFLite
+    print("Converting to TensorFlow Lite...")
+    converter = tf.lite.TFLiteConverter.from_keras_model(model)
+    converter.optimizations = [tf.lite.Optimize.DEFAULT]
+    tflite_model = converter.convert()
+    
+    with open('models/model.tflite', 'wb') as f:
+        f.write(tflite_model)
+    
+    print("TFLite model saved as 'models/model.tflite'")
+    print("Sample model creation completed!")
+
+if __name__ == "__main__":
+    create_sample_model()

create_simple_model.py

@@ -0,0 +1,25 @@
+import numpy as np
+import os
+
+def create_simple_tflite_model():
+    """Create a simple dummy TFLite model for testing."""
+    
+    # Create a minimal TFLite model structure
+    # This is a placeholder that will work for basic testing
+    
+    # For now, we'll create a simple file that can be loaded
+    # In a real scenario, you'd use TensorFlow to create this
+    
+    print("Creating simple model structure...")
+    
+    # Create a dummy model file (this is just for structure)
+    model_data = b'\x18\x00\x00\x00TFL3\x00\x00\x00\x00\x14\x00\x18\x00\x04\x00\x08\x00\x0c\x00\x10\x00\x14\x00\x00\x00'
+    
+    with open('models/model.tflite', 'wb') as f:
+        f.write(model_data)
+    
+    print("Simple model structure created!")
+    print("Note: This is a placeholder. For a real model, install TensorFlow and run create_sample_model.py")
+
+if __name__ == "__main__":
+    create_simple_tflite_model()

data_collection.py

@@ -0,0 +1,136 @@
+import cv2
+import mediapipe as mp
+import numpy as np
+import os
+import time
+from sign_utils import MediaPipeLandmarksModel
+
+class DataCollector:
+    def __init__(self):
+        self.landmark_model = MediaPipeLandmarksModel()
+        self.mp_drawing = mp.solutions.drawing_utils
+        self.mp_hands = mp.solutions.hands
+        
+    def collect_sign_data(self, sign_name, num_sequences=30, sequence_length=30):
+        """Collect data for a specific sign."""
+        
+        # Create directory for the sign
+        data_dir = f"dataset/{sign_name}"
+        os.makedirs(data_dir, exist_ok=True)
+        
+        cap = cv2.VideoCapture(0)
+        
+        # Arrays to store sequences
+        sequences = []
+        
+        print(f"Collecting data for sign: {sign_name}")
+        print(f"Will collect {num_sequences} sequences of {sequence_length} frames each")
+        print("Press 's' to start collecting, 'q' to quit")
+        
+        collecting = False
+        sequence = []
+        sequence_count = 0
+        frame_count = 0
+        
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+                
+            # Flip frame horizontally for mirror effect
+            frame = cv2.flip(frame, 1)
+            
+            # Extract landmarks
+            landmarks = self.landmark_model.predict_landmarks(frame)
+            
+            # Draw landmarks
+            if landmarks:
+                frame = self.landmark_model.draw_landmarks(frame, landmarks)
+            
+            # Display status
+            if collecting:
+                cv2.putText(frame, f'Collecting: {sign_name}', (20, 50), 
+                           cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
+                cv2.putText(frame, f'Sequence: {sequence_count + 1}/{num_sequences}', (20, 100), 
+                           cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
+                cv2.putText(frame, f'Frame: {frame_count}/{sequence_length}', (20, 150), 
+                           cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
+                
+                if landmarks:
+                    # Extract features
+                    features = self.landmark_model.extract_features(landmarks)
+                    sequence.append(features)
+                    frame_count += 1
+                    
+                    if frame_count >= sequence_length:
+                        # Save sequence
+                        sequences.append(sequence.copy())
+                        sequence = []
+                        frame_count = 0
+                        sequence_count += 1
+                        
+                        if sequence_count >= num_sequences:
+                            break
+                        
+                        # Wait before next sequence
+                        time.sleep(2)
+            else:
+                cv2.putText(frame, f'Ready to collect: {sign_name}', (20, 50), 
+                           cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+                cv2.putText(frame, "Press 's' to start", (20, 100), 
+                           cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+            
+            cv2.imshow('Data Collection', frame)
+            
+            key = cv2.waitKey(1) & 0xFF
+            if key == ord('s') and not collecting:
+                collecting = True
+                print("Started collecting...")
+            elif key == ord('q'):
+                break
+        
+        cap.release()
+        cv2.destroyAllWindows()
+        
+        # Save collected data
+        if sequences:
+            np.save(f"{data_dir}/sequences.npy", np.array(sequences))
+            print(f"Saved {len(sequences)} sequences for {sign_name}")
+        
+        return sequences
+
+def main():
+    collector = DataCollector()
+    
+    # List of signs to collect
+    signs = ['hello', 'thank_you', 'please', 'sorry', 'yes', 'no', 'good', 'bad', 'help', 'stop']
+    
+    print("Sign Language Data Collection Tool")
+    print("Available signs:", signs)
+    
+    while True:
+        print("\nOptions:")
+        print("1. Collect data for a specific sign")
+        print("2. Collect data for all signs")
+        print("3. Exit")
+        
+        choice = input("Enter your choice (1-3): ")
+        
+        if choice == '1':
+            sign_name = input("Enter sign name: ").lower().replace(' ', '_')
+            num_sequences = int(input("Number of sequences (default 30): ") or 30)
+            collector.collect_sign_data(sign_name, num_sequences)
+            
+        elif choice == '2':
+            for sign in signs:
+                print(f"\nPrepare to collect data for: {sign}")
+                input("Press Enter when ready...")
+                collector.collect_sign_data(sign, 30)
+                
+        elif choice == '3':
+            break
+        else:
+            print("Invalid choice!")
+
+if __name__ == "__main__":
+    main()

final_app.py

@@ -0,0 +1,292 @@
+import streamlit as st
+import cv2
+import numpy as np
+from streamlit_webrtc import webrtc_streamer, VideoTransformerBase, RTCConfiguration
+from av import VideoFrame
+import mediapipe as mp
+import tensorflow as tf
+import threading
+import time
+
+# Page config
+st.set_page_config(
+    page_title="Sign Language Digits Interpreter",
+    page_icon="🔢",
+    layout="wide"
+)
+
+# RTC Configuration for better WebRTC performance
+RTC_CONFIGURATION = RTCConfiguration({
+    "iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}]
+})
+
+# Global variables for thread-safe prediction sharing
+prediction_lock = threading.Lock()
+current_prediction = {"digit": "Show your hand", "confidence": 0.0}
+
+# Load model and labels
+@st.cache_resource
+def load_model():
+    try:
+        interpreter = tf.lite.Interpreter(model_path="models/model.tflite")
+        interpreter.allocate_tensors()
+        
+        with open("models/labels.txt", 'r') as f:
+            labels = [line.strip() for line in f.readlines()]
+        
+        return interpreter, labels
+    except Exception as e:
+        st.error(f"Error loading model: {e}")
+        return None, []
+
+interpreter, labels = load_model()
+
+
+@st.cache_resource
+def get_mediapipe_hands():
+    mp_hands = mp.solutions.hands
+    mp_drawing = mp.solutions.drawing_utils
+    hands = mp_hands.Hands(
+        static_image_mode=False,
+        max_num_hands=1,
+        min_detection_confidence=0.7,
+        min_tracking_confidence=0.5
+    )
+    return mp_hands, mp_drawing, hands
+
+mp_hands, mp_drawing, hands = get_mediapipe_hands()
+
+def extract_hand_features(landmarks):
+    """Extract 63 correct features from hand landmarks."""
+    try:
+        # Convert landmarks to numpy array
+        landmarks_array = np.array([(lm.x, lm.y, lm.z) for lm in landmarks.landmark])
+        
+        # Ensure we have exactly 21 landmarks
+        if len(landmarks_array) != 21:
+            return np.zeros(63)
+        
+        # Normalize relative to wrist (first landmark)
+        wrist = landmarks_array[0]
+        normalized = landmarks_array - wrist
+        
+        # Scale by hand size (distance from wrist to middle finger tip)
+        hand_size = np.linalg.norm(landmarks_array[12] - wrist)
+        if hand_size > 0:
+            normalized = normalized / hand_size
+        
+        # Flatten to 63 features
+        features = normalized.flatten()
+        
+        # Ensure exactly 63 features
+        if len(features) != 63:
+            features = np.pad(features, (0, max(0, 63 - len(features))))[:63]
+        
+        return features
+    except Exception as e:
+        print(f"Error extracting features: {e}")
+        return np.zeros(63)
+
+def predict_digit(features):
+    """Predict digit from features."""
+    if interpreter is None:
+        return "Model not loaded", 0.0
+    
+    try:
+        # Prepare input
+        input_data = np.expand_dims(features, axis=0).astype(np.float32)
+        
+        # Run inference
+        input_details = interpreter.get_input_details()
+        output_details = interpreter.get_output_details()
+        
+        interpreter.set_tensor(input_details[0]['index'], input_data)
+        interpreter.invoke()
+        
+        # Get prediction
+        output = interpreter.get_tensor(output_details[0]['index'])
+        predicted_class = np.argmax(output[0])
+        confidence = float(np.max(output[0]))
+        
+        # Apply softmax to get better confidence scores
+        exp_output = np.exp(output[0] - np.max(output[0]))
+        softmax_output = exp_output / np.sum(exp_output)
+        confidence = float(softmax_output[predicted_class])
+        
+        digit = labels[predicted_class] if predicted_class < len(labels) else str(predicted_class)
+        return digit, confidence
+    except Exception as e:
+        print(f"Prediction error: {e}")
+        return "Error", 0.0
+
+class DigitRecognizer(VideoTransformerBase):
+    def __init__(self):
+        self.frame_count = 0
+        self.last_prediction_time = 0
+        self.prediction_interval = 0.2  # Predict every 200ms
+
+    def recv(self, frame: VideoFrame) -> VideoFrame:
+        image = frame.to_ndarray(format="bgr24")
+        self.frame_count += 1
+        
+        current_time = time.time()
+        
+        # Process prediction at regular intervals
+        if current_time - self.last_prediction_time > self.prediction_interval:
+            self.last_prediction_time = current_time
+            
+            try:
+                # Convert to RGB for MediaPipe
+                rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+                results = hands.process(rgb_image)
+                
+                if results.multi_hand_landmarks:
+                    # Get first hand
+                    hand_landmarks = results.multi_hand_landmarks[0]
+                    
+                    # Draw landmarks
+                    mp_drawing.draw_landmarks(
+                        image, hand_landmarks, mp_hands.HAND_CONNECTIONS,
+                        mp_drawing.DrawingSpec(color=(0, 0, 255), thickness=2, circle_radius=2),
+                        mp_drawing.DrawingSpec(color=(0, 255, 0), thickness=2)
+                    )
+                    
+                    # Extract features and predict
+                    features = extract_hand_features(hand_landmarks)
+                    digit, confidence = predict_digit(features)
+                    
+                    # Update global prediction
+                    with prediction_lock:
+                        current_prediction["digit"] = digit
+                        current_prediction["confidence"] = confidence
+                else:
+                    with prediction_lock:
+                        current_prediction["digit"] = "No hand detected"
+                        current_prediction["confidence"] = 0.0
+            except Exception as e:
+                print(f"Processing error: {e}")
+                with prediction_lock:
+                    current_prediction["digit"] = "Processing error"
+                    current_prediction["confidence"] = 0.0
+        
+        # Add text overlay
+        with prediction_lock:
+            display_text = current_prediction["digit"]
+            confidence = current_prediction["confidence"]
+        
+        color = (0, 255, 0) if confidence > 0.5 else (0, 0, 255)
+        cv2.putText(
+            image,
+            f"{display_text} ({confidence:.2f})",
+            (20, 40),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            1.0,
+            color,
+            2
+        )
+        
+        return VideoFrame.from_ndarray(image, format="bgr24")
+
+# Main app
+st.title("🤟 AI Sign Language Interpreter")
+st.markdown("Show hand signs for numbers and letters to the camera!")
+
+# Sidebar controls
+st.sidebar.title("🎛️ Controls")
+confidence_threshold = st.sidebar.slider("Confidence Threshold", 0.0, 1.0, 0.5, 0.1)
+st.sidebar.markdown("---")
+st.sidebar.markdown("### Model Info")
+if interpreter:
+    st.sidebar.success("✅ Model loaded successfully")
+    st.sidebar.info(f"📊 Classes: {len(labels)}")
+    st.sidebar.info("🔢 Numbers: 1,2,4,5,6,7,8")
+    st.sidebar.info("🔤 Letters: A-X (except E)")
+else:
+    st.sidebar.error("❌ Model not loaded")
+
+# Create columns
+col1, col2 = st.columns([2, 1])
+
+with col1:
+    st.markdown("### 📹 Live Camera Feed")
+    # Webcam component
+    ctx = webrtc_streamer(
+        key="digit_recognition",
+        video_processor_factory=DigitRecognizer,
+        rtc_configuration=RTC_CONFIGURATION,
+        media_stream_constraints={"video": True, "audio": False},
+        async_processing=True,
+    )
+
+with col2:
+    st.markdown("### 🎯 Current Prediction")
+    
+    # Create placeholders for dynamic updates
+    prediction_placeholder = st.empty()
+    confidence_bar = st.empty()
+    confidence_text = st.empty()
+    
+    # Update display in real-time
+    if ctx.state.playing:
+        while ctx.state.playing:
+            with prediction_lock:
+                digit = current_prediction["digit"]
+                confidence = current_prediction["confidence"]
+            
+            # Display prediction
+            if confidence > confidence_threshold and digit not in ["No hand detected", "Processing error", "Error"]:
+                prediction_placeholder.markdown(f"# {digit}")
+                confidence_bar.progress(confidence)
+                confidence_text.success(f"Confidence: {confidence:.2f}")
+            else:
+                prediction_placeholder.markdown("# -")
+                confidence_bar.progress(0)
+                if digit == "No hand detected":
+                    confidence_text.info("Show your hand to the camera")
+                else:
+                    confidence_text.warning(f"Low confidence: {confidence:.2f}")
+            
+            time.sleep(0.1)  # Update every 100ms
+    else:
+        st.warning("📷 Turn on your webcam to start!")
+
+# Instructions
+st.markdown("---")
+st.markdown("""
+### 📋 Instructions:
+1. **Allow camera access** when prompted
+2. **Position your hand** clearly in the camera view
+3. **Make gesture signs** for numbers or letters
+4. **Hold the sign steady** for best results
+5. **Adjust confidence threshold** if needed
+
+### 💡 Tips for Better Recognition:
+- ✅ Ensure **good lighting**
+- ✅ Keep your **hand centered** in the frame
+- ✅ Make **clear, distinct** gesture signs
+- ✅ **Hold steady** for 1-2 seconds
+- ✅ Try different **hand orientations** if needed
+- ✅ **Avoid background clutter** behind your hand
+
+### 🎯 Supported Gestures:
+""")
+
+# Display supported gestures
+st.markdown("#### 🔢 Numbers:")
+number_labels = [label for label in labels if label.isdigit()]
+if number_labels:
+    cols = st.columns(min(len(number_labels), 8))
+    for i, label in enumerate(number_labels):
+        with cols[i % len(cols)]:
+            st.info(f"**{label}**")
+
+st.markdown("#### 🔤 Letters:")
+letter_labels = [label for label in labels if label.isalpha()]
+if letter_labels:
+    # Display letters in rows of 8
+    for row_start in range(0, len(letter_labels), 8):
+        row_labels = letter_labels[row_start:row_start + 8]
+        cols = st.columns(len(row_labels))
+        for i, label in enumerate(row_labels):
+            with cols[i]:
+                st.info(f"**{label}**")

requirements_new.txt

@@ -0,0 +1,10 @@
+streamlit==1.28.0
+streamlit-webrtc==0.47.1
+opencv-python==4.8.1.78
+mediapipe==0.10.7
+tensorflow==2.13.0
+numpy==1.24.3
+google-generativeai==0.3.2
+flask==2.3.3
+av==10.0.0
+protobuf==3.20.3

requirements_training.txt

@@ -0,0 +1,8 @@
+tensorflow>=2.0.0
+opencv-python>=4.5.0
+mediapipe>=0.8.0
+scikit-learn>=0.24.0
+matplotlib>=3.3.0
+seaborn>=0.11.0
+tqdm>=4.60.0
+numpy>=1.19.0

run_app.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+"""
+Startup script for AI Sign Language Interpreter
+This script starts both the landing page (Flask) and the main app (Streamlit)
+"""
+
+import subprocess
+import threading
+import time
+import webbrowser
+import sys
+import os
+
+def start_streamlit():
+    """Start Streamlit app"""
+    print("🚀 Starting Streamlit app...")
+    try:
+        subprocess.run([
+            sys.executable, '-m', 'streamlit', 'run', 'app_enhanced.py',
+            '--server.port=8502',
+            '--server.headless=true',
+            '--server.runOnSave=true'
+        ])
+    except KeyboardInterrupt:
+        print("Streamlit app stopped.")
+    except Exception as e:
+        print(f"Error starting Streamlit: {e}")
+
+def start_flask():
+    """Start Flask server for landing page"""
+    print("🌐 Starting Flask server...")
+    try:
+        subprocess.run([sys.executable, 'server.py'])
+    except KeyboardInterrupt:
+        print("Flask server stopped.")
+    except Exception as e:
+        print(f"Error starting Flask: {e}")
+
+def main():
+    print("=" * 60)
+    print("🤟 AI Sign Language Interpreter")
+    print("=" * 60)
+    print("Starting application servers...")
+    print()
+    
+    # Check if required files exist
+    required_files = ['app_enhanced.py', 'server.py', 'models/model.tflite', 'models/labels.txt']
+    missing_files = [f for f in required_files if not os.path.exists(f)]
+    
+    if missing_files:
+        print("❌ Missing required files:")
+        for file in missing_files:
+            print(f"   - {file}")
+        print("\nPlease ensure all required files are present.")
+        return
+    
+    print("✅ All required files found.")
+    print()
+    
+    try:
+        # Start Streamlit in a separate thread
+        streamlit_thread = threading.Thread(target=start_streamlit, daemon=True)
+        streamlit_thread.start()
+        
+        # Give Streamlit time to start
+        print("⏳ Waiting for Streamlit to initialize...")
+        time.sleep(5)
+        
+        # Start Flask (this will block)
+        print("🌐 Flask server starting on http://localhost:5000")
+        print("🤖 Streamlit app available on http://localhost:8501")
+        print()
+        print("📖 Instructions:")
+        print("   1. Visit http://localhost:5000 for the landing page")
+        print("   2. Click 'Try it Out' to access the AI interpreter")
+        print("   3. Allow camera access when prompted")
+        print("   4. Start making sign language gestures!")
+        print()
+        print("Press Ctrl+C to stop all servers")
+        print("=" * 60)
+        
+        # Open browser automatically
+        time.sleep(2)
+        webbrowser.open('http://localhost:5000')
+        
+        # Start Flask server
+        start_flask()
+        
+    except KeyboardInterrupt:
+        print("\n🛑 Shutting down servers...")
+        print("👋 Thank you for using AI Sign Language Interpreter!")
+    except Exception as e:
+        print(f"❌ Error: {e}")
+
+if __name__ == "__main__":
+    main()

run_simple_app.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""
+Simple startup script for the streamlined Sign Language Interpreter
+"""
+
+import subprocess
+import sys
+import os
+import time
+
+def check_requirements():
+    """Check if required files exist"""
+    required_files = ['simple_sign_interpreter.py', 'sign_utils.py', 'models/model.tflite', 'models/labels.txt']
+    missing_files = [f for f in required_files if not os.path.exists(f)]
+    
+    if missing_files:
+        print("❌ Missing required files:")
+        for file in missing_files:
+            print(f"   - {file}")
+        print("\nPlease ensure all required files are present.")
+        return False
+    
+    print("✅ All required files found.")
+    return True
+
+def start_streamlit():
+    """Start the simple sign interpreter app"""
+    print("🤟 Starting Simple Sign Language Interpreter...")
+    print("=" * 50)
+    
+    if not check_requirements():
+        return
+    
+    try:
+        print("🚀 Starting Streamlit app on http://localhost:8501")
+        print("📖 Instructions:")
+        print("   1. Allow camera access when prompted")
+        print("   2. Make sign language gestures for numbers (1,2,4,5,6,7,8) or letters (A-X)")
+        print("   3. Hold gestures steady for best recognition")
+        print("   4. Adjust confidence threshold if needed")
+        print()
+        print("Press Ctrl+C to stop the application")
+        print("=" * 50)
+        
+        # Start Streamlit
+        subprocess.run([
+            sys.executable, '-m', 'streamlit', 'run', 'simple_sign_interpreter.py',
+            '--server.port=8501',
+            '--server.headless=false'
+        ])
+        
+    except KeyboardInterrupt:
+        print("\n🛑 Application stopped.")
+        print("👋 Thank you for using the Sign Language Interpreter!")
+    except Exception as e:
+        print(f"❌ Error starting application: {e}")
+
+if __name__ == "__main__":
+    start_streamlit()

server.py

@@ -0,0 +1,51 @@
+from flask import Flask, render_template, redirect, url_for
+import subprocess
+import threading
+import time
+import os
+
+app = Flask(__name__)
+
+# Global variable to track Streamlit process
+streamlit_process = None
+
+def start_streamlit():
+    """Start Streamlit app in background"""
+    global streamlit_process
+    try:
+        streamlit_process = subprocess.Popen([
+            'streamlit', 'run', 'app_enhanced.py', 
+            '--server.port=8502',
+            '--server.headless=true'
+        ])
+        print("Streamlit app started on port 8502")
+    except Exception as e:
+        print(f"Error starting Streamlit: {e}")
+
+@app.route('/')
+def landing_page():
+    """Serve the landing page"""
+    return render_template('index.html')
+
+@app.route('/app')
+def launch_app():
+    """Redirect to Streamlit app"""
+    return redirect('http://localhost:8502')
+
+@app.route('/start-streamlit')
+def start_streamlit_endpoint():
+    """Start Streamlit if not running"""
+    global streamlit_process
+    if streamlit_process is None or streamlit_process.poll() is not None:
+        threading.Thread(target=start_streamlit, daemon=True).start()
+        time.sleep(3)  # Give Streamlit time to start
+    return redirect('http://localhost:8502')
+
+if __name__ == '__main__':
+    # Start Streamlit in background
+    threading.Thread(target=start_streamlit, daemon=True).start()
+    
+    # Start Flask server
+    print("Starting Flask server on http://localhost:5000")
+    print("Streamlit app will be available on http://localhost:8502")
+    app.run(host='0.0.0.0', port=5000, debug=True)

setup.py

@@ -0,0 +1,68 @@
+import os
+import subprocess
+import sys
+
+def install_requirements():
+    """Install required packages."""
+    print("Installing required packages...")
+    try:
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "-r", "requirements.txt"])
+        print("✅ Requirements installed successfully!")
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Error installing requirements: {e}")
+        return False
+    return True
+
+def create_directories():
+    """Create necessary directories."""
+    directories = [
+        "models",
+        "dataset", 
+        "static/css",
+        "templates",
+        "utils",
+        "logs"
+    ]
+    
+    for directory in directories:
+        os.makedirs(directory, exist_ok=True)
+        print(f"✅ Created directory: {directory}")
+
+def create_sample_model():
+    """Create a sample model for testing."""
+    print("Creating sample model...")
+    try:
+        subprocess.check_call([sys.executable, "create_sample_model.py"])
+        print("✅ Sample model created successfully!")
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Error creating sample model: {e}")
+        return False
+    return True
+
+def main():
+    print("🤟 Sign Language Interpreter Setup")
+    print("=" * 40)
+    
+    # Create directories
+    print("\n1. Creating directories...")
+    create_directories()
+    
+    # Install requirements
+    print("\n2. Installing requirements...")
+    if not install_requirements():
+        print("Setup failed. Please install requirements manually.")
+        return
+    
+    # Create sample model
+    print("\n3. Creating sample model...")
+    if not create_sample_model():
+        print("Warning: Sample model creation failed. You can create it later.")
+    
+    print("\n🎉 Setup completed successfully!")
+    print("\nNext steps:")
+    print("1. Run 'python data_collection.py' to collect your own sign data")
+    print("2. Run 'python train_model.py' to train a custom model")
+    print("3. Run 'streamlit run app.py' to start the application")
+
+if __name__ == "__main__":
+    main()

sign_utils.py

@@ -0,0 +1,200 @@
+import cv2
+import mediapipe as mp
+import numpy as np
+from typing import List, Tuple, Optional
+
+# Try to import TensorFlow, handle gracefully if not available
+try:
+    import tensorflow as tf
+    TF_AVAILABLE = True
+except ImportError:
+    TF_AVAILABLE = False
+    print("Warning: TensorFlow not available. Some features may be limited.")
+
+class MediaPipeLandmarksModel:
+    def __init__(self):
+        self.mp_hands = mp.solutions.hands
+        self.mp_drawing = mp.solutions.drawing_utils
+        self.hands = self.mp_hands.Hands(
+            static_image_mode=False, 
+            max_num_hands=2, 
+            min_detection_confidence=0.5,
+            min_tracking_confidence=0.5
+        )
+        self.sequence = []
+        self.sequence_length = 15  # Reduced for faster response
+
+    def predict_landmarks(self, image: np.ndarray) -> Optional[List[Tuple[float, float, float]]]:
+        """Extract hand landmarks from image."""
+        image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        results = self.hands.process(image_rgb)
+
+        if results.multi_hand_landmarks:
+            landmarks = []
+            for hand_landmarks in results.multi_hand_landmarks:
+                for landmark in hand_landmarks.landmark:
+                    landmarks.append((landmark.x, landmark.y, landmark.z))
+            return landmarks
+        return None
+
+    def draw_landmarks(self, image: np.ndarray, landmarks) -> np.ndarray:
+        """Draw hand landmarks on image."""
+        if landmarks:
+            results = self.hands.process(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
+            if results.multi_hand_landmarks:
+                for hand_landmarks in results.multi_hand_landmarks:
+                    self.mp_drawing.draw_landmarks(
+                        image, hand_landmarks, self.mp_hands.HAND_CONNECTIONS)
+        return image
+
+    def normalize_landmarks(self, landmarks: List[Tuple[float, float, float]]) -> np.ndarray:
+        """Normalize landmarks relative to wrist position."""
+        if not landmarks:
+            return np.zeros((21, 3))
+        
+        landmarks_array = np.array(landmarks)
+        
+        # Get wrist position (first landmark)
+        wrist = landmarks_array[0]
+        
+        # Normalize relative to wrist
+        normalized = landmarks_array - wrist
+        
+        # Scale by hand size (distance from wrist to middle finger tip)
+        if len(landmarks_array) >= 12:
+            hand_size = np.linalg.norm(landmarks_array[12] - wrist)
+            if hand_size > 0:
+                normalized = normalized / hand_size
+        
+        return normalized.flatten()
+
+    def extract_features(self, landmarks: List[Tuple[float, float, float]]) -> np.ndarray:
+        """Extract features from landmarks for model input."""
+        if not landmarks:
+            return np.zeros(63)  # 21 landmarks * 3 coordinates
+        
+        # Ensure we have exactly 21 landmarks (one hand)
+        if len(landmarks) > 21:
+            landmarks = landmarks[:21]  # Take first hand only
+        elif len(landmarks) < 21:
+            # Pad with zeros if we have fewer landmarks
+            while len(landmarks) < 21:
+                landmarks.append((0.0, 0.0, 0.0))
+        
+        # Convert to numpy array
+        landmarks_array = np.array(landmarks)
+        
+        # Get wrist position (first landmark)
+        wrist = landmarks_array[0]
+        
+        # Normalize relative to wrist
+        normalized = landmarks_array - wrist
+        
+        # Scale by hand size (distance from wrist to middle finger tip)
+        hand_size = np.linalg.norm(landmarks_array[12] - wrist) if len(landmarks_array) >= 12 else 1.0
+        if hand_size > 0:
+            normalized = normalized / hand_size
+            
+        # Flatten to 63 dimensions (21 landmarks * 3 coordinates)
+        features = normalized.flatten()
+        
+        # Ensure we have exactly 63 dimensions
+        if len(features) > 63:
+            features = features[:63]
+        elif len(features) < 63:
+            features = np.pad(features, (0, 63 - len(features)))
+            
+        return features
+
+    def update_sequence(self, landmarks: List[Tuple[float, float, float]]) -> np.ndarray:
+        """Update sequence for temporal modeling."""
+        features = self.extract_features(landmarks)
+        self.sequence.append(features)
+        
+        # Keep only last sequence_length frames
+        if len(self.sequence) > self.sequence_length:
+            self.sequence.pop(0)
+        
+        # Pad sequence if needed
+        if len(self.sequence) < self.sequence_length:
+            padding = np.zeros((self.sequence_length - len(self.sequence), features.shape[0]))
+            sequence_array = np.vstack([padding, np.array(self.sequence)])
+        else:
+            sequence_array = np.array(self.sequence)
+        
+        return sequence_array
+
+    def reset_sequence(self):
+        """Reset the sequence buffer."""
+        self.sequence = []
+
+class SignLanguagePredictor:
+    def __init__(self, model_path: str, labels_path: str):
+        self.landmark_model = MediaPipeLandmarksModel()
+        
+        # Load labels
+        try:
+            with open(labels_path, 'r') as f:
+                self.labels = [line.strip() for line in f.readlines()]
+        except FileNotFoundError:
+            print(f"Warning: Labels file not found at {labels_path}")
+            self.labels = ["Unknown"]
+        
+        # Initialize TFLite interpreter if available
+        if TF_AVAILABLE:
+            try:
+                self.interpreter = tf.lite.Interpreter(model_path=model_path)
+                self.interpreter.allocate_tensors()
+                self.input_details = self.interpreter.get_input_details()
+                self.output_details = self.interpreter.get_output_details()
+                self.model_loaded = True
+            except Exception as e:
+                print(f"Warning: Could not load model: {e}")
+                self.model_loaded = False
+        else:
+            print("Warning: TensorFlow not available. Running in landmark-only mode.")
+            self.model_loaded = False
+
+    def predict(self, image: np.ndarray) -> Tuple[str, float]:
+        """Predict sign from image using static prediction for compatibility."""
+        # Use static prediction instead of temporal for now to avoid dimension issues
+        return self.predict_static(image)
+
+    def predict_static(self, image: np.ndarray) -> Tuple[str, float]:
+        """Predict sign from static image (single frame)."""
+        landmarks = self.landmark_model.predict_landmarks(image)
+        
+        if not landmarks:
+            return "No hand detected", 0.0
+            
+        if not self.model_loaded:
+            return "Hand detected (Model not available)", 0.5
+            
+        try:
+            # Extract features
+            features = self.landmark_model.extract_features(landmarks)
+            
+            # Get expected input shape from model
+            input_shape = self.input_details[0]['shape']
+            
+            # Reshape features to match expected input shape
+            if len(input_shape) == 2:  # If model expects 2D input (batch_size, features)
+                input_data = features.reshape(1, -1).astype(np.float32)
+            elif len(input_shape) == 3:  # If model expects 3D input (batch_size, time_steps, features)
+                input_data = features.reshape(1, 1, -1).astype(np.float32)
+            else:
+                raise ValueError(f"Unexpected input shape: {input_shape}")
+            
+            # Run inference
+            self.interpreter.set_tensor(self.input_details[0]['index'], input_data)
+            self.interpreter.invoke()
+            
+            # Get prediction
+            output = self.interpreter.get_tensor(self.output_details[0]['index'])
+            predicted_class = np.argmax(output[0])
+            confidence = float(np.max(output[0]))
+            
+            return self.labels[predicted_class], confidence
+        except Exception as e:
+            print(f"Error during static prediction: {e}")
+            return "Error during prediction", 0.0

simple_app.py

@@ -0,0 +1,195 @@
+import streamlit as st
+import cv2
+import numpy as np
+from streamlit_webrtc import webrtc_streamer, VideoTransformerBase
+from av import VideoFrame
+import mediapipe as mp
+import tensorflow as tf
+
+# Page config
+st.set_page_config(
+    page_title="Sign Language Digits Interpreter",
+    page_icon="🔢",
+    layout="wide"
+)
+
+# Load model and labels
+@st.cache_resource
+def load_model():
+    try:
+        interpreter = tf.lite.Interpreter(model_path="models/model.tflite")
+        interpreter.allocate_tensors()
+        
+        with open("models/labels.txt", 'r') as f:
+            labels = [line.strip() for line in f.readlines()]
+        
+        return interpreter, labels
+    except Exception as e:
+        st.error(f"Error loading model: {e}")
+        return None, []
+
+interpreter, labels = load_model()
+
+# MediaPipe setup
+mp_hands = mp.solutions.hands
+mp_drawing = mp.solutions.drawing_utils
+hands = mp_hands.Hands(
+    static_image_mode=False,
+    max_num_hands=1,
+    min_detection_confidence=0.5,
+    min_tracking_confidence=0.5
+)
+
+def extract_hand_features(landmarks):
+    """Extract 63 features from hand landmarks."""
+    if not landmarks:
+        return np.zeros(63)
+    
+    # Convert landmarks to numpy array
+    landmarks_array = np.array([(lm.x, lm.y, lm.z) for lm in landmarks.landmark])
+    
+    # Normalize relative to wrist (first landmark)
+    wrist = landmarks_array[0]
+    normalized = landmarks_array - wrist
+    
+    # Scale by hand size
+    hand_size = np.linalg.norm(landmarks_array[12] - wrist)
+    if hand_size > 0:
+        normalized = normalized / hand_size
+    
+    # Flatten to 63 features
+    features = normalized.flatten()
+    
+    # Ensure exactly 63 features
+    if len(features) > 63:
+        features = features[:63]
+    elif len(features) < 63:
+        features = np.pad(features, (0, 63 - len(features)))
+    
+    return features
+
+def predict_digit(features):
+    """Predict digit from features."""
+    if interpreter is None:
+        return "Model not loaded", 0.0
+    
+    try:
+        # Prepare input
+        input_data = np.expand_dims(features, axis=0).astype(np.float32)
+        
+        # Run inference
+        input_details = interpreter.get_input_details()
+        output_details = interpreter.get_output_details()
+        
+        interpreter.set_tensor(input_details[0]['index'], input_data)
+        interpreter.invoke()
+        
+        # Get prediction
+        output = interpreter.get_tensor(output_details[0]['index'])
+        predicted_class = np.argmax(output[0])
+        confidence = float(np.max(output[0]))
+        
+        return labels[predicted_class] if predicted_class < len(labels) else str(predicted_class), confidence
+    except Exception as e:
+        return f"Error: {str(e)}", 0.0
+
+class DigitRecognizer(VideoTransformerBase):
+    def __init__(self):
+        self.prediction = "Show your hand"
+        self.confidence = 0.0
+        self.frame_count = 0
+
+    def recv(self, frame: VideoFrame) -> VideoFrame:
+        image = frame.to_ndarray(format="bgr24")
+        self.frame_count += 1
+        
+        # Process every 5th frame to reduce computation
+        if self.frame_count % 5 == 0:
+            # Convert to RGB for MediaPipe
+            rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            results = hands.process(rgb_image)
+            
+            if results.multi_hand_landmarks:
+                # Get first hand
+                hand_landmarks = results.multi_hand_landmarks[0]
+                
+                # Draw landmarks
+                mp_drawing.draw_landmarks(
+                    image, hand_landmarks, mp_hands.HAND_CONNECTIONS)
+                
+                # Extract features and predict
+                features = extract_hand_features(hand_landmarks)
+                self.prediction, self.confidence = predict_digit(features)
+            else:
+                self.prediction = "No hand detected"
+                self.confidence = 0.0
+        
+        # Add text overlay
+        color = (0, 255, 0) if self.confidence > 0.5 else (0, 0, 255)
+        cv2.putText(
+            image,
+            f"{self.prediction} ({self.confidence:.2f})",
+            (20, 40),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            1.0,
+            color,
+            2
+        )
+        
+        return VideoFrame.from_ndarray(image, format="bgr24")
+
+# Main app
+st.title("🔢 Sign Language Digits Interpreter")
+st.markdown("Show hand signs for digits 0-9 to the camera!")
+
+# Sidebar controls
+st.sidebar.title("Controls")
+confidence_threshold = st.sidebar.slider("Confidence Threshold", 0.0, 1.0, 0.5)
+
+# Create columns
+col1, col2 = st.columns([2, 1])
+
+with col1:
+    # Webcam component
+    ctx = webrtc_streamer(
+        key="digit_recognition",
+        video_processor_factory=DigitRecognizer,
+        media_stream_constraints={"video": True, "audio": False},
+        async_processing=True,
+    )
+
+with col2:
+    st.markdown("### Current Prediction")
+    
+    if ctx.video_processor:
+        # Display current prediction
+        prediction_placeholder = st.empty()
+        confidence_placeholder = st.empty()
+        
+        if hasattr(ctx.video_processor, 'prediction'):
+            if ctx.video_processor.confidence > confidence_threshold:
+                prediction_placeholder.markdown(f"# {ctx.video_processor.prediction}")
+            else:
+                prediction_placeholder.markdown("# -")
+            
+            confidence_placeholder.progress(int(ctx.video_processor.confidence * 100))
+            st.text(f"Confidence: {ctx.video_processor.confidence:.2f}")
+    else:
+        st.warning("Turn on your webcam to start!")
+
+# Instructions
+st.markdown("---")
+st.markdown("""
+### Instructions:
+1. Allow camera access when prompted
+2. Show your hand clearly in the camera view
+3. Make digit signs (0-9) with your hand
+4. Hold the sign steady for best results
+5. Adjust confidence threshold if needed
+
+### Tips:
+- Ensure good lighting
+- Keep your hand in the center of the frame
+- Make clear, distinct digit signs
+- Wait a moment between different signs
+""")

simple_sign_interpreter.py

@@ -0,0 +1,307 @@
+import streamlit as st
+from streamlit_webrtc import webrtc_streamer, VideoTransformerBase
+import cv2
+import numpy as np
+from av import VideoFrame
+from sign_utils import SignLanguagePredictor, MediaPipeLandmarksModel
+
+# Page config
+st.set_page_config(
+    page_title="Sign Language Interpreter",
+    page_icon="🤟",
+    layout="wide"
+)
+
+# Custom CSS for better UI
+st.markdown("""
+<style>
+    .main-header {
+        padding: 1rem;
+        border-radius: 10px;
+        margin-bottom: 2rem;
+        text-align: center;
+    }
+    .prediction-box {
+        background-color: #f0f2f6;
+        border-radius: 10px;
+        padding: 1rem;
+        margin: 1rem 0;
+        text-align: center;
+    }
+    .instruction-box {
+        background-color: #ffffff;
+        border: 1px solid #e0e0e0;
+        border-radius: 10px;
+        padding: 1rem;
+        margin: 1rem 0;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Initialize models
+@st.cache_resource
+def load_models():
+    try:
+        predictor = SignLanguagePredictor(
+            model_path="models/model.tflite",
+            labels_path="models/labels.txt"
+        )
+        return predictor
+    except Exception as e:
+        st.error(f"Error loading models: {str(e)}")
+        return None
+
+predictor = load_models()
+
+class SignInterpreter(VideoTransformerBase):
+    def __init__(self, confidence_threshold=0.7):
+        self.predictor = predictor
+        self.landmark_model = MediaPipeLandmarksModel()
+        self.result_text = "Show your hand sign"
+        self.confidence = 0.0
+        self.landmarks = None
+        self.prediction_counter = {}
+        self.last_prediction = None
+        self.confidence_threshold = confidence_threshold
+        self.frame_count = 0
+        self.prediction_history = []
+        self.stable_prediction = None
+        self.stable_confidence = 0.0
+        
+        # Enhanced prediction smoothing
+        self.prediction_buffer = []
+        self.buffer_size = 8  # Reduced for faster response
+        self.min_consistent_frames = 3  # Reduced for faster response
+
+    def recv(self, frame: VideoFrame) -> VideoFrame:
+        image = frame.to_ndarray(format="bgr24")
+        self.frame_count += 1
+        
+        if self.predictor:
+            # Get landmarks
+            self.landmarks = self.landmark_model.predict_landmarks(image)
+            
+            # Get prediction if hand is detected
+            if self.landmarks:
+                try:
+                    # Use temporal prediction instead of static
+                    prediction, raw_confidence = self.predictor.predict(image)
+                    
+                    # Add to prediction buffer with higher threshold for confidence
+                    if raw_confidence > 0.4:  # Only add predictions with decent confidence
+                        self.prediction_buffer.append((prediction, raw_confidence))
+                        if len(self.prediction_buffer) > self.buffer_size:
+                            self.prediction_buffer.pop(0)
+                    
+                    # Get smoothed prediction
+                    smoothed_prediction, smoothed_confidence = self._get_smoothed_prediction()
+                    
+                    # Update current values
+                    self.confidence = smoothed_confidence
+                    
+                    # Check if prediction meets confidence threshold
+                    if smoothed_confidence > self.confidence_threshold:
+                        # Count consecutive predictions
+                        if smoothed_prediction not in self.prediction_counter:
+                            self.prediction_counter = {smoothed_prediction: 1}
+                        else:
+                            self.prediction_counter[smoothed_prediction] += 1
+                        
+                        # Update stable prediction if we have enough consistent frames
+                        max_pred = max(self.prediction_counter.items(), key=lambda x: x[1])
+                        if max_pred[1] >= self.min_consistent_frames:
+                            self.stable_prediction = smoothed_prediction
+                            self.stable_confidence = smoothed_confidence
+                            self.result_text = f"Sign: {smoothed_prediction}"
+                            self.last_prediction = smoothed_prediction
+                    else:
+                        # Reset if confidence is too low
+                        if self.frame_count % 30 == 0:  # Reset every 30 frames
+                            self.prediction_counter = {}
+                            self.result_text = "Show your hand sign"
+                            
+                except Exception as e:
+                    self.result_text = "Processing..."
+                    self.confidence = 0.0
+                    self.prediction_counter = {}
+            else:
+                self.result_text = "No hand detected"
+                self.confidence = 0.0
+                self.prediction_counter = {}
+                self.prediction_buffer = []
+            
+            # Draw landmarks with better visualization
+            if self.landmarks:
+                image = self.landmark_model.draw_landmarks(image, self.landmarks)
+            
+            # Enhanced text overlay with better positioning
+            self._draw_prediction_overlay(image)
+        
+        return VideoFrame.from_ndarray(image, format="bgr24")
+    
+    def _get_smoothed_prediction(self):
+        """Get smoothed prediction from buffer"""
+        if not self.prediction_buffer:
+            return "No prediction", 0.0
+        
+        # Get predictions from last few frames
+        recent_predictions = self.prediction_buffer[-5:] if len(self.prediction_buffer) >= 5 else self.prediction_buffer
+        
+        # Count occurrences of each prediction
+        prediction_counts = {}
+        confidence_sums = {}
+        
+        for pred, conf in recent_predictions:
+            if pred not in prediction_counts:
+                prediction_counts[pred] = 0
+                confidence_sums[pred] = 0.0
+            prediction_counts[pred] += 1
+            confidence_sums[pred] += conf
+        
+        # Get most frequent prediction
+        if prediction_counts:
+            most_frequent = max(prediction_counts.items(), key=lambda x: x[1])
+            avg_confidence = confidence_sums[most_frequent[0]] / prediction_counts[most_frequent[0]]
+            return most_frequent[0], avg_confidence
+        
+        return "No prediction", 0.0
+    
+    def _draw_prediction_overlay(self, image):
+        """Draw enhanced prediction overlay"""
+        height, width = image.shape[:2]
+        
+        # Background rectangle for better text visibility
+        overlay = image.copy()
+        cv2.rectangle(overlay, (10, 10), (width-10, 100), (0, 0, 0), -1)
+        cv2.addWeighted(overlay, 0.7, image, 0.3, 0, image)
+        
+        # Main prediction text
+        color = (0, 255, 0) if self.confidence > self.confidence_threshold else (0, 165, 255)
+        cv2.putText(
+            image,
+            self.result_text,
+            (20, 40),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            1.0,
+            color,
+            2
+        )
+        
+        # Confidence text
+        cv2.putText(
+            image,
+            f"Confidence: {self.confidence:.2f}",
+            (20, 70),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            0.6,
+            (255, 255, 255),
+            1
+        )
+        
+        # Threshold indicator
+        threshold_color = (0, 255, 0) if self.confidence > self.confidence_threshold else (0, 0, 255)
+        cv2.putText(
+            image,
+            f"Threshold: {self.confidence_threshold:.2f}",
+            (20, 90),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            0.5,
+            threshold_color,
+            1
+        )
+
+def main():
+    # Header
+    st.markdown("""
+    <div class="main-header">
+        <h1>🤟 Sign Language Interpreter</h1>
+        <p>Real-time sign language recognition using computer vision</p>
+    </div>
+    """, unsafe_allow_html=True)
+
+    # Sidebar controls
+    st.sidebar.title("⚙️ Controls")
+    confidence_threshold = st.sidebar.slider(
+        "Detection Confidence",
+        min_value=0.0,
+        max_value=1.0,
+        value=0.5,  # Lowered for better live detection
+        help="Adjust the confidence threshold for sign detection"
+    )
+
+    # Create two columns for layout
+    col1, col2 = st.columns([2, 1])
+
+    with col1:
+        # Webcam component
+        st.markdown("### 📹 Camera Feed")
+        ctx = webrtc_streamer(
+            key="sign_language",
+            video_processor_factory=lambda: SignInterpreter(confidence_threshold),
+            media_stream_constraints={"video": True, "audio": False},
+            async_processing=True,
+        )
+
+    with col2:
+        # Current prediction display
+        st.markdown("### 🎯 Current Sign")
+        prediction_placeholder = st.empty()
+        confidence_meter = st.progress(0)
+        
+        # Update prediction and confidence
+        if ctx.video_transformer:
+            if ctx.video_transformer.last_prediction and ctx.video_transformer.confidence > confidence_threshold:
+                prediction_placeholder.markdown(f"""
+                <div class="prediction-box">
+                    <h2>{ctx.video_transformer.last_prediction}</h2>
+                </div>
+                """, unsafe_allow_html=True)
+            else:
+                prediction_placeholder.markdown("""
+                <div class="prediction-box">
+                    <h2>-</h2>
+                </div>
+                """, unsafe_allow_html=True)
+            
+            confidence_meter.progress(int(ctx.video_transformer.confidence * 100))
+        else:
+            st.info("📷 Start the webcam to begin recognition")
+
+    # Instructions
+    st.markdown("---")
+    
+    # Create three columns for better layout
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.markdown("### 📝 Instructions")
+        st.markdown("""
+        1. Allow camera access when prompted
+        2. Position your hand clearly in the camera view
+        3. Make hand signs for:
+           - **Numbers:** 1, 2, 4, 5, 6, 7, 8
+           - **Letters:** A through X (except E)
+        4. Hold each sign steady for best recognition
+        5. Adjust the confidence threshold if needed
+        """)
+    
+    with col2:
+        st.markdown("### 💡 Tips for Better Recognition")
+        st.markdown("""
+        - Ensure good lighting on your hands
+        - Keep your hand within the camera frame
+        - Make clear, distinct gestures
+        - Avoid rapid movements
+        - Use a plain background
+        - Keep hand at comfortable distance from camera
+        """)
+    
+    with col3:
+        st.markdown("### 📊 Supported Gestures")
+        st.markdown("**Numbers:**")
+        st.markdown("1, 2, 4, 5, 6, 7, 8")
+        st.markdown("**Letters:**")
+        st.markdown("A, B, C, D, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X")
+
+if __name__ == "__main__":
+    main()

test_system.py

@@ -0,0 +1,155 @@
+import cv2
+import numpy as np
+import os
+import sys
+from sign_utils import MediaPipeLandmarksModel, SignLanguagePredictor
+
+def test_camera():
+    """Test if camera is working."""
+    print("Testing camera...")
+    cap = cv2.VideoCapture(0)
+    
+    if not cap.isOpened():
+        print("❌ Camera not accessible")
+        return False
+    
+    ret, frame = cap.read()
+    if not ret:
+        print("❌ Cannot read from camera")
+        cap.release()
+        return False
+    
+    print("✅ Camera working")
+    cap.release()
+    return True
+
+def test_mediapipe():
+    """Test MediaPipe hand detection."""
+    print("Testing MediaPipe...")
+    try:
+        landmark_model = MediaPipeLandmarksModel()
+        
+        # Create a dummy image
+        dummy_image = np.zeros((480, 640, 3), dtype=np.uint8)
+        landmarks = landmark_model.predict_landmarks(dummy_image)
+        
+        print("✅ MediaPipe working")
+        return True
+    except Exception as e:
+        print(f"❌ MediaPipe error: {e}")
+        return False
+
+def test_model_files():
+    """Test if model files exist."""
+    print("Testing model files...")
+    
+    model_path = "models/model.tflite"
+    labels_path = "models/labels.txt"
+    
+    if not os.path.exists(model_path):
+        print(f"❌ Model file not found: {model_path}")
+        return False
+    
+    if not os.path.exists(labels_path):
+        print(f"❌ Labels file not found: {labels_path}")
+        return False
+    
+    print("✅ Model files found")
+    return True
+
+def test_predictor():
+    """Test the sign language predictor."""
+    print("Testing predictor...")
+    
+    if not test_model_files():
+        return False
+    
+    try:
+        predictor = SignLanguagePredictor(
+            model_path="models/model.tflite",
+            labels_path="models/labels.txt"
+        )
+        
+        # Create a dummy image
+        dummy_image = np.zeros((480, 640, 3), dtype=np.uint8)
+        prediction, confidence = predictor.predict(dummy_image)
+        
+        print(f"✅ Predictor working - Sample prediction: {prediction} ({confidence:.2f})")
+        return True
+    except Exception as e:
+        print(f"❌ Predictor error: {e}")
+        return False
+
+def test_dependencies():
+    """Test if all dependencies are installed."""
+    print("Testing dependencies...")
+    
+    required_modules = [
+        'cv2', 'numpy', 'tensorflow', 'mediapipe', 
+        'streamlit', 'sklearn'
+    ]
+    
+    missing_modules = []
+    
+    for module in required_modules:
+        try:
+            __import__(module)
+        except ImportError:
+            missing_modules.append(module)
+    
+    if missing_modules:
+        print(f"❌ Missing modules: {missing_modules}")
+        return False
+    
+    print("✅ All dependencies installed")
+    return True
+
+def run_full_test():
+    """Run complete system test."""
+    print("🤟 Sign Language Interpreter - System Test")
+    print("=" * 50)
+    
+    tests = [
+        ("Dependencies", test_dependencies),
+        ("Camera", test_camera),
+        ("MediaPipe", test_mediapipe),
+        ("Model Files", test_model_files),
+        ("Predictor", test_predictor)
+    ]
+    
+    passed = 0
+    total = len(tests)
+    
+    for test_name, test_func in tests:
+        print(f"\n{test_name}:")
+        if test_func():
+            passed += 1
+        else:
+            print(f"  Fix this issue before proceeding")
+    
+    print(f"\n{'='*50}")
+    print(f"Test Results: {passed}/{total} tests passed")
+    
+    if passed == total:
+        print("🎉 All tests passed! System is ready to use.")
+        print("\nNext steps:")
+        print("1. Run 'streamlit run app.py' to start the application")
+        print("2. Or run 'python data_collection.py' to collect custom data")
+    else:
+        print("❌ Some tests failed. Please fix the issues above.")
+        
+        if not test_model_files():
+            print("\n💡 Tip: Run 'python create_sample_model.py' to create a sample model")
+
+def main():
+    if len(sys.argv) > 1 and sys.argv[1] == "--quick":
+        # Quick test - just check if basic components work
+        if test_dependencies() and test_mediapipe():
+            print("✅ Quick test passed!")
+        else:
+            print("❌ Quick test failed!")
+    else:
+        run_full_test()
+
+if __name__ == "__main__":
+    main()

train_digits_model.py

@@ -0,0 +1,330 @@
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout, BatchNormalization
+from tensorflow.keras.preprocessing.image import ImageDataGenerator
+from sklearn.model_selection import train_test_split
+import cv2
+import os
+import glob
+from sign_utils import MediaPipeLandmarksModel
+import matplotlib.pyplot as plt
+
+class DigitSignTrainer:
+    def __init__(self):
+        self.landmark_model = MediaPipeLandmarksModel()
+        self.img_size = (224, 224)
+        
+    def load_image_dataset(self, dataset_path="dataset"):
+        """Load digit images and extract landmarks."""
+        X_images = []
+        X_landmarks = []
+        y = []
+        
+        print("Loading and processing images...")
+        
+        # Process each digit folder
+        for digit in range(10):
+            digit_path = os.path.join(dataset_path, str(digit))
+            if not os.path.exists(digit_path):
+                continue
+                
+            image_files = glob.glob(os.path.join(digit_path, "*.JPG"))
+            print(f"Processing {len(image_files)} images for digit {digit}")
+            
+            for img_file in image_files:
+                # Load and preprocess image
+                img = cv2.imread(img_file)
+                if img is None:
+                    continue
+                    
+                # Resize image
+                img_resized = cv2.resize(img, self.img_size)
+                
+                # Extract landmarks
+                landmarks = self.landmark_model.predict_landmarks(img)
+                
+                if landmarks is not None:
+                    # Normalize landmarks
+                    landmarks_normalized = self.landmark_model.normalize_landmarks(landmarks)
+                    
+                    X_images.append(img_resized)
+                    X_landmarks.append(landmarks_normalized)
+                    y.append(digit)
+        
+        print(f"Successfully processed {len(X_images)} images with landmarks")
+        
+        # Convert to numpy arrays
+        X_images = np.array(X_images) / 255.0  # Normalize pixel values
+        X_landmarks = np.array(X_landmarks)
+        y = np.array(y)
+        
+        return X_images, X_landmarks, y
+    
+    def create_cnn_model(self, num_classes=10):
+        """Create CNN model for image classification."""
+        model = Sequential([
+            Conv2D(32, (3, 3), activation='relu', input_shape=(224, 224, 3)),
+            BatchNormalization(),
+            MaxPooling2D(2, 2),
+            
+            Conv2D(64, (3, 3), activation='relu'),
+            BatchNormalization(),
+            MaxPooling2D(2, 2),
+            
+            Conv2D(128, (3, 3), activation='relu'),
+            BatchNormalization(),
+            MaxPooling2D(2, 2),
+            
+            Conv2D(256, (3, 3), activation='relu'),
+            BatchNormalization(),
+            MaxPooling2D(2, 2),
+            
+            Flatten(),
+            Dense(512, activation='relu'),
+            Dropout(0.5),
+            Dense(256, activation='relu'),
+            Dropout(0.3),
+            Dense(num_classes, activation='softmax')
+        ])
+        
+        model.compile(
+            optimizer='adam',
+            loss='sparse_categorical_crossentropy',
+            metrics=['accuracy']
+        )
+        
+        return model
+    
+    def create_landmark_model(self, num_classes=10):
+        """Create model for landmark-based classification."""
+        model = Sequential([
+            Dense(128, activation='relu', input_shape=(63,)),  # 21 landmarks * 3 coordinates
+            BatchNormalization(),
+            Dropout(0.3),
+            
+            Dense(64, activation='relu'),
+            BatchNormalization(),
+            Dropout(0.3),
+            
+            Dense(32, activation='relu'),
+            Dropout(0.2),
+            
+            Dense(num_classes, activation='softmax')
+        ])
+        
+        model.compile(
+            optimizer='adam',
+            loss='sparse_categorical_crossentropy',
+            metrics=['accuracy']
+        )
+        
+        return model
+    
+    def create_combined_model(self, num_classes=10):
+        """Create combined model using both images and landmarks."""
+        # Image branch
+        image_input = tf.keras.Input(shape=(224, 224, 3), name='image_input')
+        x1 = Conv2D(32, (3, 3), activation='relu')(image_input)
+        x1 = BatchNormalization()(x1)
+        x1 = MaxPooling2D(2, 2)(x1)
+        x1 = Conv2D(64, (3, 3), activation='relu')(x1)
+        x1 = BatchNormalization()(x1)
+        x1 = MaxPooling2D(2, 2)(x1)
+        x1 = Conv2D(128, (3, 3), activation='relu')(x1)
+        x1 = BatchNormalization()(x1)
+        x1 = MaxPooling2D(2, 2)(x1)
+        x1 = Flatten()(x1)
+        x1 = Dense(256, activation='relu')(x1)
+        x1 = Dropout(0.5)(x1)
+        
+        # Landmark branch
+        landmark_input = tf.keras.Input(shape=(63,), name='landmark_input')
+        x2 = Dense(128, activation='relu')(landmark_input)
+        x2 = BatchNormalization()(x2)
+        x2 = Dropout(0.3)(x2)
+        x2 = Dense(64, activation='relu')(x2)
+        x2 = Dropout(0.3)(x2)
+        
+        # Combine branches
+        combined = tf.keras.layers.concatenate([x1, x2])
+        combined = Dense(128, activation='relu')(combined)
+        combined = Dropout(0.3)(combined)
+        output = Dense(num_classes, activation='softmax')(combined)
+        
+        model = tf.keras.Model(inputs=[image_input, landmark_input], outputs=output)
+        model.compile(
+            optimizer='adam',
+            loss='sparse_categorical_crossentropy',
+            metrics=['accuracy']
+        )
+        
+        return model
+    
+    def train_model(self, model_type='combined'):
+        """Train the model."""
+        # Load dataset
+        X_images, X_landmarks, y = self.load_image_dataset()
+        
+        if len(X_images) == 0:
+            print("No valid images found with hand landmarks!")
+            return None
+        
+        # Split data
+        if model_type == 'combined':
+            X_img_train, X_img_test, X_land_train, X_land_test, y_train, y_test = train_test_split(
+                X_images, X_landmarks, y, test_size=0.2, random_state=42, stratify=y
+            )
+            X_img_train, X_img_val, X_land_train, X_land_val, y_train, y_val = train_test_split(
+                X_img_train, X_land_train, y_train, test_size=0.2, random_state=42, stratify=y_train
+            )
+        else:
+            X_train, X_test, y_train, y_test = train_test_split(
+                X_images if model_type == 'cnn' else X_landmarks, y, 
+                test_size=0.2, random_state=42, stratify=y
+            )
+            X_train, X_val, y_train, y_val = train_test_split(
+                X_train, y_train, test_size=0.2, random_state=42, stratify=y_train
+            )
+        
+        print(f"Training set: {len(y_train)} samples")
+        print(f"Validation set: {len(y_val)} samples")
+        print(f"Test set: {len(y_test)} samples")
+        
+        # Create model
+        if model_type == 'cnn':
+            model = self.create_cnn_model()
+            train_data = (X_train, y_train)
+            val_data = (X_val, y_val)
+            test_data = (X_test, y_test)
+        elif model_type == 'landmark':
+            model = self.create_landmark_model()
+            train_data = (X_train, y_train)
+            val_data = (X_val, y_val)
+            test_data = (X_test, y_test)
+        else:  # combined
+            model = self.create_combined_model()
+            train_data = ([X_img_train, X_land_train], y_train)
+            val_data = ([X_img_val, X_land_val], y_val)
+            test_data = ([X_img_test, X_land_test], y_test)
+        
+        print(f"\nModel Summary ({model_type}):")
+        model.summary()
+        
+        # Callbacks
+        callbacks = [
+            tf.keras.callbacks.EarlyStopping(patience=10, restore_best_weights=True),
+            tf.keras.callbacks.ReduceLROnPlateau(factor=0.5, patience=5),
+            tf.keras.callbacks.ModelCheckpoint(
+                f'models/best_{model_type}_model.h5', 
+                save_best_only=True
+            )
+        ]
+        
+        # Train model
+        print(f"\nTraining {model_type} model...")
+        history = model.fit(
+            train_data[0], train_data[1],
+            validation_data=val_data,
+            epochs=50,
+            batch_size=32,
+            callbacks=callbacks,
+            verbose=1
+        )
+        
+        # Evaluate model
+        print(f"\nEvaluating {model_type} model...")
+        test_loss, test_accuracy = model.evaluate(test_data[0], test_data[1], verbose=0)
+        print(f"Test Accuracy: {test_accuracy:.4f}")
+        
+        # Save model
+        model.save(f'models/{model_type}_digit_model.h5')
+        
+        # Convert to TFLite
+        self.convert_to_tflite(model, model_type)
+        
+        # Save labels
+        labels = [str(i) for i in range(10)]
+        with open('models/labels.txt', 'w') as f:
+            f.write('\n'.join(labels))
+        
+        return model, history
+    
+    def convert_to_tflite(self, model, model_type):
+        """Convert model to TensorFlow Lite."""
+        try:
+            converter = tf.lite.TFLiteConverter.from_keras_model(model)
+            converter.optimizations = [tf.lite.Optimize.DEFAULT]
+            
+            tflite_model = converter.convert()
+            
+            with open(f'models/{model_type}_model.tflite', 'wb') as f:
+                f.write(tflite_model)
+            
+            # Also save as the default model.tflite
+            with open('models/model.tflite', 'wb') as f:
+                f.write(tflite_model)
+                
+            print(f"Model converted to TFLite: {model_type}_model.tflite")
+            
+        except Exception as e:
+            print(f"TFLite conversion failed: {e}")
+    
+    def plot_training_history(self, history, model_type):
+        """Plot training history."""
+        plt.figure(figsize=(12, 4))
+        
+        plt.subplot(1, 2, 1)
+        plt.plot(history.history['accuracy'], label='Training Accuracy')
+        plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
+        plt.title(f'{model_type.title()} Model Accuracy')
+        plt.xlabel('Epoch')
+        plt.ylabel('Accuracy')
+        plt.legend()
+        
+        plt.subplot(1, 2, 2)
+        plt.plot(history.history['loss'], label='Training Loss')
+        plt.plot(history.history['val_loss'], label='Validation Loss')
+        plt.title(f'{model_type.title()} Model Loss')
+        plt.xlabel('Epoch')
+        plt.ylabel('Loss')
+        plt.legend()
+        
+        plt.tight_layout()
+        plt.savefig(f'logs/{model_type}_training_history.png')
+        plt.show()
+
+def main():
+    trainer = DigitSignTrainer()
+    
+    print("Sign Language Digits Model Training")
+    print("=" * 40)
+    
+    # Check if dataset exists
+    if not os.path.exists("dataset"):
+        print("Dataset not found!")
+        return
+    
+    # Train different models
+    models_to_train = ['landmark', 'cnn', 'combined']
+    
+    for model_type in models_to_train:
+        print(f"\n{'='*50}")
+        print(f"Training {model_type.upper()} model")
+        print(f"{'='*50}")
+        
+        try:
+            model, history = trainer.train_model(model_type)
+            if model is not None:
+                trainer.plot_training_history(history, model_type)
+                print(f"{model_type.title()} model training completed!")
+            else:
+                print(f"Failed to train {model_type} model")
+        except Exception as e:
+            print(f"Error training {model_type} model: {e}")
+    
+    print("\nTraining completed!")
+    print("You can now run the main application: streamlit run app.py")
+
+if __name__ == "__main__":
+    main()

train_gesture_dataset.py

@@ -0,0 +1,427 @@
+import os
+import cv2
+import numpy as np
+import mediapipe as mp
+import tensorflow as tf
+from tensorflow import keras
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder
+import matplotlib.pyplot as plt
+import seaborn as sns
+from tqdm import tqdm
+import json
+import pickle
+from datetime import datetime
+
+class GestureDatasetTrainer:
+    def __init__(self, dataset_path, output_dir="models"):
+        self.dataset_path = dataset_path
+        self.output_dir = output_dir
+        self.mp_hands = mp.solutions.hands
+        self.hands = self.mp_hands.Hands(
+            static_image_mode=True,
+            max_num_hands=1,
+            min_detection_confidence=0.7,
+            min_tracking_confidence=0.5
+        )
+        
+        # Create output directory
+        os.makedirs(output_dir, exist_ok=True)
+        
+        # Initialize data storage
+        self.features = []
+        self.labels = []
+        self.class_names = []
+        self.label_encoder = LabelEncoder()
+        
+    def extract_hand_landmarks(self, image_path):
+        """Extract hand landmarks from image."""
+        try:
+            # Read image
+            image = cv2.imread(image_path)
+            if image is None:
+                return None
+                
+            # Convert to RGB
+            rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            
+            # Process with MediaPipe
+            results = self.hands.process(rgb_image)
+            
+            if results.multi_hand_landmarks:
+                # Get first hand landmarks
+                hand_landmarks = results.multi_hand_landmarks[0]
+                
+                # Convert to numpy array
+                landmarks_array = np.array([(lm.x, lm.y, lm.z) for lm in hand_landmarks.landmark])
+                
+                # Normalize relative to wrist (first landmark)
+                wrist = landmarks_array[0]
+                normalized = landmarks_array - wrist
+                
+                # Scale by hand size (distance from wrist to middle finger tip)
+                hand_size = np.linalg.norm(landmarks_array[12] - wrist)
+                if hand_size > 0:
+                    normalized = normalized / hand_size
+                
+                # Flatten to 63 features (21 landmarks * 3 coordinates)
+                features = normalized.flatten()
+                
+                # Ensure exactly 63 features
+                if len(features) != 63:
+                    features = np.pad(features, (0, max(0, 63 - len(features))))[:63]
+                
+                return features
+            else:
+                return None
+                
+        except Exception as e:
+            print(f"Error processing {image_path}: {e}")
+            return None
+    
+    def load_dataset(self, max_samples_per_class=500, sample_ratio=0.1):
+        """Load and process the dataset."""
+        print("Loading dataset...")
+        
+        # Get all class directories
+        class_dirs = [d for d in os.listdir(self.dataset_path) 
+                     if os.path.isdir(os.path.join(self.dataset_path, d))]
+        class_dirs.sort()  # Ensure consistent ordering
+        
+        self.class_names = class_dirs
+        print(f"Found {len(class_dirs)} classes: {class_dirs}")
+        
+        # Process each class
+        for class_name in tqdm(class_dirs, desc="Processing classes"):
+            class_path = os.path.join(self.dataset_path, class_name)
+            
+            # Get all image files
+            image_files = [f for f in os.listdir(class_path) 
+                          if f.lower().endswith(('.jpg', '.jpeg', '.png'))]
+            
+            # Sample images if there are too many
+            if len(image_files) > max_samples_per_class:
+                # Take every nth image to get a good distribution
+                step = len(image_files) // max_samples_per_class
+                image_files = image_files[::step][:max_samples_per_class]
+            else:
+                # If fewer images, sample a percentage
+                sample_size = max(1, int(len(image_files) * sample_ratio))
+                image_files = image_files[:sample_size]
+            
+            print(f"Processing {len(image_files)} images for class '{class_name}'")
+            
+            # Process images
+            class_features = []
+            for image_file in tqdm(image_files, desc=f"Class {class_name}", leave=False):
+                image_path = os.path.join(class_path, image_file)
+                features = self.extract_hand_landmarks(image_path)
+                
+                if features is not None:
+                    class_features.append(features)
+            
+            # Add to dataset
+            if class_features:
+                self.features.extend(class_features)
+                self.labels.extend([class_name] * len(class_features))
+                print(f"Added {len(class_features)} samples for class '{class_name}'")
+            else:
+                print(f"Warning: No valid samples found for class '{class_name}'")
+        
+        # Convert to numpy arrays
+        self.features = np.array(self.features)
+        self.labels = np.array(self.labels)
+        
+        # Encode labels
+        self.labels_encoded = self.label_encoder.fit_transform(self.labels)
+        
+        print(f"\nDataset loaded successfully!")
+        print(f"Total samples: {len(self.features)}")
+        print(f"Feature shape: {self.features.shape}")
+        print(f"Number of classes: {len(self.class_names)}")
+        
+        # Print class distribution
+        unique, counts = np.unique(self.labels, return_counts=True)
+        print("\nClass distribution:")
+        for class_name, count in zip(unique, counts):
+            print(f"  {class_name}: {count} samples")
+    
+    def create_model(self, input_shape=63, num_classes=36):
+        """Create the neural network model with improved architecture."""
+        model = keras.Sequential([
+            # Input layer with data augmentation
+            keras.layers.Dense(512, activation='relu', input_shape=(input_shape,)),
+            keras.layers.Dropout(0.4),
+            keras.layers.BatchNormalization(),
+            
+            keras.layers.Dense(256, activation='relu'),
+            keras.layers.Dropout(0.3),
+            keras.layers.BatchNormalization(),
+            
+            keras.layers.Dense(128, activation='relu'),
+            keras.layers.Dropout(0.3),
+            keras.layers.BatchNormalization(),
+            
+            keras.layers.Dense(64, activation='relu'),
+            keras.layers.Dropout(0.2),
+            keras.layers.BatchNormalization(),
+            
+            keras.layers.Dense(32, activation='relu'),
+            keras.layers.Dropout(0.2),
+            
+            keras.layers.Dense(num_classes, activation='softmax')
+        ])
+        
+        model.compile(
+            optimizer=keras.optimizers.Adam(learning_rate=0.001),
+            loss='sparse_categorical_crossentropy',
+            metrics=['accuracy']
+        )
+        
+        return model
+    
+    def train_model(self, test_size=0.2, validation_split=0.2, epochs=50, batch_size=64):
+        """Train the model with improved configuration."""
+        print("\nPreparing data for training...")
+        
+        # Filter out classes with insufficient samples for stratified split
+        unique_labels, label_counts = np.unique(self.labels_encoded, return_counts=True)
+        min_samples_required = max(2, int(1 / test_size))  # At least 2 samples, or enough for test split
+        
+        # Find classes with sufficient samples
+        valid_classes = unique_labels[label_counts >= min_samples_required]
+        
+        if len(valid_classes) < len(unique_labels):
+            print(f"Warning: Removing {len(unique_labels) - len(valid_classes)} classes with insufficient samples")
+            print("Classes with insufficient samples:")
+            for label, count in zip(unique_labels, label_counts):
+                if count < min_samples_required:
+                    class_name = self.class_names[label] if label < len(self.class_names) else f"Class_{label}"
+                    print(f"  {class_name}: {count} samples (minimum required: {min_samples_required})")
+        
+        # Filter data to only include valid classes
+        valid_indices = np.isin(self.labels_encoded, valid_classes)
+        filtered_features = self.features[valid_indices]
+        filtered_labels = self.labels_encoded[valid_indices]
+        
+        # Update class names to only include valid classes
+        valid_class_names = [self.class_names[i] for i in valid_classes if i < len(self.class_names)]
+        
+        # Remap labels to be continuous (0, 1, 2, ...)
+        label_mapping = {old_label: new_label for new_label, old_label in enumerate(valid_classes)}
+        remapped_labels = np.array([label_mapping[label] for label in filtered_labels])
+        
+        print(f"Training with {len(valid_classes)} classes and {len(filtered_features)} samples")
+        
+        # Calculate class weights for handling imbalance
+        from sklearn.utils.class_weight import compute_class_weight
+        class_weights = compute_class_weight(
+            'balanced',
+            classes=np.unique(remapped_labels),
+            y=remapped_labels
+        )
+        class_weight_dict = dict(enumerate(class_weights))
+        
+        # Split data - use stratify only if we have enough samples
+        try:
+            X_train, X_test, y_train, y_test = train_test_split(
+                filtered_features, remapped_labels, 
+                test_size=test_size, 
+                random_state=42, 
+                stratify=remapped_labels
+            )
+        except ValueError as e:
+            print(f"Warning: Stratified split failed ({e}), using random split instead")
+            X_train, X_test, y_train, y_test = train_test_split(
+                filtered_features, remapped_labels, 
+                test_size=test_size, 
+                random_state=42
+            )
+        
+        # Update class names for saving
+        self.class_names = valid_class_names
+        
+        print(f"Training samples: {len(X_train)}")
+        print(f"Testing samples: {len(X_test)}")
+        
+        # Create model
+        num_classes = len(self.class_names)
+        model = self.create_model(num_classes=num_classes)
+        
+        print("\nModel architecture:")
+        model.summary()
+        
+        # Enhanced callbacks
+        callbacks = [
+            keras.callbacks.EarlyStopping(
+                monitor='val_accuracy', 
+                patience=15, 
+                restore_best_weights=True,
+                verbose=1
+            ),
+            keras.callbacks.ReduceLROnPlateau(
+                monitor='val_loss', 
+                factor=0.3, 
+                patience=7, 
+                min_lr=1e-7,
+                verbose=1
+            ),
+            keras.callbacks.ModelCheckpoint(
+                os.path.join(self.output_dir, 'best_model.h5'),
+                monitor='val_accuracy',
+                save_best_only=True,
+                verbose=1
+            )
+        ]
+        
+        # Train model with class weights
+        print("\nStarting training...")
+        history = model.fit(
+            X_train, y_train,
+            validation_split=validation_split,
+            epochs=epochs,
+            batch_size=batch_size,
+            class_weight=class_weight_dict,
+            callbacks=callbacks,
+            verbose=1
+        )
+        
+        # Evaluate on test set
+        print("\nEvaluating on test set...")
+        test_loss, test_accuracy = model.evaluate(X_test, y_test, verbose=0)
+        print(f"Test accuracy: {test_accuracy:.4f}")
+        print(f"Test loss: {test_loss:.4f}")
+        
+        # Save model and metadata
+        self.save_model_and_metadata(model, history, test_accuracy)
+        
+        # Plot training history
+        self.plot_training_history(history)
+        
+        return model, history
+    
+    def save_model_and_metadata(self, model, history, test_accuracy):
+        """Save the trained model and associated metadata."""
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        
+        # Save Keras model
+        model_path = os.path.join(self.output_dir, f'gesture_model_{timestamp}.h5')
+        model.save(model_path)
+        print(f"Model saved to: {model_path}")
+        
+        # Convert to TensorFlow Lite
+        converter = tf.lite.TFLiteConverter.from_keras_model(model)
+        converter.optimizations = [tf.lite.Optimize.DEFAULT]
+        tflite_model = converter.convert()
+        
+        tflite_path = os.path.join(self.output_dir, f'gesture_model_{timestamp}.tflite')
+        with open(tflite_path, 'wb') as f:
+            f.write(tflite_model)
+        print(f"TFLite model saved to: {tflite_path}")
+        
+        # Save labels
+        labels_path = os.path.join(self.output_dir, f'labels_{timestamp}.txt')
+        with open(labels_path, 'w') as f:
+            for label in self.class_names:
+                f.write(f"{label}\n")
+        print(f"Labels saved to: {labels_path}")
+        
+        # Save label encoder
+        encoder_path = os.path.join(self.output_dir, f'label_encoder_{timestamp}.pkl')
+        with open(encoder_path, 'wb') as f:
+            pickle.dump(self.label_encoder, f)
+        
+        # Save training metadata
+        metadata = {
+            'timestamp': timestamp,
+            'test_accuracy': float(test_accuracy),
+            'num_classes': len(self.class_names),
+            'class_names': self.class_names,
+            'total_samples': len(self.features),
+            'feature_shape': self.features.shape,
+            'model_path': model_path,
+            'tflite_path': tflite_path,
+            'labels_path': labels_path
+        }
+        
+        metadata_path = os.path.join(self.output_dir, f'training_metadata_{timestamp}.json')
+        with open(metadata_path, 'w') as f:
+            json.dump(metadata, f, indent=2)
+        print(f"Metadata saved to: {metadata_path}")
+    
+    def plot_training_history(self, history):
+        """Plot training history."""
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
+        
+        # Plot accuracy
+        ax1.plot(history.history['accuracy'], label='Training Accuracy')
+        ax1.plot(history.history['val_accuracy'], label='Validation Accuracy')
+        ax1.set_title('Model Accuracy')
+        ax1.set_xlabel('Epoch')
+        ax1.set_ylabel('Accuracy')
+        ax1.legend()
+        ax1.grid(True)
+        
+        # Plot loss
+        ax2.plot(history.history['loss'], label='Training Loss')
+        ax2.plot(history.history['val_loss'], label='Validation Loss')
+        ax2.set_title('Model Loss')
+        ax2.set_xlabel('Epoch')
+        ax2.set_ylabel('Loss')
+        ax2.legend()
+        ax2.grid(True)
+        
+        plt.tight_layout()
+        
+        # Save plot
+        plot_path = os.path.join(self.output_dir, 'training_history.png')
+        plt.savefig(plot_path, dpi=300, bbox_inches='tight')
+        print(f"Training history plot saved to: {plot_path}")
+        plt.show()
+
+def main():
+    # Configuration
+    DATASET_PATH = r"C:\Users\krishna\Downloads\archive (2)\Gesture Image Data"
+    OUTPUT_DIR = "models"
+    
+    # Training parameters - Optimized for better performance
+    MAX_SAMPLES_PER_CLASS = 500  # Increased for better generalization
+    SAMPLE_RATIO = 0.1  # Use 10% of available images if less than max
+    TEST_SIZE = 0.2
+    VALIDATION_SPLIT = 0.2
+    EPOCHS = 50  
+    BATCH_SIZE = 64  # Increased for faster training
+    
+    print("=== Sign Language Gesture Dataset Training ===")
+    print(f"Dataset path: {DATASET_PATH}")
+    print(f"Output directory: {OUTPUT_DIR}")
+    print(f"Max samples per class: {MAX_SAMPLES_PER_CLASS}")
+    print(f"Sample ratio: {SAMPLE_RATIO}")
+    
+    # Initialize trainer
+    trainer = GestureDatasetTrainer(DATASET_PATH, OUTPUT_DIR)
+    
+    # Load dataset
+    trainer.load_dataset(
+        max_samples_per_class=MAX_SAMPLES_PER_CLASS,
+        sample_ratio=SAMPLE_RATIO
+    )
+    
+    # Train model
+    model, history = trainer.train_model(
+        test_size=TEST_SIZE,
+        validation_split=VALIDATION_SPLIT,
+        epochs=EPOCHS,
+        batch_size=BATCH_SIZE
+    )
+    
+    print("\n=== Training Complete ===")
+    print("Check the 'models' directory for saved files:")
+    print("- .h5 file: Keras model")
+    print("- .tflite file: TensorFlow Lite model")
+    print("- labels.txt: Class labels")
+    print("- training_metadata.json: Training information")
+    print("- training_history.png: Training plots")
+
+if __name__ == "__main__":
+    main()

train_model.py

@@ -0,0 +1,176 @@
+import numpy as np
+import tensorflow as tf
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder
+import os
+import glob
+from utils.model_utils import create_model, get_training_callbacks, evaluate_model
+from utils.data_utils import DataProcessor
+
+class SignLanguageTrainer:
+    def __init__(self):
+        self.data_processor = DataProcessor()
+        self.label_encoder = LabelEncoder()
+        
+    def load_dataset(self, dataset_path="dataset"):
+        """Load dataset from collected data."""
+        X, y = [], []
+        labels = []
+        
+        # Get all sign directories
+        sign_dirs = [d for d in os.listdir(dataset_path) if os.path.isdir(os.path.join(dataset_path, d))]
+        
+        for sign_name in sign_dirs:
+            sign_path = os.path.join(dataset_path, sign_name)
+            sequence_file = os.path.join(sign_path, "sequences.npy")
+            
+            if os.path.exists(sequence_file):
+                sequences = np.load(sequence_file)
+                
+                for sequence in sequences:
+                    X.append(sequence)
+                    y.append(sign_name)
+                    
+                if sign_name not in labels:
+                    labels.append(sign_name)
+                    
+                print(f"Loaded {len(sequences)} sequences for {sign_name}")
+        
+        # Save labels
+        with open('models/labels.txt', 'w') as f:
+            f.write('\n'.join(labels))
+        
+        # Encode labels
+        y_encoded = self.label_encoder.fit_transform(y)
+        
+        return np.array(X), y_encoded, labels
+    
+    def prepare_data(self, X, y, test_size=0.2, val_size=0.2):
+        """Prepare data for training."""
+        # Split into train and test
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, test_size=test_size, random_state=42, stratify=y
+        )
+        
+        # Split train into train and validation
+        X_train, X_val, y_train, y_val = train_test_split(
+            X_train, y_train, test_size=val_size, random_state=42, stratify=y_train
+        )
+        
+        return X_train, X_val, X_test, y_train, y_val, y_test
+    
+    def train_model(self, X_train, y_train, X_val, y_val, 
+                   num_classes, epochs=50, batch_size=32):
+        """Train the sign language model."""
+        
+        # Get input shape
+        sequence_length, num_features = X_train.shape[1], X_train.shape[2]
+        
+        # Create model
+        model = create_model(num_classes, sequence_length, num_features)
+        
+        print("Model Summary:")
+        model.summary()
+        
+        # Get callbacks
+        callbacks = get_training_callbacks()
+        
+        # Train model
+        history = model.fit(
+            X_train, y_train,
+            validation_data=(X_val, y_val),
+            epochs=epochs,
+            batch_size=batch_size,
+            callbacks=callbacks,
+            verbose=1
+        )
+        
+        return model, history
+    
+    def save_model(self, model, model_name="sign_language_model"):
+        """Save the trained model."""
+        # Save Keras model
+        model.save(f'models/{model_name}.h5')
+        
+        # Convert to TFLite
+        converter = tf.lite.TFLiteConverter.from_keras_model(model)
+        converter.optimizations = [tf.lite.Optimize.DEFAULT]
+        
+        # Quantization for smaller model size
+        def representative_dataset():
+            for _ in range(100):
+                yield [np.random.random((1, 30, 126)).astype(np.float32)]
+        
+        converter.representative_dataset = representative_dataset
+        converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
+        converter.inference_input_type = tf.uint8
+        converter.inference_output_type = tf.uint8
+        
+        try:
+            tflite_model = converter.convert()
+            with open('models/model.tflite', 'wb') as f:
+                f.write(tflite_model)
+            print("Model converted to TFLite successfully!")
+        except Exception as e:
+            print(f"TFLite conversion failed: {e}")
+            # Fallback to float32 model
+            converter = tf.lite.TFLiteConverter.from_keras_model(model)
+            converter.optimizations = [tf.lite.Optimize.DEFAULT]
+            tflite_model = converter.convert()
+            with open('models/model.tflite', 'wb') as f:
+                f.write(tflite_model)
+            print("Model converted to TFLite (float32) successfully!")
+
+def main():
+    trainer = SignLanguageTrainer()
+    
+    print("Sign Language Model Training")
+    print("=" * 40)
+    
+    # Check if dataset exists
+    if not os.path.exists("dataset"):
+        print("Dataset not found! Please run data_collection.py first.")
+        return
+    
+    # Load dataset
+    print("Loading dataset...")
+    X, y, labels = trainer.load_dataset()
+    
+    if len(X) == 0:
+        print("No data found! Please collect data first using data_collection.py")
+        return
+    
+    print(f"Loaded {len(X)} sequences for {len(labels)} signs")
+    print(f"Signs: {labels}")
+    
+    # Prepare data
+    print("Preparing data...")
+    X_train, X_val, X_test, y_train, y_val, y_test = trainer.prepare_data(X, y)
+    
+    print(f"Training set: {len(X_train)} sequences")
+    print(f"Validation set: {len(X_val)} sequences")
+    print(f"Test set: {len(X_test)} sequences")
+    
+    # Train model
+    print("Training model...")
+    model, history = trainer.train_model(
+        X_train, y_train, X_val, y_val,
+        num_classes=len(labels),
+        epochs=50,
+        batch_size=32
+    )
+    
+    # Evaluate model
+    print("Evaluating model...")
+    results = evaluate_model(model, X_test, y_test)
+    print(f"Test Accuracy: {results['accuracy']:.4f}")
+    
+    # Save model
+    print("Saving model...")
+    trainer.save_model(model)
+    
+    print("Training completed successfully!")
+    print("You can now run the main application: streamlit run app.py")
+
+if __name__ == "__main__":
+    main()

train_platform.py

@@ -0,0 +1,70 @@
+import streamlit as st
+import cv2
+import numpy as np
+import os
+import tensorflow as tf
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import LSTM, Dense, Dropout
+from tensorflow.keras.callbacks import ModelCheckpoint, TensorBoard
+import mediapipe as mp
+from utils.data_utils import process_video, extract_landmarks
+from utils.model_utils import create_model, convert_to_tflite
+
+def main():
+    st.title("Sign Language Model Training Platform")
+    
+    # Sidebar for training configuration
+    st.sidebar.header("Training Configuration")
+    
+    # Model parameters
+    num_classes = st.sidebar.number_input("Number of Sign Classes", min_value=2, value=10)
+    epochs = st.sidebar.number_input("Training Epochs", min_value=1, value=50)
+    batch_size = st.sidebar.number_input("Batch Size", min_value=1, value=32)
+    
+    # Dataset upload
+    st.header("Dataset Upload")
+    dataset_path = st.file_uploader("Upload Dataset (ZIP file containing video folders)", type=['zip'])
+    
+    if dataset_path:
+        # Create progress bar
+        progress_bar = st.progress(0)
+        status_text = st.empty()
+        
+        # Extract dataset
+        status_text.text("Extracting dataset...")
+        # TODO: Add dataset extraction logic
+        
+        # Process videos and extract landmarks
+        status_text.text("Processing videos and extracting landmarks...")
+        X_train, y_train = [], []
+        # TODO: Add video processing logic using MediaPipe
+        
+        # Create and train model
+        if st.button("Start Training"):
+            status_text.text("Creating model...")
+            model = create_model(num_classes)
+            
+            status_text.text("Training model...")
+            history = model.fit(
+                X_train, y_train,
+                epochs=epochs,
+                batch_size=batch_size,
+                validation_split=0.2,
+                callbacks=[
+                    ModelCheckpoint('models/best_model.h5', save_best_only=True),
+                    TensorBoard(log_dir='logs')
+                ]
+            )
+            
+            # Convert to TFLite
+            status_text.text("Converting model to TFLite...")
+            convert_to_tflite(model, 'models/model.tflite')
+            
+            st.success("Training completed! Model saved as 'model.tflite'")
+            
+            # Display training metrics
+            st.header("Training Results")
+            st.line_chart(history.history)
+
+if __name__ == "__main__":
+    main()

train_simple.py

@@ -0,0 +1,176 @@
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Dense, Dropout, BatchNormalization
+import cv2
+import os
+import glob
+from sign_utils import MediaPipeLandmarksModel
+
+def load_and_process_dataset():
+    """Load digit images and extract landmarks."""
+    landmark_model = MediaPipeLandmarksModel()
+    
+    X_landmarks = []
+    y = []
+    
+    print("Loading and processing images...")
+    
+    # Process each digit folder
+    for digit in range(10):
+        digit_path = os.path.join("dataset", str(digit))
+        if not os.path.exists(digit_path):
+            continue
+            
+        image_files = glob.glob(os.path.join(digit_path, "*.JPG"))
+        print(f"Processing {len(image_files)} images for digit {digit}")
+        
+        count = 0
+        for img_file in image_files:
+            # Load image
+            img = cv2.imread(img_file)
+            if img is None:
+                continue
+                
+            # Extract landmarks
+            landmarks = landmark_model.predict_landmarks(img)
+            
+            if landmarks is not None:
+                # Normalize landmarks
+                landmarks_normalized = landmark_model.normalize_landmarks(landmarks)
+                
+                X_landmarks.append(landmarks_normalized)
+                y.append(digit)
+                count += 1
+                
+                # Limit to 100 images per digit for faster training
+                if count >= 100:
+                    break
+        
+        print(f"Successfully processed {count} images for digit {digit}")
+    
+    print(f"Total processed: {len(X_landmarks)} images with landmarks")
+    
+    # Check if we have any data
+    if len(X_landmarks) == 0:
+        return np.array([]), np.array([])
+    
+    # Ensure all landmark arrays have the same shape
+    landmark_shape = X_landmarks[0].shape[0]
+    filtered_landmarks = []
+    filtered_y = []
+    
+    for i, landmarks in enumerate(X_landmarks):
+        if landmarks.shape[0] == landmark_shape:
+            filtered_landmarks.append(landmarks)
+            filtered_y.append(y[i])
+    
+    print(f"After filtering: {len(filtered_landmarks)} valid samples")
+    
+    return np.array(filtered_landmarks), np.array(filtered_y)
+
+def create_simple_model(num_classes=10):
+    """Create a simple neural network for landmark classification."""
+    model = Sequential([
+        Dense(128, activation='relu', input_shape=(63,)),  # 21 landmarks * 3 coordinates
+        BatchNormalization(),
+        Dropout(0.3),
+        
+        Dense(64, activation='relu'),
+        BatchNormalization(),
+        Dropout(0.3),
+        
+        Dense(32, activation='relu'),
+        Dropout(0.2),
+        
+        Dense(num_classes, activation='softmax')
+    ])
+    
+    model.compile(
+        optimizer='adam',
+        loss='sparse_categorical_crossentropy',
+        metrics=['accuracy']
+    )
+    
+    return model
+
+def main():
+    print("Simple Sign Language Digits Training")
+    print("=" * 40)
+    
+    # Load dataset
+    X, y = load_and_process_dataset()
+    
+    if len(X) == 0:
+        print("No valid images found with hand landmarks!")
+        return
+    
+    # Split data (simple split without sklearn)
+    n_samples = len(X)
+    n_train = int(0.8 * n_samples)
+    
+    # Shuffle data
+    indices = np.random.permutation(n_samples)
+    train_indices = indices[:n_train]
+    test_indices = indices[n_train:]
+    
+    X_train, X_test = X[train_indices], X[test_indices]
+    y_train, y_test = y[train_indices], y[test_indices]
+    
+    print(f"Training set: {len(X_train)} samples")
+    print(f"Test set: {len(X_test)} samples")
+    
+    # Create model
+    model = create_simple_model()
+    print("\nModel Summary:")
+    model.summary()
+    
+    # Train model
+    print("\nTraining model...")
+    history = model.fit(
+        X_train, y_train,
+        validation_data=(X_test, y_test),
+        epochs=30,
+        batch_size=32,
+        verbose=1
+    )
+    
+    # Evaluate model
+    print("\nEvaluating model...")
+    test_loss, test_accuracy = model.evaluate(X_test, y_test, verbose=0)
+    print(f"Test Accuracy: {test_accuracy:.4f}")
+    
+    # Save model
+    print("\nSaving model...")
+    
+    # Create models directory if it doesn't exist
+    os.makedirs('models', exist_ok=True)
+    
+    # Save Keras model
+    model.save('models/digit_model.h5')
+    
+    # Convert to TFLite
+    try:
+        converter = tf.lite.TFLiteConverter.from_keras_model(model)
+        converter.optimizations = [tf.lite.Optimize.DEFAULT]
+        
+        tflite_model = converter.convert()
+        
+        with open('models/model.tflite', 'wb') as f:
+            f.write(tflite_model)
+            
+        print("Model converted to TFLite successfully!")
+        
+    except Exception as e:
+        print(f"TFLite conversion failed: {e}")
+    
+    # Save labels
+    labels = [str(i) for i in range(10)]
+    with open('models/labels.txt', 'w') as f:
+        f.write('\n'.join(labels))
+    
+    print("Training completed successfully!")
+    print("You can now run the main application: streamlit run app.py")
+
+if __name__ == "__main__":
+    main()