Mastering Derivatives: From Math to Code - Python Numerical Differentiation

Unlock the secrets of derivatives! Learn the mathematical concept, see how it translates into Python code, and discover three numerical differentiation methods: forward, backward, and central. Watch as we visualize their performance, helping you understand which method provides the most precise results for your calculations!

📼 Youtube: https://www.youtube.com/watch?v=Xynwf7su6DI

👋 Check my blog post for the text content

✌️The Jupyter notebook can be found here

Gradient Descent: Downhill to the Minima. A Visual Journey to Optimization.

Whether you're a beginner curious about AI or an expert looking to deepen your understanding, this video is crafted for you! Follow along with our interactive Python plot where we demonstrate the gradient descent in action. See how the algorithm navigates through a function's landscape to find the optimal solution. Watch as we code in Python, but also explain the logic behind each line.

📼 YouTube: https://youtu.be/LE9O2ntmXGg

👋 Check my blog post for the text content

✌️The Jupyter notebook can be found here

3D Gradient Descent: The Rollercoaster of Optimization

Learn what the gradient is, why it's key to finding the steepest path, and how to use it in both 2D and 3D spaces. We'll code, visualize, and play with gradient descent, showing you how to adjust settings like learning rate and iterations. See it in action with a 3D paraboloid, where we chase the minimum down a hill. Get hands-on with interactive plots and find all the code linked below the video.

📼 YouTube: https://youtu.be/ijhJMyxYZfw

Unlocking Global Minima with Momentum

In this video, we tackle real-world problems by exploring a multi-dimensional, non-linear function - the QFSP (Quadratic Function with Sinusoidal Perturbations). Dive into the complexities of optimization in machine learning with this deep dive into gradient descent.

📼 YouTube: https://www.youtube.com/watch?v=Ob-AxSwNTFA

Cross-Entropy Loss Explained: A Complete Visual Guide

Learn Cross-Entropy Loss step by step! We start with simple building blocks and gradually move to the full picture. Perfect for everyone who wants to understand deep learning classification.

📼 YouTube: https://www.youtube.com/watch?v=BKjOBO1hkkA

Understanding Logits to Probabilities: How Neural Networks Make Decisions with Sigmoid Function

Learn how neural networks transform raw outputs (logits) into interpretable probabilities! This tutorial walks through the complete process using NumPy and Python. Perfect for anyone wanting to understand the fundamentals of neural network decision-making.

📼 YouTube: https://youtu.be/rcg1PTRDAWc

Understanding Weight Initialization in Neural Networks: Normal, Xavier, He, and Leaky He

Weight initialization is crucial in training neural networks, as it sets the starting point for optimization algorithms. The activation function applies a non-linear transformation in our network. Different activation functions serve different purposes. Choosing the right weight initialization and activation function is key to better neural network performance.

📼 YouTube: https://www.youtube.com/watch?v=MQzim4eHr6Q

We implement a complete linear layer with forward and backward propagation, binary cross-entropy loss, and stochastic gradient descent with momentum.

📼 YouTube: https://youtu.be/RO0cDCnPeyE

AI competition

Deepseek r1, a Chinese ChatGPT rival, launched this weekend. Built by grad students on a fraction of OpenAI’s budget, it rivals GPT tech without massive hardware needs!
Check this out: https://chat.deepseek.com

Building a Multi-Layer Neural Network from Scratch: Solving the Spiral Classification Problem.

Learn how neural networks evolved from the simple perceptron to modern deep learning architectures. In this tutorial, we implement a multi-layer neural network from scratch to solve the non-linear spiral classification problem that a single-layer perceptron can't handle.

https://www.youtube.com/watch?v=F09squ1quN0

Fixing Unstable Gradient Descent: Momentum and Gradient Clipping in Deep Learning

Learn how to solve common stability issues in neural network training with two powerful techniques. In this tutorial, we fix unstable stochastic gradient descent (SGD) by implementing proper momentum and gradient clipping from scratch. Watch how we transform an unstable training process that fails to converge into a robust optimization algorithm that can handle higher learning rates and train 5x faster!

📼 YouTube: https://youtu.be/V60ylfHqTe8

Dive deep into machine learning by implementing a neural network from scratch to classify clothing items using the Fashion MNIST dataset

📼 YouTube: https://www.youtube.com/watch?v=reiqm-oI4oc

Building MicroTorch: Implementing a PyTorch-like Tensor Class from Scratch. Backbone of the Tensor

Dive into the foundational elements of deep learning frameworks by building MicroTorch, a PyTorch-inspired tensor library. In this tutorial, we implement a Tensor class with automatic differentiation capabilities essential for neural network training.

📼 YouTube: https://www.youtube.com/watch?v=7GHa_Cla5wU

Clone - Musculoskeletal, superintelligent androids.

Ground zero for the age of androids.

https://x.com/clonerobotics

Building PyTorch from Scratch: Tensor Operations, Transpose & Backward Method Explained

Learn how to build PyTorch from scratch! In this video, we implement transpose operation and the backward method for automatic differentiation. Understand how tensors track dependencies, compute gradients, and apply the chain rule for backpropagation.

📼 YouTube: https://www.youtube.com/watch?v=xUkEKzq7XeQ

Building PyTorch: A Hands-On Guide to the Core Foundations of a Training Framework

Dive into the essentials of neural networks with this hands-on tutorial! Learn how to create a neural network from the ground up, focusing on the Parameter and Module classes, backpropagation, and practical implementation. Explore key concepts like initialization methods (Xavier, He), gradient tracking, and sequential deep learning models - all explained step-by-step with real code examples.

📼 YouTube: https://www.youtube.com/watch?v=b16qKLmp2ro

Building PyTorch: Crafting Linear Layers and Parameter Counting in MicroTorch

In this hands-on tutorial, we refine our tensor operations and introduce linear layers from scratch. Explore how to fix transpose gradients, implement parameter counting for modules, and build efficient linear layers using matrix dot products. We’ll dive into dimensionality checks, Xavier initialization, and bias handling - all with practical code examples.

📼 YouTube: https://www.youtube.com/watch?v=F9GH3nF4nkM

Me

Building PyTorch: Mastering Matrix Multiplication and Linear Layers in MicroTorch

Dive deep into implementing matrix multiplication (dot product) and linear layers from scratch. Learn the calculus behind forward and backward passes, handle multi-dimensional tensors, and build PyTorch-style APIs with real code examples. We’ll cover gradient computation, broadcasting, and operator overloading—key foundations for neural network training.

📼 YouTube: https://www.youtube.com/watch?v=UQIGmdXZd_U