In this Answer, we delve into the process of image classification using
The process can be illustrated in the following flowchart:
The first step in this process involves creating a custom dataset. A drawing widget has been developed for this purpose, enabling the drawing of two different shapes. These shapes will form the two classes for the image classification model. The flexibility of this approach allows the creation of a classifier between any two shapes of choice.
Note: Guidelines for using the sketchpad:
Enter the names of the two classes (shapes) to be drawn in the “Class A Name” and “Class B Name” fields.
Draw the shapes in the canvas area, ensuring that the shapes are drawn within the boundaries of the canvas.
After drawing a shape, click on the “Save Image” button to save the image. The image will be saved under the class that is currently selected.
Switch between classes by selecting the radio button of the class to be drawn next.
To clear the canvas, click on the “Clear” button.
Once an equal number of shapes (ideally >10 each) for both classes have been drawn, click on the “Done” button to stop the server and proceed with the next steps.
import React from 'react'; require('./style.css'); import ReactDOM from 'react-dom'; import App from './app.js'; ReactDOM.render( <App />, document.getElementById('root') );
The model.py
script serves as a crucial element in this image classification guide because it plays a fundamental role in creating and training the classification model using Keras. It leverages the Keras framework to construct a Convolutional Neural Network (CNN) model.
create_model
function defines the model architecture.prepare_data
function from the data_preparation.py
script. This function loads the images, resizes them to a target size of 100x100 pixels, normalizes the pixel values, and splits the data into training and validation sets.Conv2D
layers with MaxPooling2D
layers to extract and downsample features.relu
activation function introduces nonlinearity.Flatten
layer converts 2D feature maps to a 1D vector, followed by a Dense
layer with 128 units and relu
activation to learn high-level representations.softmax
activation produces class probabilities.After defining the model, it’s compiled with the Adam optimizer and fit
method trains the model using training images and labels, specifying the number of epochs
and optional validation data. We can customize the model by adjusting layer architecture, units, and activation functions. The trained model can be saved for future use.
Note: To commence the model training, please ensure that you’ve added the class labels in the
model.py
script. Subsequently, click the “Run” button. Lastly, in the terminal, inputpython3 /usercode/model.py
and pressenter
to initiate the training process.
import os import numpy as np from tensorflow.keras.preprocessing.image import load_img, img_to_array def load_data(path, classes): images = [] labels = [] for label, class_name in enumerate(classes): class_path = os.path.join(path, class_name) for image_path in os.listdir(class_path): image = load_img(os.path.join(class_path, image_path), target_size=(100, 100)) image_array = img_to_array(image) / 255.0 images.append(image_array) labels.append(label) images = np.array(images) labels = np.array(labels) return images, labels def prepare_data(dataset_path, classes): images, labels = load_data(dataset_path, classes) indices = np.arange(len(images)) np.random.shuffle(indices) train_size = int(0.8 * len(images)) train_indices = indices[:train_size] validation_indices = indices[train_size:] train_images = images[train_indices] train_labels = labels[train_indices] validation_images = images[validation_indices] validation_labels = labels[validation_indices] return (train_images, train_labels), (validation_images, validation_labels)
This section is added to assess the performance of the trained image classification model by submitting custom test images, drawn using the provided sketchpad, and observing the model's classification results.
Note: Guidelines for submitting test image:
Run the code by clicking the “Run” button.
Enter the command
python3 /submit_test.py
to execute the script for capturing the test image.Open the provided app link to access the custom sketchpad.
Draw the test image within the canvas, ensuring it belongs to one of the two classes previously created.
After completing the drawing, click the “Submit” button to save the test image as
test_img.png
.
import React from 'react'; require('./style.css'); import ReactDOM from 'react-dom'; import App from './app.js'; ReactDOM.render( <App />, document.getElementById('root') );
The provided test code utilizes Keras to evaluate the trained image classification model and predict the class label for a custom test image.
First, the saved model classification_model.h5
is loaded using load_model
from tensorflow.keras.models
.
The class names, representing the possible labels, are defined.
Then, the test image located at /test_img.png
is loaded and preprocessed.
The image is resized to match the input size expected by the model, normalized, and expanded to include a batch dimension.
The model is then used to predict the class of the test image using model.predict
.
The predictions are obtained as probability scores for each class.
The np.argmax
function identifies the class with the highest probability, and the corresponding class name is retrieved from the classes list.
Finally, the predicted class label is printed.
Note: Prior to running the code, verify and match the order of class labels with the training labels in the highlighted line. After clicking the “Run” button, use the command
python3 /usercode/eval.py
in the terminal to predict the label of the test image.
import os os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' import tensorflow as tf import logging tf.get_logger().setLevel(logging.ERROR) from tensorflow.keras.models import load_model from tensorflow.keras.preprocessing import image import numpy as np # Loading the saved model model = load_model('classification_model.h5') # Defining the class labels classes = ['square', 'circle'] # Loading and preprocessing the test image image_path = '/test_img.png' img = image.load_img(image_path, target_size=(100, 100)) img_array = image.img_to_array(img) img_array /= 255.0 img_array = np.expand_dims(img_array, axis=0) # Using the model to predict the class of the test image predictions = model.predict(img_array) predicted_class = np.argmax(predictions) class_name = classes[predicted_class] print('Predicted class:', class_name)
In summary, this comprehensive Answer redefines image classification with its innovative approach, by allowing us to seamlessly generate custom datasets and build personalized classification models.
Free Resources