Upload folder using huggingface_hub

.gitattributes

@@ -1,35 +1,4 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+models/model.pth filter=lfs diff=lfs merge=lfs -text
+assets/1.png filter=lfs diff=lfs merge=lfs -text
+assets/2.png filter=lfs diff=lfs merge=lfs -text
+assets/drowsy_demo.mp4 filter=lfs diff=lfs merge=lfs -text

LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Eslam Tarek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,19 +1,102 @@
----
-title: DrowSeeAi
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Is a deep learning solution for detecting  driver drowsiness
----
-
-# 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).
+# Drowsy Detector
+
+## About the Project
+
+Drowsy Detector is an end-to-end deep learning solution for detecting driver drowsiness from facial images. The project leverages transfer learning with a pre-trained ResNet50 model, custom data preprocessing, and a user-friendly Streamlit web interface for real-time predictions. It is designed to help improve road safety by providing an automated tool to identify signs of driver fatigue. The repository includes all code, a training and evaluation notebook, and demo media for easy testing and demonstration.
+
+## About the Dataset
+
+This project is built upon the [Drowsiness Prediction Dataset](https://www.kaggle.com/datasets/rakibuleceruet/drowsiness-prediction-dataset) from Kaggle. The dataset contains thousands of labeled facial images of drivers, divided into two categories: "Fatigue Subjects" (drowsy) and "Active Subjects" (alert). Images are collected under various lighting conditions, backgrounds, and driver poses, making the dataset robust and suitable for real-world drowsiness detection. The dataset is organized into folders by class, and each image is labeled for supervised learning. This diversity and structure allow for effective training and evaluation of deep learning models for driver monitoring systems.
+
+## Notebook Summary
+
+The notebook provides a comprehensive, step-by-step workflow for building a deep learning-based driver drowsiness detection system:
+- **Data Exploration:** Visualizes the dataset structure, displays sample images from each class, and analyzes class distribution to ensure balanced training.
+- **Data Preparation:** Implements a custom PyTorch dataset and DataLoader, applies image preprocessing (resizing, normalization), and uses data augmentation to improve model generalization.
+- **Model Architecture:** Utilizes transfer learning with a pre-trained ResNet50 model, adapting its final layers for binary classification and fine-tuning the last few layers.
+- **Training Loop:** Sets up the training process with early stopping to prevent overfitting, tracks loss and accuracy metrics, and saves the best-performing model.
+- **Evaluation:** Assesses model performance on validation and test sets, visualizes results with confusion matrices, and plots training/validation loss curves for diagnostics.
+
+## Model Results
+
+### Preprocessing
+- **Image Resizing:** All images are resized to 224x224 pixels to match ResNet50's input requirements.
+- **Normalization:** Images are converted to tensors and normalized to standardize input distributions.
+- **Augmentation:** The training set uses augmentations such as random flips and rotations to improve generalization and robustness.
+
+### Training
+- **Transfer Learning:** The model uses a pre-trained ResNet50 backbone. All layers are frozen except the last three, which are fine-tuned on the drowsiness dataset.
+- **Custom Classifier Head:** The final fully connected layer is replaced with a sequence of linear, ReLU, and dropout layers, ending with a two-class output.
+- **Loss Function:** Cross-entropy loss is used for binary classification.
+- **Optimizer:** Adam optimizer is employed with a learning rate of 1e-4.
+- **Early Stopping:** Training is monitored on the validation set and stops early if validation loss does not improve for several epochs.
+
+### Evaluation
+- **Accuracy:** The model achieves up to 96% accuracy on the test set, demonstrating strong performance in distinguishing between drowsy and alert drivers.
+- **Confusion Matrix:** The confusion matrix shows high true positive and true negative rates, with minimal misclassifications.
+- **Loss Curves:** Training and validation loss curves are plotted to visualize convergence and detect any signs of overfitting or underfitting.
+
+## How to Install
+
+1. **Clone the repository:**
+   ```bash
+   git clone <repo-url>
+   cd DrowsyDetector
+   ```
+2. **Create and activate a virtual environment:**
+   ```bash
+   python -m venv venv
+   # On Windows:
+   venv\Scripts\activate
+   # On macOS/Linux:
+   source venv/bin/activate
+   ```
+3. **Install dependencies:**
+   ```bash
+   pip install -r requirements.txt
+   ```
+   This will install PyTorch, torchvision, Streamlit, Pillow, NumPy, and other dependencies.
+
+4. **Download the dataset:**
+   - Download the dataset from [Kaggle](https://www.kaggle.com/datasets/rakibuleceruet/drowsiness-prediction-dataset).
+   - Extract it and place it in the appropriate directory as referenced in the notebook.
+
+## How to Use the Software
+
+1. **Demo Application:**
+   - The project includes a Streamlit-based web application for real-time drowsiness detection.
+   - To launch the demo, run:
+     ```bash
+     streamlit run app.py
+     ```
+   - The app allows you to upload an image of a driver and predicts whether the driver is drowsy or alert.
+
+2. **Using Demo Media:**
+   - Simply upload any image from the `assets` directory via the web interface and click predict button.
+   
+   ## [demo-video](assets/drowsy_demo.mp4)
+
+   - **Demo Images:**
+       ![demo1](assets/1.png)
+       ![demo2](assets/2.png)
+       
+
+3. **Notebook Usage:**
+   - Open the notebook in Jupyter or VS Code and run all cells to reproduce the training and evaluation process.
+   - You can modify paths and parameters as needed to experiment with different settings.
+
+## Technologies Used
+
+- **PyTorch:** The primary deep learning framework used for model definition, training, and inference. PyTorch provides flexibility for custom dataset handling and model customization.
+- **Torchvision:** Supplies pre-trained models (ResNet50), image transforms, and utility functions for computer vision tasks.
+- **Pandas & NumPy:** Used for data manipulation, analysis, and efficient numerical computations.
+- **Matplotlib:** For visualizing images, loss curves, and confusion matrices during exploration and evaluation.
+- **scikit-learn:** Provides metrics such as confusion matrix and accuracy score for model evaluation.
+- **Streamlit:** Enables rapid development of interactive web applications for model deployment and demonstration.
+- **Pillow:** Used for image loading and processing within the custom dataset class.
+
+These technologies together enable efficient data handling, model training, evaluation, and deployment in a user-friendly interface.
+
+## License
+
+This project is licensed under the MIT License. You are free to use, modify, and distribute this software for personal or commercial purposes, provided that you include the original copyright and license.

app.py

@@ -0,0 +1,50 @@
+import streamlit as st
+from ui import upload_image
+from utils import load_model, predict
+
+# -------------------------------
+# 1) Set the path to your saved model file:
+#    Change this to the correct path where you saved your .pth/.pt
+# -------------------------------
+MODEL_PATH = "./models/model.pth"  # ← replace with your actual path
+
+# -------------------------------
+# 2) Cache the model load so it isn't reloaded on every run:
+# -------------------------------
+@st.cache_resource
+def get_model():
+    """
+    Load and cache the PyTorch model so that Streamlit does not reload it on every interaction.
+    """
+    model = load_model(MODEL_PATH)
+    return model
+
+# -------------------------------
+# 3) Main Streamlit UI
+# -------------------------------
+def main():
+
+    # apply the styles.css here
+    with open("./styles.css") as f:
+        st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
+
+    # Load the model once
+    model = get_model()
+
+    # Let the user upload an image via ui.upload_image()
+    image = upload_image()
+
+    if image is not None:
+        # Only show the “Predict” button if an image has been uploaded
+        if st.button("Predict Drowsiness"):
+            # Run inference
+            label = predict(model, image)
+
+            # Display results
+            if label == 1:
+                st.error("🚨 Drowsiness Detected (1)")
+            else:
+                st.success("✅ Not Drowsy (0)")
+
+if __name__ == "__main__":
+    main()

assets/drowsy_demo.mp4

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

models/model.pth

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

requirements.txt

@@ -1,3 +1,5 @@
-altair
-pandas
-streamlit
+torch==2.2.2
+torchvision==0.17.2
+streamlit==1.34.0
+pillow==10.3.0
+numpy==1.26.4

styles.css

@@ -0,0 +1,5 @@
+/* Hide Streamlit default UI elements */
+#MainMenu, header, footer {
+    visibility: hidden;
+}
+

ui.py

@@ -0,0 +1,25 @@
+import streamlit as st
+from PIL import Image
+
+def upload_image():
+    """
+    Display a Streamlit file uploader. If an image is uploaded, show a preview and return it.
+
+    Returns:
+        PIL.Image.Image or None: The uploaded image as a PIL Image (RGB), or None if nothing uploaded.
+    """
+    st.title("🛏️ Drowsiness Detection App")
+    st.write("Upload a face image and the model will predict whether the person is drowsy (1) or not (0).")
+
+    uploaded_file = st.file_uploader(
+        label="Choose an image file (JPG/PNG)", 
+        type=["jpg", "jpeg", "png"]
+    )
+
+    if uploaded_file is not None:
+        # Convert the uploaded file to a PIL image
+        image = Image.open(uploaded_file).convert("RGB")
+        st.image(image, caption="Uploaded Image", use_column_width=True)
+        return image
+
+    return None

utils.py

@@ -0,0 +1,63 @@
+import torch
+import torchvision.transforms as transforms
+from PIL import Image
+
+
+val_test_transform = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+  
+])
+
+
+
+def load_model(model_path: str):
+    """
+    Load a trained PyTorch model from disk (saved via torch.save(model, path))
+    and set it to eval() mode.
+
+    Args:
+        model_path (str): Path to the .pth or .pt file containing your trained model.
+
+    Returns:
+        torch.nn.Module: The loaded model in eval mode (on CPU).
+    """
+
+
+    model = torch.load(
+        model_path,
+        map_location=torch.device("cpu"),
+        weights_only=False,   # Allow loading the entire saved model object
+    )
+    model.eval()
+    return model
+
+
+
+def predict(model: torch.nn.Module, image: Image.Image) -> int:
+    """
+    Given a loaded model and a PIL.Image, return 0 (not drowsy) or 1 (drowsy).
+
+    Args:
+        model (torch.nn.Module): Your trained PyTorch model in eval() mode.
+        image (PIL.Image.Image): A PIL image (RGB) of a human face.
+
+    Returns:
+        int: 0 if non-drowsy, 1 if drowsy.
+    """
+    # Apply the validation/test transform:
+    image_tensor = val_test_transform(image)        # [3, 224, 224]
+    image_tensor = image_tensor.unsqueeze(0)        # [1, 3, 224, 224]
+
+    with torch.no_grad():
+        outputs = model(image_tensor)               # assume shape [1, 2] or [1, 1]
+        # If your model outputs two logits (for classes 0 vs 1):
+        if outputs.dim() == 2 and outputs.shape[1] == 2:
+            # e.g. softmax‐based two‐class output
+            _, predicted = torch.max(outputs, dim=1)
+            return int(predicted.item())
+        else:
+            # If your model outputs a single logit (e.g. using `nn.Linear(…) -> [1, 1]`):
+            # apply a sigmoid threshold of 0.5
+            prob = torch.sigmoid(outputs).item()
+            return 1 if prob >= 0.5 else 0