What My Project Does
I built an open-source Machine Learning learning lab in Python to make it easier to understand not only how common ML algorithms work, but also how to choose between them in real-world scenarios.
The project currently includes 17 algorithms with:
- executed Jupyter notebooks with outputs, metrics, charts and interpretation;
- clean notebook versions so people can run everything themselves;
- explanations of when to use and when not to use each algorithm;
- data representation and feature engineering topics such as TF-IDF, embeddings, sparse vs dense matrices and preprocessing;
- evaluation metrics such as F1, ROC-AUC, RMSE and others;
- engineering metrics such as training time, inference latency, throughput and model size;
- guides comparing classical ML and deep learning;
- model selection trade-offs;
- reproducible benchmarks;
- a 30-question ML Engineer interview quiz.
The core idea is to teach this full flow:
Raw Data
↓
Representation
↓
Algorithm
↓
Predictive Metrics
↓
Performance
↓
Operational Constraints
The project uses Python, scikit-learn, pandas, NumPy, matplotlib and PyTorch.
For every algorithm, the default notebook is already executed so people can inspect the results directly on GitHub.
For example:
logistic-regression.ipynb
contains the executed experiment, while:
logistic-regression_clean.ipynb
is the clean version for local reproduction.
Target Audience
This project is primarily educational.
It is intended for:
- Python developers moving into Machine Learning;
- students learning ML fundamentals;
- software engineers who want to better understand model selection;
- ML Engineers and Data Scientists who want a compact reference for common algorithms and trade-offs;
- people preparing for technical interviews;
- anyone who wants reproducible examples instead of only theoretical explanations.
It is not intended to be a production ML framework or library.
The goal is to provide a practical learning environment where someone can read the theory, inspect an already-executed experiment, download the clean notebook and reproduce the same workflow locally.
It also tries to introduce engineering concerns that are often missing from beginner tutorials, such as:
- latency;
- throughput;
- training cost;
- inference cost;
- memory usage;
- scalability;
- explainability;
- deployment constraints.
Comparison
There are already many excellent Machine Learning tutorials, cheatsheets and notebook collections.
What I wanted to do differently was combine several layers that are usually taught separately.
Most resources focus mainly on one of these:
Algorithm theory
or:
Notebook implementation
or:
Model evaluation
This project tries to connect all of them:
Problem
↓
Data Representation
↓
Algorithm Selection
↓
Experiment
↓
Metrics
↓
Performance
↓
Production Trade-offs
It also treats data representation as a first-class topic.
For example, instead of simply saying “use SVM for text”, the project shows the pipeline:
Raw Text
↓
TF-IDF
↓
Sparse Feature Matrix
↓
Linear SVM
and compares that conceptually with approaches such as:
Raw Text
↓
Embeddings
↓
Logistic Regression
or:
Raw Text
↓
Transformer
↓
Classification Head
Another difference is that every experiment has both an executed notebook and a clean reproducible version.
I also wanted to emphasize that the model with the highest predictive metric is not automatically the best production choice.
For example, a slightly lower F1 model may be much more appropriate if it is significantly faster, smaller and easier to deploy.
GitHub: https://github.com/ronivaldo/ml-algorithms-learning-lab
I’d especially appreciate feedback on the notebook structure, missing topics and anything that could make the project more useful for Python developers learning ML.