00 Introduction¶
This section has three short parts: a welcome video that introduces the whole course (the finished project first, then the plan, the tools, who it is for, and where the code is), an article with the links to the code and the website, and a 1 to 2 minute Important Notes video.
Table of Contents¶
| Step | Topic |
|---|---|
| Step-01 | Welcome: What You Will Build |
| Step-02 | Important Notes |
Step-01: Welcome: What You Will Build¶
You build one complete machine learning project in Python: a credit card fraud detector, from raw data to your own prediction API. It is plain Python scripts, not notebooks, organized the way real projects are.
See the End Result First¶
By the end of the course you have two prediction APIs running on your own computer, each with a small web page:
- the baseline API (Section 04 B, port 8000), with the first model we build;
- the tuned API (Section 08, port 8001), with the final model, after feature engineering and tuning.
Here both get the same real transaction from our test data: $363.26 at a gas station, card not present, more than twice this customer's usual amount. We know the true answer: it was fraud.
| Transaction | True answer | Baseline API (port 8000) | Tuned API (port 8001) |
|---|---|---|---|
| Test row 7382: $363.26 gas station, card not present | Fraud | LEGITIMATE, 38.7% (lets it through) | FRAUD, 67.3% (catches it) |
| The page's Fraud Example: $2,500 of electronics at 2 AM, from another country | (a made-up example) | FRAUD, 99.7% | FRAUD, 99.8% |
On an obvious fraud, both models agree. The difference is in the harder cases, and over the 2,000 test transactions that difference is worth thousands of dollars. Getting from the left model to the right one, and proving it in dollars, is what this course is about.
Each API also has a /docs page, so any program can call it, not just the web page. You run both APIs yourself in Section 08. To run this whole demo right now, use the intro-demo-scripts folder: one script creates both models, starts both APIs and opens this side-by-side page. Your exact numbers may differ a little from these (see Important Notes).
The Machine Learning Workflow¶
Most machine learning projects follow these seven stages, and Section 01 covers each one. Stages 1 to 6 are the core machine learning job, and this course builds all of them. In stage 6 we put the model behind an API; running that API on infrastructure (Docker, Kubernetes, cloud) is MLOps work. Stage 7, monitoring and retraining, is MLOps too: monitoring feeds fresh data back in, and the model is retrained. Section 01 explains both, but we do not build them.
A Quick Note Before We Continue¶
The rest of this introduction gives you the whole plan: the course map, how our scripts follow the workflow, the tools, the journey in dollars, who the course is for, and where the code lives. Many students like to see all of this before they start; you choose your path. If you would rather start right away, go to the next lecture, then Section 01, Machine Learning Fundamentals.
The Course Map¶
The course has ten sections, and every section adds one piece to the same project:
How Our Project Follows the Workflow¶
In our project, each machine learning stage is a Python script, and each section builds one of them:
| Step | Script(s) | Section |
|---|---|---|
| Data | p1_ | 03 |
| Train + evaluate (baseline) | p3_ | 04 A |
| Serve (baseline API) | p3_ + p3_ test | 04 B |
| Explore (EDA) | p2_ + auto-EDA tools | 05 |
| Feature engineering | p4_ / p4_ / p4_ | 06 |
| Hyperparameter tuning + tuned model | p5_ / p5_ / p5_ | 07 |
| Serve (tuned API) | p5_ + p5_ test | 08 |
We build a working baseline first (Section 04), then come back to explore and improve it.
The Whole Project in One Picture¶
Here is everything together, in one picture. Read it in three parts.
- The top row: the general machine learning workflow. These are the stages most machine learning projects go through, from collecting the data to serving the model, with a feedback loop back to data preprocessing.
- The second row: what we build in this course, at a single glance. Each box is one Python script of our project, from generating the data to the two APIs on ports 8000 and 8001. Don't worry about the names yet: Section 01 walks through this map box by box. (The picture draws EDA before the baseline. In the course we build and serve the baseline first, then come back and explore the data, as the map above shows.)
-
Monitoring, drift detection and retraining: explained, not built. In the top row they come after the model goes live. Section 01 explains them, but we do not build them in this course. Here is why:
- 3.1. It is MLOps work, not the core machine learning job. The core job of a machine learning engineer is what this course teaches end to end: get the data, train the model, judge it by the money it saves, improve and tune it, and serve it behind an API. Running monitoring and retraining in production is the next layer, MLOps, and it only makes sense once you can build the model itself.
- 3.2. A makeshift version is not worth your time. Real teams use dedicated tools for this (for example MLflow, Evidently, Prometheus and Grafana, with a scheduler and a model registry), and that is a whole topic of its own.
The Tools You Will Use¶
| Group | Tools | Sections |
|---|---|---|
| Setup | Python 3.14, Miniconda, pip (mlops-env1, requirements.txt) | Section 02 |
| Data | pandas, NumPy | Section 03 |
| Explore (EDA) | Matplotlib, Seaborn; optional: fg-data-profiling, Sweetviz | Sections 05 and 06 |
| Machine learning | scikit-learn (Pipeline, LogisticRegression, RandomizedSearchCV, GridSearchCV) | Sections 04 A, 06 and 07 |
| Serve as an API | FastAPI, Uvicorn, Pydantic (/, /, /, /) | Sections 04 B and 08 |
| Project + code | Python scripts, not notebooks; shared utils/ modules; pickle, JSON, PyYAML | Sections 03 to 08 |
Every tool is explained the first time we use it. Docker, Kubernetes, MLflow and cloud deployment are not part of this course.
The Journey in Dollars¶
We judge every change by the money it saves the bank (Net Benefit, measured on the 2,000 test transactions). The baseline API runs the first model on this chart, and the tuned API runs the last one:
| Section | What we do | Net Benefit |
|---|---|---|
| 04 A | Baseline Model: Logistic Regression on 8 features | $39,625 |
| 06 | + Feature Engineering: one new feature, amount_ | $39,700 |
| 07 | + Hyperparameter Tuning using Random Search (RandomizedSearchCV, narrow class_ grid) | $37,025 |
| 07 | + Hyperparameter Tuning using Grid Search (GridSearchCV, wider money-weighted class_ grid) | $50,550 |
Who This Course Is For¶
- Made for: DevOps, SRE, and cloud engineers moving into machine learning; MLOps and AIOps engineers who want the machine learning foundation; developers, data engineers, and students with some Python and no machine learning yet; Python learners ready for their first machine learning project.
- Before you start: Python basics. No machine learning needed. A Mac, Windows or Linux computer. Free tools, no cloud account.
Your Course Repo and Website¶
This course has two places. The GitHub repository is the primary one: you work there. The website is an add-on, for reference anytime.
- Course GitHub repository (primary, start here): github.com/stacksimplify/mlops-01-ccfd-project. All the code is here. Each section's code sits in a
ccfd-project/folder inside its section folder (Section 04 has one per part), and the README in each folder walks you through every step. Clone or download it once, then run all the code from here. - Course website (add-on, for reference anytime): machine-learning-end-to-end.stacksimplify.com. The same READMEs, laid out for easy reading, with search across every section. Open it anytime, on any device.
Get the code (one time). Pick one of the two ways:
- Download ZIP: on the repository page, click Code, then Download ZIP. Unzip it (the folder is called
mlops-01-ccfd-project-main) and open a terminal in that folder. - Clone it with git:
git clone https://github.com/stacksimplify/mlops-01-ccfd-project.git
cd mlops-01-ccfd-project
Every command in this course runs from that folder (the repository root) or from a section folder inside it.
Step-02: Important Notes¶
A short video, 1 to 2 minutes, with four notes that save you time:
- Code and website: all the code is in the course GitHub repo, and the website has the same READMEs (see "Your Course Repo and Website" above).
- Your numbers may differ from the videos (Intel Mac vs Apple Silicon Mac).
- MLflow, KServe, other MLOps tools and "advanced sections" mentioned in some lectures are not part of this course.
- If
pipis missing in a new conda environment: activate it, then runconda install pip.
Read the full notes: Important Notes
Next: 01 - Machine Learning Fundamentals
Prefer to learn by watching?
The video course builds this whole project with you on screen, step by step.
Next: 01 Machine Learning Fundamentals












