Week 8: The Deep Learning Leap — From Single Neurons to Computer Vision

Author: Hammad Ali Date: March 22, 2026 Reading Time: ~8 minutes

The Evolution of Intelligence

During the first several weeks of the GDGOC Attock AI/ML Fellowship, we spent our time mastering classical machine learning on structured data. We learned how to find the lines of best fit, cluster customers, and build decision trees.

But this week, the game completely changed.

We officially entered the domain of Deep Learning & Neural Networks where the goal isn’t just to find statistical patterns, but to build architectures inspired by the hierarchical processing of the human brain.

Here is a breakdown of what we covered and what I built this week!

1. Cracking the Code of the Neuron

Before building massive networks, you have to understand the foundational building block: the Perceptron.

We learned how a single artificial neuron takes weighted inputs, adds a bias term, and passes the result through an activation function to make a decision. To truly understand this, I took on the “From Scratch” Challenge:

• Backpropagation without Frameworks: I wrote the code to train a simple feedforward neural network completely from scratch using only NumPy. There is nowhere to hide when you are manually calculating the chain rule of calculus to update weights and minimize Mean Squared Error (MSE)!
• Activation Functions: I experimented with mathematical functions like Sigmoid, Tanh, and Softmax, and learned exactly why ReLU (Rectified Linear Unit) has become the gold standard for hidden layers (hint: to avoid the dreaded vanishing gradient problem).

2. The “Hello World” of Deep Learning: MNIST

For our main practical assignment, I tackled the famous MNIST Handwritten Digit Recognition task.

Using Keras and TensorFlow, I built a multi-layer Artificial Neural Network (ANN) to classify thousands of 28x28 grayscale images of handwritten numbers (0–9).

• The Architecture: I designed a deep, fully-connected network utilizing Flatten(), dense layers, batch normalization, and Dropout() to prevent over-fitting.
• The Result: Seeing the model reach over 97% accuracy on unseen test data was a massive testament to the raw power of deep architectures compared to the classical ML algorithms we used in earlier weeks!

3. Seeing the World through CNNs

While standard ANNs are powerful, they struggle with raw image data because they lose vital spatial information when you flatten a 2D image into a 1D vector.

This led to the highlight of the week: Convolutional Neural Networks (CNNs).

• Convolutional Layers: These act as sliding “feature detectors,” learning to identify basic edges and gradients in the early layers, and assembling them into complex shapes and textures in the deeper layers.
• Pooling Layers: I implemented MaxPooling2D to down-sample feature maps, drastically reducing computation time and making the model invariant to small shifts or distortions in the images.
• Transfer Learning: Finally, I explored the incredible power of standing on the shoulders of giants. Why spend days training a model from scratch when you can load a pre-trained MobileNetV2 or VGG16 architecture and casually fine-tune it for your own custom dataset?

4. Beyond Basic Classification

We wrapped up the week by looking at the bleeding edge of Computer Vision. We didn’t just stop at labeling whole images; we explored how AI actually “sees” complex environments:

• Object Detection: Identifying exactly where an object is located using bounding boxes (e.g., YOLO models).
• Semantic Segmentation: Labeling every single pixel in an image — which is exactly how self-driving cars distinguish between the “road,” “pedestrians,” and the “sidewalk.”

Reflection: The Complexity of “Simple” Vision

This week taught me that “vision” — something humans do effortlessly — is incredibly computationally expensive for machines.

I learned that data preprocessing (normalizing pixel values, one-hot encoding labels) and Data Augmentation (randomly rotating, zooming, and shifting images to expand the dataset) are just as important as the model architecture itself.

Looking back at my thousands of lines of manual backpropagation code compared to building a state-of-the-art CNN in exactly 15 lines using the high-level Keras API, I feel a profound appreciation for the software abstractions that allow us to build world-changing AI today.

The journey continues. Next stop: Advanced Deep Learning!

👉 Check out my complete code and MNIST implementation on GitHub: https://github.com/hammadali155/AI-ML-Fellowship-GDGOC-2026

Tags: #GDGOCAttock #AIMLFellowship #DeepLearning #ComputerVision #TensorFlow #Keras #CNN #NeuralNetworks #MNIST