Topic: CNN (Convolutional Neural Networks) – Part 1: Introduction and Basic Concepts

---

1. What is a CNN?

• A Convolutional Neural Network (CNN) is a type of deep learning model primarily used for analyzing visual data.

• CNNs automatically learn spatial hierarchies of features through convolutional layers.

---

2. Key Components of CNN

• Convolutional Layer: Applies filters (kernels) to input images to extract features like edges, textures, and shapes.

• Activation Function: Usually ReLU (Rectified Linear Unit) is applied after convolution for non-linearity.

• Pooling Layer: Reduces the spatial size of feature maps, typically using Max Pooling.

• Fully Connected Layer: After feature extraction, maps features to output classes.

---

3. How Convolution Works

• A kernel (small matrix) slides over the input image, computing element-wise multiplications and summing them up to form a feature map.

• Kernels detect features like edges, lines, and patterns.

---

4. Basic CNN Architecture Example

| Layer Type | Description |
| --------------- | ---------------------------------- |
| Input | Image of size (e.g., 28x28x1) |
| Conv Layer | 32 filters of size 3x3 |
| Activation | ReLU |
| Pooling Layer | MaxPooling 2x2 |
| Fully Connected | Flatten + Dense for classification |

---

5. Simple CNN with PyTorch Example

import torch.nn as nn
import torch.nn.functional as F

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3)  # 1 input channel, 32 filters
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(32 * 13 * 13, 10)  # Assuming input 28x28

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = x.view(-1, 32 * 13 * 13)  # Flatten
        x = self.fc1(x)
        return x

---

6. Why CNN over Fully Connected Networks?

• CNNs reduce the number of parameters by weight sharing in kernels.

• They preserve spatial relationships unlike fully connected layers.

---

Summary

• CNNs are powerful for image and video tasks due to convolution and pooling.

• Understanding convolution, pooling, and architecture basics is key to building models.

---

Exercise

• Implement a CNN with two convolutional layers and train it on MNIST digits.

---

#CNN #DeepLearning #NeuralNetworks #Convolution #MachineLearning

https://xn--r1a.website/DataScience4

Topic: CNN (Convolutional Neural Networks) – Part 2: Layers, Padding, Stride, and Activation Functions

---

1. Convolutional Layer Parameters

• Kernel (Filter) Size: Size of the sliding window (e.g., 3x3, 5x5).

• Stride: Number of pixels the filter moves at each step. Larger stride means smaller output.

• Padding: Adding zeros around the input to control output size.

* Valid padding: No padding, output smaller than input.

* Same padding: Pads input so output size equals input size.

---

2. Calculating Output Size

For input size $N$, filter size $F$, padding $P$, stride $S$:

$$
\text{Output size} = \left\lfloor \frac{N - F + 2P}{S} \right\rfloor + 1
$$

---

3. Activation Functions

• ReLU (Rectified Linear Unit): Most common, outputs zero for negatives, linear for positives.

• Other activations: Sigmoid, Tanh, Leaky ReLU.

---

4. Pooling Layers

• Reduces spatial dimensions to lower computational cost.

• Max Pooling: Takes the maximum value in a window.

• Average Pooling: Takes the average value.

---

5. Example PyTorch CNN with Padding and Stride

import torch.nn as nn
import torch.nn.functional as F

class CNNWithPadding(nn.Module):
    def __init__(self):
        super(CNNWithPadding, self).__init__()
        self.conv1 = nn.Conv2d(1, 16, kernel_size=3, stride=1, padding=1)  # output same size as input
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=0)  # valid padding
        self.fc1 = nn.Linear(32 * 13 * 13, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))  # 28x28 -> 28x28 -> 14x14 after pooling
        x = F.relu(self.conv2(x))              # 14x14 -> 12x12
        x = x.view(-1, 32 * 12 * 12)
        x = self.fc1(x)
        return x

---

6. Summary

• Padding and stride control output dimensions of convolution layers.

• ReLU is widely used for non-linearity.

• Pooling layers reduce dimensionality, improving performance.

---

Exercise

• Modify the example above to add a third convolutional layer with stride 2 and observe output sizes.

---

#CNN #DeepLearning #ActivationFunctions #Padding #Stride

https://xn--r1a.website/DataScience4

Topic: CNN (Convolutional Neural Networks) – Part 3: Batch Normalization, Dropout, and Regularization

---

1. Batch Normalization (BatchNorm)

• Normalizes layer inputs to improve training speed and stability.

• It reduces internal covariate shift by normalizing activations over the batch.

• Formula applied for each batch:

$$
\hat{x} = \frac{x - \mu}{\sqrt{\sigma^2 + \epsilon}} \quad;\quad y = \gamma \hat{x} + \beta
$$

where $\mu$, $\sigma^2$ are batch mean and variance, $\gamma$ and $\beta$ are learnable parameters.

---

2. Dropout

• A regularization technique that randomly "drops out" neurons during training to prevent overfitting.

• The dropout rate (e.g., 0.5) specifies the probability of dropping a neuron.

---

3. Adding BatchNorm and Dropout in PyTorch

import torch.nn as nn
import torch.nn.functional as F

class CNNWithBNDropout(nn.Module):
    def __init__(self):
        super(CNNWithBNDropout, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, 3, padding=1)
        self.bn1 = nn.BatchNorm2d(32)
        self.dropout = nn.Dropout(0.5)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(32 * 14 * 14, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.bn1(self.conv1(x))))
        x = x.view(-1, 32 * 14 * 14)
        x = F.relu(self.fc1(x))
        x = self.dropout(x)
        x = self.fc2(x)
        return x

---

4. Why Use BatchNorm and Dropout?

• BatchNorm helps the model converge faster and allows higher learning rates.

• Dropout helps reduce overfitting by making the network less sensitive to specific neuron weights.

---

5. Other Regularization Techniques

• Weight Decay: Adds an L2 penalty to weights during optimization.

• Early Stopping: Stops training when validation loss starts increasing.

---

Summary

• Batch normalization and dropout are essential tools for training deep CNNs effectively.

• Regularization improves generalization and reduces overfitting.

---

Exercise

• Modify the CNN above by adding dropout after the second fully connected layer and train it on a dataset to compare results with/without dropout.

---

#CNN #BatchNormalization #Dropout #Regularization #DeepLearning

https://xn--r1a.website/DataScienceM

Topic: CNN (Convolutional Neural Networks) – Part 3: Flattening, Fully Connected Layers, and Final Output

---

1. Flattening the Feature Maps

• After convolution and pooling layers, the resulting feature maps are multi-dimensional tensors.

• Flattening transforms these 3D tensors into 1D vectors to be passed into fully connected (dense) layers.

Example:

x = x.view(x.size(0), -1)

This reshapes the tensor from shape [batch_size, channels, height, width] to [batch_size, features].

---

2. Fully Connected (Dense) Layers

• These layers are used to perform classification based on the extracted features.

• Each neuron is connected to every neuron in the previous layer.

• They are placed after convolutional and pooling layers.

---

3. Output Layer

• The final layer is typically a fully connected layer with output neurons equal to the number of classes.

• Apply a softmax activation for multi-class classification (e.g., 10 classes for digits 0–9).

---

4. Complete CNN Example (PyTorch)

import torch.nn as nn
import torch.nn.functional as F

class FullCNN(nn.Module):
    def __init__(self):
        super(FullCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, 3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
        self.fc1 = nn.Linear(64 * 7 * 7, 128)  # assumes input 28x28
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))   # 28x28 -> 14x14
        x = self.pool(F.relu(self.conv2(x)))   # 14x14 -> 7x7
        x = x.view(-1, 64 * 7 * 7)             # Flatten
        x = F.relu(self.fc1(x))
        x = self.fc2(x)                        # Output layer
        return x

---

5. Why Fully Connected Layers Are Important

• They combine all learned spatial features into a single feature vector for classification.

• They introduce the final decision boundary between classes.

---

Summary

• Flattening bridges the convolutional part of the network to the fully connected part.

• Fully connected layers transform features into class scores.

• The output layer applies classification logic like softmax or sigmoid depending on the task.

---

Exercise

• Modify the CNN above to classify CIFAR-10 images (3 channels, 32x32) and calculate the total number of parameters in each layer.

---

#CNN #NeuralNetworks #Flattening #FullyConnected #DeepLearning

https://xn--r1a.website/DataScienceM

Topic: CNN (Convolutional Neural Networks) – Part 4: Training, Loss Functions, and Evaluation Metrics

---

1. Preparing for Training

To train a CNN, we need:

• Dataset – Typically image data with labels (e.g., MNIST, CIFAR-10).

• Loss Function – Measures the difference between predicted and actual values.

• Optimizer – Updates model weights based on gradients.

• Evaluation Metrics – Accuracy, precision, recall, F1 score, etc.

---

2. Common Loss Functions for CNNs

• CrossEntropyLoss – For multi-class classification (most common).

criterion = nn.CrossEntropyLoss()

• BCELoss – For binary classification.

---

3. Optimizers

• SGD (Stochastic Gradient Descent)
• Adam – Adaptive learning rate; widely used for faster convergence.

optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

---

4. Basic Training Loop in PyTorch

for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0

    for images, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()

    print(f"Epoch {epoch+1}, Loss: {running_loss:.4f}")

---

5. Evaluating the Model

correct = 0
total = 0
model.eval()

with torch.no_grad():
    for images, labels in test_loader:
        outputs = model(images)
        _, predicted = torch.max(outputs, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

accuracy = 100 * correct / total
print(f"Test Accuracy: {accuracy:.2f}%")

---

6. Tips for Better CNN Training

• Normalize images.

• Shuffle training data for better generalization.

• Use validation sets to monitor overfitting.

• Save checkpoints (torch.save(model.state_dict())).

---

Summary

• CNN training involves feeding batches of images, computing loss, backpropagation, and updating weights.

• Evaluation metrics like accuracy help track progress.

• Loss functions and optimizers are critical for learning quality.

---

Exercise

• Train a CNN on CIFAR-10 for 10 epochs using CrossEntropyLoss and Adam, then print accuracy and plot loss over epochs.

---

#CNN #DeepLearning #Training #LossFunction #ModelEvaluation

https://xn--r1a.website/DataScienceM

💡 Building a Simple Convolutional Neural Network (CNN)

Constructing a basic Convolutional Neural Network (CNN) is a fundamental step in deep learning for image processing. Using TensorFlow's Keras API, we can define a network with convolutional, pooling, and dense layers to classify images. This example sets up a simple CNN to recognize handwritten digits from the MNIST dataset.

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import mnist
import numpy as np

# 1. Load and preprocess the MNIST dataset
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

# Reshape images for CNN: (batch_size, height, width, channels)
# MNIST images are 28x28 grayscale, so channels = 1
train_images = train_images.reshape((60000, 28, 28, 1)).astype('float32') / 255
test_images = test_images.reshape((10000, 28, 28, 1)).astype('float32') / 255

# 2. Define the CNN architecture
model = models.Sequential()

# First Convolutional Block
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(layers.MaxPooling2D((2, 2)))

# Second Convolutional Block
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))

# Flatten the 3D output to 1D for the Dense layers
model.add(layers.Flatten())

# Dense (fully connected) layers
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10, activation='softmax')) # Output layer for 10 classes (digits 0-9)

# 3. Compile the model
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# Print a summary of the model layers
model.summary()

# 4. Train the model (uncomment to run training)
# print("\nTraining the model...")
# model.fit(train_images, train_labels, epochs=5, batch_size=64, validation_split=0.1)

# 5. Evaluate the model (uncomment to run evaluation)
# print("\nEvaluating the model...")
# test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
# print(f"Test accuracy: {test_acc:.4f}")

Code explanation: This script defines a simple CNN using Keras. It loads and normalizes MNIST images. The Sequential model adds Conv2D layers for feature extraction, MaxPooling2D for downsampling, a Flatten layer to transition to 1D, and Dense layers for classification. The model is then compiled with an optimizer, loss function, and metrics, and a summary of its architecture is printed. Training and evaluation steps are included as commented-out examples.

#Python #DeepLearning #CNN #Keras #TensorFlow

━━━━━━━━━━━━━━━
By: @DataScienceM ✨

#CNN #DeepLearning #Python #Tutorial

Lesson: Building a Convolutional Neural Network (CNN) for Image Classification

This lesson will guide you through building a CNN from scratch using TensorFlow and Keras to classify images from the CIFAR-10 dataset.

---

Part 1: Setup and Data Loading

First, we import the necessary libraries and load the CIFAR-10 dataset. This dataset contains 60,000 32x32 color images in 10 classes.

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

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

# Check the shape of the data
print("Training data shape:", x_train.shape)
print("Test data shape:", x_test.shape)

#TensorFlow #Keras #DataLoading

---

Part 2: Data Exploration and Preprocessing

We need to prepare the data before feeding it to the network. This involves:
• Normalization: Scaling pixel values from the 0-255 range to the 0-1 range.
• One-Hot Encoding: Converting class vectors (integers) to a binary matrix.

Let's also visualize some images to understand our data.

# Define class names for CIFAR-10
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']

# Visualize a few images
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])
    plt.xlabel(class_names[y_train[i][0]])
plt.show()

# Normalize pixel values to be between 0 and 1
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0

# One-hot encode the labels
y_train = tf.keras.utils.to_categorical(y_train, num_classes=10)
y_test = tf.keras.utils.to_categorical(y_test, num_classes=10)

#DataPreprocessing #Normalization #Visualization

---

Part 3: Building the CNN Model

Now, we'll construct our CNN model. A common architecture consists of a stack of Conv2D and MaxPooling2D layers, followed by Dense layers for classification.

• Conv2D: Extracts features (like edges, corners) from the input image.
• MaxPooling2D: Reduces the spatial dimensions (downsampling), which helps in making the feature detection more robust.
• Flatten: Converts the 2D feature maps into a 1D vector.
• Dense: A standard fully-connected neural network layer.

model = models.Sequential()

# Convolutional Base
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
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, activation='softmax')) # 10 output classes

# Print the model summary
model.summary()

#ModelBuilding #CNN #KerasLayers

---

Part 4: Compiling the Model

Before training, we need to configure the learning process. This is done via the compile() method, which requires:
• Optimizer: An algorithm to update the model's weights (e.g., 'adam').
• Loss Function: A function to measure how inaccurate the model is during training (e.g., 'categorical_crossentropy' for multi-class classification).
• Metrics: Used to monitor the training and testing steps (e.g., 'accuracy').

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

#ModelCompilation #Optimizer #LossFunction

---

📌 Understanding Convolutional Neural Networks (CNNs) Through Excel

🗂 Category: DEEP LEARNING

🕒 Date: 2025-11-17 | ⏱️ Read time: 12 min read

Demystify the 'black box' of deep learning by exploring Convolutional Neural Networks (CNNs) with a surprising tool: Microsoft Excel. This hands-on approach breaks down the fundamental operations of CNNs, such as convolution and pooling layers, into understandable spreadsheet calculations. By visualizing the mechanics step-by-step, this method offers a uniquely intuitive and accessible way to grasp how these powerful neural networks learn and process information, making complex AI concepts tangible for developers and data scientists at any level.

#DeepLearning #CNN #MachineLearning #Excel #AI

🧬 𝐓𝐇𝐄 𝐀𝐈 𝐀𝐍𝐀𝐋𝐘𝐓𝐈𝐂𝐀𝐋 𝐂𝐄𝐍𝐓𝐄𝐑 — 𝐂𝐎𝐍𝐕𝐎𝐋𝐔𝐓𝐈𝐎𝐍𝐀𝐋 𝐍𝐄𝐔𝐑𝐀𝐋 𝐍𝐄𝐓𝐖𝐎𝐑𝐊𝐒 (𝐂𝐍𝐍𝐬)

CNNs are a class of deep neural networks designed specifically for processing grid-like data, such as images. They automatically learn spatial hierarchies of features using convolution operations, moving from simple edges to complex object recognition. 🧠🖼🔍

𝟏. 𝐂𝐎𝐑𝐄 𝐀𝐑𝐂𝐇𝐈𝐓𝐄𝐂𝐓𝐔𝐑𝐄 & 𝐖𝐎𝐑𝐊𝐅𝐋𝐎𝐖
The strength of a CNN lies in its structured approach to feature extraction and classification. ⚙️✨

📥 𝐈𝐧𝐩𝐮𝐭 𝐋𝐚𝐲𝐞𝐫: Raw image pixels are fed into the network.

🧩 𝐂𝐨𝐧𝐯𝐨𝐥𝐮𝐭𝐢𝐨𝐧 𝐋𝐚𝐲𝐞𝐫: Filters slide over the image to detect spatial patterns.

📉 𝐏𝐨𝐨𝐥𝐢𝐧𝐠 𝐋𝐚𝐲𝐞𝐫: Reduces spatial dimensions while preserving the most critical features through Max or Average pooling.

🧠 𝐅𝐮𝐥𝐥𝐲 𝐂𝐨𝐧𝐧𝐞𝐜𝐭𝐞𝐝 𝐋𝐚𝐲𝐞𝐫: Combines all learned features to make a final decision.

𝟐. 𝐊𝐄𝐘 𝐂𝐇𝐀𝐑𝐀𝐂𝐓𝐄𝐑𝐈𝐒𝐓𝐈𝐂𝐒
What makes CNNs unique compared to standard ANNs? 🤔🆚

🔍 𝐋𝐨𝐜𝐚𝐥 𝐂𝐨𝐧𝐧𝐞𝐜𝐭𝐢𝐯𝐢𝐭𝐲: Captures specific regions of an image.

📉 𝐖𝐞𝐢𝐠𝐡𝐭 𝐒𝐡𝐚𝐫𝐢𝐧𝐠: Reduces the number of parameters, making the model more efficient.

🔄 𝐓𝐫𝐚𝐧𝐬𝐥𝐚𝐭𝐢𝐨𝐧 𝐈𝐧𝐯𝐚𝐫𝐢𝐚𝐧𝐜𝐞: Recognition remains accurate even if the object's position shifts slightly.

𝟑. 𝐋𝐄𝐆𝐄𝐍𝐃𝐀𝐑𝐘 𝐂𝐍𝐍 𝐌𝐎𝐃𝐄𝐋𝐒
🏆 𝐋𝐞𝐧𝐞𝐭-𝟓: The pioneer in digit recognition.

🔥 𝐀𝐥𝐞𝐱𝐍𝐞𝐭: The 2012 model that ignited the modern deep learning revolution.

🧱 𝐑𝐞𝐬𝐍𝐞𝐭: Introduced \"Residual Blocks\" to allow for incredibly deep networks without losing information.

🚀 𝐄𝐟𝐟𝐢𝐜𝐢𝐞𝐧𝐭𝐍𝐞𝐭: Optimized for the best balance between speed and accuracy.

𝟒. 𝐑𝐄𝐀𝐋-𝐖𝐎𝐑𝐋𝐃 𝐀𝐏𝐏𝐋𝐈𝐂𝐀𝐓𝐈𝐎𝐍𝐒
CNNs are the silent engine behind many modern technologies: 🌐🛠

🏥 𝐌𝐞𝐝𝐢𝐜𝐚𝐥 𝐈𝐦𝐚𝐠𝐢𝐧𝐠: Automating the detection of anomalies in scans.

🚗 𝐀𝐮𝐭𝐨𝐧𝐨𝐦𝐨𝐮𝐬 𝐕𝐞𝐡𝐢𝐜𝐥𝐞𝐬: Enabling cars to perceive their surroundings in real-time.

🔐 𝐅𝐚𝐜𝐞 𝐑𝐞𝐜𝐨𝐠𝐧𝐢𝐭𝐢𝐨𝐧: Powering security and authentication systems.

𝟓. 𝐓𝐄𝐂𝐇𝐍𝐈𝐂𝐀𝐋 𝐀𝐍𝐀𝐋𝐘𝐒𝐈𝐒: 𝐂𝐎𝐍𝐕𝐎𝐋𝐔𝐓𝐈𝐎𝐍 & 𝐏𝐎𝐎𝐋𝐈𝐍𝐆
📝 𝐂𝐨𝐧𝐯𝐨𝐥𝐮𝐭𝐢𝐨𝐧 𝐋𝐚𝐲𝐞𝐫: Filters (kernels) slide over the input image to detect patterns like shapes and textures.

📈 𝐑𝐄𝐋𝐔 𝐀𝐜𝐭𝐢𝐯𝐚𝐭𝐢𝐨𝐧: Introduces non-linearity, allowing the model to learn complex patterns while remaining computationally efficient.

📉 𝐏𝐨𝐨𝐥𝐢𝐧𝐠 𝐋𝐚𝐲𝐞𝐫: Reduces spatial dimensions (Max or Average Pooling) while preserving the most important information.

𝟔. 𝐓𝐇𝐄 𝐅𝐈𝐍𝐀𝐋 𝐒𝐓𝐀𝐆𝐄: 𝐅𝐑𝐎𝐌 𝐅𝐄𝐀𝐓𝐔𝐑𝐄𝐒 𝐓𝐎 𝐃𝐄𝐂𝐈𝐒𝐈𝐎𝐍
Once features are extracted, the model moves to decision-making: 🎯🧠

📊 𝐅𝐥𝐚𝐭𝐭𝐞𝐧𝐢𝐧𝐠: 2D feature maps are converted into a 1D vector.

🧩 𝐅𝐮𝐥𝐥𝐲 𝐂𝐨𝐧𝐧𝐞𝐜𝐭𝐞𝐝 𝐋𝐚𝐲𝐞𝐫: Combines learned features to perform final high-level reasoning.

📉 𝐒𝐨𝐟𝐭𝐦𝐚𝐱 𝐋𝐚𝐲𝐞𝐫: Converts scores into probabilities for each class (e.g., Cat vs. Dog).

\"CNNs taught machines to see the world—one filter at a time.\" 👁🌍🤖

#AI #DeepLearning #CNN #NeuralNetworks #ComputerVision #Tech