Deep Learning with TensorFlow and Keras – Master ANN, CNN & RNN

Introduction

In the ever-evolving world of Artificial Intelligence (AI), deep learning with TensorFlow and Keras stands out as a cornerstone for creating cutting-edge applications — from voice recognition systems to self-driving cars. This post explores how to practically implement Artificial Neural Networks (ANN), Convolutional Neural Networks (CNN), and Recurrent Neural Networks (RNN) using TensorFlow and Keras, offering a hands-on guide for beginners and intermediate learners.

Whether you're a student, a data scientist, or a software developer diving into AI, this post is your go-to blueprint.

Why TensorFlow and Keras?

TensorFlow, backed by Google, is an open-source deep learning framework that excels in computational efficiency and scalability. Keras, now tightly integrated into TensorFlow, provides a high-level API that allows for rapid model prototyping with readable and clean code.

Expert View – Dr. Rajat Sharma (AI Researcher, IIT Delhi):

"Deep learning with TensorFlow and Keras is the best way to start your journey in neural networks — it’s practical, well-documented, and industry-relevant."

Setting Up the Environment

Before diving in, ensure the following setup:

pip install tensorflow

Confirm version:

import tensorflow as tf
print(tf.__version__)

1. Understanding ANN – Artificial Neural Networks

🔹 What is ANN?

Artificial Neural Networks mimic the human brain’s neuron structure. They're effective for structured data, classification, and regression problems.

🔹 Building a Simple ANN

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
import numpy as np

# Sample dataset
X = np.array([[0,0],[0,1],[1,0],[1,1]])
y = np.array([[0],[1],[1],[0]])  # XOR problem

model = Sequential()
model.add(Dense(10, input_dim=2, activation='relu'))
model.add(Dense(1, activation='sigmoid'))

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
model.fit(X, y, epochs=200, verbose=0)
print("Accuracy:", model.evaluate(X, y)[1])

🧪 Try with real-world structured datasets like Iris or Titanic for better understanding.

2. CNN – Convolutional Neural Networks

🔹 What is CNN?

CNNs are ideal for image recognition and visual data. They use convolution layers to extract features and pooling layers for downsampling.

🔹 Hands-On Example with MNIST Digits

from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten

# Load dataset
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train.reshape(-1, 28, 28, 1).astype('float32') / 255
X_test = X_test.reshape(-1, 28, 28, 1).astype('float32') / 255
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)

model = Sequential([
    Conv2D(32, kernel_size=(3,3), activation='relu', input_shape=(28,28,1)),
    MaxPooling2D(pool_size=(2,2)),
    Flatten(),
    Dense(128, activation='relu'),
    Dense(10, activation='softmax')
])

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model.fit(X_train, y_train, epochs=5, batch_size=128)
score = model.evaluate(X_test, y_test)
print("Test Accuracy:", score[1])

📌 CNNs are the backbone of facial recognition, medical image classification, and self-driving car vision systems.

3. RNN – Recurrent Neural Networks

🔹 What is RNN?

RNNs are specially designed for sequential data such as time-series, speech, and natural language. They retain memory across time steps.

🔹 Simple RNN for Text Sequences

from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.layers import Embedding, SimpleRNN

# Sample corpus
texts = ["I love deep learning", "deep learning with TensorFlow and Keras is powerful"]

tokenizer = Tokenizer()
tokenizer.fit_on_texts(texts)
sequences = tokenizer.texts_to_sequences(texts)
padded = pad_sequences(sequences)

vocab_size = len(tokenizer.word_index) + 1

model = Sequential()
model.add(Embedding(vocab_size, 10, input_length=padded.shape[1]))
model.add(SimpleRNN(8))
model.add(Dense(1, activation='sigmoid'))

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
# model.fit(padded, labels) # You can create labels and train accordingly

👨‍🏫 RNNs excel in language modelling, chatbots, and speech synthesis.

Key Differences: ANN vs CNN vs RNN

Feature	ANN	CNN	RNN
Data Type	Tabular	Images	Sequential/Text
Strength	General-purpose	Feature extraction	Temporal patterns
Common Use	Classification, Regression	Image Recognition	Language, Time Series

Best Practices for Using TensorFlow and Keras

• Always normalise input data.

• Use EarlyStopping and ModelCheckpoint to optimise training.

• Choose the right activation: ReLU for hidden, sigmoid/softmax for output.

• Visualise using TensorBoard for debugging and insights.

Final Words

Mastering deep learning with TensorFlow and Keras equips you with the skills to solve real-world problems. Begin with simple ANN models, move to CNN for image tasks, and explore RNN for sequential data. With consistent practice and real datasets, you can build powerful AI applications that impact industries.

Start small, stay consistent, and explore datasets that excite you. That’s the best way to learn AI.

Read more AI tutorials here

🏠

Previous Post 👉 Introduction to Neural Networks – Architecture, activation functions, forward/backpropagation