Thu. Dec 7th, 2023
Introduction to MXNet for Image Classification

MXNet is a deep learning framework that has gained popularity in recent years due to its scalability, flexibility, and ease of use. It is an open-source software library that allows developers to build and train neural networks for a variety of applications, including image classification.

Image classification is the process of categorizing images into different classes or categories based on their visual features. It is a fundamental task in computer vision and has numerous applications, such as object recognition, face detection, and medical image analysis.

In this article, we will provide a step-by-step guide on how to use MXNet for image classification. We will cover the following topics:

1. Installing MXNet
2. Preparing the dataset
3. Building the model
4. Training the model
5. Evaluating the model
6. Making predictions

Before we dive into the details, let’s briefly discuss the benefits of using MXNet for image classification.

MXNet is a highly efficient framework that supports distributed training, which means that it can distribute the workload across multiple devices or machines, making it possible to train large-scale models in a reasonable amount of time. It also supports multiple programming languages, including Python, C++, and R, making it accessible to a wide range of developers.

Moreover, MXNet provides a high-level API called Gluon, which simplifies the process of building and training neural networks. Gluon allows developers to define their models using a simple and intuitive syntax, without having to worry about low-level details such as tensor operations and memory management.

Now that we have a basic understanding of MXNet and its benefits, let’s move on to the first step: installing MXNet.

To install MXNet, you can use pip, a package manager for Python. Open your terminal or command prompt and type the following command:

pip install mxnet

This will install the latest version of MXNet along with its dependencies. If you want to install a specific version, you can use the following command:

pip install mxnet==

Once MXNet is installed, we can move on to the next step: preparing the dataset.

The dataset is a collection of images that we will use to train and evaluate our model. There are many publicly available datasets for image classification, such as CIFAR-10, MNIST, and ImageNet. For this tutorial, we will use the CIFAR-10 dataset, which consists of 60,000 32×32 color images in 10 classes.

You can download the CIFAR-10 dataset from the official website or use the following command to download it directly from MXNet:

python -m cifar10

This will download the dataset and save it in a directory called cifar10.

Next, we need to preprocess the dataset by resizing the images and normalizing the pixel values. We can do this using the following code:

import mxnet as mx
from mxnet import gluon, nd, image

def transform(data, label):
data = data.astype(‘float32’) / 255
data = image.imresize(data, 224, 224)
data = nd.transpose(data, (2,0,1))
return data, label

train_data =,
batch_size=64, shuffle=True, num_workers=4)

test_data =,
batch_size=64, shuffle=False, num_workers=4)

This code defines a function called transform that resizes the images to 224×224 and normalizes the pixel values. It also defines two data loaders, one for the training set and one for the test set, which use the transform function to preprocess the data.

Now that we have prepared the dataset, we can move on to the next step: building the model.

To build the model, we will use the Gluon API, which provides a high-level interface for defining and training neural networks. We will use a pre-trained model called ResNet50, which has achieved state-of-the-art performance on many image classification tasks.

The following code defines the ResNet50 model and initializes its parameters with pre-trained weights:

net =

We can also modify the last layer of the model to output 10 classes instead of 1000, which is the default number of classes in ImageNet:

with net.name_scope():
net.output = gluon.nn.Dense(10)

Now that we have defined the model, we can move on to the next step: training the model.

To train the model, we need to define a loss function and an optimizer. The loss function measures the difference between the predicted output and the true label, while the optimizer updates the parameters of the model to minimize the loss.

We will use the cross-entropy loss function and the stochastic gradient descent (SGD) optimizer with a learning rate of 0.1:

softmax_cross_entropy = gluon.loss.SoftmaxCrossEntropyLoss()
trainer = gluon.Trainer(net.collect_params(), ‘sgd’, {‘learning_rate’: 0.1})

Next, we define a function called train_epoch that trains the model for one epoch:

def train_epoch(net, train_data, loss_fn, trainer, ctx):
train_loss = 0.
train_acc = mx.metric.Accuracy()
for data, label in train_data:
data = data.as_in_context(ctx)
label = label.as_in_context(ctx)
with mx.autograd.record():
output = net(data)
loss = loss_fn(output, label)
train_loss += nd.mean(loss).asscalar()
train_acc.update(label, output)
return train_loss / len(train_data), train_acc.get()[1]

This function iterates over the training data, computes the forward and backward pass, updates the parameters of the model, and computes the training loss and accuracy.

We can then define a function called evaluate_accuracy that computes the accuracy of the model on the test set:

def evaluate_accuracy(net, test_data, ctx):
test_acc = mx.metric.Accuracy()
for data, label in test_data:
data = data.as_in_context(ctx)
label = label.as_in_context(ctx)
output = net(data)
test_acc.update(label, output)
return test_acc.get()[1]

Finally, we can train the model for multiple epochs using the following code:

ctx = mx.gpu()
epochs = 10
for epoch in range(epochs):
train_loss, train_acc = train_epoch(net, train_data, softmax_cross_entropy, trainer, ctx)
test_acc = evaluate_accuracy(net, test_data, ctx)
print(“Epoch %d: train_loss=%.4f train_acc=%.4f test_acc=%.4f” % (epoch+1, train_loss, train_acc, test_acc))

This code trains the model for 10 epochs and prints the training loss, training accuracy, and test accuracy after each epoch.

Once the model is trained, we can evaluate its performance on new images using the following code:

import matplotlib.pyplot as plt

def predict(net, image_path):
image = image.imread(image_path)
image = transform(image, None)[0]
image = image.expand_dims(axis=0)
image = image.as_in_context(ctx)
output = net(image)
prediction = nd.argmax(output, axis=1)
return prediction.asscalar()

image_path = ‘cat.jpg’
prediction = predict(net, image_path)
print(“Prediction:”, prediction)

This code loads an image, preprocesses it using the transform function, feeds it to the model, and returns the predicted class.

In conclusion, MXNet is a powerful and flexible framework for image classification that provides a high-level API for building and training neural networks. By following this step-by-step guide, you should now have a basic understanding of how to use MXNet for image classification and be able to apply it to your own datasets and models.