Build Your First Neural Network in Python with TensorFlow/Keras

Learn how to build and train your first Deep Learning model with TensorFlow and Keras using Convolutional Neural Network.

Artificial Intelligence (AI) has revolutionized the way we interact with technology, enabling machines to perform tasks that once used to typically require human intelligence. From Large Language Models (LLMs) like GPT, Gemini & Llama to Voice Assistants like Siri and Alexa, AI’s applications are vast and continually expanding. Among the various branches of AI, machine learning and deep learning stand out for their ability to learn from data and make intelligent decisions. In this blog, we’ll embark on a hands-on journey to build your first neural network using Python’s TensorFlow and Keras libraries. By the end, you’ll have a solid foundation to explore more complex AI models and applications.

What We’ll Accomplish Today

In this blog, I’ll guide you through the process of creating an image classification model using the CIFAR-10 dataset. Image classification is a fundamental task in computer vision, where the goal is to assign a label to an input image from a predefined set of categories. We’ll leverage TensorFlow and Keras to build, train, and evaluate our neural network. Here’s an overview of what we’ll cover:

1. Introduction to AI and Neural Networks
2. Setting Up the Development Environment
3. Understanding the CIFAR-10 Dataset
4. Building the Neural Network Model
5. Training and Evaluating the Model
6. Making Predictions and Visualizing Results
7. Conclusion and Next Steps

Workflow Overview

Before diving into the code, it’s essential to understand the workflow we’ll follow:

1. Set Up the Environment: Install necessary libraries and set up your Python environment.
2. Load and Explore the Data: Understand the dataset’s structure and contents.
3. Preprocess the Data: Normalize and prepare the data for training.
4. Build the Model: Define the architecture of the neural network.
5. Compile the Model: Specify the optimizer, loss function, and metrics.
6. Train the Model: Fit the model to the training data.
7. Evaluate the Model: Assess the model’s performance on test data.
8. Make Predictions: Use the trained model to make predictions on new data.
9. Visualize Results: Display the predictions alongside the input images.

Getting Started: A Brief Introduction

Neural networks are inspired by the human brain’s interconnected neuron structure. They consist of layers of nodes (neurons) that process input data, learn patterns, and make decisions. In this tutorial, we’ll use the CIFAR-10 dataset, which contains 60,000 32×32 color images across 10 different classes, such as airplanes, cars, birds, cats, and more. This dataset is a great starting point for beginners looking to build image classification models.

Prerequisites

Before we begin, ensure you have the following:

• Python Installed: Preferably Python 3.6 or higher.
• TensorFlow and Keras: We’ll use TensorFlow’s Keras API for building our model.
• Basic Python Knowledge: Familiarity with Python programming will be helpful.

If you haven’t installed TensorFlow yet, you can do so using pip:

pip install tensorflow

Step-by-Step Guide to Building an Image Classification Model

Let’s dive into the step-by-step process of building our first neural network.

1. Importing Necessary Libraries

First, we’ll import the essential libraries required for our project.

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, models
import matplotlib.pyplot as plt
import numpy as np

2. Loading the CIFAR-10 Dataset

TensorFlow provides easy access to the CIFAR-10 dataset. We’ll load the data and explore its structure.

# Load CIFAR-10 dataset
(x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data()

Understanding the Data:

• x_train & x_test: These are the image data, each with a shape of (number of samples, 32, 32, 3). The last dimension represents the RGB color channels.
• y_train & y_test: These are the labels for the images, ranging from 0 to 9, each corresponding to a specific class.

Let’s visualize some sample images from the dataset.

# Define class names
class_names = ['Airplane', 'Automobile', 'Bird', 'Cat', 'Deer',
               'Dog', 'Frog', 'Horse', 'Ship', 'Truck']

# Plot the first 25 images from the training set
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(x_train[i])
    # The CIFAR labels are arrays, so we need the first element
    plt.xlabel(class_names[y_train[i][0]])
plt.show()

3. Preprocessing the Data

Before feeding the data into the neural network, it’s crucial to preprocess it to ensure better performance.

Normalization:

Neural networks perform better when input data is normalized. We’ll scale the pixel values from the range [0, 255] to [0, 1].

# Normalize pixel values
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0

4. Building the Neural Network Model

We’ll construct a Convolutional Neural Network (CNN), which is particularly effective for image classification tasks.

# Define the model
model = models.Sequential()
# First convolutional layer
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(layers.MaxPooling2D((2, 2)))
# Second convolutional layer
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
# Third convolutional layer
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
# Flatten and Dense layers
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10))

5. Compiling the Model

Next, we’ll compile the model by specifying the optimizer, loss function, and evaluation metrics.

Next, we’ll compile the model by specifying the optimizer, loss function, and evaluation metrics.

# Compile the model
model.compile(optimizer='adam',
              loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

6. Training the Model

With the model defined and compiled, we can now train it using the training data.

# Train the model
history = model.fit(x_train, y_train, epochs=10, 
                    validation_data=(x_test, y_test))

Training Output Example:

Epoch 1/10
1563/1563 [==============================] - 25s 16ms/step - loss: 1.6922 - accuracy: 0.3842 - val_loss: 1.3685 - val_accuracy: 0.5104
...
Epoch 10/10
1563/1563 [==============================] - 24s 15ms/step - loss: 0.6075 - accuracy: 0.8100 - val_loss: 0.7203 - val_accuracy: 0.7651

7. Evaluating the Model

After training, we’ll evaluate the model’s performance on the test dataset.

# Evaluate the model
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
print(f'\nTest accuracy: {test_acc}')

Sample Output:

313/313 - 2s - loss: 0.7203 - accuracy: 0.7651

Test accuracy: 0.7651

8. Making Predictions

To make predictions, we’ll use the trained model to classify new images.

# Create a probability model
probability_model = models.Sequential([model, 
                                       layers.Softmax()])

# Predict the first 5 images from the test set
predictions = probability_model.predict(x_test[:5])

for i in range(5):
    print(f"Image {i+1} Prediction: {class_names[np.argmax(predictions[i])]}, True Label: {class_names[y_test[i][0]]}")

Source Output:

Image 1 Prediction: Cat, True Label: Cat
Image 2 Prediction: Dog, True Label: Dog
Image 3 Prediction: Frog, True Label: Frog
Image 4 Prediction: Horse, True Label: Horse
Image 5 Prediction: Ship, True Label: Ship

9. Visualizing Predictions

Let’s visualize the predictions alongside the actual images.

# Plot the first 5 test images, their predicted labels, and the true labels
# Use the probabilities to set the color of the labels
plt.figure(figsize=(10,10))
for i in range(5):
    plt.subplot(1,5,i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(x_test[i])
    predicted_label = class_names[np.argmax(predictions[i])]
    true_label = class_names[y_test[i][0]]
    if predicted_label == true_label:
        color = 'blue'
    else:
        color = 'red'
    plt.xlabel(f"Pred: {predicted_label}\nTrue: {true_label}", color=color)
plt.show()

Conclusion and Next Steps

Congratulations! You’ve successfully built, trained, and evaluated your first neural network for image classification using TensorFlow and Keras. This foundational project has equipped you with the essential skills to delve deeper into the world of deep learning and AI. Here are some recommended next steps to further enhance your understanding and skills:

1. Experiment with Model Architecture: Try adding more layers, changing activation functions, or using different types of layers like Dropout to prevent overfitting.
2. Data Augmentation: Implement techniques like rotation, flipping, and scaling to increase the diversity of your training data.
3. Hyperparameter Tuning: Adjust learning rates, batch sizes, and other hyperparameters to optimize model performance.
4. Explore Other Datasets: Challenge yourself with more complex datasets like CIFAR-100 or ImageNet.
5. Deploy Your Model: Learn how to deploy your trained model to a web application or mobile device for real-world applications.
6. Learn About Transfer Learning: Utilize pre-trained models to achieve better performance with less training time.

Embarking on this journey opens up endless possibilities in AI and machine learning. Keep experimenting, stay curious, and continue building innovative solutions!