Dog Breed Classifier Using TensorFlow (MobileNetV2)

In this tutorial, we will guide you through the process of creating a dog breed classifier using Tensorflow, powered by MobileNetV2. Tensorflow is a versatile deep learning library that allows us to leverage pre-trained models like MobileNetV2, which is known for its efficiency and accuracy in image classification tasks.

By the end of this tutorial, you will have a fully functional classifier that can accurately predict dog breeds from a given image. The steps involved include loading the pre-trained model, preparing the dataset, training the classifier, and evaluating its performance.

Prerequisites

Before we begin, make sure you have the following:

• Basic knowledge of Python.
• A working installation of TensorFlow.
• A dataset of dog images, categorized by breed (you can use this DATASET).

Step 1: Importing the Necessary Libraries

We start by importing all the essential libraries that will be used throughout the project. Here's a breakdown of each import:

Step 2: Loading and Exploring the Dataset

Before we train the model, we need to load and explore the dataset to ensure that it's structured correctly. In this case, we are working with a dataset of dog images that is divided into different folders, where each folder corresponds to a dog breed.

Step 3: Defining Dataset Directories and Visualization

In this step, we define the paths to our training, validation, and test datasets. These directories contain the images that will be used to train and evaluate the dog breed classifier.

• TRAIN_DIR: This is the directory path where the training images are stored. These images will be used to train the model to classify different dog breeds.
• VAL_DIR: This path points to the validation dataset, which will be used during the training process to evaluate the model's performance on unseen data after each epoch. This helps in preventing overfitting and in tuning hyperparameters.
• TEST_DIR: The test directory contains images that will be used to test the model's performance after the training is complete. It serves as the final evaluation to measure how well the model generalizes to completely unseen data.

To get a better understanding of our dataset, we can visualize some sample images from the training set. This step helps us verify that the images are correctly labeled and gives us insight into the diversity of breeds in our dataset.

Explanation:

1. Importing Libraries: We import matplotlib.pyplot for plotting and Image from the PIL library for opening and manipulating images.
2. Listing Training Dogs: train_dogs = os.listdir(TRAIN_DIR) retrieves the names of all folders (each representing a dog breed) within the training directory.
3. Creating Subplots: fig, axes = plt.subplots(nrows=2, ncols=5, figsize=(15, 7)) sets up a grid of subplots (2 rows and 5 columns) to display 10 images. The figsize parameter adjusts the overall size of the figure.
4. Displaying Images: The for loop iterates through the axes of the subplots. For each subplot, it constructs the directory path to the images of the respective dog breed and displays the first image using ax.imshow(). ax.set_title(train_dogs[i]) sets the title of each subplot to the corresponding dog breed name.
5. Final Touches: plt.tight_layout() optimizes the layout of the plots to avoid overlaps. plt.show() renders the plots on the screen.

Step 5: Data Preprocessing and Augmentation

In this step, we set up data generators for our training, validation, and test datasets. Data augmentation helps improve the robustness of our model by artificially increasing the size of the training dataset and introducing variability in the training data.

Explanation:

1. ImageDataGenerator for Training:
   • train_data_gen = ImageDataGenerator(...) initializes the ImageDataGenerator for training images with several augmentation parameters:
   • horizontal_flip=True: Randomly flip images horizontally. rotation_range=20: Randomly rotate images in the range of 20 degrees. width_shift_range=0.1: Randomly shift images horizontally by up to 10% of the image width.
   • height_shift_range=0.1: Randomly shift images vertically by up to 10% of the image height.
   • zoom_range=0.2: Randomly zoom in on images by up to 20%.
2. Creating the Training Data Generator:
   • train_generator = train_data_gen.flow_from_directory(...)creates the training data generator that will read images from the TRAIN_DIR.
   • target_size=(224, 224): Resizes all images to 224x224 pixels, which is the input size expected by MobileNetV2.
   • color_mode='rgb': Specifies that the images should be read in RGB color mode.
   • batch_size=32: Specifies the number of images to be yielded from the generator per batch.
   • class_mode='categorical': Indicates that the labels will be one-hot encoded (suitable for multi-class classification).
   • shuffle=True: Randomly shuffles the training data for each epoch.
3. Validation Data Generator:
   • val_data_gen = ImageDataGenerator() initializes a generator for the validation set without any augmentation (to maintain the integrity of validation data).
   • val_generator = val_data_gen.flow_from_directory(...) sets up the validation data generator similarly to the training generator.
4. Test Data Generator:
   • The same procedure is followed for the test dataset using test_generator. Like the validation generator, it does not include augmentation.

Step 6: Mapping Class Indices to Class Labels

In this step, we extract the class indices from the training generator and create a mapping from the indices to the corresponding dog breed names. This mapping will help us understand which index corresponds to which dog breed when making predictions.

Step 7: Building the MobileNetV2 Model

In this step, we define the architecture of our dog breed classifier using the MobileNetV2 model. This model is efficient for image classification tasks, especially with limited computational resources.

Explanation:

1. Preprocessing Layer:
   • before_mobilenet : This sequential model includes an input layer that specifies the shape of the input images (224x224 pixels with 3 color channels for RGB).
   • Lambda(preprocess_input): This layer applies the preprocess_input function from MobileNetV2, which normalizes the image data to be compatible with the MobileNetV2 model's expectations.
2. MobileNetV2 Base Model:
   • mobilenet = MobileNetV2(input_shape=(224, 224, 3), include_top=False): This line initializes the MobileNetV2 model without the top classification layer (hence include_top=False). This allows us to use the pre-trained model as a feature extractor for our specific classification task.
3. Post-processing Layers:
   • after_mobilenet: This sequential model adds layers after the MobileNetV2 base:
   • GlobalAveragePooling2D(): This layer reduces the spatial dimensions of the output from the MobileNetV2 model by averaging the feature maps, resulting in a 1D tensor that can be easily processed.
   • Dropout(0.2): This layer randomly drops 20% of the neurons during training to help prevent overfitting.
   • Dense(70, activation='softmax'): This fully connected layer outputs the final predictions, where 70 corresponds to the number of dog breeds (classes), and softmax activation ensures that the output values represent probabilities that sum to 1.
4. Combining the Models:
   • model = Sequential([before_mobilenet, mobilenet, after_mobilenet]): This line combines all the layers into a single sequential model that can be trained.

Step 8: Compiling the Model and Building it

In this step, we compile the MobileNetV2 model by specifying the optimizer, loss function, and evaluation metrics. This step prepares the model for training.

Explanation:

1. Choosing an Optimizer:
   • opt = Adam(learning_rate=0.00001): This line initializes the Adam optimizer with a very small learning rate of 0.00001. Adam is a popular optimization algorithm that adapts the learning rate for each parameter, making it effective for a wide range of problems.
2. Compiling the Model:
   • model.compile(...): This method configures the model for training with the following parameters:
   • optimizer=opt: Uses the Adam optimizer we defined earlier.
   • loss='categorical_crossentropy': Specifies the loss function to be used during training. Categorical crossentropy is suitable for multi-class classification tasks, where each training sample belongs to one of multiple classes (in our case, dog breeds).
   • metrics=['accuracy']: Specifies that we want to track the accuracy of the model during training and evaluation. Accuracy is a common metric for classification tasks, indicating the proportion of correct predictions.
3. Building the Model:
   • model.build(((None, 224, 224, 3))): This line explicitly builds the model by specifying the input shape of the images. The None indicates that the batch size can vary. The shape (224, 224, 3) corresponds to the input images, which are 224x224 pixels in size with 3 color channels (RGB).
4. Displaying Summaries:
   • before_mobilenet.summary(): Displays a summary of the before_mobilenet model, showing the layers, output shapes, and the number of parameters in each layer.
   • mobilenet.summary(): Displays a summary of the MobileNetV2 base model, providing similar details for its architecture.
   • after_mobilenet.summary(): Displays a summary of the after_mobilenet model, which includes the pooling, dropout, and dense layers.

Step 10: Training the Model

In this step, we train the MobileNetV2 model using the training data while validating its performance on a separate validation dataset. We also utilize a callback to save the best model during training.

Explanation:

1. Model Checkpoint Callback:
   • train_cb = ModelCheckpoint('./model/', save_best_only=True): This line creates a callback that saves the model to the specified directory (./model/). The save_best_only=True argument ensures that only the model with the best validation performance (lowest validation loss) is saved, preventing the storage of inferior models during training.
2. Fitting the Model:
   • model.fit(...): This method trains the model on the training data (train_generator) and evaluates it on the validation data (val_generator). The training process involves the following parameters:
   • train_generator: Provides the training data in batches.
   • validation_data=val_generator: Evaluates the model on the validation dataset after each epoch, helping to monitor performance.
   • callbacks=[train_cb]: Includes the train_cb to save the best model during training based on validation loss.
   • epochs=20: Specifies that the model will be trained for 20 epochs. An epoch is one complete pass through the training dataset.

Step 11: Saving and Evaluating the Model

In this final step, we save the trained MobileNetV2 model to a file and evaluate its performance on the test dataset.

Explanation:

1. Saving the Model:
   • model.save('MobileNetV2_model.h5'): This line saves the entire trained model to a file named MobileNetV2_model.h5. This file format (HDF5) allows us to store the model architecture, weights, and training configuration in a single file, making it easy to load and use later without the need for retraining.
2. Evaluating the Model:
   • model.evaluate(test_generator): This method evaluates the saved model on the test dataset provided by test_generator. The evaluation returns the loss value (0.16) and any metrics specified during the model compilation (in our case, accuracy i.e 0.96 ). This is crucial for assessing how well the model performs on completely unseen data.

Conclusion

In this tutorial, we successfully built a dog breed classifier using the MobileNetV2 model, leveraging transfer learning techniques to achieve effective image classification. Here’s a summary of what we covered:

1. Data Preparation: We started by preparing the dataset, including training, validation, and test sets, and visualized some sample images to understand the data better.

2. Data Augmentation: We implemented data augmentation techniques to enhance the training dataset, helping the model generalize better and reduce the risk of overfitting.

3. Model Architecture: We constructed the model using MobileNetV2, combining it with additional layers to adapt it for our specific classification task.

4. Model Compilation: We compiled the model with the Adam optimizer and categorical crossentropy loss function, preparing it for the training phase.

5. Training the Model: The model was trained on the training data, with validation data used to monitor its performance and save the best version of the model.

6. Model Evaluation: Finally, we saved the trained model and evaluated its performance on the test dataset, giving us a final accuracy score.

This tutorial demonstrates the complete workflow of building an image classification model using deep learning. You can now take this knowledge and apply it to other classification tasks or further refine the model with more advanced techniques.

Feel free to explore and experiment with the model, adjust hyperparameters, and try different architectures to improve performance. Happy coding and best of luck with your machine learning journey!