Day 1 (Tuesday, July 01, 2025)

Topic: Course introduction and Python environment setup

Key Concepts: Python installation, Anaconda/virtualenv, Jupyter notebooks, basic syntax (print, comments)
Tools/Libraries Introduced: Python 3.x, Anaconda or venv, Jupyter Notebook
Outcome by EOD: Environment is set up; student can run Python code and understand basic syntax.
Hands-On Exercise: Install Anaconda or Python, launch Jupyter, write 'Hello World', do simple arithmetic in a
notebook.
Deliverable: A Jupyter notebook with Hello World and simple calculations.

Day 2 (Wednesday, July 02, 2025)

Topic: Variables and data types in Python
Key Concepts: Variables, data types (int, float, str, bool), type conversion, basic operations
Tools/Libraries Introduced: Python built-in types
Outcome by EOD: Declare variables of different types and perform operations and type casting.
Hands-On Exercise: Create variables of each type, perform arithmetic and string concatenation.
Deliverable: Notebook with examples of variables and operations.

Day 3 (Thursday, July 03, 2025)

Topic: Control flow in Python (if, loops)
Key Concepts: Conditional statements (if/elif/else), for loops, while loops, break/continue
Tools/Libraries Introduced: -- (Python syntax)
Outcome by EOD: Write scripts using loops and conditionals to control program flow.
Hands-On Exercise: Write FizzBuzz or factorial calculator using loops and conditionals.
Deliverable: Notebook with loop and conditional examples (e.g., FizzBuzz output).

Day 4 (Friday, July 04, 2025)

Topic: Python data structures (lists, tuples)
Key Concepts: List creation, indexing, slicing, iteration; tuple immutability, uses
Tools/Libraries Introduced: --
Outcome by EOD: Use lists and tuples to store collections and manipulate them.
Hands-On Exercise: Create a list of numbers/strings, perform indexing and slicing, loop through list.
Deliverable: Notebook demonstrating list and tuple operations.

1
Day 5 (Saturday, July 05, 2025)
Topic: Python data structures (dictionaries, sets)
Key Concepts: Dictionary key-value pairs, accessing/updating, set operations (union, intersection)
Tools/Libraries Introduced: --
Outcome by EOD: Use dict and set data structures to organize data and remove duplicates.
Hands-On Exercise: Count word frequencies in a string using a dict; demonstrate set operations.
Deliverable: Notebook with dictionary and set examples (word count, set uniqueness).

Day 6 (Sunday, July 06, 2025)

Topic: Functions and modular code in Python
Key Concepts: Defining functions, parameters, return values, scope, importing modules
Tools/Libraries Introduced: Python standard library (e.g., math, random)
Outcome by EOD: Write reusable functions and use Python libraries (e.g., math, random).
Hands-On Exercise: Write a function for factorial or gcd, import math and random modules.
Deliverable: Notebook or script with custom functions and examples using math library.

Day 7 (Monday, July 07, 2025)

Topic: Week 1 Integration project – Python fundamentals
Key Concepts: Combined review of Python basics, script writing, data I/O
Tools/Libraries Introduced: Python, Jupyter
Outcome by EOD: Apply Python basics to a simple real task.
Hands-On Exercise: Create a Python script or notebook that reads a text file or CSV, processes data (e.g.,
counts words), and prints results.
Deliverable: Week 1 Project notebook/script on GitHub (basic data processing).

Week 1 Project
Title: Python Fundamentals Practice
Summary: Build a basic Python script or notebook that demonstrates use of variables, loops, and data
structures on a small data processing task (e.g., text word count or simple calculation).
Tools Used: Python, Jupyter Notebook
Expected Deliverable: A GitHub repository or notebook with code, showing Python fundamentals in action.

Day 8 (Tuesday, July 08, 2025)

Topic: Introduction to Git and version control
Key Concepts: Git basics (init, clone, commit, push), version control workflow
Tools/Libraries Introduced: Git, GitHub, command line
Outcome by EOD: Create a GitHub account, initialize a repo, make initial commits.
Hands-On Exercise: Initialize a local Git repository, make changes to the Week 1 project files, commit and

2
push to GitHub.
Deliverable: GitHub repository with initial commits of project code.

Day 9 (Wednesday, July 09, 2025)

Topic: Command Line and Bash basics
Key Concepts: Navigating directories, managing files (ls, cd, mkdir, cp, mv, rm), piping and redirection
Tools/Libraries Introduced: Bash shell or terminal
Outcome by EOD: Use the command line to navigate the file system and run Python scripts.
Hands-On Exercise: Use CLI to create a project directory, move files, and run a Python script from the
terminal.
Deliverable: Text file or script showing commands used and output of a Python run.

Day 10 (Thursday, July 10, 2025)

Topic: Python Environment and Package Management
Key Concepts: Virtual environments (venv/conda), installing packages (pip), managing dependencies
Tools/Libraries Introduced: venv or conda, pip
Outcome by EOD: Set up an isolated Python environment and install libraries like numpy, pandas.
Hands-On Exercise: Create and activate a virtual environment, install numpy and pandas using pip or conda.
Deliverable: Screenshot or log of environment setup commands and installed package list.

Day 11 (Friday, July 11, 2025)

Topic: Introduction to NumPy
Key Concepts: NumPy arrays, array creation, indexing, basic array operations
Tools/Libraries Introduced: NumPy
Outcome by EOD: Use NumPy for numerical operations on arrays (vectorized ops, slicing).
Hands-On Exercise: Create NumPy arrays (1D and 2D), perform elementwise operations, compute mean
and sum.
Deliverable: Notebook demonstrating array creation and basic NumPy operations.

Day 12 (Saturday, July 12, 2025)

Topic: Introduction to Pandas: DataFrames and Series
Key Concepts: Pandas Series, DataFrame, reading data from CSV/Excel, head, tail, info, describe
Tools/Libraries Introduced: Pandas
Outcome by EOD: Load a CSV file into a DataFrame and perform basic inspection and summary.
Hands-On Exercise: Download a sample dataset (e.g., Iris or a CSV from UCI), load it into Pandas and display
first few rows and summary stats.
Deliverable: Notebook with Pandas data loading and initial inspection.

3
Day 13 (Sunday, July 13, 2025)
Topic: Data wrangling with Pandas
Key Concepts: DataFrame indexing, selection, filtering, handling missing values, adding/removing columns
Tools/Libraries Introduced: Pandas
Outcome by EOD: Manipulate DataFrames by selecting subsets, handling nulls, and creating new features.
Hands-On Exercise: Use Pandas to filter rows based on condition, fill or drop missing data, and create a new
column (e.g., total from components).
Deliverable: Notebook demonstrating Pandas data wrangling tasks.

Day 14 (Monday, July 14, 2025)

Topic: Data visualization with Matplotlib and Seaborn
Key Concepts: Plot types (line, bar, scatter, histogram, boxplot), customizing plots (labels, title, legend)
Tools/Libraries Introduced: Matplotlib, Seaborn
Outcome by EOD: Create basic visualizations for data exploration.
Hands-On Exercise: Plot histograms, scatter plots, and boxplots using Matplotlib/Seaborn on the loaded
dataset.
Deliverable: Notebook with several plots visualizing data distributions and relationships.

Week 2 Project
Title: Git and Data Exploration Project
Summary: Create a GitHub repo, add a dataset (e.g., Iris or Titanic CSV), commit code that loads data with
Pandas, cleans it, and produces initial plots (e.g., histograms or scatter plots).
Tools Used: Python, Pandas, Matplotlib/Seaborn, Git
Expected Deliverable: GitHub repo with code and visualizations showing data loading, cleaning, and basic
plots.

Day 15 (Tuesday, July 15, 2025)

Topic: Exploratory Data Analysis (EDA) and Data Cleaning
Key Concepts: Handling missing data, data imputation, outlier detection, data summarization
Tools/Libraries Introduced: Pandas (continued)
Outcome by EOD: Identify and handle missing or anomalous data, compute summary statistics.
Hands-On Exercise: Use Pandas to find missing values in the dataset, fill with mean/median, detect outliers
using standard deviation or visualization.
Deliverable: Notebook showing data cleaning steps and summary statistics of the dataset.

Day 16 (Wednesday, July 16, 2025)

Topic: More Data Visualization (Seaborn advanced)
Key Concepts: Seaborn pairplot, heatmap of correlations, categorical plots (boxplot, violin)
Tools/Libraries Introduced: Seaborn (continued)

4
Outcome by EOD: Create pair plots and heatmaps to explore relationships; visualize categories.
Hands-On Exercise: Generate a pairplot of numeric features, a correlation heatmap, and boxplots for
categorical vs numeric data.
Deliverable: Notebook with visual exploration plots (pairplot, heatmap, boxplots).

Day 17 (Thursday, July 17, 2025)

Topic: Mathematical foundations – Linear Algebra I
Key Concepts: Vectors and matrices, operations (addition, multiplication), transpose, identity matrix
Tools/Libraries Introduced: NumPy (continued)
Outcome by EOD: Perform basic vector and matrix operations using NumPy.
Hands-On Exercise: Create NumPy arrays representing vectors and matrices; compute their dot product and
matrix multiplication.
Deliverable: Notebook with examples of linear algebra operations using NumPy.

Day 18 (Friday, July 18, 2025)

Topic: Mathematical foundations – Linear Algebra II
Key Concepts: Matrix inversion, determinants, rank, eigenvalues and eigenvectors
Tools/Libraries Introduced: NumPy.linalg, SciPy
Outcome by EOD: Compute matrix inverse/determinant and understand their significance; compute eigen
decomposition.
Hands-On Exercise: Use NumPy/SciPy to compute the inverse, determinant, eigenvalues/vectors of sample
matrices.
Deliverable: Notebook with linear algebra computations (inverse, eigenvalues).

Day 19 (Saturday, July 19, 2025)

Topic: Mathematical foundations – Probability & Statistics I
Key Concepts: Probability basics, probability distributions (binomial, normal), expectation and variance
Tools/Libraries Introduced: SciPy.stats
Outcome by EOD: Calculate probabilities and visualize distributions (normal, binomial).
Hands-On Exercise: Plot PDF and CDF of normal and binomial distributions using SciPy; calculate
probabilities for given events.
Deliverable: Notebook showing probability distribution plots and computed probabilities.

Day 20 (Sunday, July 20, 2025)

Topic: Mathematical foundations – Probability & Statistics II
Key Concepts: Descriptive statistics (mean, median, mode), hypothesis testing basics (t-test, p-values)
Tools/Libraries Introduced: SciPy.stats, Pingouin or Statsmodels
Outcome by EOD: Compute statistical measures and perform a simple hypothesis test.
Hands-On Exercise: Compute mean/median/mode for a dataset; perform a t-test comparing two sample

5
groups.
Deliverable: Notebook with descriptive stats and t-test results.

Day 21 (Monday, July 21, 2025)

Topic: Project - Data Analysis and Visualization
Key Concepts: Integrating Pandas, visualization, and statistics
Tools/Libraries Introduced: Pandas, Matplotlib, Seaborn
Outcome by EOD: Apply the week’s learning to a mini data project.
Hands-On Exercise: Perform complete EDA on a new dataset (e.g., Iris or Housing) including cleaning,
plotting, and statistical summary.
Deliverable: Notebook with comprehensive EDA and visualizations; charts and summary statistics.

Week 3 Project
Title: Exploratory Data Analysis Project
Summary: Conduct an end-to-end exploratory analysis on a chosen dataset, including data cleaning,
visualization, and basic statistical insights.
Tools Used: Python, Pandas, Matplotlib/Seaborn
Expected Deliverable: A well-documented Jupyter notebook (on GitHub) demonstrating the EDA process
with visuals and observations.

Day 22 (Tuesday, July 22, 2025)

Topic: Mathematical foundations – Calculus basics
Key Concepts: Derivatives, gradients, rate of change, partial derivatives (intuition)
Tools/Libraries Introduced: SymPy (optional for symbolic derivation)
Outcome by EOD: Understand basic calculus concepts and compute derivatives of simple functions.
Hands-On Exercise: Compute derivative of a polynomial function manually and using SymPy; plot function
and its slope.
Deliverable: Notebook with calculus examples (function, derivative, graph).

Day 23 (Wednesday, July 23, 2025)

Topic: Month 1 Capstone Project – Titanic Data Analysis
Key Concepts: Data cleaning, EDA, basic classification ideas
Tools/Libraries Introduced: Pandas, Matplotlib/Seaborn, Jupyter
Outcome by EOD: Perform a thorough analysis of the Titanic dataset to draw insights about passenger
survival.
Hands-On Exercise: Clean the Titanic data (handle missing Age/Embarked), create insightful visualizations
(e.g., survival by gender or class), compute descriptive stats.
Deliverable: Jupyter notebook summarizing EDA, visualizations, and key findings on Titanic dataset.

Month 1 Capstone Project

Title: Titanic Survival Data Exploration

6
Problem Statement: Analyze the Titanic passenger dataset to understand factors that influenced survival
rates.
Skills Integrated: Python fundamentals, data cleaning, Pandas operations, data visualization, basic statistics
Deliverables: A comprehensive notebook (or report) with data loading, cleaning steps, visualizations
(survival by class, gender, age distribution) and interpretations.
Bonus/Stretch Goal: Implement a simple logistic regression model to predict survival and evaluate its
accuracy.

Day 24 (Thursday, July 24, 2025)

Topic: Introduction to Machine Learning and the Data Pipeline
Key Concepts: ML workflow, supervised vs unsupervised learning, features and labels
Tools/Libraries Introduced: scikit-learn overview
Outcome by EOD: Understand basic ML concepts and the structure of a typical ML project.
Hands-On Exercise: Outline steps of a machine learning pipeline on paper (data collection, cleaning,
modeling, evaluation).
Deliverable: A text or markdown file summarizing the machine learning workflow.

Day 25 (Friday, July 25, 2025)

Topic: Supervised Learning – Regression (Linear Regression)
Key Concepts: Simple linear regression, least squares, model fitting
Tools/Libraries Introduced: scikit-learn (LinearRegression), NumPy
Outcome by EOD: Implement linear regression on a dataset and interpret coefficients.
Hands-On Exercise: Use scikit-learn to fit a LinearRegression model on a small dataset (e.g., predict house
prices from size).
Deliverable: Notebook with code fitting a linear model and showing coefficients and predictions.

Day 26 (Saturday, July 26, 2025)

Topic: Regression Metrics
Key Concepts: MSE, RMSE, MAE, R-squared
Tools/Libraries Introduced: scikit-learn metrics
Outcome by EOD: Compute and interpret common regression evaluation metrics.
Hands-On Exercise: Calculate MSE and R^2 for the regression model from yesterday on a test set.
Deliverable: Notebook showing metric calculations for regression.

Day 27 (Sunday, July 27, 2025)

Topic: Supervised Learning – Classification (Logistic Regression)
Key Concepts: Logistic function, binary classification, decision boundary
Tools/Libraries Introduced: scikit-learn (LogisticRegression)
Outcome by EOD: Train a logistic regression model for classification.

7
Hands-On Exercise: Apply LogisticRegression on a sample classification dataset (e.g., Iris binary classes or
Titanic data prepared).
Deliverable: Notebook with code training logistic regression and predicting classes.

Day 28 (Monday, July 28, 2025)

Topic: Classification Metrics
Key Concepts: Accuracy, precision, recall, F1-score, confusion matrix
Tools/Libraries Introduced: scikit-learn metrics (classification_report, confusion_matrix)
Outcome by EOD: Evaluate classification performance using different metrics.
Hands-On Exercise: Compute and visualize a confusion matrix and classification report for the logistic
regression model.
Deliverable: Notebook showing confusion matrix and metric outputs.

Day 29 (Tuesday, July 29, 2025)

Topic: Model Validation – Overfitting & Cross-Validation
Key Concepts: Train/test split, overfitting vs underfitting, k-fold cross-validation
Tools/Libraries Introduced: scikit-learn (train_test_split, cross_val_score)
Outcome by EOD: Split data into train/test and perform cross-validation to assess model generalization.
Hands-On Exercise: Split a dataset (e.g., Iris) into train/test, train a model, and compute cross-val scores.
Deliverable: Notebook showing train/test split and cross-validation scores.

Day 30 (Wednesday, July 30, 2025)

Topic: Week 5 Project – Simple Predictive Modeling
Key Concepts: Applying regression and classification models end-to-end
Tools/Libraries Introduced: scikit-learn, Pandas, Matplotlib
Outcome by EOD: Build simple regression and classification models on real data.
Hands-On Exercise: Choose a dataset (e.g., Boston Housing for regression, Iris for classification), build a
model pipeline, and evaluate it.
Deliverable: Notebook with at least one regression model and one classification model, including train/test
split and metrics.

Week 5 Project
Title: Regression and Classification Models
Summary: Develop a regression model (predicting numeric target) and a classification model (predicting
categorical target) using scikit-learn. Include data splitting, model training, and evaluation.
Tools Used: Python, scikit-learn, Pandas, Matplotlib
Expected Deliverable: A notebook containing data preprocessing, model training, and performance
evaluation for both a regression and a classification task.

8
Day 31 (Thursday, July 31, 2025)
Topic: Feature Engineering – Encoding and Scaling
Key Concepts: One-hot encoding for categorical data, label encoding, feature scaling (standardization,
normalization)
Tools/Libraries Introduced: scikit-learn (OneHotEncoder, StandardScaler)
Outcome by EOD: Transform categorical features and scale numeric features appropriately.
Hands-On Exercise: Use pandas and sklearn to one-hot encode a categorical column and scale numeric
columns of a dataset.
Deliverable: Notebook showing encoded and scaled features ready for modeling.

Day 32 (Friday, August 01, 2025)

Topic: Machine Learning Pipelines
Key Concepts: Automating workflows with sklearn Pipeline, chaining preprocessing and model steps
Tools/Libraries Introduced: scikit-learn (Pipeline, ColumnTransformer)
Outcome by EOD: Create a pipeline that applies transformations and fits a model in one step.
Hands-On Exercise: Build an sklearn Pipeline for a dataset that includes preprocessing steps and a classifier
or regressor.
Deliverable: Notebook demonstrating pipeline construction and usage.

Day 33 (Saturday, August 02, 2025)

Topic: Hyperparameter Tuning
Key Concepts: Grid search, random search, cross-validation for tuning
Tools/Libraries Introduced: scikit-learn (GridSearchCV, RandomizedSearchCV)
Outcome by EOD: Optimize model performance by searching for best hyperparameters.
Hands-On Exercise: Use GridSearchCV to tune hyperparameters of a decision tree or SVM on a dataset.
Deliverable: Notebook showing hyperparameter search results and selected best model.

Day 34 (Sunday, August 03, 2025)

Topic: Decision Trees
Key Concepts: Tree structure, splits, overfitting in trees, pruning concept
Tools/Libraries Introduced: scikit-learn (DecisionTreeClassifier/Regressor)
Outcome by EOD: Train a decision tree and understand its splits and overfitting behavior.
Hands-On Exercise: Train a decision tree on a classification dataset, visualize the tree structure, and analyze
overfitting by adjusting max_depth.
Deliverable: Notebook with decision tree training and visualization (using export_graphviz or plot_tree).

9
Day 35 (Monday, August 04, 2025)
Topic: Ensemble Methods – Random Forest
Key Concepts: Bagging, random forests, out-of-bag error, feature importance
Tools/Libraries Introduced: scikit-learn (RandomForestClassifier/Regressor)
Outcome by EOD: Build a random forest ensemble and interpret its feature importances.
Hands-On Exercise: Train a RandomForest on a dataset, extract feature importances, and compare
performance to a single decision tree.
Deliverable: Notebook with random forest results and feature importance plot.

Day 36 (Tuesday, August 05, 2025)

Topic: Ensemble Methods – Boosting Basics
Key Concepts: Boosting introduction (AdaBoost, gradient boosting concepts)
Tools/Libraries Introduced: scikit-learn (AdaBoost, GradientBoostingClassifier)
Outcome by EOD: Understand boosting concept; train an AdaBoost or GradientBoost model.
Hands-On Exercise: Train an AdaBoost classifier on a dataset and compare its performance to a single tree.
Deliverable: Notebook with AdaBoost training and comparison metrics.

Day 37 (Wednesday, August 06, 2025)

Topic: Week 6 Project – Advanced Supervised Models
Key Concepts: Feature engineering, model tuning, ensemble learning
Tools/Libraries Introduced: Python, scikit-learn
Outcome by EOD: Build a machine learning pipeline including preprocessing, an ensemble model, and
hyperparameter tuning.
Hands-On Exercise: Choose a complex dataset (e.g., Kaggle Titanic or a public dataset with categorical
features). Build a pipeline with encoding, scaling, and a Random Forest or boosted model; tune
hyperparameters.
Deliverable: Notebook with end-to-end workflow: data preprocessing, model training (RandomForest/
AdaBoost), hyperparameter tuning, and evaluation.

Week 6 Project
Title: ML Pipeline with Ensemble Model
Summary: Integrate feature engineering, pipeline creation, and an ensemble model (random forest or
boosted trees) on a real dataset. Include hyperparameter tuning and evaluation.
Tools Used: Python, pandas, scikit-learn
Expected Deliverable: A notebook or script on GitHub demonstrating the full ML pipeline and ensemble
model performance with commentary.

10
Day 38 (Thursday, August 07, 2025)
Topic: Ensemble Methods – XGBoost and Gradient Boosting
Key Concepts: Gradient Boosting Machines, XGBoost algorithm, tuning boosting parameters
Tools/Libraries Introduced: XGBoost or LightGBM, scikit-learn interface
Outcome by EOD: Train an XGBoost model and understand its performance improvements.
Hands-On Exercise: Install xgboost and train an XGBClassifier on a dataset, compare with Random Forest.
Deliverable: Notebook with XGBoost model training and performance comparison.

Day 39 (Friday, August 08, 2025)

Topic: Unsupervised Learning – K-Means Clustering
Key Concepts: K-means algorithm, choosing number of clusters, inertia, elbow method
Tools/Libraries Introduced: scikit-learn (KMeans)
Outcome by EOD: Perform k-means clustering and evaluate cluster quality.
Hands-On Exercise: Apply KMeans to a dataset (e.g., Iris without labels), use elbow method to choose k.
Deliverable: Notebook with clustering results and elbow plot.

Day 40 (Saturday, August 09, 2025)

Topic: Unsupervised Learning – Hierarchical Clustering and DBSCAN
Key Concepts: Agglomerative clustering, distance metrics, dendrogram; DBSCAN for density-based clusters
Tools/Libraries Introduced: scipy.cluster, scikit-learn (AgglomerativeClustering, DBSCAN)
Outcome by EOD: Explore different clustering approaches and their use cases.
Hands-On Exercise: Perform hierarchical clustering and plot a dendrogram; apply DBSCAN on a dataset and
visualize clusters.
Deliverable: Notebook with hierarchical clustering dendrogram and DBSCAN cluster visualization.

Day 41 (Sunday, August 10, 2025)

Topic: Dimensionality Reduction – PCA
Key Concepts: Principal Component Analysis, variance explained, dimensionality reduction
Tools/Libraries Introduced: scikit-learn (PCA)
Outcome by EOD: Reduce data dimensionality and visualize in 2D/3D principal component space.
Hands-On Exercise: Apply PCA on a dataset, plot data in first two principal component dimensions, and
analyze variance explained.
Deliverable: Notebook with PCA transformation plots and explained variance.

Day 42 (Monday, August 11, 2025)

Topic: Dimensionality Reduction – t-SNE and UMAP
Key Concepts: t-SNE for non-linear embedding, UMAP overview
Tools/Libraries Introduced: scikit-learn (TSNE), umap-learn (optional)

11
Outcome by EOD: Visualize high-dimensional data structure in 2D.
Hands-On Exercise: Use t-SNE on a dataset (e.g., MNIST or CIFAR reduced features) and plot clusters in 2D.
Deliverable: Notebook with t-SNE/UMAP scatter plot of data clusters.

Day 43 (Tuesday, August 12, 2025)

Topic: Unsupervised Learning – Anomaly Detection
Key Concepts: Identifying outliers, Isolation Forest, One-Class SVM
Tools/Libraries Introduced: scikit-learn (IsolationForest)
Outcome by EOD: Detect anomalies in data using unsupervised models.
Hands-On Exercise: Train an IsolationForest to detect outliers in a dataset and visualize anomalies.
Deliverable: Notebook showing anomaly detection results and evaluation.

Day 44 (Wednesday, August 13, 2025)

Topic: Week 7 Project – Unsupervised Learning and Clustering
Key Concepts: Clustering, dimensionality reduction, ensemble application
Tools/Libraries Introduced: scikit-learn, XGBoost
Outcome by EOD: Apply unsupervised methods and boosting to derive insights from data.
Hands-On Exercise: On a chosen dataset (e.g., customer data), perform clustering (KMeans), reduce
dimensionality (PCA or t-SNE), and optionally detect anomalies.
Deliverable: Notebook with clustering analysis, dimensionality reduction visualization, and anomaly
detection summary.

Week 7 Project
Title: Clustering and Dimensionality Reduction Project
Summary: Use K-means, hierarchical clustering, and PCA/t-SNE on a real dataset to segment the data and
visualize clusters. Optionally include anomaly detection.
Tools Used: Python, scikit-learn, matplotlib/seaborn
Expected Deliverable: A Jupyter notebook showing data clusters, plots of reduced dimensions, and
interpretation of clusters.

Day 45 (Thursday, August 14, 2025)

Topic: Review – Python, Git, and Environments
Key Concepts: Key Git commands, virtualenv usage, Python syntax refresher
Tools/Libraries Introduced: --
Outcome by EOD: Reinforce understanding of environment setup and version control.
Hands-On Exercise: Recall common Git commands in a quick quiz format; explain difference between conda
and venv.
Deliverable: Brief notes or answers to review questions.

12
Day 46 (Friday, August 15, 2025)
Topic: Review – Data Manipulation and Visualization
Key Concepts: Pandas DataFrame operations, Matplotlib/Seaborn plot types
Tools/Libraries Introduced: --
Outcome by EOD: Solidify understanding of data wrangling and visualization techniques.
Hands-On Exercise: Summarize how to handle missing data, and create one example plot of each type
learned.
Deliverable: Notebook or notes with sample visualizations and data cleaning steps.

Day 47 (Saturday, August 16, 2025)

Topic: Review – Mathematical Concepts
Key Concepts: Linear algebra operations, probability distributions, statistics
Tools/Libraries Introduced: --
Outcome by EOD: Strengthen grasp of math foundations covered.
Hands-On Exercise: Calculate a simple dot product, probability from distribution, and perform a z-test
manually.
Deliverable: Notebook with math review exercises and solutions.

Day 48 (Sunday, August 17, 2025)

Topic: Review – Machine Learning Basics
Key Concepts: Key ML algorithm steps, metrics, pipelines
Tools/Libraries Introduced: --
Outcome by EOD: Recall ML workflow and evaluation.
Hands-On Exercise: Describe steps to build and evaluate a model; list at least three evaluation metrics and
their use.
Deliverable: Written answers or code snippets demonstrating review of ML concepts.

Day 49 (Monday, August 18, 2025)

Topic: Practice – Mini Data Project
Key Concepts: End-to-end mini project application
Tools/Libraries Introduced: Python, Pandas
Outcome by EOD: Apply knowledge in a small combined task.
Hands-On Exercise: Take a small dataset (e.g., Iris) and perform one full cycle: load, clean (if needed), simple
modeling, and evaluation.
Deliverable: Notebook with the complete mini-project process.

13
Day 50 (Tuesday, August 19, 2025)
Topic: Review – Key Tools and Libraries
Key Concepts: Summary of packages used, best practices
Tools/Libraries Introduced: --
Outcome by EOD: Consolidate familiarity with tools.
Hands-On Exercise: Create flashcards or brief notes summarizing the purpose of libraries used (pandas,
numpy, sklearn, etc.) and commands learned.
Deliverable: Collection of flashcards or summary notes.

Day 51 (Wednesday, August 20, 2025)

Topic: Week 8 Project – Consolidated Analysis
Key Concepts: Integrated application of Python, data manipulation, and ML fundamentals
Tools/Libraries Introduced: Jupyter, scikit-learn, pandas, matplotlib
Outcome by EOD: Complete an integrated project applying all reviewed knowledge.
Hands-On Exercise: Perform a comprehensive analysis on a chosen dataset (e.g., Titanic or Iris) including
data loading, cleaning, exploratory plots, and fit a simple model.
Deliverable: Notebook with end-to-end analysis and a short write-up of findings.

Week 8 Project
Title: Integrated Data Analysis Challenge
Summary: Conduct a full data analysis cycle on a dataset, combining data cleaning, visualization, and a
basic model, showcasing everything learned so far.
Tools Used: Python, Pandas, Scikit-learn, Matplotlib/Seaborn
Expected Deliverable: A notebook/report demonstrating the entire workflow from raw data to initial insights
and model.

Day 52 (Thursday, August 21, 2025)

Topic: Review – Python, Git, and Environments
Key Concepts: Key Git commands, virtualenv usage, Python syntax refresher
Tools/Libraries Introduced: --
Outcome by EOD: Reinforce understanding of environment setup and version control.
Hands-On Exercise: Recall common Git commands in a quick quiz format; explain difference between conda
and venv.
Deliverable: Brief notes or answers to review questions.

Day 53 (Friday, August 22, 2025)

Topic: Review – Data Manipulation and Visualization
Key Concepts: Pandas DataFrame operations, Matplotlib/Seaborn plot types
Tools/Libraries Introduced: --

14
Outcome by EOD: Solidify understanding of data wrangling and visualization techniques.
Hands-On Exercise: Summarize how to handle missing data, and create one example plot of each type
learned.
Deliverable: Notebook or notes with sample visualizations and data cleaning steps.

Day 54 (Saturday, August 23, 2025)

Topic: Review – Mathematical Concepts
Key Concepts: Linear algebra operations, probability distributions, statistics
Tools/Libraries Introduced: --
Outcome by EOD: Strengthen grasp of math foundations covered.
Hands-On Exercise: Calculate a simple dot product, probability from distribution, and perform a z-test
manually.
Deliverable: Notebook with math review exercises and solutions.

Day 55 (Sunday, August 24, 2025)

Topic: Review – Machine Learning Basics
Key Concepts: Key ML algorithm steps, metrics, pipelines
Tools/Libraries Introduced: --
Outcome by EOD: Recall ML workflow and evaluation.
Hands-On Exercise: Describe steps to build and evaluate a model; list at least three evaluation metrics and
their use.
Deliverable: Written answers or code snippets demonstrating review of ML concepts.

Day 56 (Monday, August 25, 2025)

Topic: Practice – Mini Data Project
Key Concepts: End-to-end mini project application
Tools/Libraries Introduced: Python, Pandas
Outcome by EOD: Apply knowledge in a small combined task.
Hands-On Exercise: Take a small dataset (e.g., Iris) and perform one full cycle: load, clean (if needed), simple
modeling, and evaluation.
Deliverable: Notebook with the complete mini-project process.

Day 57 (Tuesday, August 26, 2025)

Topic: Review – Key Tools and Libraries
Key Concepts: Summary of packages used, best practices
Tools/Libraries Introduced: --
Outcome by EOD: Consolidate familiarity with tools.
Hands-On Exercise: Create flashcards or brief notes summarizing the purpose of libraries used (pandas,

15
numpy, sklearn, etc.) and commands learned.
Deliverable: Collection of flashcards or summary notes.

Day 58 (Wednesday, August 27, 2025)

Topic: Week 8 Project – Consolidated Analysis
Key Concepts: Integrated application of Python, data manipulation, and ML fundamentals
Tools/Libraries Introduced: Jupyter, scikit-learn, pandas, matplotlib
Outcome by EOD: Complete an integrated project applying all reviewed knowledge.
Hands-On Exercise: Perform a comprehensive analysis on a chosen dataset (e.g., Titanic or Iris) including
data loading, cleaning, exploratory plots, and fit a simple model.
Deliverable: Notebook with end-to-end analysis and a short write-up of findings.

Week 8 Project
Title: Integrated Data Analysis Challenge
Summary: Conduct a full data analysis cycle on a dataset, combining data cleaning, visualization, and a
basic model, showcasing everything learned so far.
Tools Used: Python, Pandas, Scikit-learn, Matplotlib/Seaborn
Expected Deliverable: A notebook/report demonstrating the entire workflow from raw data to initial insights
and model.

Day 59 (Thursday, August 28, 2025)

Topic: Capstone Project Preparation
Key Concepts: Project planning, dataset selection, preprocessing roadmap
Tools/Libraries Introduced: --
Outcome by EOD: Plan the approach for the month’s capstone project.
Hands-On Exercise: Outline steps and gather any required data for the capstone (e.g., download dataset,
explore features).
Deliverable: A README or outline document describing the project plan and dataset details.

Day 60 (Friday, August 29, 2025)

Topic: Month 2 Capstone Project – House Prices Prediction
Problem Statement: Predict house sale prices using a public dataset (e.g., Kaggle House Prices).
Skills Integrated: Data cleaning, feature engineering, regression modeling, evaluation, model tuning
Deliverables: A Jupyter notebook with full data loading, preprocessing steps (handling missing values,
encoding), feature engineering, model training (e.g., linear regression and XGBoost), and evaluation.
Bonus/Stretch Goal: Create a simple web app or Streamlit dashboard to visualize predictions or model
performance.

16
Day 61 (Saturday, August 30, 2025)
Topic: Introduction to Neural Networks and Deep Learning
Key Concepts: Perceptron, neurons, activation functions, architecture of neural networks
Tools/Libraries Introduced: TensorFlow and PyTorch installation
Outcome by EOD: Understand perceptron model and set up deep learning frameworks.
Hands-On Exercise: Implement a simple perceptron in Python; install TensorFlow and PyTorch libraries.
Deliverable: Notebook with a perceptron example and proof of installation (versions printed).

Day 62 (Sunday, August 31, 2025)

Topic: Multi-Layer Perceptron (MLP) and Backpropagation
Key Concepts: Hidden layers, forward pass, backpropagation, loss functions (MSE, cross-entropy)
Tools/Libraries Introduced: TensorFlow/Keras basics
Outcome by EOD: Build a basic MLP model in TensorFlow/Keras.
Hands-On Exercise: Create and train a simple MLP on a toy dataset (e.g., classify points or MNIST subset).
Deliverable: Notebook with Keras MLP model definition, training logs, and accuracy.

Day 63 (Monday, September 01, 2025)

Topic: Introduction to PyTorch
Key Concepts: Tensors in PyTorch, computation graph, autograd
Tools/Libraries Introduced: PyTorch tensors, torch.nn
Outcome by EOD: Set up a PyTorch environment and create simple tensor operations.
Hands-On Exercise: Perform basic tensor arithmetic in PyTorch and build a linear layer.
Deliverable: Notebook showing PyTorch tensor operations and a simple neural layer.

Day 64 (Tuesday, September 02, 2025)

Topic: Training Neural Networks – Optimizers and Training Loop
Key Concepts: Gradient descent, stochastic gradient descent, optimizer algorithms (SGD, Adam)
Tools/Libraries Introduced: Keras/TensorFlow optimizers, PyTorch optim
Outcome by EOD: Train a neural network using backprop with an optimizer.
Hands-On Exercise: Train the previous Keras model for a few epochs, and implement a training loop in
PyTorch.
Deliverable: Notebook with training code and loss/accuracy plots over epochs.

Day 65 (Wednesday, September 03, 2025)

Topic: Week 9 Project – Basic Neural Network
Key Concepts: End-to-end neural network implementation
Tools/Libraries Introduced: TensorFlow or PyTorch
Outcome by EOD: Apply a neural network to solve a classification problem.

17
Hands-On Exercise: Choose a dataset (e.g., MNIST or Fashion-MNIST), build a simple neural network in
TensorFlow or PyTorch, train it, and evaluate accuracy.
Deliverable: Notebook with neural network training and test accuracy on the chosen dataset.

Week 9 Project
Title: Handwritten Digit Recognition with Neural Network
Summary: Train a simple feedforward neural network on the MNIST dataset to classify handwritten digits.
Tools Used: Python, TensorFlow (or PyTorch)
Expected Deliverable: A trained neural network model and a report of its performance (accuracy, confusion
matrix).

Day 66 (Thursday, September 04, 2025)

Topic: Convolutional Neural Networks (CNN) Basics
Key Concepts: Convolution operation, filters, feature maps, pooling layers
Tools/Libraries Introduced: TensorFlow/Keras (Conv2D), PyTorch (nn.Conv2d)
Outcome by EOD: Build a simple CNN for image data.
Hands-On Exercise: Define a CNN architecture and train on a small image dataset (e.g., MNIST or CIFAR-10
subset).
Deliverable: Notebook with CNN model architecture and training results (accuracy/loss curves).

Day 67 (Friday, September 05, 2025)

Topic: Week 10 Project – Convolutional Neural Network
Key Concepts: CNN implementation and evaluation
Tools/Libraries Introduced: TensorFlow/PyTorch
Outcome by EOD: Use CNNs to improve image classification.
Hands-On Exercise: Train a CNN on the Fashion-MNIST or CIFAR-10 dataset and compare its accuracy to the
MLP.
Deliverable: Notebook with CNN training code and performance comparison to the previous model.

Week 10 Project
Title: CNN for Image Classification
Summary: Implement and train a convolutional neural network on an image classification dataset, and
report performance improvements over a simple MLP.
Tools Used: Python, Keras (TensorFlow) or PyTorch, Matplotlib
Expected Deliverable: Trained CNN model and evaluation metrics in a notebook.

Day 68 (Saturday, September 06, 2025)

Topic: Recurrent Neural Networks (RNN) Basics
Key Concepts: Sequence data, time steps, recurrent layer, RNN unrolling
Tools/Libraries Introduced: Keras (SimpleRNN), PyTorch (nn.RNN)
Outcome by EOD: Build a simple RNN for sequence data.

18
Hands-On Exercise: Use an RNN (e.g., SimpleRNN in Keras) on a toy sequence dataset (e.g., binary sequence
classification).
Deliverable: Notebook with RNN model and results on the sequence task.

Day 69 (Sunday, September 07, 2025)

Topic: Long Short-Term Memory (LSTM) Networks
Key Concepts: LSTM cells, addressing vanishing gradients, gates
Tools/Libraries Introduced: Keras (LSTM), PyTorch (nn.LSTM)
Outcome by EOD: Train an LSTM on sequence or time-series data.
Hands-On Exercise: Use an LSTM on a text sequence (e.g., sentiment analysis on small dataset) or simple
time series prediction.
Deliverable: Notebook with LSTM model and evaluation (e.g., text classification accuracy).

Day 70 (Monday, September 08, 2025)

Topic: Week 11 Project – Sequence Modeling
Key Concepts: RNN/LSTM implementation, sequence data classification
Tools/Libraries Introduced: Python, Keras or PyTorch
Outcome by EOD: Apply an LSTM or RNN to a real sequence problem.
Hands-On Exercise: Train a sentiment analysis model using an LSTM on a movie reviews dataset (e.g., IMDB)
or any sequence dataset.
Deliverable: Notebook with sequence model training and test accuracy (or other relevant metric).

Week 11 Project
Title: Sentiment Analysis with LSTM
Summary: Fine-tune an LSTM network on a text classification task (e.g., IMDB sentiment analysis) and
evaluate its performance.
Tools Used: Python, Keras or PyTorch, NLTK or similar for text preprocessing
Expected Deliverable: A trained LSTM model and a notebook showing test accuracy and confusion matrix.

Day 71 (Tuesday, September 09, 2025)

Topic: Transformers and Attention Mechanisms
Key Concepts: Self-attention, transformer architecture (encoder-decoder), BERT, GPT
Tools/Libraries Introduced: Hugging Face Transformers library
Outcome by EOD: Understand transformer basics and use a pre-trained model for NLP.
Hands-On Exercise: Load a pre-trained BERT model from Hugging Face and perform text classification or
question-answering on sample data.
Deliverable: Notebook demonstrating BERT model usage on sample NLP tasks.

19
Day 72 (Wednesday, September 10, 2025)
Topic: Advanced NLP – Using Pretrained Models
Key Concepts: Tokenization, embeddings, fine-tuning pre-trained models (BERT/GPT)
Tools/Libraries Introduced: Hugging Face Transformers (BertTokenizer, model classes)
Outcome by EOD: Tokenize text data and fine-tune a BERT model for classification.
Hands-On Exercise: Fine-tune BERT on a small text classification problem (e.g., sentiment or topic
classification) and evaluate.
Deliverable: Notebook with tokenization, model fine-tuning code, and evaluation metrics.

Day 73 (Thursday, September 11, 2025)

Topic: Generative Models – Generative Adversarial Networks (GANs)
Key Concepts: Generator and discriminator, adversarial training
Tools/Libraries Introduced: Keras (tf.keras.layers), PyTorch (nn.Module)
Outcome by EOD: Build a simple GAN to generate data.
Hands-On Exercise: Implement a simple GAN to generate handwritten digits (using MNIST).
Deliverable: Notebook with GAN architecture and sample generated images.

Day 74 (Friday, September 12, 2025)

Topic: Generative Models – Variational Autoencoders (VAEs)
Key Concepts: Latent space, encoder-decoder, sampling from latent distribution
Tools/Libraries Introduced: Keras or PyTorch for custom models
Outcome by EOD: Build and train a VAE for data reconstruction.
Hands-On Exercise: Implement a VAE for the MNIST dataset and visualize decoded images from latent
space.
Deliverable: Notebook with VAE model code and reconstructed image samples.

Day 75 (Saturday, September 13, 2025)

Topic: Week 12 Project – Advanced Deep Learning
Key Concepts: Complex neural network architectures (Transformer, GAN, etc.)
Tools/Libraries Introduced: Hugging Face, TensorFlow/PyTorch
Outcome by EOD: Apply an advanced model (e.g., Transformers or GANs) to a problem.
Hands-On Exercise: Use a pretrained Transformer (e.g., BERT) for a text task or train a GAN for image
generation, depending on interest.
Deliverable: Notebook with advanced model usage and results (e.g., text classification or image generation).

Week 12 Project
Title: Advanced Neural Network Project
Summary: Demonstrate mastery of advanced deep learning by implementing either a transformer-based
NLP model or a generative model (GAN/VAE) and analyzing results.

20
Tools Used: Python, TensorFlow/PyTorch, Hugging Face Transformers
Expected Deliverable: A notebook showing the use of the chosen advanced model, training process, and
evaluation or generated samples.

Day 76 (Sunday, September 14, 2025)

Topic: Time Series Analysis Basics
Key Concepts: Time series components, stationarity, ARIMA models
Tools/Libraries Introduced: statsmodels
Outcome by EOD: Analyze a time series dataset and understand ARIMA modeling.
Hands-On Exercise: Load a time series dataset (e.g., monthly sales), plot it, and fit a simple ARIMA model.
Deliverable: Notebook showing time series plot and ARIMA model results.

Day 77 (Monday, September 15, 2025)

Topic: Time Series Forecasting with LSTM
Key Concepts: Sequence forecasting, sliding window, LSTM in Keras for time series
Tools/Libraries Introduced: Keras (LSTM)
Outcome by EOD: Use an LSTM to forecast time series data.
Hands-On Exercise: Prepare time series data for training an LSTM (windowed), train LSTM and evaluate
forecast.
Deliverable: Notebook with LSTM time series forecasting and error metrics.

Day 78 (Tuesday, September 16, 2025)

Topic: Time Series Forecasting with Prophet
Key Concepts: Facebook Prophet library, trend & seasonality modeling
Tools/Libraries Introduced: Prophet
Outcome by EOD: Use Prophet for a quick time series forecast.
Hands-On Exercise: Fit a Prophet model on a time series and visualize forecast components.
Deliverable: Notebook with Prophet forecast plot.

Day 79 (Wednesday, September 17, 2025)

Topic: Week 13 Project – Time Series Forecasting
Key Concepts: Applying different time series techniques
Tools/Libraries Introduced: statsmodels, Keras, Prophet
Outcome by EOD: Forecast future values of a time series using at least two methods.
Hands-On Exercise: Given a time series dataset (e.g., stock prices), apply ARIMA and LSTM to forecast and
compare results.
Deliverable: Notebook with forecasts from both models and discussion of accuracy.

21
Week 13 Project
Title: Time Series Forecasting Challenge
Summary: Forecast a real-world time series (e.g., temperature, sales) using ARIMA and LSTM; compare their
performance.
Tools Used: Python, statsmodels, TensorFlow/Keras
Expected Deliverable: A notebook with forecasts, plots of actual vs predicted, and evaluation metrics for
each method.

Day 80 (Thursday, September 18, 2025)

Topic: Review of Deep Learning and Preparation
Key Concepts: Summary of CNN, RNN, GAN, transformer concepts
Tools/Libraries Introduced: --
Outcome by EOD: Consolidate knowledge and prepare for capstone.
Hands-On Exercise: Outline the capstone approach, revisit key notes or flashcards on advanced topics.
Deliverable: Final project plan and refreshed notes on DL topics.

Day 81 (Friday, September 19, 2025)

Topic: Deep Learning Review Quiz
Key Concepts: Concepts from neural networks, CNNs, RNNs, transformers, GANs
Tools/Libraries Introduced: --
Outcome by EOD: Reinforce knowledge of key deep learning concepts.
Hands-On Exercise: Complete a quiz covering all major deep learning topics learned so far.
Deliverable: Answers to review questions (can be markdown or text file).

Day 82 (Saturday, September 20, 2025)

Topic: Model Development Best Practices
Key Concepts: Saving/loading models (pickle, h5, ONNX), experiment tracking
Tools/Libraries Introduced: joblib, TensorFlow model.save, PyTorch torch.save
Outcome by EOD: Save and reload trained models.
Hands-On Exercise: Save the best model from a previous exercise to disk and write code to load it and make
predictions.
Deliverable: Code for saving and loading a model; saved model file.

Day 83 (Sunday, September 21, 2025)

Topic: Cloud Computing Basics for ML
Key Concepts: Cloud ML services overview (AWS/GCP notebooks, GPUs), environment setup in cloud
Tools/Libraries Introduced: --
Outcome by EOD: Understand how to leverage cloud resources for ML.
Hands-On Exercise: Launch a Google Colab or AWS SageMaker notebook and run a snippet of model

22
training on GPU.
Deliverable: Screenshot or log of training on a cloud GPU environment.

Day 84 (Monday, September 22, 2025)

Topic: Ethics and Fairness in AI (Optional)
Key Concepts: Bias, ethical implications of AI models, fairness metrics
Tools/Libraries Introduced: AI Fairness 360 (optional)
Outcome by EOD: Reflect on ethical considerations of ML.
Hands-On Exercise: Read a short article on AI ethics and summarize how bias can be introduced in ML.
Deliverable: Brief summary paragraph on fairness in AI.

Day 85 (Tuesday, September 23, 2025)

Topic: Kaggle Competition Practice
Key Concepts: Entering a Kaggle competition, submission format
Tools/Libraries Introduced: Kaggle API (optional)
Outcome by EOD: Get experience with Kaggle workflow.
Hands-On Exercise: Choose a simple Kaggle dataset, download it, and make a baseline submission.
Deliverable: Predicted CSV file and brief description of baseline model.

Day 86 (Wednesday, September 24, 2025)

Topic: Interview Preparation – ML Questions
Key Concepts: Common ML interview questions (explain overfitting, regularization, etc.)
Tools/Libraries Introduced: --
Outcome by EOD: Prepare answers for typical ML questions.
Hands-On Exercise: Write down answers to 5 common ML interview questions.
Deliverable: Q&A notes on machine learning concepts.

Day 87 (Thursday, September 25, 2025)

Topic: System Design for ML Pipelines (Intro)
Key Concepts: High-level design of ML systems (data pipeline, model deployment)
Tools/Libraries Introduced: --
Outcome by EOD: Sketch architecture for an end-to-end ML application.
Hands-On Exercise: Draw a diagram of an ML pipeline including data ingestion, model serving, and
monitoring.
Deliverable: Diagram or description of an ML system design.

23
Day 88 (Friday, September 26, 2025)
Topic: Final Project Preparation
Key Concepts: Integrating skills, project planning
Tools/Libraries Introduced: --
Outcome by EOD: Plan the capstone deliverables and prepare any last-minute needs.
Hands-On Exercise: Review all project requirements and prepare final materials; double-check environment
and code.
Deliverable: Updated README with final capstone plan and dataset links.

Day 89 (Saturday, September 27, 2025)

Topic: Month 3 Capstone Project – Advanced AI Application
Problem Statement: Integrate multiple advanced AI techniques into a comprehensive solution (e.g., object
detection with a deep CNN, or a language model application).
Skills Integrated: Deep learning, transfer learning, model optimization, deployment considerations
Deliverables: A final project notebook or report implementing the solution, including code, visualizations,
and analysis of results.
Bonus/Stretch Goal: Deploy the solution as a live demo or incorporate an additional feature (e.g., real-time
inference, user interface).

Day 90 (Sunday, September 28, 2025)

Topic: Month 3 Capstone Project – Image Classification with Deep Learning
Problem Statement: Train a convolutional neural network to classify images from the CIFAR-10 dataset into
10 categories.
Skills Integrated: CNNs, data augmentation, neural network training, evaluation metrics, deep learning
frameworks
Deliverables: Jupyter notebook with data loading, model training code, and evaluation results (accuracy,
confusion matrix). Mention any improvements tried (e.g., data augmentation, tuning hyperparameters).
Bonus/Stretch Goal: Achieve >75% accuracy by using a deeper network or transfer learning (e.g., pretrained
ResNet) and compare performance.

Day 91 (Monday, September 29, 2025)

Topic: Transfer Learning in Computer Vision
Key Concepts: Using pretrained CNNs (e.g., ResNet, VGG) as feature extractors or fine-tuning
Tools/Libraries Introduced: TensorFlow/Keras Applications, PyTorch Hub
Outcome by EOD: Leverage pre-trained models to improve training efficiency.
Hands-On Exercise: Load a pre-trained model (e.g., ResNet50) and use it to extract features from images.
Deliverable: Notebook demonstrating feature extraction with a pretrained CNN.

24
Day 92 (Tuesday, September 30, 2025)
Topic: Fine-Tuning Pretrained Models
Key Concepts: Retraining last layers, freezing base layers
Tools/Libraries Introduced: Keras functional API for fine-tuning
Outcome by EOD: Fine-tune a pre-trained network on a new dataset.
Hands-On Exercise: Freeze convolutional base of a pretrained model and train new dense layers on a small
dataset.
Deliverable: Notebook showing fine-tuning process and training results.

Day 93 (Wednesday, October 01, 2025)

Topic: Image Segmentation with U-Net
Key Concepts: Semantic segmentation, U-Net architecture
Tools/Libraries Introduced: TensorFlow/Keras (Custom model), PyTorch (nn.Module)
Outcome by EOD: Build an image segmentation model.
Hands-On Exercise: Implement a U-Net for segmenting simple images (e.g., create a synthetic dataset or
use a medical imaging sample).
Deliverable: Notebook with U-Net training code and example segmentation output.

Day 94 (Thursday, October 02, 2025)

Topic: Object Detection Overview (YOLO/SSD)
Key Concepts: Object detection, bounding boxes, one-stage vs two-stage detectors
Tools/Libraries Introduced: TensorFlow Object Detection API (optional)
Outcome by EOD: Understand how object detectors work.
Hands-On Exercise: Use a pre-trained YOLO or SSD model to detect objects in sample images.
Deliverable: Images with bounding boxes drawn using a pre-trained detector.

Day 95 (Friday, October 03, 2025)

Topic: Transformer Models in Vision and NLP
Key Concepts: Vision Transformers (ViT), comparison of CNN vs Transformer
Tools/Libraries Introduced: Hugging Face Vision Transformers
Outcome by EOD: Explore transformer architecture applied to images.
Hands-On Exercise: Use a pre-trained Vision Transformer to classify images on a small test set.
Deliverable: Notebook showing ViT model predictions on images.

Day 96 (Saturday, October 04, 2025)

Topic: Model Explainability (LIME/SHAP)
Key Concepts: Explaining model predictions, local vs global interpretability
Tools/Libraries Introduced: SHAP, LIME libraries

25
Outcome by EOD: Visualize what features influence model predictions.
Hands-On Exercise: Use SHAP to explain predictions of a trained model (e.g., tree or neural net) on sample
data.
Deliverable: Notebook with SHAP plots and explanations.

Day 97 (Sunday, October 05, 2025)

Topic: Week 14 Project – Advanced Vision Models
Key Concepts: Applying transfer learning or segmentation models to real data
Tools/Libraries Introduced: Python, TensorFlow/Keras or PyTorch
Outcome by EOD: Improve model performance using advanced techniques.
Hands-On Exercise: On a chosen image dataset, implement transfer learning with a pre-trained CNN and
fine-tune it; or train a segmentation model on labeled images.
Deliverable: Notebook showing improved image classification accuracy or segmentation results using
advanced models.

Week 14 Project
Title: Image Classification with Transfer Learning
Summary: Use a pretrained CNN to build an image classifier on a custom dataset (e.g., cats vs dogs), fine-
tune it, and evaluate performance.
Tools Used: Python, TensorFlow/Keras (or PyTorch)
Expected Deliverable: A trained model and a notebook documenting the transfer learning process and
results.

Day 98 (Monday, October 06, 2025)

Topic: Neural Machine Translation (Seq2Seq)
Key Concepts: Encoder-decoder RNN architecture, attention mechanism in seq2seq
Tools/Libraries Introduced: Keras (Seq2Seq RNN) or Hugging Face Transformers
Outcome by EOD: Build a basic seq2seq model for simple translation.
Hands-On Exercise: Train an encoder-decoder model on a small parallel text dataset (e.g., English-French
phrase pairs).
Deliverable: Notebook with translation model training and sample translations.

Day 99 (Tuesday, October 07, 2025)

Topic: BERT and Question Answering
Key Concepts: BERT for NLP tasks, question-answering pipelines
Tools/Libraries Introduced: Hugging Face Transformers (BertForQuestionAnswering)
Outcome by EOD: Use BERT to answer questions from text passages.
Hands-On Exercise: Use a pretrained BERT QA model on SQuAD or any text passage to answer questions.
Deliverable: Notebook demonstrating BERT-based Q&A on sample text.

26
Day 100 (Wednesday, October 08, 2025)
Topic: GPT for Text Generation
Key Concepts: Transformer-based text generation, GPT-2/3
Tools/Libraries Introduced: Hugging Face (GPT-2), OpenAI API (optional)
Outcome by EOD: Generate coherent text using a pre-trained GPT model.
Hands-On Exercise: Use Hugging Face to generate text continuations from a prompt using GPT-2.
Deliverable: Notebook with prompts and generated text samples.

Day 101 (Thursday, October 09, 2025)

Topic: Reinforcement Learning (Intro)
Key Concepts: Agent, environment, rewards, Q-learning
Tools/Libraries Introduced: OpenAI Gym, Stable Baselines (optional)
Outcome by EOD: Understand basic RL components.
Hands-On Exercise: Run a simple Gym environment (CartPole) using a basic algorithm or pre-built agent.
Deliverable: Notebook or script with an RL training loop (or use Stable Baselines to train) and performance
plot.

Day 102 (Friday, October 10, 2025)

Topic: Graph Neural Networks (GNN)
Key Concepts: Graph data, message passing, GCN, GAT
Tools/Libraries Introduced: PyTorch Geometric (optional)
Outcome by EOD: Get introduced to neural networks on graphs.
Hands-On Exercise: Use a small graph dataset (e.g., node classification) with a GNN library to train a model.
Deliverable: Notebook demonstrating a GNN on a toy graph dataset.

Day 103 (Saturday, October 11, 2025)

Topic: Ethics and Privacy in Machine Learning
Key Concepts: Data privacy, bias, model accountability
Tools/Libraries Introduced: --
Outcome by EOD: Consider the social impact of AI.
Hands-On Exercise: Research a case study on ML ethics and summarize key points.
Deliverable: A short report or presentation slides on the case study.

Day 104 (Sunday, October 12, 2025)

Topic: Week 15 Project – Advanced Model Integration
Key Concepts: Combining models (NLP or RL)
Tools/Libraries Introduced: Python, Hugging Face, OpenAI Gym
Outcome by EOD: Apply an advanced model to a non-trivial task.

27
Hands-On Exercise: Use a pre-trained BERT/GPT model for a new NLP task (e.g., text summarization) or train
an RL agent on a custom environment.
Deliverable: Notebook showing results of the advanced model on the chosen task.

Week 15 Project
Title: NLP/AI Integration Project
Summary: Use an advanced model (e.g., GPT-2 for story generation or a RL agent for a game) and analyze
its outputs.
Tools Used: Python, Hugging Face Transformers or RL library
Expected Deliverable: A demonstration of the model's output on a complex task and discussion of its
performance.

Day 105 (Monday, October 13, 2025)

Topic: Model Compression and Optimization
Key Concepts: Pruning, quantization, model size reduction
Tools/Libraries Introduced: TensorFlow Lite (optional), PyTorch quantization tools
Outcome by EOD: Reduce model complexity for deployment.
Hands-On Exercise: Apply weight pruning or quantization to an existing neural network model.
Deliverable: Notebook showing model size before/after compression and performance.

Day 106 (Tuesday, October 14, 2025)

Topic: Federated Learning and Privacy
Key Concepts: Training on edge devices, data privacy, secure aggregation
Tools/Libraries Introduced: TensorFlow Federated (conceptual)
Outcome by EOD: Understand how models can be trained on distributed data without centralizing.
Hands-On Exercise: Simulate simple federated learning by splitting data across virtual clients and averaging
model updates.
Deliverable: Notebook simulating federated training on a dataset.

Day 107 (Wednesday, October 15, 2025)

Topic: Graphical Models Overview (Optional)
Key Concepts: Probabilistic graphical models (Bayesian networks), relation to neural nets
Tools/Libraries Introduced: pgmpy (optional)
Outcome by EOD: Learn about an alternative modeling approach.
Hands-On Exercise: Build a simple Bayesian network for a toy probability problem.
Deliverable: Notebook with a graphical model and inference.

28
Day 108 (Thursday, October 16, 2025)
Topic: Meta-Learning and AutoML (Overview)
Key Concepts: Learning to learn, automated model selection
Tools/Libraries Introduced: AutoKeras or Google AutoML (conceptual)
Outcome by EOD: Explore AutoML tools briefly.
Hands-On Exercise: Try an AutoML library (e.g., AutoKeras) on a small dataset.
Deliverable: Notebook showing AutoML usage and results.

Day 109 (Friday, October 17, 2025)

Topic: Reinforcement Learning – Advanced (Deep Q-Network)
Key Concepts: Deep reinforcement learning (DQN), experience replay
Tools/Libraries Introduced: Stable Baselines (PPO/DQN)
Outcome by EOD: Build a deep RL agent.
Hands-On Exercise: Train a DQN agent (via library) on an OpenAI Gym environment.
Deliverable: Notebook or script showing RL training and reward plot.

Day 110 (Saturday, October 18, 2025)

Topic: Miscellaneous – Cutting-edge Topics
Key Concepts: Any emerging topic of interest (e.g., Quantum ML, edge AI)
Tools/Libraries Introduced: --
Outcome by EOD: Awareness of emerging trends.
Hands-On Exercise: Read about a new AI topic and summarize it.
Deliverable: Summary paragraph on the new topic.

Day 111 (Sunday, October 19, 2025)

Topic: Week 16 Project – Cutting-edge Model Application
Key Concepts: Integrating one or more advanced techniques
Tools/Libraries Introduced: Various (selected for project)
Outcome by EOD: Demonstrate knowledge of an advanced concept in practice.
Hands-On Exercise: Apply a state-of-the-art approach (e.g., use a pretrained GPT-3-like model via API, or
train an RL agent with a deep network) to a problem.
Deliverable: Notebook demonstrating the advanced technique and its results.

Week 16 Project
Title: Advanced AI Project
Summary: Use one of the latest AI technologies or models (e.g., DQN agent, AutoML, GPT) on a suitable
task, demonstrating its potential.
Tools Used: Python, relevant libraries (e.g., Stable Baselines, Hugging Face)

29
Expected Deliverable: A report or notebook showing the application of the advanced AI method and
outcome analysis.

Day 112 (Monday, October 20, 2025)

Topic: Comprehensive Review Quiz
Key Concepts: Review of all topics covered
Tools/Libraries Introduced: --
Outcome by EOD: Test knowledge of advanced topics.
Hands-On Exercise: Create and answer a set of quiz questions covering the month’s material.
Deliverable: List of questions and answers in a text file.

Day 113 (Tuesday, October 21, 2025)

Topic: Kaggle Competition Practice
Key Concepts: Data exploration and modeling in a competitive setting
Tools/Libraries Introduced: Kaggle notebooks
Outcome by EOD: Experience running code on Kaggle and submitting predictions.
Hands-On Exercise: Participate in a live Kaggle competition or use a public dataset; create a notebook with
EDA and a model.
Deliverable: Kaggle notebook link and submission file.

Day 114 (Wednesday, October 22, 2025)

Topic: Algorithm Practice
Key Concepts: Data structures (arrays, trees), sorting/search algorithms
Tools/Libraries Introduced: Python standard library
Outcome by EOD: Strengthen coding skills for interviews.
Hands-On Exercise: Solve one medium-level coding problem (e.g., binary tree traversal or sorting) in Python.
Deliverable: Python code file with problem solution and brief explanation.

Day 115 (Thursday, October 23, 2025)

Topic: Resume and Portfolio Update
Key Concepts: Showcasing skills and projects effectively
Tools/Libraries Introduced: Markdown, LinkedIn
Outcome by EOD: Polish resume and project portfolio entries.
Hands-On Exercise: Update your resume with recent projects and create/refresh GitHub README files for
key projects.
Deliverable: Updated resume PDF and GitHub profile with project READMEs.

30
Day 116 (Friday, October 24, 2025)
Topic: Interview Question Practice
Key Concepts: Common ML/AI interview scenarios
Tools/Libraries Introduced: --
Outcome by EOD: Prepare answers for potential questions.
Hands-On Exercise: Write down answers or give a mock response to 3 typical interview questions (e.g.,
explain bias-variance, describe a project).
Deliverable: Document or recorded answers to the questions.

Day 117 (Saturday, October 25, 2025)

Topic: Mock Technical Interview
Key Concepts: Simulating interview environment
Tools/Libraries Introduced: --
Outcome by EOD: Gain confidence in interviewing.
Hands-On Exercise: Pair up with a friend or mentor to conduct a mock interview covering ML and coding
questions.
Deliverable: Notes on mock interview performance and feedback.

Day 118 (Sunday, October 26, 2025)

Topic: Final Project Planning
Key Concepts: Consolidating learning objectives
Tools/Libraries Introduced: --
Outcome by EOD: Finalize capstone approach and ensure readiness.
Hands-On Exercise: Review all project requirements and prepare final materials; double-check environment
and code.
Deliverable: A to-do list or timeline for finishing the capstone.

Day 119 (Monday, October 27, 2025)

Topic: Month 4 Capstone Project – Advanced AI Application
Problem Statement: Integrate multiple advanced AI techniques into a comprehensive solution (e.g., object
detection with a deep CNN, or a language model application).
Skills Integrated: Deep learning, transfer learning, model optimization, deployment considerations
Deliverables: A final project notebook or report implementing the solution, including code, visualizations,
and analysis of results.
Bonus/Stretch Goal: Deploy the solution as a live demo or incorporate an additional feature (e.g., real-time
inference, user interface).

31
Day 120 (Tuesday, October 28, 2025)
Topic: Month 4 Capstone Project – Advanced AI Application
Problem Statement: Integrate multiple advanced AI techniques into a comprehensive solution (e.g., object
detection with a deep CNN, or a language model application).
Skills Integrated: Deep learning, transfer learning, model optimization, deployment considerations
Deliverables: A final project notebook or report implementing the solution, including code, visualizations,
and analysis of results.
Bonus/Stretch Goal: Deploy the solution as a live demo or incorporate an additional feature (e.g., real-time
inference, user interface).

Day 121 (Wednesday, October 29, 2025)

Topic: Introduction to Docker and Containers
Key Concepts: Docker images and containers, virtualization vs containerization
Tools/Libraries Introduced: Docker
Outcome by EOD: Install Docker and run a simple container.
Hands-On Exercise: Pull a Docker image (e.g., hello-world), run a container, and inspect container details.
Deliverable: Screenshot or log of successful Docker container run.

Day 122 (Thursday, October 30, 2025)

Topic: Building Docker Images (Dockerfile)
Key Concepts: Writing Dockerfiles, layers, image building
Tools/Libraries Introduced: Docker CLI, Dockerfile syntax
Outcome by EOD: Create a Docker image for a Python app.
Hands-On Exercise: Write a Dockerfile for a simple Python script (e.g., Flask API) and build the image.
Deliverable: Dockerfile and image built (image ID or repository tag).

Day 123 (Friday, October 31, 2025)

Topic: Docker Compose and Multi-Container Apps
Key Concepts: Docker Compose, defining multi-container environments (e.g., app + database)
Tools/Libraries Introduced: Docker Compose
Outcome by EOD: Orchestrate multiple Docker containers using Compose.
Hands-On Exercise: Create a docker-compose.yml for a simple app with a database (e.g., web app + Redis).
Deliverable: Compose file and 'docker-compose up' run output.

Day 124 (Saturday, November 01, 2025)

Topic: Containerizing an ML Model
Key Concepts: Exporting ML models, serving via REST API inside a container
Tools/Libraries Introduced: Flask/FastAPI inside Docker

32
Outcome by EOD: Deploy a trained model as a REST API in a Docker container.
Hands-On Exercise: Take a small trained model (e.g., sklearn classifier), write a Flask app for prediction,
containerize it.
Deliverable: Dockerfile for the model API and demo of it responding to a request.

Day 125 (Sunday, November 02, 2025)

Topic: Introduction to Kubernetes
Key Concepts: Orchestration, Kubernetes pods and services, deployment
Tools/Libraries Introduced: kubectl (Minikube or a local k8s cluster)
Outcome by EOD: Deploy a container to Kubernetes.
Hands-On Exercise: Start a local Kubernetes (Minikube), create a deployment for a sample container (e.g.,
nginx), and expose it via a service.
Deliverable: Commands and outputs for kubectl apply deployment and service.

Day 126 (Monday, November 03, 2025)

Topic: Kubernetes Scaling and Management
Key Concepts: Scaling pods, rolling updates, config maps, secrets
Tools/Libraries Introduced: Kubernetes objects (Deployment, Service, ConfigMap)
Outcome by EOD: Manage a Kubernetes deployment's lifecycle.
Hands-On Exercise: Scale a deployment up and down; perform a rolling update of container version.
Deliverable: kubectl commands and verification of scaled pods and updated version.

Day 127 (Tuesday, November 04, 2025)

Topic: Week 17 Project – Containerize an ML Service
Key Concepts: Dockerizing and running an ML API
Tools/Libraries Introduced: Docker, Flask/FastAPI
Outcome by EOD: Create a containerized web service for an ML model.
Hands-On Exercise: Build a Docker image for a simple ML prediction API (from Day 124) and run it locally.
Deliverable: Dockerfile and successful run (with sample prediction) documented.

Week 17 Project
Title: ML Model in Docker
Summary: Containerize a machine learning model by wrapping it in a Flask or FastAPI web service inside
Docker.
Tools Used: Python, Flask or FastAPI, Docker
Expected Deliverable: A Docker image that exposes a prediction endpoint, with usage instructions.

33
Day 128 (Wednesday, November 05, 2025)
Topic: CI/CD Concepts
Key Concepts: Continuous Integration/Continuous Deployment pipelines, automation
Tools/Libraries Introduced: GitHub Actions (or Travis CI)
Outcome by EOD: Understand how code changes trigger automated pipelines.
Hands-On Exercise: Write a basic CI workflow (e.g., GitHub Actions YAML) that runs tests or lints the code.
Deliverable: Workflow file and passing build for a sample repo.

Day 129 (Thursday, November 06, 2025)

Topic: Automated Testing and Linting
Key Concepts: Unit tests, test suites, code quality checks
Tools/Libraries Introduced: pytest, flake8
Outcome by EOD: Integrate testing into CI.
Hands-On Exercise: Write unit tests for a Python function and configure the CI pipeline to run them.
Deliverable: Test code and successful CI run showing test results.

Day 130 (Friday, November 07, 2025)

Topic: Container Registry and Deployment
Key Concepts: Pushing images to Docker Hub or ECR/GCR, deploying from registry
Tools/Libraries Introduced: Docker Hub, AWS ECR
Outcome by EOD: Publish Docker images for sharing.
Hands-On Exercise: Push the ML service image to Docker Hub and run it on another machine or cloud VM.
Deliverable: Docker Hub repository URL and pull/run commands output.

Day 131 (Saturday, November 08, 2025)

Topic: Model Versioning with MLflow or DVC
Key Concepts: Tracking model versions, datasets, parameters
Tools/Libraries Introduced: MLflow or DVC
Outcome by EOD: Log experiments and models systematically.
Hands-On Exercise: Use MLflow to train a model and log its parameters/metrics, then load that model back.
Deliverable: Code showing MLflow experiment tracking and a link to the dashboard.

Day 132 (Sunday, November 09, 2025)

Topic: Kubernetes for ML Workloads
Key Concepts: Running training on Kubernetes (TFJob, Kubeflow)
Tools/Libraries Introduced: Kubeflow (intro)
Outcome by EOD: Understand how to orchestrate training on k8s.

34
Hands-On Exercise: (Conceptual) Describe how you would run a distributed training job on Kubernetes.
Deliverable: Diagram or description of a training job setup.

Day 133 (Monday, November 10, 2025)

Topic: Week 18 Project – CI/CD Pipeline
Key Concepts: Automating build and test of ML code
Tools/Libraries Introduced: GitHub Actions or similar
Outcome by EOD: Set up a continuous integration workflow for a project.
Hands-On Exercise: Implement a CI pipeline for a small ML project that runs tests and builds a Docker
image on push.
Deliverable: CI configuration file (YAML) with passing runs.

Week 18 Project
Title: Continuous Integration for ML Project
Summary: Create a CI workflow for an ML repo that automatically builds and tests code changes.
Tools Used: GitHub Actions (or Travis/Jenkins)
Expected Deliverable: A working CI pipeline definition and documentation on how it works.

Day 134 (Tuesday, November 11, 2025)

Topic: Cloud ML Services (AWS/GCP)
Key Concepts: Cloud machine learning platforms, managed notebooks
Tools/Libraries Introduced: AWS SageMaker basics, GCP AI Platform
Outcome by EOD: Explore cloud ML offerings.
Hands-On Exercise: Run a notebook on Google Colab or AWS SageMaker and train a model.
Deliverable: Screenshot or notebook from the cloud environment.

Day 135 (Wednesday, November 12, 2025)

Topic: Serving Models on Cloud (AWS Lambda, GCP Functions)
Key Concepts: Serverless deployment of ML models
Tools/Libraries Introduced: AWS Lambda or Google Cloud Functions
Outcome by EOD: Deploy a lightweight model as a serverless function.
Hands-On Exercise: Package a simple prediction function and deploy it as an AWS Lambda with API
Gateway.
Deliverable: API endpoint URL and sample response.

Day 136 (Thursday, November 13, 2025)

Topic: Building ML Web Apps (Streamlit)
Key Concepts: Interactive ML dashboards
Tools/Libraries Introduced: Streamlit

35
Outcome by EOD: Create a simple interactive app.
Hands-On Exercise: Build a Streamlit app that takes user input and shows a model prediction or data
visualization.
Deliverable: Streamlit app code and a link to deployed app or screenshot.

Day 137 (Friday, November 14, 2025)

Topic: Building ML Web Apps (Gradio)
Key Concepts: Quick ML web interface
Tools/Libraries Introduced: Gradio
Outcome by EOD: Create a small model demo interface.
Hands-On Exercise: Use Gradio to build an interface for an image or text model (e.g., image classifier).
Deliverable: Gradio interface code and example usage.

Day 138 (Saturday, November 15, 2025)

Topic: Week 19 Project – Model Deployment
Key Concepts: Deploying ML models as web services
Tools/Libraries Introduced: Flask/Streamlit/Gradio
Outcome by EOD: Integrate a model into a web or serverless application.
Hands-On Exercise: Deploy the CNN model from Month3 in a Streamlit app or Flask API and test it with new
inputs.
Deliverable: Working app/endpoint demo and source code.

Week 19 Project
Title: ML Model Web App
Summary: Deploy an existing trained model as a web app or API (using Streamlit, Gradio, or Flask) for
interactive use.
Tools Used: Python, chosen web framework, deployed on local server or cloud
Expected Deliverable: A hosted app or API endpoint with usage instructions.

Day 139 (Sunday, November 16, 2025)

Topic: Model Monitoring and Logging
Key Concepts: Tracking model performance in production, logging inputs/outputs
Tools/Libraries Introduced: Prometheus, Grafana (conceptual)
Outcome by EOD: Understand how to monitor deployed models.
Hands-On Exercise: Simulate logging model predictions and visualize basic metrics (can use spreadsheets
or basic scripts).
Deliverable: Example logs and a simple chart showing model accuracy over time.

36
Day 140 (Monday, November 17, 2025)
Topic: A/B Testing for Models
Key Concepts: Comparing multiple model versions with live traffic
Tools/Libraries Introduced: --
Outcome by EOD: Learn how to evaluate models in production.
Hands-On Exercise: Design an A/B test plan for two model versions (describe how you'd split traffic and
measure).
Deliverable: Written A/B testing strategy outline.

Day 141 (Tuesday, November 18, 2025)

Topic: Workflow Orchestration (Airflow)
Key Concepts: Automating pipelines with workflow managers
Tools/Libraries Introduced: Apache Airflow (conceptual)
Outcome by EOD: Plan an automated ML pipeline.
Hands-On Exercise: Sketch an Airflow DAG for data preprocessing, training, and evaluation tasks.
Deliverable: Diagram or code snippet of the DAG.

Day 142 (Wednesday, November 19, 2025)

Topic: Week 20 Project – Full ML Pipeline Deployment
Key Concepts: End-to-end deployment, monitoring
Tools/Libraries Introduced: Various (selected by project)
Outcome by EOD: Combine deployment and monitoring elements.
Hands-On Exercise: Take the deployed model from week 19 and set up basic monitoring dashboards or
logging; optionally containerize the service.
Deliverable: A short report or demo of the end-to-end pipeline including deployment and monitoring setup.

Week 20 Project
Title: End-to-End ML Deployment
Summary: Demonstrate an end-to-end ML system from model training to deployment and monitoring.
Include an example of how the model is served and how its performance is tracked over time.
Tools Used: Python, Docker/Cloud, monitoring tools (Prometheus/Grafana)
Expected Deliverable: Documentation of the complete pipeline and any dashboards or logs produced.

Day 143 (Thursday, November 20, 2025)

Topic: Deployment Review Quiz
Key Concepts: All deployment and MLOps topics covered
Tools/Libraries Introduced: --
Outcome by EOD: Reinforce MLOps knowledge.

37
Hands-On Exercise: Create a set of 5 quiz questions covering Docker, Kubernetes, CI/CD, and cloud.
Deliverable: Quiz questions and answers in a text file.

Day 144 (Friday, November 21, 2025)

Topic: Auto-Scaling and Cost Management
Key Concepts: Kubernetes autoscaling, spot instances, cost-efficient deployments
Tools/Libraries Introduced: --
Outcome by EOD: Understand scaling and cost trade-offs.
Hands-On Exercise: Explain how you would configure auto-scaling for a service (horizontal pod autoscaler)
and consider using spot instances for cost savings.
Deliverable: A written strategy for auto-scaling and cost optimization.

Day 145 (Saturday, November 22, 2025)

Topic: Monitoring Case Study
Key Concepts: Real-world ML system incidents, monitoring importance
Tools/Libraries Introduced: --
Outcome by EOD: Learn from production issues.
Hands-On Exercise: Find and summarize a case study where a deployed ML model caused issues (e.g.,
model drift, bias) and how monitoring could help.
Deliverable: Summary report of the case study findings.

Day 146 (Sunday, November 23, 2025)

Topic: Final MLOps Project Prep
Key Concepts: Integration of all MLOps components
Tools/Libraries Introduced: --
Outcome by EOD: Finalize plan for capstone deployment.
Hands-On Exercise: Outline the final steps to deploy your capstone model, including environment and
pipeline.
Deliverable: Final checklist and design for deployment.

Day 147 (Monday, November 24, 2025)

Topic: Month 5 Capstone Project – Model Deployment System
Problem Statement: Deploy a machine learning model as a scalable service with logging and monitoring
(e.g., containerized API or web app).
Skills Integrated: Docker/Kubernetes deployment, CI/CD, cloud services
Deliverables: A working deployed service (or simulation) with documentation on architecture. Include
scripts or configs (Dockerfile, Kubernetes manifests, CI pipeline) and monitoring setup.
Bonus/Stretch Goal: Implement autoscaling or serverless deployment and show cost/performance analysis.

38
Day 148 (Tuesday, November 25, 2025)
No specific task (buffer for capstone work)

Day 149 (Wednesday, November 26, 2025)

No specific task (buffer for capstone work)

Day 150 (Thursday, November 27, 2025)

Topic: Month 5 Capstone Project – Model Deployment System
Problem Statement: Deploy a machine learning model as a scalable service with logging and monitoring
(e.g., containerized API or web app).
Skills Integrated: Docker/Kubernetes deployment, CI/CD, cloud services
Deliverables: A working deployed service (or simulation) with documentation on architecture. Include
scripts or configs (Dockerfile, Kubernetes manifests, CI pipeline) and monitoring setup.
Bonus/Stretch Goal: Implement autoscaling or serverless deployment and show cost/performance analysis.

Day 151 (Friday, November 28, 2025)

Topic: Launch Interview Preparation – Data Structures and Algorithms
Key Concepts: Arrays, linked lists, sorting, searching, big-O notation
Tools/Libraries Introduced: Python (collections)
Outcome by EOD: Review fundamental algorithms and data structures.
Hands-On Exercise: Write and test Python functions for sorting (e.g., merge sort) or searching in a list.
Deliverable: Python scripts with algorithm implementations and brief analysis of complexity.

Day 152 (Saturday, November 29, 2025)

Topic: System Design for AI
Key Concepts: High-level architecture, scalability, data flow, fault tolerance
Tools/Libraries Introduced: --
Outcome by EOD: Understand how to architect large-scale ML systems.
Hands-On Exercise: Design a high-level system for a recommender service (draw components and data
flow).
Deliverable: Diagram or document outlining system components and interactions.

Day 153 (Sunday, November 30, 2025)

Topic: Final Portfolio Tasks
Key Concepts: Consolidating projects, writing blog posts
Tools/Libraries Introduced: Markdown, GitHub Pages (optional)

39
Outcome by EOD: Prepare portfolio materials.
Hands-On Exercise: Write a blog post summarizing one of your projects; ensure code is organized in a
GitHub repo.
Deliverable: Completed blog post markdown and updated GitHub repository links.

Day 154 (Monday, December 01, 2025)

Topic: Coding Interview Practice – Medium Problems
Key Concepts: Problem-solving under time constraints
Tools/Libraries Introduced: Online judge (LeetCode/HackerRank)
Outcome by EOD: Improve speed and accuracy on coding problems.
Hands-On Exercise: Solve two medium-level coding problems in Python within a timed session.
Deliverable: Code solutions for the problems with test cases.

Day 155 (Tuesday, December 02, 2025)

Topic: Mock Technical Interview – Machine Learning
Key Concepts: Reinforce ML interview responses
Tools/Libraries Introduced: --
Outcome by EOD: Simulate real interview scenario.
Hands-On Exercise: Conduct a mock interview with a peer or mentor covering ML concepts and review
feedback.
Deliverable: Notes on performance and areas to improve.

Day 156 (Wednesday, December 03, 2025)

Topic: Review and Relaxation (Break Day)
Key Concepts: Stress management, concept recap
Tools/Libraries Introduced: --
Outcome by EOD: Recharge and ensure retention of key points.
Hands-On Exercise: Take a short quiz on topics as a fun review; ensure all deliverables are backed up.
Deliverable: List of any remaining questions and answers; final review notes.

Day 157 (Thursday, December 04, 2025)

Topic: Month 6 Capstone Project – Culminating Application
Problem Statement: Integrate data science and ML skills into a final product (e.g., an AI web app or
comprehensive analysis report).
Skills Integrated: End-to-end ML pipeline, deployment, documentation, communication
Deliverables: A complete project (e.g., deployed application or interactive dashboard) and a portfolio write-
up.
Bonus/Stretch Goal: Present your project to a peer or create a video demo.

40
Day 158 (Friday, December 05, 2025)
No specific task (final presentations and submission)

Day 159 (Saturday, December 06, 2025)

Completion Day – All deliverables final

41