Basic CNN Architecture: A Detailed Explanation of the 5 Layers in Convolutional Neural Networks

Did You Know?  CNNs offer a distinct advantage over traditional machine learning models, achieving a 20% improvement in performance metrics!

Convolutional  Neural Networks (CNNs) are key for processing visual data, especially in tasks like image recognition. The basic CNN architecture consists of five main layers: input, convolutional, activation, pooling, and fully connected. Each layer plays a specific role in feature extraction and model performance. 

This blog will break down these five layers, explaining how each contributes to the overall architecture and improves machine learning outcomes. 

Let’s dive into the details of CNNs!

Basic CNN Architecture: A Detailed Understanding

Convolutional Neural Networks (CNNs) are a type of deep learning model used for image recognition, processing, and classification. With basic CNN architecture, you can automatically and efficiently extract features from input data. But what is CNN in machine learning? 

CNNs are a key technique in machine learning and deep learning, specializing in processing grid-like data such as images. Unlike traditional models like decision trees or SVMs, CNNs use filters to detect patterns like edges or shapes automatically. 

This efficient feature extraction allows CNNs to handle complex visual data, making them ideal for tasks like image classification over other algorithms.

The working of basic CNN architecture is like solving a puzzle. It first identifies individual pieces (comparable to identifying features like edges or shapes in an image) and then puts them to get the full picture (similar to classification or output).

CNN algorithm helps streamline this process of extracting and learning from visual data efficiently.

Currently, CNNs are widely used for purposes such as video recognition (e.g., facial recognition), medical imaging (e.g., detecting cancerous tumors), self-driving cars (e.g., identifying road signs), and natural language processing (e.g., text classification). These are some examples of CNN types, where CNNs are applied across different domains.

The CNN architecture can be divided into five components. Here’s an overview of the five layers.

• Feature Extraction through Convolutional Layers

Convolutional layers scan the input data using filters (kernels) to detect patterns like edges, textures, or shapes.

• Pooling Layers

Pooling layers preserve key features while reducing computational complexity. This helps reduce multiple dimensions.

• Activation Layers

Activation layers apply non-linear functions like ReLU to introduce non-linearity. This enables the network to learn complex patterns.

• Flattening and Fully Connected Layers

Once the feature has been extracted, the data is converted into a vector and passed through fully connected layers for classification.

• Output Layer

The output layer provides the final prediction using a Softmax function for classification tasks.

Convolution is the core operation in CNN architecture, allowing the model to extract key features from input data. It applies filters to detect patterns such as edges, textures, and shapes in images. Understanding this process is essential for building models that perform well in image recognition and classification tasks.

Some of the major features of a CNN architecture include: 

Now that you’ve seen an overview of basic CNN architecture, let’s explore the five layers of CNN architecture in detail.

Comprehensive Overview of the 5 Key Layers in CNN Architecture

The convolutional layer, pooling layer, fully connected layer, dropout layer, and activation functions work together in CNNs to extract features and classify data efficiently. Here’s a breakdown of all the five layers in CNN architecture.

1. Convolutional Layer

The convolutional layer is crucial in CNNs (Convolutional Neural Networks) for extracting features from input images. It applies filters (kernels) to detect basic patterns, like edges, corners, and textures, while preserving the spatial relationships between pixels. 

This feature extraction helps the network understand visual content, making it foundational for both CNN in machine learning and CNN in deep learning.

Key Concepts:

• Kernel (Filter): A small matrix (e.g., 3x3 or 5x5) that slides across the input image, detecting specific features. For example, a kernel might highlight vertical edges:

Vertical Edge Detection Kernel:
[[-1, 0, 1],
[-1, 0, 1],
[-1, 0, 1]]

• Stride: Stride defines how many pixels the filter moves at each step. A stride of 1 means the filter moves one pixel at a time. Larger strides reduce the size of the output feature map.
• Padding: Padding helps control the spatial dimensions of the output. Same padding keeps the input and output dimensions equal, while valid padding reduces the output size.

How it works:

1. The kernel slides over the image based on the stride.
2. For each position, the filter performs element-wise multiplication with the image’s pixel values.
3. The results are summed to produce a single value in the feature map.
4. This process is repeated to create the full feature map, highlighting features such as edges or textures.

Example:

In a CNN designed to detect a cat in an image, the first convolutional layer may detect simple features like the cat’s ears or whiskers. Later layers combine these features to identify more complex patterns, like the shape of the cat’s face.

Code Example (TensorFlow - Keras):

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D

model = Sequential()
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(64, 64, 3)))

• 32 is the number of filters.
• (3, 3) is the kernel size.
• ReLU is the activation function.
• input_shape defines the input image shape.

Why it matters:

The convolutional layer is the foundation of CNNs in machine learning and deep learning. It’s essential for image classification, object detection, and many other tasks that rely on identifying patterns in visual data. 

The ability to extract meaningful features from images is what makes CNNs powerful for tasks like face recognition or medical image analysis.

2. Pooling Layer

The pooling layer reduces the spatial dimensions (height and width) of the feature map while preserving the essential features. This helps lower computational costs and reduces the risk of overfitting by summarizing the features extracted in the convolutional layer.

Key Concepts:

• Max Pooling: Selects the maximum value from a region of the feature map. This helps retain the most significant feature.
• Average Pooling: Takes the average value from a region of the feature map, providing a smooth approximation of the data.
• Sum Pooling: Sums up the values in a region of the feature map, though it’s less common than max or average pooling.

How it works:

The pooling layer divides the feature map into smaller sections, typically 2x2 or 3x3, and applies one of the pooling methods (max, average, or sum) to each section. This reduces the size of the feature map while retaining the most important information for further processing.

Example:

If the CNN is detecting a cat in an image, the pooling layer simplifies the whisker features by summarizing them into a smaller region, reducing the resolution but keeping the critical information. This helps the network focus on the most prominent features, like the shape of the whiskers, rather than detailed pixel-level information.

Why it matters:

The pooling layer acts as a bridge between the convolutional and fully connected layers, making the network more efficient. By reducing the feature map size, it helps the network generalize learned features better, leading to improved performance and reduced overfitting in tasks like image recognition.

3. Fully Connected Layer

The fully connected (FC) layer connects every neuron in one layer to every neuron in the next. It combines all extracted features to make final decisions. After convolution and pooling, feature maps are flattened into a one-dimensional vector. This vector is then passed through one or more FC layers, typically used for classification tasks.

Key Concepts:

• Flattening: Converts multi-dimensional feature maps into a one-dimensional vector, making it suitable for processing in the fully connected layers.
• Mathematical Operations: Each neuron in the FC layer performs weighted sums and applies an activation function (e.g., ReLU or softmax).
• Why Multiple FC Layers: Having two or more FC layers allows the network to learn more complex patterns and improve classification accuracy.

How it works:

The output of the convolutional and pooling layers is flattened into a vector. This vector is then passed through the fully connected layers, where the network learns to combine features and make final predictions, such as classification.

Example:

For a CNN designed to detect a cat, the fully connected layer checks if the combination of extracted features (like whiskers, ears, and eyes) collectively represent a cat. The output could be a probability value for the cat class.

Why it matters:

The fully connected layer is crucial for classification in CNNs. It integrates the learned features and makes the final decision about the image, playing a key role in tasks like object detection and classification.

4. Dropout Layer

The Dropout Layer randomly deactivates a fraction of neurons during training to avoid overfitting. This prevents the model from relying too much on specific neurons, helping it generalize better on unseen data. By forcing the model to learn redundant, robust features, it reduces the likelihood of overfitting.

Key Concepts:

• Random Deactivation: During training, a random subset of neurons is turned off (set to zero), preventing the model from relying too heavily on any particular neuron.
• Overfitting Prevention: By disabling certain neurons, the model is forced to learn redundant, robust features that work across different data inputs.
• Fraction of Neurons: Typically, 20-50% of neurons are dropped out during each training iteration.

How it works: 

During each training iteration, a certain percentage of neurons (e.g., 30%) are "dropped" or turned off randomly. This helps reduce the model's reliance on specific features, improving its ability to generalize and perform well on new, unseen data.

Example:

In the case of identifying a cat in an image, during training, 30% of the neurons in a layer are turned off. This helps prevent the model from becoming overly reliant on specific features like the cat’s ears or whiskers, ensuring better performance on unseen images.

Why it matters:

The dropout layer is essential for improving generalization and reducing overfitting. It's particularly useful in deep learning models like CNNs, where the risk of overfitting is higher due to the large number of parameters being learned.

Also Read: What is Overfitting & Underfitting In Machine Learning? [Everything You Need to Learn]  

5. Activation Functions

The activation function introduces non-linearity into the model, enabling it to capture complex relationships in the data. It helps the network decide which information should be passed forward and which should be ignored, influencing the flow of computation.

Key Concepts:

• Non-linearity: Activation functions allow the network to learn complex patterns and make conditional decisions, something a simple linear function cannot achieve.
• Types of Activation Functions:
  • ReLU (Rectified Linear Unit): Often used for hidden layers. It outputs zero for negative values and the input for positive values.
  • Sigmoid: Outputs values between 0 and 1, ideal for binary classification.
  • Softmax: Converts the raw output of the model into a probability distribution for multi-class classification.

How it works:

Each neuron in the network applies an activation function to the weighted sum of its inputs. This determines whether the neuron should "fire" and pass information to the next layer. For instance, ReLU only allows positive values to pass through, which helps the network focus on significant features.

Example:

In a CNN tasked with detecting a cat in an image, ReLU ensures that only relevant features (e.g., the cat's distinct patterns) are passed forward. It filters out unnecessary information, helping the model focus on the most important aspects of the image.

Why it matters:

Activation functions are crucial for enabling neural networks to learn non-linear patterns, which is essential for tasks like image classification, speech recognition, and more. They determine the decision-making process of each neuron, making them fundamental in deep learning models like CNNs.

Now that you’ve explored the layers in CNN architecture, let’s understand how ReLU functions in CNN.

ReLU: A Key Activation Function in Convolutional Neural Networks

ReLU (Rectified Linear Unit) is the most widely used activation function in CNNs. It introduces non-linearity in CNN, thus allowing the network to learn and model complex patterns efficiently.

Here’s the ability of ReLU to introduce non-linearity in CNN.

• ReLU replaces all negative values in the input with zero while keeping positive values unchanged.
• This non-linear transformation process allows the network to learn and model complex, non-linear patterns in the data.
• Without non-linearity, a neural network would function like a linear regression model. This will limit its ability to solve real-world problems.

ReLU’s ability to introduce non-linearity allows the model to learn complex patterns in data. Here’s how ReLU impacts the learning of these patterns.

• Focus on Relevant Features

ReLU removes irrelevant negative values, ensuring the network focuses on useful patterns.

• Prevents Saturation

Unlike activation functions like tanH or Sigmoid, ReLU doesn’t saturate for large positive values. This allows better gradient flow during training.

• Improves Computational Efficiency

ReLU’s simple mathematical operation increases training speed by reducing computation time.

• Supports Deep Architectures

ReLU’s effectiveness in passing gradients helps prevent the vanishing gradient problem, making it suitable for deep networks.

Also Read: Everything you need to know about Activation Function in ML

Now that you understand ReLU and its role in enhancing CNN’s capabilities, let’s take a closer look at LeNet-5.

LeNet-5: A Key Type of CNN in Neural Network History

LeNet-5, introduced by Yann LeCun in 1998, was a pioneering CNN for handwritten digit recognition, marking the start of modern deep learning. Its architecture laid the groundwork for models like AlexNet and VGG, which perform better on larger datasets due to deeper networks and improved computational power. 

While LeNet-5 demonstrated CNN’s ability to recognize images with limited resources, it struggles with modern, complex tasks, which are better handled by deeper models like AlexNet and VGG.

Here’s an in-depth breakdown of the seven layers in the LeNet-5 architecture.

1. The Input Layer

The input layer takes a 32x32 grayscale image as an input. It normalizes pixel values to a range of 0 to 1, ensuring consistent input for the network.

The dimensions of the image shift from 32x32x1 to 28x28x6.

2. Convolutional Layer 1

This layer makes use of 6 filters of size 5x5 with a stride of 1 (filter moves one filter at a time) to scan the input. It captures low-level features like edges and corners and produces 6 feature maps of size 28x28. 

ReLU activation introduces non-linearity at this layer, allowing the network to learn complex patterns.

3. Pooling Layer 1

A pooling layer with a 2x2 filter and stride 2 (spatial dimensions are reduced by half) cuts down the size of each feature map to 14x14.

4. Convolutional Layer 2

It applies 16 filters of size 5x5 with a stride of 1 (scans pixel by pixel) to the 14x14 feature maps from the previous layer. 

The layer generates 16 feature maps of size 10x10 by extracting higher-level features like shapes or specific patterns. ReLU activation reapplied to improve learning.

5. Pooling Layer 2

The pooling layer with a 2x2 filter and stride 2 (reducing spatial dimensions by half) further reduces the size of the feature maps to 5x5. This simplifies the data while preserving critical data.

6. Fully-Connected Layer

The 5x5 feature maps are flattened into a vector of 400 values. This vector is connected to 120 neurons in the first fully connected layer, which represents the features in more abstract representations. A second fully connected layer with 84 neurons further refines the learned representations. ReLU activation is used to maintain non-linearity.

7. Output Layer

The output layer uses a Softmax activation function to convert raw scores into probabilities for multi-class classification. While effective, Softmax can encounter numerical stability issues with large values, leading to instability in computations. 

In such cases, alternative functions like LogSoftmax are often used to prevent these issues. The output layer typically contains one neuron per class, with the highest probability indicating the predicted class.

Here’s a Python implementation of LeNet-5 using Keras and TensorFlow.

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, AveragePooling2D, Flatten, Dense, 
Softmax

# Define the LeNet-5 model
model = Sequential([

# First convolutional layer: 6 filters of size 5x5, ReLU activation, input shape (32, 32, 1)
Conv2D(filters=6, kernel_size=(5, 5), activation='relu', input_shape=(32, 32, 1)),

# First pooling layer: Average pooling with pool size 2x2 to downsample the feature map
AveragePooling2D(pool_size=(2, 2)),

# Second convolutional layer: 16 filters of size 5x5, ReLU activation
Conv2D(filters=16, kernel_size=(5, 5), activation='relu'),

# Second pooling layer: Average pooling with pool size 2x2
AveragePooling2D(pool_size=(2, 2)),

# Flatten layer: Converts the 2D feature maps into a 1D vector
Flatten(),

# First fully connected (Dense) layer: 120 units with ReLU activation
Dense(units=120, activation='relu'),

# Second fully connected (Dense) layer: 84 units with ReLU activation
Dense(units=84, activation='relu'),

# Output layer: 10 units for 10 classes with Softmax activation to output probabilities
Dense(units=10, activation='softmax')  # Output layer for 10 classes
])

# Compile the model
# 'adam' optimizer is used, categorical cross-entropy for multi-class classification, and accuracy metric
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# Display the model summary to check the architecture
model.summary()

Explanation:

• Conv2D Layer: The first two Conv2D layers perform convolution to extract features from the input image. Each filter captures different features like edges or textures.
• AveragePooling2D Layer: These layers downsample the feature maps using average pooling (computing the average value in the specified window), reducing the spatial dimensions.
• Flatten Layer: Converts the 2D output from the convolutional layers into a 1D array so it can be fed into the fully connected layers.
• Dense Layer: These are fully connected layers, which learn the complex combinations of features extracted in the previous layers. The final layer uses Softmax activation to output class probabilities for 10 classes.
• Model Compilation: The model is compiled using the Adam optimizer and categorical cross-entropy loss, which is typical for multi-class classification problems.
• Summary: The model's architecture is displayed to ensure it's correctly defined.

Also Read: Top 10 Neural Network Architectures in 2024 ML Engineers Need to Learn

Now that you’ve explored LeNet-5 in detail, let’s examine the best practices for implementing CNNs.

Best Practices and Challenges: CNN Implementation in 2025

Adherence to best practices in Convolutional Neural Networks (CNNs) ensures optimal performance, prevents overfitting, and enhances model generalization. Along with best practices, it is also necessary to take into account the major challenges in implementation and their practical solutions. 

In this section, let’s cover both the best practices and the challenges one by one. Let’s begin with the best practices:

Also Read: Types of Optimizers in Deep Learning: Best Optimizers for Neural Networks in 2025

After best practices, it is important to consider the challenges in CNN implementation as well. Here is a brief look at the same. 

Here’s the updated table with expanded challenges in CNN implementation:

Now that you’re familiar with the best practices and challenges for implementing basic CNN architecture, let’s explore its top applications.

Top 5 Applications of CNNs in the Real World

CNNs’ ability to extract and process features from complex data like images, text, and videos has led to their widespread use in sectors such as surveillance and healthcare. Here are the top applications of CNNs in the real world.

Learn how to solve real-world problems by combining AI and machine learning. Join the free course on Artificial Intelligence in the Real World.

Now that you’ve explored real-life applications of CNNs, let’s explore ways to deepen your knowledge of CNN.

Conclusion

The basic architecture of Convolutional Neural Networks (CNNs) is essential for deep learning, enabling machines to process and interpret images. The five layers i.e. convolutional, pooling, activation, fully connected, and output, work in harmony to extract features and make classifications. Understanding these layers is fundamental for tasks like image recognition. 

To succeed in this field, you’ll need a blend of technical expertise (neural networks, programming language, and data analytics) and soft skills (problem-solving, analytical thinking, and critical thinking).

upGrad’s machine learning courses help you learn essential skills, covering everything from neural networks to advanced CNN techniques, providing a strong foundation to build your career.

Here are the courses that can help learn CNN.

• Fundamentals of Deep Learning and Neural Networks
• Post Graduate Certificate in Machine Learning and Deep Learning (Executive)
• Post Graduate Programme in ML & AI  from IIIT B (Executive)
• Advanced Certificate Program in Generative AI

Do you need help deciding which courses can help you in neural networking? Contact upGrad for personalized counseling and valuable insights. For more details, you can also visit your nearest upGrad offline center.

Expand your expertise with the best resources available. Browse the programs below to find your ideal fit in Best Machine Learning and AI Courses Online.

Best Machine Learning and AI Courses Online

Discover in-demand Machine Learning skills to expand your expertise. Explore the programs below to find the perfect fit for your goals.

In-demand Machine Learning Skills

Discover popular AI and ML blogs and free courses to deepen your expertise. Explore the programs below to find your perfect fit.

Popular AI and ML Blogs & Free Courses

Reference Links:
https://www.nature.com/articles/s41598-024-53778-7
https://www.numberanalytics.com/blog/10-stats-cnn-efficiency-transform-ai-model-design