How to Build AI Models Using Keras

Building AI models using Keras is an exciting and powerful way to dive into deep learning. Keras is a high-level neural network API written in Python that runs on top of TensorFlow (and previously Theano, which is now deprecated). It’s designed for easy and fast prototyping, supporting both convolutional (CNN) and recurrent (RNN) networks, along with combinations of the two.

Here's a step-by-step guide to building AI models using Keras:

1. Install Keras

If you're using TensorFlow 2.x (which integrates Keras), Keras is included by default. You can install TensorFlow using pip:

pip install tensorflow

Alternatively, if you need just Keras, you can install it separately:

pip install keras

2. Import Necessary Libraries

After installing Keras, you can import the necessary modules to build and train your model.

import tensorflow as tf

from tensorflow import keras

from tensorflow.keras import layers

import numpy as np

import matplotlib.pyplot as plt

3. Prepare the Dataset

For demonstration, let's use a simple dataset. We'll start with the MNIST dataset, which consists of handwritten digits (0-9).

a. Load MNIST Dataset

Keras has built-in access to popular datasets. Here's how to load the MNIST dataset:

# Load the MNIST dataset (images and labels)

(X_train, y_train), (X_test, y_test) = keras.datasets.mnist.load_data()

# Normalize the images to have pixel values between 0 and 1

X_train, X_test = X_train / 255.0, X_test / 255.0

# Reshape the data to fit the model's input (28x28 pixels, 1 channel for grayscale)

X_train = X_train.reshape(-1, 28, 28, 1)

X_test = X_test.reshape(-1, 28, 28, 1)

# Ensure that the labels are in the correct format (one-hot encoded)

y_train = keras.utils.to_categorical(y_train, 10)

y_test = keras.utils.to_categorical(y_test, 10)

4. Build the Model

In Keras, models are built using sequential or functional APIs. For simplicity, we will use the Sequential API to build a Convolutional Neural Network (CNN) for image classification.

a. Define the Model Architecture

We will define a CNN model with:

Convolutional layers (to extract features)

MaxPooling layers (to reduce dimensionality)

Dense layers (for the final classification)

model = keras.Sequential([

# Convolutional layer: Extract features from images

layers.Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1)),

layers.MaxPooling2D(pool_size=(2, 2)),

# Add another convolutional layer

layers.Conv2D(64, kernel_size=(3, 3), activation='relu'),

layers.MaxPooling2D(pool_size=(2, 2)),

# Flatten layer: Flatten the 2D output to 1D for Dense layers

layers.Flatten(),

# Fully connected layer (Dense layer)

layers.Dense(128, activation='relu'),

# Output layer: 10 units for 10 classes (digits 0-9)

layers.Dense(10, activation='softmax') # 'softmax' for multi-class classification

])

# Print the model summary

model.summary()

This architecture includes:

Two convolutional layers to detect features in the images.

Two max-pooling layers to reduce the image dimensions.

One dense layer for classification.

The final softmax layer for multi-class classification (digits 0-9).

5. Compile the Model

After building the model, you need to compile it, specifying:

The optimizer (which algorithm will update the model weights)

The loss function (how the model evaluates its performance)

The metrics (the metrics used to evaluate the model)

For our task, we will use Adam optimizer, categorical cross-entropy (for multi-class classification), and accuracy as a metric.

model.compile(optimizer='adam',

loss='categorical_crossentropy',

metrics=['accuracy'])

6. Train the Model

Now that the model is compiled, you can train it on your dataset using the fit() method.

history = model.fit(X_train, y_train, epochs=5, batch_size=64, validation_split=0.2)

Parameters:

epochs: Number of times the model will see the entire training data.

batch_size: Number of samples per gradient update.

validation_split: Proportion of data to use for validation during training.

7. Evaluate the Model

After training, evaluate your model’s performance on the test set.

test_loss, test_acc = model.evaluate(X_test, y_test, verbose=2)

print(f"Test accuracy: {test_acc}")

8. Make Predictions

You can now use the trained model to make predictions on new, unseen data.

# Predict on the test set

predictions = model.predict(X_test)

# Get the predicted class (highest probability)

predicted_classes = np.argmax(predictions, axis=1)

# Display the first 5 predictions

print("Predictions:", predicted_classes[:5])

9. Visualize the Training Process

It’s a good idea to visualize the training and validation accuracy over epochs to ensure that the model is learning well.

# Plot training & validation accuracy values

plt.plot(history.history['accuracy'])

plt.plot(history.history['val_accuracy'])

plt.title('Model Accuracy')

plt.xlabel('Epoch')

plt.ylabel('Accuracy')

plt.legend(['Train', 'Test'], loc='upper left')

plt.show()

# Plot training & validation loss values

plt.plot(history.history['loss'])

plt.plot(history.history['val_loss'])

plt.title('Model Loss')

plt.xlabel('Epoch')

plt.ylabel('Loss')

plt.legend(['Train', 'Test'], loc='upper left')

plt.show()

10. Save and Load the Model

Once you’re happy with your model, you can save it and reload it for future use.

a. Save the Model

# Save the model to a file (HDF5 format)

model.save('mnist_cnn_model.h5')

b. Load the Model

# Load the saved model

loaded_model = keras.models.load_model('mnist_cnn_model.h5')

# Evaluate the loaded model

test_loss, test_acc = loaded_model.evaluate(X_test, y_test)

print(f"Loaded model Test accuracy: {test_acc}")

11. End-to-End Example: Full Code

Here’s the full process of building, training, evaluating, and saving a Keras model for MNIST digit classification:

import tensorflow as tf

from tensorflow import keras

from tensorflow.keras import layers

import numpy as np

import matplotlib.pyplot as plt

# Load and preprocess data

(X_train, y_train), (X_test, y_test) = keras.datasets.mnist.load_data()

X_train, X_test = X_train / 255.0, X_test / 255.0

X_train = X_train.reshape(-1, 28, 28, 1)

X_test = X_test.reshape(-1, 28, 28, 1)

y_train = keras.utils.to_categorical(y_train, 10)

y_test = keras.utils.to_categorical(y_test, 10)

# Build the model

model = keras.Sequential([

layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),

layers.MaxPooling2D((2, 2)),

layers.Conv2D(64, (3, 3), activation='relu'),

layers.MaxPooling2D((2, 2)),

layers.Flatten(),

layers.Dense(128, activation='relu'),

layers.Dense(10, activation='softmax')

])

# Compile the model

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# Train the model

history = model.fit(X_train, y_train, epochs=5, batch_size=64, validation_split=0.2)

# Evaluate the model

test_loss, test_acc = model.evaluate(X_test, y_test)

print(f"Test accuracy: {test_acc}")

# Save the model

model.save('mnist_cnn_model.h5')

# Load the model

loaded_model = keras.models.load_model('mnist_cnn_model.h5')

# Evaluate the loaded model

test_loss, test_acc = loaded_model.evaluate(X_test, y_test)

print(f"Loaded model Test accuracy: {test_acc}")

Conclusion

Keras is incredibly user-friendly for building AI models, and with TensorFlow as the backend, you get scalability and power under the hood. By following this guide, you’ve learned how to:

Load and preprocess datasets.

Build and train a model using Keras.

Evaluate and visualize performance.

Save and load models

Learn AI ML Course in Hyderabad

The Best Frameworks for Machine Learning: TensorFlow vs. PyTorch

Top AI and ML Libraries You Need to Know

Tools, Frameworks, and Libraries

Visit Our Quality Thought Training Institute in Hyderabad

Get Directions