Image Classification Using Keras in Python

One of the core tasks in computer vision is image classification, which aims to categorize or label an input image according to its contents. Numerous fields, including medical image analysis, object identification, and facial recognition, can benefit from this work. High-level neural network architectures such as Keras are a potent tool for developing and refining deep learning models, including image categorization algorithms.

We will walk through the process of utilizing Python's Keras library to create an image classification model.

1. Importing Libraries:

Importing the required libraries, such as Keras and other relevant modules, will be our first step.

2. Loading and Preprocessing Data:

An essential first step in any machine learning effort is data preparation. This section will look at loading and preprocessing image data to ensure it's ready for training.

3. Building the Neural Network Model:

Using Keras, we will create a convolutional neural network (CNN). CNNs are very good at classifying images because they can pick up patterns and spatial hierarchies.

4. Compiling the Model:

After its design, the model must be compiled by defining the optimizer, loss function, and evaluation metric. It is a crucial stage in setting up the training procedure.

5. Training the Model:

The prepared dataset is subsequently used to train the model. We'll review how to monitor the training process and tweak it as needed to get better model performance.

6. Evaluating the Model:

Once training is complete, we'll evaluate the model's performance on a separate test set to assess its generalization capabilities.

7. Making Predictions:

Lastly, we will show you how to apply the learned model to new, untrained photos to generate predictions.

Code:

1. Import the required libraries

import matplotlib.pyplot as plt
import seaborn as sns
import keras
from keras.models import Sequential
from keras.layers import Dense, Conv2D , MaxPool2D , Flatten , Dropout 
from keras.preprocessing.image import ImageDataGenerator
from keras.optimizers import Adam
from sklearn.metrics import classification_report,confusion_matrix
import tensorflow as tf
import cv2
import os
import numpy as np

2. Loading the data

labels = ['rugby', 'soccer']
img_size = 224
def get_data(data_dir):
    data = [] 
    for label in labels: 
        path = os.path.join(data_dir, label)
        class_num = labels.index(label)
        for img in os.listdir(path):
            try:
                img_arr = cv2.imread(os.path.join(path, img))[...,::-1] #convert BGR to RGB format
                resized_arr = cv2.resize(img_arr, (img_size, img_size)) # Reshaping images to preferred size
                data.append([resized_arr, class_num])
            except Exception as e:
                print(e)
    return np.array(data)

3. Data Preprocessing and Data Augmentation

x_train = []
y_train = []
x_val = []
y_val = []
for feature, label in train:
  x_train.append(feature)
  y_train.append(label)
for feature, label in val:
  x_val.append(feature)
  y_val.append(label)
# Normalize the data
x_train = np.array(x_train) / 255
x_val = np.array(x_val) / 255
x_train.reshape(-1, img_size, img_size, 1)
y_train = np.array(y_train)
x_val.reshape(-1, img_size, img_size, 1)
y_val = np.array(y_val)
datagen = ImageDataGenerator(
        featurewise_center=False,  # set input mean to 0 over the dataset
        samplewise_center=False,  # set each sample mean to 0
        featurewise_std_normalization=False,  # divide inputs by std of the dataset
        samplewise_std_normalization=False,  # divide each input by its std
        zca_whitening=False,  # apply ZCA whitening
        rotation_range = 30,  # randomly rotate images in the range (degrees, 0 to 180)
        zoom_range = 0.2, # Randomly zoom image 
        width_shift_range=0.1,  # randomly shift images horizontally (fraction of total width)
        height_shift_range=0.1,  # randomly shift images vertically (fraction of total height)
        horizontal_flip = True,  # randomly flip images
        vertical_flip=False)  # randomly flip images
datagen.fit(x_train)

4. Define the Model

model = Sequential()
model.add(Conv2D(32,3,padding="same", activation="relu", input_shape=(224,224,3)))
model.add(MaxPool2D())
model.add(Conv2D(32, 3, padding="same", activation="relu"))
model.add(MaxPool2D())
model.add(Conv2D(64, 3, padding="same", activation="relu"))
model.add(MaxPool2D())
model.add(Dropout(0.4))
model.add(Flatten())
model.add(Dense(128,activation="relu"))
model.add(Dense(2, activation="softmax"))
model.summary()
opt = Adam(lr=0.000001)
model.compile(optimizer = opt , loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True) , metrics = ['accuracy'])
history = model.fit(x_train,y_train,epochs = 500 , validation_data = (x_val, y_val))

5. Evaluating the result

acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs_range = range(500)
plt.figure(figsize=(15, 15))
plt.subplot(2, 2, 1)
plt.plot(epochs_range, acc, label='Training Accuracy')
plt.plot(epochs_range, val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')
plt.subplot(2, 2, 2)
plt.plot(epochs_range, loss, label='Training Loss')
plt.plot(epochs_range, val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()

Output:

Image Classification Using Keras in Python

predictions = model.predict_classes(x_val)
predictions = predictions.reshape(1,-1)[0]
print(classification_report(y_val, predictions, target_names = ['Rugby (Class 0)','Soccer (Class 1)']))

Output:

Conclusion

In conclusion, developing and implementing deep learning models is possible with the robust and user-friendly framework Python's Keras image categorization offers. During the process, we went over important procedures like data preparation, model architecture design, training, and evaluation. When working with small amounts of data, pre-trained models, such as those in the Keras Applications module, can greatly improve performance. Effective methods for modifying these previously trained models for particular tasks have been identified as fine-tuning and transfer learning. Keras is a great option for novices and seasoned practitioners because of its intuitive API, making it easier to design sophisticated neural networks. Keras is an important tool for image classification tasks as deep learning advances, providing a flexible and effective framework for developing state-of-the-art models.

The model's accuracy can be further improved by experimenting with other topologies, hyperparameters, and optimization strategies, showcasing Keras' versatility and adaptability in handling various image categorization problems.

Next TopicMath tan function in python

← prev next →