# Machine Learning Self-Study Roadmap 2026: Skills to Portfolio

> Published 2026-09-13 · https://www.promptzone.com/lukas_tanaka/machine-learning-self-study-roadmap-2026-skills-to-portfolio-2oja

---
title: "Machine Learning Self-Study Roadmap 2026: Skills to Portfolio"
published: true
description: "Follow a machine learning self study roadmap with free courses, practical projects, and weekly plans for building a portfolio."
tags: ai, machinelearning, learning, career
---

For machine learning self study, plan in months: the suggested schedule below spans 32 weeks at 10 hours a week, assuming some basic programming familiarity. Learn Python and essential mathematics, then classical machine learning, deep learning, a specialization, and portfolio development; a more intensive schedule allocates 13 weeks at 25 hours. These are planning targets for building practical foundations, with progress determined by working projects rather than a promised hiring date.

There is no verified universal completion time. For perspective, Andrew Ng's [Machine Learning Specialization](https://www.coursera.org/specializations/machine-learning-introduction) lists component workloads of 33, 34, and 28 hours: 95 hours in total, before your independent projects. That makes a substantial introductory course only part of a self-study machine learning roadmap.

## The roadmap at a glance

The weeks below are suggested allocations at 10 hours per week, not course-provider completion guarantees. Select the material needed for each checkpoint; this schedule does not require completing every linked course. For alternatives, use the [full curated AI learning resources list](/ai-resources).

| Phase | Weeks | What you learn | Free resource | Paid option | Project to build |
| --- | --- | --- | --- | --- | --- |
| 0: Prerequisites | 1–4 | Python, data handling, essential math | [Python tutorial](https://docs.python.org/3/tutorial/) and [Dive into Deep Learning](https://d2l.ai/) preliminaries | None needed for this route | A data-cleaning report |
| 1: Classical ML | 5–14 | Regression, classification, validation, trees | [Introduction to Statistical Learning, Python edition](https://www.statlearning.com/) | [Machine Learning Specialization](https://www.coursera.org/specializations/machine-learning-introduction), paid, see site | A prediction model with a baseline |
| 2: Deep learning | 15–22 | Neural networks, training, transfer learning | [fast.ai Practical Deep Learning](https://course.fast.ai/) | [Deep Learning Specialization](https://www.coursera.org/specializations/deep-learning), paid, see site | An image classifier and error report |
| 3: Specialization | 23–28 | Language models, vision, or model operations | [Hugging Face LLM Course](https://huggingface.co/learn/llm-course/chapter1/1), D2L, or [MLOps Zoomcamp](https://github.com/DataTalksClub/mlops-zoomcamp) | Deep Learning Specialization vision/language units, paid, see site | A focused application or model service |
| 4: Portfolio | 29–32 | Reproducibility, explanation, interview practice | MLOps Zoomcamp project materials | None needed for this route | A documented, reproducible showcase |

Paid options replace relevant free material. Check course pages for prices; completing a longer specialization in full may require extending its phase.

## Phase 0: prerequisites

Learn enough Python to manipulate data independently before adding a modeling library. Your checkpoint is a small program that reads records, handles missing values explicitly, calculates summaries, and produces an explanation of what it found.

Practice functions, loops, lists, dictionaries, imports, file handling, and reading exceptions. The [official Python tutorial](https://docs.python.org/3/tutorial/) covers these topics, but explicitly assumes general programming knowledge. If you are completely new to programming, start with [CS50's Introduction to Programming with Python](https://cs50.harvard.edu/python/), which accepts beginners and provides free course materials, exercises, and a final project. It contains ten weeks of material; allow additional prerequisite time instead of treating the table's refresher allocation as a beginner deadline.

For mathematics, start with vectors and matrices, derivatives, probability, and basic statistics. [Dive into Deep Learning](https://d2l.ai/) includes preliminaries covering linear algebra, calculus, automatic differentiation, and probability and statistics. Use those chapters alongside code so that the notation has a concrete purpose.

As practice, multiply a small matrix by a vector, explain the direction of a derivative, and compare a dataset's mean with its median. When an equation feels abstract, work through a tiny numerical example.

Do not make advanced mathematics a gate to your first project. fast.ai explicitly teaches the calculus and linear algebra needed during its course and does not require university mathematics. For this applied route, postpone proof-heavy topics until a project or research question gives you a reason to study them. [fast.ai prerequisites](https://course.fast.ai/).

## Phase 1: classical machine learning

Start with a prediction problem whose inputs, target, and evaluation method you can explain. Read the regression, classification, resampling, regularization, and tree chapters in [An Introduction to Statistical Learning](https://www.statlearning.com/). Its Python edition includes labs that connect the chapters to implementation.

Andrew Ng's Machine Learning Specialization is an alternative structured route. The official syllabus includes linear and logistic regression, decision trees and ensembles, clustering, and recommendation systems, using libraries including NumPy and scikit-learn. Choose it if guided assignments suit you better than a textbook. [Course syllabus](https://www.coursera.org/specializations/machine-learning-introduction).

For your independent project, choose a question such as predicting delivery duration from information available when an order is placed. Write that prediction moment down before choosing features. Compare a simple baseline with a regression model and a tree-based approach, keeping the evaluation procedure consistent.

Separate training and test data before learning preprocessing transformations. scikit-learn warns that allowing test information into model development produces overly optimistic evaluation. Its documentation recommends pipelines to keep preprocessing inside the appropriate training process. [Common pitfalls](https://scikit-learn.org/stable/common_pitfalls.html).

Your deliverable should explain the target, the baseline, the evaluation result, and the cases where predictions fail. Include a short feature audit: which columns would actually be known when a prediction is needed? A beautiful score deserves scrutiny if you cannot explain where the input information came from.

Move on when you can rebuild the project without copying a tutorial and explain why the test data did not influence model selection.

## Phase 2: deep learning

Learn a complete training workflow, then inspect its mechanics. [fast.ai Practical Deep Learning for Coders](https://course.fast.ai/) is a free course covering computer vision, language, tabular data, and deployment with PyTorch and related libraries. Use it as the main practical route through this phase.

Complement that work with Andrej Karpathy's [Neural Networks: Zero to Hero](https://karpathy.ai/zero-to-hero.html). It builds neural networks in code, beginning with backpropagation and progressing toward language models. Its prerequisites include solid Python and introductory mathematics, so use it after you can comfortably follow a program's data flow.

Choose a small image-classification task and keep an experiment notebook. Record the training choices, evaluation conditions, observed mistakes, and your reason for the next change. Try explaining a training loop aloud before changing its implementation. If you cannot account for an array's dimensions, pause and inspect a small batch.

Use [Dive into Deep Learning](https://d2l.ai/) as a reference when you need more detail on convolution, optimization, or attention. Read the relevant section, reproduce its example, and return to your project with a specific question to test.

The paid [Deep Learning Specialization](https://www.coursera.org/specializations/deep-learning) covers neural-network architectures, optimization, convolutional networks, and sequence models. It expects intermediate Python and recommends basic linear algebra. Choose its relevant foundational units as an alternative, rather than attempting every course alongside fast.ai in the same allocation.

Finish with a working classifier, examples it handles poorly, and the data you would collect before trusting it in a real workflow.

## Phase 3: pick a specialization

Choose the kind of work you want to practice next. Keep this phase focused enough that you can finish an application and evaluate it.

### LLMs and generative AI

Use the free [Hugging Face LLM Course](https://huggingface.co/learn/llm-course/chapter1/1). It covers Transformers, datasets, tokenizers, fine-tuning, and sharing models. The course recommends good Python knowledge and an introductory deep-learning course, which makes it a sensible follow-on to Phase 2.

Start with its introductory chapters and build a document classifier or a question-answering experiment over a small collection you understand. Create evaluation examples before modifying the model or prompt. Include cases where the correct response should acknowledge missing information.

For experimentation on your own hardware, follow the [guide to running local LLMs at home](/lukas_tanaka/local-llms-2026-run-llama-mistral-qwen-on-your-hardware-complete-guide-46ib). Evaluate whether its answers meet your requirements.

### Computer vision

Follow the computer-vision material in [Dive into Deep Learning](https://d2l.ai/), including image augmentation, fine-tuning, and object detection. Extend your classifier with a carefully scoped comparison, or attempt detection if locating objects is central to your question.

For the project, collect evaluation examples that reflect the conditions you care about: different backgrounds, lighting, or capture devices. Present results by condition as well as overall. Describe any collection gaps rather than implying that success on your examples proves general reliability.

### MLOps

[DataTalks.Club's MLOps Zoomcamp](https://github.com/DataTalksClub/mlops-zoomcamp) offers free material on experimentation, deployment, orchestration, monitoring, and a final project. Its stated prerequisites include Python, Docker, command-line basics, machine learning, and programming experience. Use selected modules here; its full course is described as nine weeks, so extend your schedule for the complete route.

Turn your classical model into a repeatable service or batch job. Document how to reproduce training, inspect a failed prediction, and replace a model safely. Make the operational questions part of the demonstration rather than hiding them behind a screenshot.

## Phase 4: portfolio and job-readiness

Build a portfolio that lets another person examine your decisions. Select your strongest completed projects and make them easy to run, understand, and challenge.

For each project, include the problem, data source, permitted use of the data, setup instructions, baseline, evaluation method, failure examples, and next steps. State exactly which parts you built and which came from a course. Describe limitations in the same place as the headline result.

Ask a peer to reproduce the work using only the documentation and fix the steps where they get stuck. MLOps Zoomcamp provides project materials alongside testing and deployment topics. [Project and course materials](https://github.com/DataTalksClub/mlops-zoomcamp).

For interview preparation, practice explaining your feature choices, data split, evaluation metric, and a failed experiment. Reimplement a familiar model workflow with different data. Use actual job descriptions to identify gaps in your preparation, and separate those gaps from topics you are studying out of curiosity.

Assess job-readiness against a particular role. Course completion cannot specify an employer's hiring decision or a universal time to employment.

## Weekly study plan

These suggested allocations balance guided learning with independent implementation. They are schedules to try, not measured learning-speed claims.

| Activity | 10 h/week | 25 h/week |
| --- | --- | --- |
| Course lessons and reading | 3 hours | 7 hours |
| Exercises and rebuilding examples | 3 hours | 8 hours |
| Independent project work | 3 hours | 8 hours |
| Review, explanations, and planning | 1 hour | 2 hours |

The slower schedule provides 320 planned hours across 32 weeks; the intensive schedule provides 325 across 13 weeks. Increasing weekly hours does not guarantee proportionally faster understanding. Keep the same project checkpoints and extend a phase when the work is not yet independent.

End each week with a runnable result, a written explanation, and a question for the next session. When a lesson takes longer than expected, reduce optional material before removing the project block.

## Mistakes that stall self-learners

- **Collecting courses without finishing experiments.** Choose a main resource for the phase and use others to resolve specific questions.
- **Watching solutions before attempting the work.** Try from a blank notebook, then compare your approach with the example.
- **Trusting a score without auditing the data.** Check prediction-time availability and training boundaries; revisit scikit-learn's leakage guidance.
- **Expanding the project whenever a new tool appears.** Keep a written completion criterion and save extra ideas for later.
- **Letting an assistant replace your understanding.** Use explanations as starting points, then test them and account for the resulting code yourself.

## FAQ

### How long does machine learning self study take?

Use the suggested 32-week, 10-hour schedule as a foundation-building target if you already have some programming familiarity. Complete beginners should add prerequisite time. Your pace should follow the project checkpoints; a guaranteed time to employment is not published by these resources.

### Can I learn machine learning on my own for free?

Yes: CS50P, the downloadable statistical-learning book, fast.ai, the Hugging Face course, and MLOps Zoomcamp provide a free learning route. Paid course access is optional. Start with the exercises and projects before deciding whether a paid alternative helps you.

### How much mathematics do I need before starting?

Begin with basic algebra and learn vectors, matrices, derivatives, probability, and statistics alongside implementation. fast.ai does not require university mathematics; more advanced study can follow the needs of your specialization.

### Should I start with machine learning or deep learning?

For this roadmap, begin with classical machine learning so you can practice baselines and evaluation on a focused problem. Experienced programmers who prefer a practical deep-learning entry point can use fast.ai, then return to statistical-learning material to fill gaps.

## Sources

- [Machine Learning Specialization: syllabus and workload](https://www.coursera.org/specializations/machine-learning-introduction)
- [The official Python tutorial](https://docs.python.org/3/tutorial/)
- [CS50's Introduction to Programming with Python](https://cs50.harvard.edu/python/)
- [An Introduction to Statistical Learning: Python edition and downloads](https://www.statlearning.com/)
- [scikit-learn: common pitfalls and recommended practices](https://scikit-learn.org/stable/common_pitfalls.html)
- [fast.ai: Practical Deep Learning for Coders](https://course.fast.ai/)
- [Andrej Karpathy: Neural Networks: Zero to Hero](https://karpathy.ai/zero-to-hero.html)
- [Dive into Deep Learning](https://d2l.ai/)
- [Deep Learning Specialization: syllabus and prerequisites](https://www.coursera.org/specializations/deep-learning)
- [Hugging Face LLM Course: introduction and prerequisites](https://huggingface.co/learn/llm-course/chapter1/1)
- [DataTalks.Club: MLOps Zoomcamp](https://github.com/DataTalksClub/mlops-zoomcamp)