8-Week Deep Learning Study Plan

8-Week Deep Learning Study Plan (Starting December 1)

My goal over the next 8 weeks is to build a solid foundation in machine learning and deep learning, while keeping a realistic schedule alongside work and existing commitments.

Constraints:

  • Work: roughly 9:00–14:30 on weekdays
  • Running: ~2 hours, 3 days per week
  • At least one full rest day per week
  • Target study time: ~8–10 hours per week
  • Start of Week 1: December 1

Long-term goals:

  • Transition into the ML/AI industry
  • Prepare for a future master’s degree with a research focus
  • Build long-term habits: regular blogging and Anki review

This plan is aligned with the phases in my Deep Learning Architecture Roadmap (math → tools → ML fundamentals → deep learning).

Global Structure and Habits

Before diving into week-by-week details, here are the cross-cutting habits I will maintain.

Time Allocation (per typical week)

  • 2× “deep focus” sessions (non-running weekday evenings): ~1.5 hours each
  • 3× “light” sessions (running days): 30–45 minutes each
  • 1× longer weekend block (study day): 3–4 hours
  • 1× full rest day: 0 hours

Total target: 8–10 hours per week

I’ll treat this as the baseline and adjust dynamically if I have more or less energy.

Anki Routine

  • Create 5–10 new cards on most study days
  • Review 20–40 cards per day
  • Focus on:
    • Core definitions (gradient, loss, bias/variance, etc.)
    • Key formulas (e.g., gradients of common functions)
    • Notation and shapes (dimensions of matrices/tensors)
    • Terminology and concepts (overfitting, regularization, etc.)

Blogging Routine

  • One post per week, 600–1200 words
  • Each post tied directly to that week’s learning
  • Style: explanation + personal reflection, not just notes
  • Goal: build public learning log, improve writing, and prepare for future research writing

Week 1 (Dec 1–Dec 7) — Setup, Gradients, and Vectors

Theme: Foundations and environment

Objectives:

  • Set up a clean Python environment for ML/DL work
  • Refresh key math concepts: vectors, matrices, gradients
  • Establish Anki and blogging workflows

Study Tasks:

  1. Environment

    • Set up:
      • Python (3.x)
      • virtualenv or conda environment
      • numpy, scipy, matplotlib, pandas
      • Jupyter or VS Code notebooks
    • Create a dedicated “ml-playground” repo or folder for all experiments.

  2. Math Foundations (Light but Practical)

    • Refresh:
      • Vectors and matrices (addition, multiplication, dot products)
      • Matrix–vector multiplication as “combining features”
      • Basic derivatives: polynomials, exponentials, logs
    • Focus on:
      • Gradient of a scalar function w.r.t. a vector
      • Chain rule in the context of simple compositions

  3. Anki

    • Create initial deck(s):
      • “ML Math Basics”
      • Example cards:
        • “Definition of gradient”
        • “Matrix–vector product shape rule”
        • “Chain rule (short statement)”
        • “What does ∇f(x) represent?”

  4. Blog

    • Post 1 (suggested title):
      • “Starting My 8-Week Deep Learning Sprint”
    • Content ideas:
      • Why I’m doing this
      • Constraints and realistic time budget
      • Overview of this 8-week plan
      • Initial feelings: ambition, uncertainty, but structured approach

Week 2 (Dec 8–Dec 14) — NumPy and Logistic Regression

Theme: From math to code

Objectives:

  • Get comfortable with NumPy for vectorized numerical computing
  • Implement logistic regression in NumPy (binary classification)

Study Tasks:

  1. NumPy Essentials

    • Arrays, shapes, indexing, slicing
    • Broadcasting rules in practice
    • np.dot, @, np.sum, np.mean, np.max/np.argmax
    • Random initialization (np.random.randn, np.random.seed)

  2. Logistic Regression in NumPy

    • Implement:
      • Sigmoid function
      • Binary cross-entropy loss
      • Prediction: ŷ = σ(XW + b)
    • Use gradient descent to fit a simple 2D toy dataset:
      • E.g., two classes separable by a line

  3. Anki

    • Cards for:
      • Sigmoid function definition
      • Gradient of sigmoid
      • Binary cross-entropy formula
      • Basic NumPy broadcasting rules

  4. Blog

    • Post 2 (suggested title):
      • “Implementing Logistic Regression in NumPy as a Software Engineer”
    • Content ideas:
      • Explain logistic regression intuitively
      • Show a small code snippet (not entire project if too long)
      • Reflect on switching from Java/JS mindset to vectorized NumPy

Week 3 (Dec 15–Dec 21) — Softmax, Multiclass, and Overfitting

Theme: Multiclass classification and generalization

Objectives:

  • Understand softmax and multiclass classification
  • Understand overfitting, regularization, and train/validation splits

Study Tasks:

  1. Softmax Classifier

    • Implement:
      • Softmax function with numerical stability
      • Cross-entropy loss for multiclass
    • Try on a tiny synthetic dataset with 3+ classes.

  2. Overfitting and Regularization

    • Concepts:
      • Train vs validation split
      • Overfitting vs underfitting
      • L2 regularization intuition
    • Implement L2 penalty in logistic or softmax model.

  3. Anki

    • Cards for:
      • Softmax formula
      • Gradient of softmax + cross-entropy (at high level)
      • Definitions: overfitting, underfitting, regularization
      • “What is train/validation split?”

  4. Blog

    • Post 3 (suggested title):
      • “From Sigmoid to Softmax: Understanding Multiclass Classification”
    • Content ideas:
      • Explain softmax in words and simple math
      • Show why numerical stability matters
      • Share an example of overfitting in a small experiment

Week 4 (Dec 22–Dec 28) — Classical ML with Scikit-Learn

Theme: Practical ML pipelines

Objectives:

  • Solidify understanding of classical ML workflow
  • Use scikit-learn to quickly experiment with models and evaluation

Study Tasks:

  1. ML Workflow with scikit-learn

    • Use a simple dataset (e.g., from sklearn.datasets):
      • Train/test split
      • Fit models: logistic regression, decision tree, maybe random forest
      • Evaluate accuracy, confusion matrix, basic metrics

  2. Pipelines and Preprocessing

    • Practice:
      • Scaling features (StandardScaler)
      • Using pipelines (Pipeline or make_pipeline)
    • Understand:
      • Why scaling matters for some models
      • How pipelines avoid data leakage

  3. Anki

    • Cards for:
      • Definition of data leakage
      • What scaling does
      • Difference between training and test error
      • Names and basic roles of commonly used scikit-learn components

  4. Blog

    • Post 4 (suggested title):
      • “My First End-to-End ML Pipeline with Scikit-Learn”
    • Content ideas:
      • Show how little code is needed to do something useful
      • Reflect on connection between manual NumPy models and high-level sklearn
      • Mention lessons about evaluation and train/test leakage

Week 5 (Dec 29–Jan 4) — Introduction to Neural Networks

Theme: From linear models to neural networks

Objectives:

  • Understand what a neural network computes
  • Implement a forward pass for a small MLP (multi-layer perceptron)

Study Tasks:

  1. Conceptual

    • Layers as linear transformation + nonlinearity
    • Activations: ReLU, sigmoid, tanh
    • Loss functions revisited: MSE vs cross-entropy

  2. Forward Pass in NumPy

    • Implement:
      • 2-layer network: X → W1,b1 → activation → W2,b2 → softmax
    • Focus on:
      • Shape tracking
      • Clean, modular functions for each step

  3. Anki

    • Cards for:
      • Definition of an MLP
      • Common activation functions and their properties
      • High-level view of forward pass

  4. Blog

    • Post 5 (suggested title):
      • “What a Neural Network Actually Computes”
    • Content ideas:
      • Explain NN as chained linear functions + nonlinearity
      • Use diagrams to show the layers
      • Connect back to logistic/softmax regression as one-layer networks

Week 6 (Jan 5–Jan 11) — Backpropagation and Training an MLP from Scratch

Theme: Learning in neural networks

Objectives:

  • Derive or at least deeply understand backpropagation
  • Train a simple MLP from scratch on a small dataset (ideally MNIST or a subset)

Study Tasks:

  1. Backprop Conceptually

    • Understand:
      • Chain rule through layers
      • How gradients flow from output to input
    • Work through:
      • Gradients for a 2-layer MLP manually on paper or in notes

  2. Training Loop in NumPy

    • Implement:
      • Parameter initialization
      • Forward pass
      • Loss computation
      • Backward pass (gradients)
      • Parameter update (gradient descent)
    • Train on:
      • Either a small synthetic dataset
      • Or MNIST (even if slow)

  3. Anki

    • Cards for:
      • Verbal explanation of backpropagation
      • Key gradient expressions (at a high or mid-level)
      • Problem types where MLP is appropriate

  4. Blog

    • Post 6 (suggested title):
      • “Backpropagation Demystified: Training My First Neural Network from Scratch”
    • Content ideas:
      • Show simplified derivations
      • Describe bugs you encountered (NaNs, exploding loss, shape mismatches)
      • Reflect on how understanding backprop changes your view of DL frameworks

Week 7 (Jan 12–Jan 18) — PyTorch Fundamentals

Theme: Moving from raw NumPy to a DL framework

Objectives:

  • Learn the core PyTorch abstractions
  • Re-implement your MLP using PyTorch

Study Tasks:

  1. PyTorch Basics

    • Tensors: creation, device placement (CPU/GPU if available)
    • Autograd: requires_grad, backward, grad
    • nn.Module, nn.Linear, activation functions
    • Optimizers: SGD, Adam
    • DataLoader for batching

  2. Re-implement MLP

    • Build:
      • An nn.Module for a small MLP
    • Training loop:
      • Forward pass
      • Loss with nn.CrossEntropyLoss
      • optimizer.zero_grad(), loss.backward(), optimizer.step()
    • Train on:
      • MNIST or similar dataset via torchvision (or your prepared dataset)

  3. Anki

    • Cards for:
      • Key PyTorch concepts (Tensor, Module, DataLoader, optimizer)
      • Typical training loop steps
      • Common gotchas (e.g. forgetting zero_grad)

  4. Blog

    • Post 7 (suggested title):
      • “Learning PyTorch: Rebuilding My Neural Network with Autograd”
    • Content ideas:
      • Compare manual gradients vs autograd
      • Show key PyTorch code snippets
      • Reflect on where frameworks “hide” complexity and why foundational understanding still matters

Week 8 (Jan 19–Jan 25) — Consolidation and First “Real” Project

Theme: Consolidation and reflection

Objectives:

  • Solidify everything learned so far
  • Complete one small but “real” deep learning project
  • Reflect on 8-week journey and plan next steps

Study Tasks:

  1. Mini-Project Choose one:

    • Option A: Improved MNIST Classifier
      • Add one or two improvements:
        • Learning-rate scheduling
        • Better initialization
        • Dropout
        • Batch normalization (optional)
    • Option B: Tiny CNN
      • Replace MLP with a small convolutional network
      • Learn how Conv2D, pooling, and flattening work
    • Option C: Simple Tabular Model
      • Use PyTorch for a regression/classification problem on tabular data
      • Compare performance with classical ML baseline

  2. Cleanup and Documentation

    • Organize code into a “projects” folder
    • Add at least one README describing:
      • Problem
      • Data
      • Model
      • Results
      • Lessons learned

  3. Anki

    • Review:
      • All key decks created so far
    • Prune:
      • Remove or edit cards that feel unclear or too long
    • Goal:
      • Have a lean, high-quality deck that will support future study (e.g., for a master’s).

  4. Blog

    • Post 8 (suggested title):
      • “What I Learned in 8 Weeks of Focused Deep Learning Study”
    • Content ideas:
      • Summarize milestones:
        • Logistic regression → softmax
        • Classical ML → MLP from scratch
        • Backprop → PyTorch implementation
      • Reflect on:
        • What concepts felt hardest
        • Where you want to go next (CNNs, transformers, generative models, or research)
        • How the habits of blogging and Anki have helped

After the 8 Weeks

This 8-week plan is not the end goal; it’s a ramp.

After this, I will be in a good position to:

  • Start exploring deeper architectures (CNNs, transformers, VAEs, etc.)
  • Read and implement ideas from research papers
  • Consider formal study (master’s program) with much stronger foundations
  • Grow my blog into a long-term record of my ML journey
  • Continue expanding my Anki decks as the “long-term memory” layer for math and ML concepts

The key outcome is not just the models I build, but the combination of:

  • consistent study habit
  • clear understanding of core ML/DL concepts
  • writing and reflection skills
  • a reproducible workflow I can follow and upgrade over time.