A 12-Month Study Plan for Machine Learning

Who this plan is for and how to use it

This plan is for someone who can already write simple Python scripts, remembers roughly what a derivative is from school, and wants a structured route into machine learning rather than a pile of disconnected tutorials. It assumes you can spend around six to eight hours a week on this, split across two or three sessions. If you have less time, stretch the plan to eighteen months rather than skipping steps. If you have more time, use it to build extra projects, not to rush ahead, because the thing that actually builds skill is finishing projects, not watching more videos.

The plan is organised into six two-month blocks. Each block has a learning goal, a short list of topics, and at least one project you build with your own hands. Projects matter more than topics here. You can read about cross-validation for an afternoon and forget it by next week, but if you use it to pick a model and watch the accuracy change, it sticks.

• Project first, theory on demand: pick a small project, then learn the theory you need to finish it, rather than studying theory with no target to apply it to.
• Spaced practice: revisit earlier topics briefly every few weeks instead of studying them once and moving on forever.
• Build in public: write short notes or a blog post about what you built, even if only three people read it. Explaining a concept in your own words is the fastest way to find the gaps in your understanding.
• One tool at a time: pick one library per task (pandas for data work, scikit-learn for classical models, one deep learning framework) and get fluent in it before adding a second.

Before you start: a two-week readiness check

Spend up to two weeks confirming the basics are solid, because everything after this assumes them. You do not need mastery, just enough comfort that a small gap does not stop you cold in month three.

• Python: can you write a function, use a list comprehension, read a stack trace, and know what a dictionary is for?
• Math: can you explain what a derivative measures in plain words (the rate of change of a function), and do you remember how to multiply two matrices by hand for a small case, say two 2x2 matrices?
• Statistics: do you know the difference between the mean and the median, and why one is more sensitive to outliers than the other?

If any of these feel shaky, that is fine. Spend the two weeks on a short Python refresher and a few practice problems on derivatives and matrix multiplication. You do not need a full calculus course. You need enough to follow an explanation of gradient descent without getting lost in notation.

Months 1-2: foundations you cannot skip

The goal of these two months is to become comfortable manipulating data in Python and to rebuild the small amount of math you actually need, by using it rather than memorising it.

Python for data work

Learn NumPy and pandas well enough that reading and reshaping a CSV file feels routine. Practice loading a dataset, filtering rows, grouping by a column, and computing summary statistics. Do this with a real but small dataset, for example a public CSV of a few hundred to a few thousand rows on a topic you find mildly interesting, such as weather records or sports results. The size does not matter much at this stage; what matters is that you touch every common pandas operation at least once: selecting columns, filtering with conditions, grouping and aggregating, merging two tables, and handling missing values.

Math refresher: linear algebra, calculus, probability

You need three things from linear algebra: vectors, matrices, and what it means to multiply them, because every machine learning model is, underneath, a sequence of these operations. You need one thing from calculus: the derivative as a slope, and the idea that following the negative slope downhill, repeatedly, is how a model learns. You need two things from probability and statistics: what a distribution is, and what the mean, variance, and standard deviation tell you about a set of numbers.

A concrete way to make gradient descent click is to minimise a simple function by hand. Suppose we want to find the value of x that minimises f(x) = (x - 3) squared. The derivative is 2(x - 3). If we start at x = 0, the derivative there is 2(0 - 3) = -6. Gradient descent says: move in the direction opposite the derivative, scaled by a small step size, say 0.1. The update is x_new = x - 0.1 times (-6) = x + 0.6, so x becomes 0.6. Repeat this a few times and x creeps toward 3, which is exactly where the function is smallest. This tiny example is the entire mechanism behind training a neural network with millions of parameters; only the scale changes, not the idea.

def f_grad(x):
    return 2 * (x - 3)

x = 0.0
learning_rate = 0.1
for step in range(20):
    grad = f_grad(x)
    x = x - learning_rate * grad
    print(f"step {step}: x = {x:.4f}")

Running this prints x getting closer to 3.0 with every step, with the steps shrinking in size as x approaches the minimum. This is worth running yourself and watching the numbers, because the pattern you see here, large corrections early and small corrections later, reappears every time you watch a training loss curve flatten out.

Project for months 1-2

Pick any small public dataset and write a short exploratory analysis: load it, clean missing values, compute summary statistics for each column, make two or three plots, and write three sentences about what you found. The deliverable is not a model yet. It is proof that you can go from a raw file to a clear, correct description of what is in it.

Months 3-4: classical machine learning

Now you start building models. The goal of this block is to understand a handful of classical algorithms well enough to explain them to someone else, and to get comfortable with the full cycle of training, evaluating, and comparing models using scikit-learn.

Core algorithms

Study, in this order: linear regression, logistic regression, decision trees, k-nearest neighbours, and a simple ensemble method such as random forests. For each one, make sure you can answer three questions in plain language: what is it predicting, what does the model actually learn (a line, a set of splitting rules, a set of neighbours), and what happens when you give it more or less data. Do not move to the next algorithm until you can answer these for the current one without looking at notes.

Model evaluation, with a worked example

Suppose you train a classifier to detect spam email on a test set of 200 messages, of which 40 are actually spam and 160 are not. Your model predicts 50 messages as spam. Of those 50, 35 are truly spam and 15 are not (false positives). Of the 150 it predicts as not spam, 5 are actually spam that it missed (false negatives) and 145 are correctly identified as not spam.

From these four numbers you can compute precision and recall. Precision asks, of the messages flagged as spam, how many really were spam: 35 divided by 50, which is 0.70. Recall asks, of the messages that really were spam, how many did we catch: 35 divided by 40, which is 0.875. Accuracy, the simplest metric, is the total correct (35 plus 145 equals 180) divided by the total (200), which is 0.90. Notice that accuracy alone hides the fact that we missed 5 spam messages and wrongly flagged 15 good ones; precision and recall tell you where the mistakes are concentrated, which matters a great deal in a case like spam filtering where a false positive (a real email marked as spam) can be more costly than a false negative.

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import precision_score, recall_score, accuracy_score
from sklearn.datasets import make_classification

# Generate a synthetic dataset to practice the workflow end to end
X, y = make_classification(n_samples=1000, n_features=10, random_state=42)

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

model = LogisticRegression()
model.fit(X_train, y_train)
predictions = model.predict(X_test)

print("accuracy:", accuracy_score(y_test, predictions))
print("precision:", precision_score(y_test, predictions))
print("recall:", recall_score(y_test, predictions))

This example uses scikit-learn, assuming a reasonably recent version such as 1.x, and a synthetic dataset generated with make_classification so you can run it immediately without downloading anything. The pattern it demonstrates, split the data, train on one part, evaluate on the held-out part, and look at more than one metric, is the backbone of nearly every classical machine learning project you will do.

Project for months 3-4

Take a tabular dataset with a clear target column, for example predicting whether a loan will default, whether a customer will churn, or the price of a house. Build the full pipeline: clean the data, split it into training and test sets, train two or three different algorithms, compare them using appropriate metrics (accuracy and a confusion matrix for classification, mean absolute error or root mean squared error for regression), and write up which model you would actually ship and why. This project, done properly, is worth more than three more tutorials.

Months 5-6: deep learning foundations

Classical algorithms handle a huge share of real-world tabular problems, but deep learning is where you need to go for images, text, audio, and many modern applications. This block is about understanding neural networks from the ground up, not about memorising architectures.

Neural network basics

A neural network, at its simplest, is a chain of linear operations (weighted sums, the same matrix multiplication from month one) followed by a small nonlinear function, stacked in layers. The nonlinearity matters because without it, stacking linear layers just collapses back into one linear layer, no matter how many you add. Training the network means repeating the gradient descent idea from month one, but now with thousands or millions of parameters instead of one. The algorithm that computes all those gradients efficiently is called backpropagation; you do not need to derive it by hand, but you should understand that it is just the chain rule from calculus applied layer by layer, working backward from the error at the output.

Pick one framework

Choose either PyTorch or TensorFlow and commit to it for this block rather than splitting attention between both. PyTorch tends to be the more common default in research and in many current job postings, but either is a reasonable choice, and the underlying concepts transfer between them. Work through building a small network by hand: define layers, choose a loss function, pick an optimiser, and write the training loop yourself at least once, even though higher-level helpers exist, because writing the loop is what makes the training process concrete rather than magical.

Project for months 5-6

Train an image classifier on a small, well-known dataset such as a digit or clothing image dataset with ten classes and a modest number of images per class. Get a basic version working end to end first, even with mediocre accuracy, before trying to improve it. Then make one change at a time, such as adding a convolutional layer, adjusting the learning rate, or adding dropout, and record how each change affects accuracy on a held-out set. The goal is to build an intuition for which changes help and why, rather than to memorise a list of tricks.

Months 7-8: choose a specialisation

By now you have a working foundation in both classical and deep learning methods. Trying to go deep in every subfield at once spreads you thin, so pick one direction for these two months based on what you find genuinely interesting, since that interest is what will keep you working through the harder weeks.

• Natural language processing: study how text is turned into numbers (tokenisation and embeddings), then build a project such as a sentiment classifier on product or movie reviews, or a simple text summariser using a pretrained model.
• Computer vision: go deeper into convolutional networks, study transfer learning (reusing a model trained on a large dataset and fine-tuning it on your smaller one), and build a project such as classifying your own photos into categories or detecting a specific object type.
• Tabular and time series: study gradient boosting libraries in depth, since they are frequently the strongest performers on structured business data, and build a project forecasting something with a time component, such as daily sales or website traffic, being careful to split train and test sets by time rather than randomly.
• Recommender systems: study collaborative filtering and content-based approaches, and build a small movie or book recommender using a public ratings dataset.

Whichever path you pick, the project for this block should be more ambitious than earlier ones: it should involve a dataset you had to clean yourself, a model you had to tune rather than use with default settings, and a written explanation of at least one mistake you made and fixed along the way. That last part matters for your portfolio later, because explaining a mistake shows more judgement than only showing a polished result.

Months 9-10: from model to product

A model sitting in a notebook is not the same as a model doing useful work. This block is about the engineering skills that turn a trained model into something that can be used, monitored, and trusted, often grouped under the label MLOps.

Data and experiment tracking

As soon as you train more than a handful of models, you will forget which settings produced which result. Practice recording, for every experiment, the data version used, the model settings, and the resulting metrics, even if you do this in a simple spreadsheet at first. Many teams use dedicated experiment tracking tools, but the habit matters more than the specific tool, and the habit is: never trust a result you cannot reproduce.

Deployment basics

Learn to wrap a trained model behind a small web API, so that sending it input data returns a prediction. A minimal version of this is a short script using a lightweight web framework that loads a saved model and exposes one endpoint. Also learn the basics of containerising an application, which means packaging your code and its dependencies so it runs the same way on any machine, since this is one of the most commonly expected skills for applied roles even at a beginner level.

from flask import Flask, request, jsonify
import joblib
import numpy as np

app = Flask(__name__)
model = joblib.load("model.joblib")  # a model saved earlier with joblib.dump

@app.route("/predict", methods=["POST"])
def predict():
    data = request.get_json()
    features = np.array(data["features"]).reshape(1, -1)
    prediction = model.predict(features)
    return jsonify({"prediction": prediction.tolist()})

if __name__ == "__main__":
    app.run(port=5000)

This small Flask application, assuming Flask is installed, loads a model you saved earlier with joblib and exposes it over HTTP. Sending a POST request with a list of feature values to the /predict endpoint returns the model's prediction as JSON. It is intentionally bare bones, with no input validation or error handling, because the point here is to see the shape of the idea: a trained model becomes useful once something else can call it over a network, rather than requiring you to run a notebook cell by hand.

Monitoring and drift

Learn the concept of data drift: the idea that the data a model sees in production can gradually diverge from the data it was trained on, which silently degrades its accuracy over time. You do not need to build a full monitoring system in this block, but you should understand why a model that worked well on launch day can quietly get worse months later, and what signals (such as a change in the distribution of input features) would tell you to investigate.

Project for months 9-10

Take the specialisation project from months 7-8 and turn it into a small deployed service: wrap it behind an API, containerise it, and write a short README explaining how someone else would run it. This is the project that signals, to anyone reviewing your work later, that you can finish things rather than only prototype them.

Months 11-12: portfolio, depth, and job readiness

The final block is about presenting everything you have built and closing the remaining gaps that matter for interviews, rather than learning large amounts of new material.

A capstone project

Pick one more project, ideally the most ambitious one you attempt all year, and give it real polish: a clean repository, a clear written explanation of the problem and your approach, the mistakes you made, and the final result with honest limitations stated. A capstone that says plainly where the model struggles is more convincing to an experienced reviewer than one that only claims success, because every real model has limitations and hiding them signals inexperience rather than confidence.

Writing about your work

Write short posts, even informal ones, about two or three of your projects from across the year. The act of writing forces you to check whether you actually understand a method or are just able to call a function for it. It also gives you material to point to when someone asks what you have been doing for the past year.

Interview preparation

Three kinds of questions typically come up for applied machine learning roles: general coding questions (data structures, basic algorithms), machine learning concept questions (explain overfitting, explain the bias-variance tradeoff, explain why you would choose precision over recall in a given scenario), and applied or system design questions (how would you build a recommendation system for this product, what would you monitor after deployment). Spend a few weeks each on all three, since many strong candidates lose offers by over-preparing for coding questions while neglecting the conceptual and applied ones.

Networking and applying

Start applying and talking to people well before you feel fully ready, because the interview process itself is a learning experience, and feedback from real interviews is more useful than another month of solo study. A polished portfolio with three solid, well-explained projects will take you further than a vague familiarity with ten different topics.

Weekly rhythm: how to spend your hours

With a budget of roughly six to eight hours a week, a workable split is: two to three hours of structured learning (reading, a course, working through exercises), three to four hours of hands-on project work, and one hour of review, where you revisit a topic from a previous month, write a short summary of it in your own words, or redo a small exercise from memory. The review hour feels unnecessary in the moment and is usually the first thing people cut, but it is what keeps month two's material alive by month eight instead of fading away.

Common mistakes that derail progress

• Tutorial hell: endlessly following along with video tutorials without ever building something from a blank file. The fix is to stop a tutorial partway through and try to finish the rest yourself before watching the solution.
• Skipping the math because it feels slow: a little bit of linear algebra and calculus, worked through with small concrete numbers as in the gradient descent example above, pays for itself many times over when debugging a model that refuses to train.
• No finished projects: five half-started projects are worth less than one finished one with a clear write-up, because interviewers and collaborators judge what you can complete, not what you understand in theory.
• Chasing every new tool or paper: the field moves quickly, but the fundamentals from months one through four barely change year to year. A new technique is far easier to pick up once the fundamentals are solid.
• Ignoring evaluation: a model with 95 percent accuracy on an imbalanced dataset where 95 percent of examples belong to one class has learned nothing useful. Always ask what a trivial baseline would score before celebrating a number.

How to know the plan is working: checkpoints

At the end of each two-month block, test yourself honestly rather than assuming progress happened just because time passed.

• After months 1-2: can you take a new, unfamiliar CSV file and produce a clean summary of it within an hour, without looking up basic pandas syntax?
• After months 3-4: can you explain, to a non-technical friend, what precision and recall mean using a concrete example like the spam filter above?
• After months 5-6: can you write a basic training loop for a small neural network from memory, even if you need to look up exact function names?
• After months 7-8: can you describe one real mistake you made in your specialisation project and how you diagnosed it?
• After months 9-10: can you walk someone through what happens, step by step, from a user's request arriving to a prediction being returned by your deployed model?
• After months 11-12: can you talk through your capstone project for fifteen minutes, including its limitations, without reading from notes?

Summary and what comes next

This plan moves from Python and math fundamentals, through classical machine learning and deep learning, into a chosen specialisation, basic engineering and deployment skills, and finally a polished portfolio and interview preparation. The through-line across all twelve months is the same: learn a concept, then immediately use it on a small, concrete project with real data, however modest, rather than collecting knowledge you have not yet applied. A year spent this way leaves you with a handful of finished projects you can explain in depth, which is worth far more than a long list of topics you have merely read about.

After the twelve months, the natural next step is not to start a second, more advanced curriculum from scratch, but to pick a direction based on what you enjoyed most this year, whether that is going deeper into a specialisation, contributing to an open-source project in the area, or applying for roles and letting the specific demands of a real job guide what you learn next.