diff --git a/contrib/machine-learning/CNN.md b/contrib/machine-learning/CNN.md
new file mode 100644
index 00000000..cf9692d6
--- /dev/null
+++ b/contrib/machine-learning/CNN.md
@@ -0,0 +1,184 @@
+## **Understanding Convolutional Neural Networks (CNNs)**
+
+### **1. Introduction to CNNs**
+
+Convolutional Neural Networks (CNNs) are a type of deep learning model particularly well-suited for processing data that has a grid-like topology, such as images. Unlike traditional neural networks, CNNs can automatically and adaptively learn spatial hierarchies of features from input images. This makes them extremely effective for tasks such as image classification, object detection, and segmentation.
+
+### **2. Key Components of CNNs**
+
+A CNN typically consists of several different types of layers, each designed to perform a specific function:
+
+- **Convolutional Layer**
+- **ReLU (Rectified Linear Unit) Layer**
+- **Pooling Layer**
+- **Flattening Layer**
+- **Fully Connected Layer**
+
+Let's explore each component in detail.
+
+### **3. Convolutional Layer**
+
+#### **Definition**
+
+The convolutional layer is the core building block of a CNN. This layer's primary function is to extract features from the input image. It does this by sliding a small matrix, known as a filter or kernel, over the image and performing a dot product between the filter and sections of the input.
+
+#### **How It Works**
+
+- **Filters/Kernels**: Filters are small grids (e.g., 3x3 or 5x5) that slide over the input image. Each filter is applied to a patch of the image, and a convolution operation is performed, resulting in a single value.
+  
+- **Convolution Operation**: The filter convolves over the input image, calculating the dot product between the filter values and the image pixels it overlaps. The result is a feature map that represents the presence of a specific feature at different spatial locations in the input.
+
+#### **Example Scenario**
+
+Imagine you have a grayscale image of a cat and you use a 3x3 edge-detection filter (kernel). As this filter moves across the image, it multiplies its values with the pixel values in the input image and sums them up to produce a new value. This operation detects edges in the image because the filter emphasizes areas with high pixel intensity variation.
+
+#### **Visual Example**
+
+If the input image is:
+```
+[[1, 1, 1],
+ [0, 0, 0],
+ [1, 1, 1]]
+```
+and the filter is:
+```
+[[1, 0, -1],
+ [1, 0, -1],
+ [1, 0, -1]]
+```
+The convolution operation will detect vertical edges in the image.
+
+### **4. ReLU (Rectified Linear Unit) Layer**
+
+#### **Definition**
+
+The ReLU layer applies the Rectified Linear Unit activation function to the output of the convolutional layer. The ReLU function is defined as `f(x) = max(0, x)`, which means it replaces all negative pixel values in the feature map with zeros.
+
+#### **How It Works**
+
+- **Non-linearity**: ReLU introduces non-linearity into the model, allowing it to learn more complex patterns and features. Without non-linearity, a CNN would essentially become a linear classifier.
+
+#### **Example Scenario**
+
+Suppose the output of a convolution operation on a particular filter produces a feature map that has some negative values:
+```
+[[3, -2, 4],
+ [1, -1, 0],
+ [-3, 5, 2]]
+```
+After applying the ReLU activation function, this feature map becomes:
+```
+[[3, 0, 4],
+ [1, 0, 0],
+ [0, 5, 2]]
+```
+
+### **5. Pooling Layer**
+
+#### **Definition**
+
+The pooling layer is a down-sampling operation that reduces the dimensionality of the feature map. This helps to reduce the computational complexity and prevents overfitting.
+
+#### **Types of Pooling**
+
+- **Max Pooling**: Takes the maximum value from each window of the feature map.
+- **Average Pooling**: Takes the average value from each window of the feature map.
+
+#### **How It Works**
+
+Pooling is performed on the output of the ReLU layer. A common pooling operation is max pooling with a 2x2 filter and stride of 2. This means that for every 2x2 block in the feature map, the maximum value is taken, and the output is reduced by a factor of 2.
+
+#### **Example Scenario**
+
+If the ReLU output is:
+```
+[[3, 0, 4, 6],
+ [1, 2, 5, 2],
+ [0, 1, 4, 1],
+ [2, 3, 1, 0]]
+```
+Applying a 2x2 max pooling operation results in:
+```
+[[3, 6],
+ [3, 4]]
+```
+
+### **6. Flattening Layer**
+
+#### **Definition**
+
+The flattening layer transforms the pooled feature map into a single column vector. This step is necessary to connect the convolutional and pooling layers to the fully connected layers.
+
+#### **How It Works**
+
+After several convolutional and pooling layers, the resulting feature maps are flattened into a 1D vector that can be fed into a fully connected layer.
+
+#### **Example Scenario**
+
+If the output of the final pooling layer is:
+```
+[[3, 6],
+ [3, 4]]
+```
+Flattening this would result in:
+```
+[3, 6, 3, 4]
+```
+
+### **7. Fully Connected Layer**
+
+#### **Definition**
+
+The fully connected (dense) layer is a traditional neural network layer where each input is connected to every output by a weight. This layer performs the classification based on the features extracted by previous layers.
+
+#### **How It Works**
+
+- **Weighted Sum**: Each node in the fully connected layer computes a weighted sum of the input from the flattened layer, adds a bias, and then applies an activation function.
+- **Output Layer**: The final fully connected layer has as many nodes as there are classes in the classification problem. The output is typically passed through a softmax function to generate probabilities.
+
+#### **Example Scenario**
+
+In a cat vs. dog classifier, if the flattened vector is:
+```
+[3, 6, 3, 4]
+```
+and the weights and biases are:
+```
+Weights = [0.5, -0.2, 0.3, 0.7],
+Bias = 0.1
+```
+The output before the activation function would be:
+```
+Output = (3 * 0.5) + (6 * -0.2) + (3 * 0.3) + (4 * 0.7) + 0.1 = 3.4
+```
+After passing through a softmax function, this would give the probability of the image being a cat or a dog.
+
+### **8. Putting It All Together**
+
+CNNs work by combining these layers in a sequence. The convolutional layers and ReLU layers act as feature extractors, learning increasingly complex patterns in the data. The pooling layers reduce the dimensionality and computation, while the fully connected layers perform the final classification.
+
+#### **Example Scenario**
+
+For a simple CNN designed to classify images of digits (0-9) from the MNIST dataset:
+
+1. **Convolutional Layer**: Detects edges, textures, or simple patterns.
+2. **ReLU Layer**: Applies non-linearity to increase model capacity.
+3. **Pooling Layer**: Reduces dimensionality, keeping only important features.
+4. **Flattening Layer**: Converts 2D matrix into a 1D vector.
+5. **Fully Connected Layer**: Classifies the digit based on the extracted features.
+
+### **9. Summary**
+
+CNNs are a powerful type of neural network specifically designed for processing structured grid data like images. By using layers such as convolutional, ReLU, pooling, flattening, and fully connected, CNNs can learn hierarchical features, enabling them to perform exceptionally well in visual recognition tasks.
+
+### **10. Real-World Applications**
+
+- **Image Classification**: Recognizing objects in photos (e.g., identifying cats and dogs).
+- **Object Detection**: Locating and identifying objects within an image.
+- **Image Segmentation**: Dividing an image into segments or regions, often used in medical imaging.
+- **Facial Recognition**: Identifying individuals from facial images.
+- **Autonomous Vehicles**: Detecting and interpreting traffic signs and obstacles.
+
+By understanding these components and how they interact, you can grasp the fundamentals of CNNs and their application to real-world problems.
+
+---