Driver Drowsiness Detection Using Pretrained Model

Drowsy driving is one of the major causes of road accidents around the world. Even a momentary lapse in driver attention can lead to fatal consequences. That’s why detecting driver fatigue early can be life-saving. In this project, we will build a driver drowsiness detection system using deep learning techniques.

We will use the Driver Drowsiness Dataset (DDD) sourced from Kaggle. It contains 41,000+ preprocessed facial images of drivers categorized into two classes:

• Drowsy
• Non Drowsy

Instead of training a CNN from scratch, we will apply transfer learning using a pretrained MobileNetV2 model. This approach helps us leverage powerful image features learned from large-scale datasets and adapt them to our drowsiness detection task.

Check our Top 25+ Essential Data Science Projects GitHub to Explore in 2025 blog for more project ideas like this one.  

What Should You Know Beforehand?

It is better to have at least some background in:

• Python Programming - functions, loops, and libraries.
• Image Classification - how images are labeled and classified using deep learning
• Convolutional Neural Networks (CNNs) - how CNNs use filters and layers to detect features in images.
• Transfer Learning - how pretrained models can be adapted to new classification tasks
• Keras and TensorFlow - to load pretrained models (like MobileNetV2) and
• Google Colab - how to upload datasets, run code cells, and use the GPU is beneficial.
• File Paths & Image Formats - how image datasets are structured and accessed 

Technologies and Libraries Used

For this project, the following tools and libraries will be used:

Time Taken and Difficulty Level

On average, it will take about 4 to 5 hours to complete. Duration may increase/decrease depending on your familiarity with - Python, CNNs, image classification, & TensorFlow/Keras. It’s best for beginners to intermediate level.

How to Build a Driver Drowsiness Detection Model

Let’s start building the project from scratch. We will start by:

• Downloading the Driver Drowsiness Dataset (DDD) using kagglehub
• Exploring and preprocessing the dataset, including:
  • Resizing images to 224×224
  • Normalizing pixel values
  • Splitting the data into training and validation sets
• Loading the MobileNetV2 pretrained model and modifying it for binary classification
• Training the model on labeled facial images (Drowsy vs Non-Drowsy)
• Evaluating its performance using - accuracy, loss curves, and confusion matrix
• Visualizing predictions to test the model on unseen data
• Saving the model for future use 

Without any further delay, let’s start!

Step 1: Download the Dataset Using kagglehub

First, we will be downloading the Driver Drowsiness Dataset (DDD) from Kaggle. Use the code given below to do so:

# Install kagglehub
!pip install kagglehub --quiet

# Import kagglehub
import kagglehub

# Download the dataset
path = kagglehub.dataset_download("ismailnasri20/driver-drowsiness-dataset-ddd")

print("Path to dataset files:", path)

Output:

Downloading from https://www.kaggle.com/api/v1/datasets/download/ismailnasri20/driver-drowsiness-dataset-ddd?dataset_version_number=1...

100%|██████████| 2.58G/2.58G [01:06<00:00, 41.5MB/s]Extracting files...

Path to dataset files: /root/.cache/kagglehub/datasets/ismailnasri20/driver-drowsiness-dataset-ddd/versions/1

The output shows you the path where the dataset has been downloaded and extracted.

Step 2: Explore and Preprocess the Dataset

In this step, we will:

• Load all images directly from the folder structure (Drowsy and Non-Drowsy)
• Resize them to 224×224, which is the required input size for MobileNetV2
• Normalize pixel values by scaling them between 0 and 1
• Automatically split the dataset into training (80%) and validation (20%) sets
• Automatically assign labels based on folder names
• Drowsy - 1
• Non Drowsy - 0

Use the code given below to accomplish all this:

from tensorflow.keras.preprocessing.image import ImageDataGenerator
import os

# Set the dataset path
dataset_path = "/kaggle/input/driver-drowsiness-dataset-ddd/Driver Drowsiness Dataset (DDD)"

# Image data generators with validation split
train_datagen = ImageDataGenerator(
    rescale=1./255,
    validation_split=0.2  # 80% training, 20% validation
)

# Load training images
train_generator = train_datagen.flow_from_directory(
    dataset_path,
    target_size=(224, 224),
    batch_size=32,
    class_mode='binary',
    subset='training',
    shuffle=True
)

# Load validation images
val_generator = train_datagen.flow_from_directory(
    dataset_path,
    target_size=(224, 224),
    batch_size=32,
    class_mode='binary',
    subset='validation',
    shuffle=False
)

Output:

Found 33435 images belonging to 2 classes.
Found 8358 images belonging to 2 classes.

Step 3: Build the Model Using Transfer Learning

In this step, we will build our driver drowsiness detection model using MobileNetV2. Instead of training a CNN from scratch, we use transfer learning.  Here's what we would be doing in this step:

• Load the MobileNetV2 model with ImageNet weights. Will exclude its top layers.
• Freeze its base (convolutional layers). This will stop them from updating during training.
• Add a GlobalAveragePooling2D layer. Doing so will help flatten the output feature maps.
• Add Dropout layers to reduce overfitting.
• Add a Dense layer with ReLU activation, followed by a final Dense layer with sigmoid activation for binary classification:
  • 0 - Non Drowsy
  • 1 - Drowsy
• Compile the model using binary crossentropy loss and the Adam optimizer.

Use the below-mentioned code to achieve all this:

from tensorflow.keras.applications import MobileNetV2
from tensorflow.keras.models import Model
from tensorflow.keras.layers import GlobalAveragePooling2D, Dropout, Dense
from tensorflow.keras.optimizers import Adam

# Load MobileNetV2 base model (excluding top classifier layers)
base_model = MobileNetV2(
    weights='imagenet',
    include_top=False,
    input_shape=(224, 224, 3)
)

# Freeze the base model (we don't train its layers)
base_model.trainable = False

# Add custom layers on top
x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dropout(0.3)(x)
x = Dense(128, activation='relu')(x)
x = Dropout(0.3)(x)
output = Dense(1, activation='sigmoid')(x)

# Final model
model = Model(inputs=base_model.input, outputs=output)

# Compile the model
model.compile(
    optimizer=Adam(learning_rate=0.0001),
    loss='binary_crossentropy',
    metrics=['accuracy']
)

# Summary of the model
model.summary()

Output:

Model: "functional_1"

Total params: 2,422,081 (9.24 MB)
Trainable params: 164,097 (641.00 KB)
Non-trainable params: 2,257,984 (8.61 MB)

Step 4: Train the Driver Drowsiness Detection Model

The MobileNetV2 model is ready. Now we will: 

• Feed the images into the model in batches.
• Use 10 epochs (adjustable).
• Monitor both training and validation accuracy.
• Save training history for later evaluation and plotting.

Here is the code to do so:

# Train the model
history = model.fit(
    train_generator,
    epochs=10,
    validation_data=val_generator
)

Output:

usr/local/lib/python3.11/dist-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.

  self._warn_if_super_not_called()

Epoch 1/10

1045/1045 ━━━━━━━━━━━━━━━━━━━━ 1883s 2s/step - accuracy: 0.8021 - loss: 0.4217 - val_accuracy: 0.5983 - val_loss: 0.9446

Epoch 2/10

1045/1045 ━━━━━━━━━━━━━━━━━━━━ 1878s 2s/step - accuracy: 0.9733 - loss: 0.0939 - val_accuracy: 0.6145 - val_loss: 1.0695

Epoch 3/10

1045/1045 ━━━━━━━━━━━━━━━━━━━━ 1886s 2s/step - accuracy: 0.9879 - loss: 0.0482 - val_accuracy: 0.6338 - val_loss: 1.2522

Epoch 4/10

1045/1045 ━━━━━━━━━━━━━━━━━━━━ 1951s 2s/step - accuracy: 0.9922 - loss: 0.0315 - val_accuracy: 0.6071 - val_loss: 1.3467

Epoch 5/10

1045/1045 ━━━━━━━━━━━━━━━━━━━━ 1868s 2s/step - accuracy: 0.9940 - loss: 0.0223 - val_accuracy: 0.6102 - val_loss: 1.5587

Epoch 6/10

1045/1045 ━━━━━━━━━━━━━━━━━━━━ 1870s 2s/step - accuracy: 0.9953 - loss: 0.0173 - val_accuracy: 0.5946 - val_loss: 1.6377

Epoch 7/10

1045/1045 ━━━━━━━━━━━━━━━━━━━━ 1882s 2s/step - accuracy: 0.9966 - loss: 0.0131 - val_accuracy: 0.5836 - val_loss: 1.6422

Epoch 8/10

1045/1045 ━━━━━━━━━━━━━━━━━━━━ 1868s 2s/step - accuracy: 0.9977 - loss: 0.0095 - val_accuracy: 0.5844 - val_loss: 1.5191

Epoch 9/10

1045/1045 ━━━━━━━━━━━━━━━━━━━━ 1859s 2s/step - accuracy: 0.9974 - loss: 0.0088 - val_accuracy: 0.5873 - val_loss: 1.4839

Epoch 10/10

1045/1045 ━━━━━━━━━━━━━━━━━━━━ 1868s 2s/step - accuracy: 0.9987 - loss: 0.0059 - val_accuracy: 0.5518 - val_loss: 1.5908

What does the output mean?

The output tells us that - 

• The training accuracy consistently increased and reached ~99.9%.
• The validation accuracy peaked at ~63.4% (Epoch 3) and declined afterwards.
• The validation loss increased. Indicating overfitting. The model is memorizing training data but not generalizing well to unseen data.

Here;s the code to visualize accuracy and loss:

import matplotlib.pyplot as plt

# Plot accuracy
plt.plot(history.history['accuracy'], label='Train Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()
plt.title('Model Accuracy over Epochs')
plt.show()

# Plot loss
plt.plot(history.history['loss'], label='Train Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.title('Model Loss over Epochs')
plt.show()

Output:

Step 5: Save the Trained Model

Now, let’s save the dataset so that we can reuse it later. Either for real-time predictions or deployment, without retraining.

Here’s the code to do so:

# Save the model to a .h5 file
model.save('drowsiness_detection_model.h5')

print("Model saved successfully!")

Output:

Model saved successfully!

Conclusion

Training Accuracy (Last Epoch): 99.87%
Validation Accuracy (Last Epoch): 55.18%

The training accuracy is very high. But the validation accuracy is much lower and started decreasing after epoch 2. This suggests overfitting. The model performs well on the training data but struggles to generalize to unseen validation data.

Unlock the power of data with our popular Data Science courses, designed to make you proficient in analytics, machine learning, and big data!

Explore our Popular Data Science Courses

Elevate your career by learning essential Data Science skills such as statistical modeling, big data processing, predictive analytics, and SQL!

Top Data Science Skills to Learn

Stay informed and inspired with our popular Data Science articles, offering expert insights, trends, and practical tips for aspiring data professionals!

Read our popular Data Science Articles

Colab Link:
https://colab.research.google.com/drive/1dqhd8ICCtQ_x_COhV1xwMLBVC_fdAHjC?usp=sharing