Table of Contents
- Introduction
- Prerequisites
- Setup
- Step 1: Importing the Required Libraries
- Step 2: Loading and Preparing the Data
- Step 3: Exploratory Data Analysis
- Step 4: Preprocessing the Images
- Step 5: Building the Model
- Step 6: Training the Model
- Step 7: Evaluating the Model
- Conclusion
Introduction
In this tutorial, we will learn how to build an image classification model using Python. Image classification is a technique of labeling images into different predefined categories based on their visual content. By the end of this tutorial, you will be able to create a model that can classify images into multiple categories.
Prerequisites
Before starting this tutorial, you should have a basic understanding of Python programming language, as well as familiarity with the concepts of machine learning and deep learning. Additionally, you should have the following software and libraries installed on your machine:
- Python (version >= 3.5)
- TensorFlow (version >= 2.0)
- Keras (version >= 2.4)
- NumPy (version >= 1.18)
- Matplotlib (version >= 3.2)
Setup
To get started, let’s create a new directory for our project and navigate into it using the following commands:
python
mkdir image_classification
cd image_classification
Now, open your favorite Python editor or IDE and create a new Python script file named image_classifier.py in the image_classification directory.
Step 1: Importing the Required Libraries
In the first step, we need to import the necessary libraries that we will be using throughout the tutorial. Add the following lines of code at the beginning of the image_classifier.py file:
python
import tensorflow as tf
from tensorflow import keras
import numpy as np
import matplotlib.pyplot as plt
Here, we import tensorflow and keras libraries for building and training the model. numpy will be used for numerical operations on the image data, and matplotlib will help us visualize the image data.
Step 2: Loading and Preparing the Data
In the second step, we will load and prepare the data for training and testing our image classification model. We will be using a pre-existing dataset called CIFAR-10, which consists of 60,000 32x32 color images in 10 different classes.
Add the following code to load the CIFAR-10 dataset:
python
(train_images, train_labels), (test_images, test_labels) = keras.datasets.cifar10.load_data()
Next, let’s normalize the pixel values of the images by dividing them by 255.0:
python
train_images = train_images / 255.0
test_images = test_images / 255.0
Now, let’s convert the labels into categorical form using one-hot encoding:
python
train_labels = keras.utils.to_categorical(train_labels)
test_labels = keras.utils.to_categorical(test_labels)
Step 3: Exploratory Data Analysis
In this step, let’s perform some exploratory data analysis to better understand the dataset. Add the following code to visualize a few sample images from the CIFAR-10 dataset: ```python class_names = [‘airplane’, ‘automobile’, ‘bird’, ‘cat’, ‘deer’, ‘dog’, ‘frog’, ‘horse’, ‘ship’, ‘truck’]
plt.figure(figsize=(10, 10))
for i in range(25):
plt.subplot(5, 5, i+1)
plt.xticks([])
plt.yticks([])
plt.grid(False)
plt.imshow(train_images[i], cmap=plt.cm.binary)
plt.xlabel(class_names[np.argmax(train_labels[i])])
plt.show()
``` This code will display a grid of 25 images along with their corresponding labels.
Step 4: Preprocessing the Images
Now, let’s preprocess the images by resizing them to a fixed size and performing any necessary data augmentation techniques. For simplicity, we will skip data augmentation in this tutorial.
Add the following code to resize the images to a fixed size of 32x32: ```python IMG_SIZE = 32
train_images_resized = tf.image.resize(train_images, [IMG_SIZE, IMG_SIZE])
test_images_resized = tf.image.resize(test_images, [IMG_SIZE, IMG_SIZE])
``` ## Step 5: Building the Model
In this step, we will define the architecture of our image classification model. For simplicity, we will use a basic Convolutional Neural Network (CNN) model.
Add the following code to define the model:
python
model = keras.Sequential([
keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(IMG_SIZE, IMG_SIZE, 3)),
keras.layers.MaxPooling2D((2, 2)),
keras.layers.Conv2D(64, (3, 3), activation='relu'),
keras.layers.MaxPooling2D((2, 2)),
keras.layers.Conv2D(64, (3, 3), activation='relu'),
keras.layers.Flatten(),
keras.layers.Dense(64, activation='relu'),
keras.layers.Dense(10, activation='softmax')
])
Here, we define a 3-layer CNN followed by two fully connected layers. The output layer has 10 units with softmax activation, representing the 10 different classes in the CIFAR-10 dataset.
Step 6: Training the Model
Next, let’s train the model using the prepared dataset. Add the following code to compile and train the model:
python
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model.fit(train_images_resized, train_labels, epochs=10, batch_size=64)
This code compiles the model with the Adam optimizer and categorical cross-entropy loss, and then trains the model on the resized training images and their corresponding labels.
Step 7: Evaluating the Model
Finally, let’s evaluate the performance of our trained model on the test dataset. Add the following code:
python
test_loss, test_acc = model.evaluate(test_images_resized, test_labels)
print('Test accuracy:', test_acc)
This code evaluates the model on the resized test images and their corresponding labels, and prints the test accuracy.
Conclusion
In this tutorial, we have learned how to build an image classification model using Python. We started by importing the necessary libraries, then loaded and prepared the CIFAR-10 dataset. We performed exploratory data analysis and preprocessed the images. Next, we defined the architecture of our model and trained it using the prepared dataset. Finally, we evaluated the model’s performance on the test dataset.
By following this tutorial, you now have the knowledge to build your own image classification models and classify images into different categories using Python.
Glossary:
- Image Classification: A technique of labeling images into different predefined categories based on their visual content.
- CNN: Convolutional Neural Network, a type of deep learning model commonly used for image classification.
- CIFAR-10: A dataset of 60,000 32x32 color images in 10 different classes.