Learning AI for Beginners: 90-Day Roadmap, Tools, and Projects

Learning AI for Beginners: 90-Day Roadmap, Tools, and Projects
Theodore Summers 11 September 2025 0 Comments

You don’t need a PhD or a fancy GPU to get useful results from AI. You need a focused plan, steady practice, and small wins that stack. This guide gives you a clear route from zero to shipping simple AI projects in 90 days. Expect a practical path, not magic. We’ll keep the math light, the tools simple, and the outcomes real.

TL;DR

  • Follow one stack for 90 days: Python, NumPy, pandas, scikit‑learn, PyTorch, Hugging Face, and Google Colab or Kaggle.
  • Ship three small projects that solve real problems. Start with tabular data, then text, then a tiny image model.
  • Use a weekly rhythm: learn 2 hours, build 2 hours, document 1 hour, review 1 hour.
  • Common traps: tutorial hell, chasing hype, skipping evaluation. Fix: baseline first, measure, iterate.
  • Portfolio > certificate. Employers and clients want proof you can deliver value.

This guide is about learning AI for beginners with a system that fits real life. I’m writing this from Perth, where bandwidth and time zones aren’t always friendly, so everything here works with a laptop and free or low‑cost tools.

Your 90‑day AI roadmap that actually works

Here’s the job: reduce confusion, build skill through reps, and ship small wins. Think of this in three phases. Each week has clear outputs so you can see progress.

Rule of thumb: 6 hours per week is enough to get traction. If you have more time, double the build time, not the theory time.

Phase 1 - Foundation (Weeks 1-4)

  1. Week 1: Python and data basics
    • Install Python 3.11+, VS Code, and set up a virtual environment.
    • Learn just enough Python: variables, lists, dicts, functions, loops, comprehensions.
    • pandas basics: load a CSV, clean columns, handle missing values, basic plots.
    • Deliverable: a cleaned dataset notebook with 3 insights and a simple chart.
  2. Week 2: Math you’ll actually use
    • Linear algebra lite: vectors, dot products. Why? Similarity and model inputs.
    • Probability: distributions, expectation, conditional probability.
    • Calculus for ML: gradients conceptually (no proofs), what a loss is.
    • Deliverable: a short note where you explain gradient descent in your own words, plus a tiny function that computes mean squared error.
  3. Week 3: Machine learning basics with scikit‑learn
    • Supervised learning: train/test split, cross‑validation, overfitting vs underfitting.
    • Models: linear regression, logistic regression, decision trees.
    • Metrics: RMSE for regression; accuracy, precision, recall, F1 for classification.
    • Deliverable: a notebook that trains 2 models on the same dataset and compares metrics with a clear chart.
  4. Week 4: Deep learning fundamentals
    • Neural nets: layers, activations, parameters, loss, optimizer.
    • PyTorch 2.x: tensors, autograd, a tiny MLP on a toy dataset.
    • Transfer learning idea: start from a pretrained model, fine‑tune a bit.
    • Deliverable: your first PyTorch notebook that fits a small model and logs losses.

Phase 2 - Build real skills (Weeks 5-8)

  1. Week 5: Tabular project
    • Pick a business‑ish dataset (sales, churn, credit risk, pricing from Kaggle or UCI).
    • Set a baseline (e.g., logistic regression), then try a tree‑based model (RandomForest, XGBoost).
    • Deliverable: a short report with problem statement, features, two models, metrics, and next steps.
  2. Week 6: NLP starter
    • Use Hugging Face pipelines to run sentiment or topic classification.
    • Clean text: lowercase, basic tokenization; learn about context windows.
    • Deliverable: a script that labels customer reviews and a chart of positive vs negative by product.
  3. Week 7: Computer vision starter
    • Set up torchvision; load a small dataset (CIFAR‑10 or a folder of images).
    • Transfer‑learn a ResNet‑18 on 2-3 classes. Use data augmentation.
    • Deliverable: a notebook with accuracy and a few misclassified image examples.
  4. Week 8: Reproducibility and presentation
    • Document your work: README with problem, data, approach, metrics, and a screenshot.
    • Track experiments: even a CSV log with hyperparameters and results beats guesswork.
    • Deliverable: clean repo with environment file and clear instructions to run.

Phase 3 - Ship value (Weeks 9-12)

  1. Week 9: Productize one project
    • Wrap your best notebook with Gradio or Streamlit so anyone can try it.
    • Host with Hugging Face Spaces or a small VM.
    • Deliverable: a working demo link and a 60‑second screen recording.
  2. Week 10: Data quality and error analysis
    • Find where the model fails: slice by category, time, user segment.
    • Improve data: more examples for failing slices often beats tuning hyperparameters.
    • Deliverable: an error analysis markdown with 3 fixes and before/after metrics.
  3. Week 11: Ethics and risk basics
    • Read the NIST AI Risk Management Framework (2023) summary.
    • Check consent for data; anonymize sensitive fields; add a disclaimer to your demo.
    • Deliverable: a short risk note in your README listing constraints and intended use.
  4. Week 12: Portfolio polish and feedback
    • Write a 500‑word project story: problem, approach, impact, what you’d do next.
    • Ask for feedback from a local meetup or online forum; iterate once.
    • Deliverable: LinkedIn post or blog highlighting your demo and key metric.

Heuristics that save months

  • Baseline first: start with the simplest model that could work. Only add complexity if metrics stall.
  • Data beats model: doubling good data often outperforms switching to a fancier model.
  • Measure what matters: pick 1-2 metrics tied to the goal; don’t chase leaderboard scores blindly.
  • Time split: 50% data work, 30% modeling, 20% documentation and presentation.
  • Study ratio: 70% building, 20% learning, 10% theory. Reverse that and you’ll stall.

Hands‑on examples you can copy and adapt

Start with tabular data. It’s closer to work problems and teaches you the discipline of evaluation and iteration.

Example 1 - Tabular classification with scikit‑learn

# Binary classification on the breast cancer dataset
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, confusion_matrix
import pandas as pd

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

clf = LogisticRegression(max_iter=1000)
clf.fit(X_train, y_train)

preds = clf.predict(X_test)
print(confusion_matrix(y_test, preds))
print(classification_report(y_test, preds, digits=3))

Why this matters: it gives you a quick baseline, teaches scaling, and shows precision/recall trade‑offs. If classes are imbalanced, use stratified splits and watch F1 or AUROC instead of accuracy.

Example 2 - Quick NLP with a pretrained pipeline

# Sentiment classification in a few lines
from transformers import pipeline
nlp = pipeline('sentiment-analysis')
reviews = [
    'Shipping was fast but the product broke in two days.',
    'Love the build quality and customer support!',
]
print(nlp(reviews))

This gives you instant value for support tickets, product reviews, or surveys. For a proper project, collect your own labels for a domain‑specific classifier and compare it against the generic model.

Example 3 - Tiny image classifier with transfer learning (PyTorch)

import torch, torch.nn as nn, torch.optim as optim
from torchvision import models, datasets, transforms
from torch.utils.data import DataLoader

# Data
train_tfms = transforms.Compose([
    transforms.Resize(224), transforms.RandomHorizontalFlip(), transforms.ToTensor()
])
val_tfms = transforms.Compose([
    transforms.Resize(224), transforms.ToTensor()
])
train_ds = datasets.ImageFolder('data/train', transform=train_tfms)
val_ds = datasets.ImageFolder('data/val', transform=val_tfms)
train_dl = DataLoader(train_ds, batch_size=32, shuffle=True)
val_dl = DataLoader(val_ds, batch_size=32)

# Model
model = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)
for p in model.parameters():
    p.requires_grad = False
num_feats = model.fc.in_features
model.fc = nn.Linear(num_feats, len(train_ds.classes))

# Train
device = 'cuda' if torch.cuda.is_available() else 'cpu'
model.to(device)
loss_fn = nn.CrossEntropyLoss()
opt = optim.Adam(model.fc.parameters(), lr=1e-3)

for epoch in range(3):
    model.train()
    for x, y in train_dl:
        x, y = x.to(device), y.to(device)
        opt.zero_grad()
        out = model(x)
        loss = loss_fn(out, y)
        loss.backward()
        opt.step()
    print('epoch', epoch, 'done')

Even 2-3 epochs with a frozen backbone can get decent accuracy on a small, clean dataset. Show misclassifications to spot labeling or lighting issues before model tweaks.

Project ideas by role

  • Student: Predict study outcomes from attendance and quiz scores; auto‑tag lecture notes by topic.
  • Marketer: Classify campaign leads as hot/warm/cold; segment emails by intent; summarize feedback.
  • Small business owner: Forecast weekly sales; flag late‑paying invoices; match support tickets to help articles.
  • Analyst: Detect anomalies in transactions; build a churn early‑warning score; run a what‑if pricing simulator.

Picking metrics that matter

  • Balanced classification: accuracy is fine; add F1 if false positives and negatives both hurt.
  • Imbalanced classification: use AUROC or average precision; report recall on the minority class.
  • Regression: start with RMSE; if scale varies across segments, add MAPE for business readability.

Common pitfalls in your first projects

  • Data leakage: features that wouldn’t exist at prediction time leak future info. Split first, transform after.
  • Overfitting: training accuracy high, test poor. Fix with regularization, simpler models, or more data.
  • Confusing correlation with causation: models predict, they don’t prove why. Keep claims modest.
  • Chasing SOTA: if the baseline is weak, fancy models won’t rescue bad data or fuzzy goals.
Tools, checklists, and cheat sheets

Tools, checklists, and cheat sheets

Your starter stack (2025‑ready)

  • Editor and environment: VS Code, conda or venv.
  • Data: pandas, NumPy; visualization with matplotlib or seaborn.
  • Models: scikit‑learn for classical ML; PyTorch for deep learning; transformers for NLP.
  • Compute: Google Colab or Kaggle; upgrade to a paid GPU only when jobs queue too long.
  • Experiment tracking: a simple CSV log or Weights & Biases when you want graphs.
  • Deployment: Gradio/Streamlit for demos; Hugging Face Spaces for free hosting; FastAPI if you need an API.
  • Datasets: Kaggle, UCI Repository, Hugging Face Datasets.

Decision guide: what model to try first?

  • Tabular, small to medium data: Start with Logistic/Linear Regression, then RandomForest. If non‑linear patterns show up, try XGBoost or LightGBM.
  • Text classification: Start with Hugging Face pipeline (distilbert family). If you need custom labels, fine‑tune a small model.
  • Images, few classes: Transfer learn a ResNet‑18; only train the head first, then unfreeze later if needed.
  • Need explainability: prefer linear models or tree‑based models with SHAP plots over black‑box deep nets.

90‑day study rhythm checklist

  • Weekly plan: 2h learn, 2h build, 1h document, 1h review.
  • Deliverables: a notebook, a README, and one chart every week.
  • Feedback loop: share one artifact for critique every 2 weeks.
  • Portfolio rule of three: three solid projects beat ten half‑finished notebooks.

Project checklist (from data to demo)

  • Define the question: who benefits, what metric moves, what decision changes?
  • Get the data: source, shape, quality; check missing values and leakage risks.
  • Baseline: simplest possible model and a single metric.
  • Improve: add features, try one alternative model, tune 1-2 hyperparameters.
  • Evaluate: compare on a hold‑out set; error analysis by segment.
  • Ship: wrap in Gradio; write a short readme with limitations and intended use.

Debugging cheat sheet

  • Underfitting signs: both train and test metrics are poor. Fix: stronger model or features.
  • Overfitting signs: train great, test poor. Fix: regularization, more data, simpler model, or augment.
  • Data bugs: sudden metric jumps after a change often mean a leak or mis‑split.
  • Training stuck: learning rate likely too high or too low; try 10x up or down.
  • GPU issues: batch size too big; reduce batch size or image size.

Ethics and safety quick checks

  • Consent and privacy: do you have the right to use this data? Mask PII. Store minimally.
  • Fairness: evaluate subgroups. If a slice performs worse, call it out and fix if possible.
  • Intended use: add a limitation note. Reference the NIST AI Risk Management Framework for risk categories.

Courses and references that age well

  • Machine Learning Specialization by Andrew Ng (DeepLearning.AI) for a grounded intro.
  • fast.ai Practical Deep Learning for hands‑on deep learning without heavy math.
  • Stanford CS229 notes for a rigorous view when you’re ready to go deeper.
  • Hugging Face documentation for modern NLP and model hubs.
  • scikit‑learn user guide for crisp, practical ML patterns.

FAQ and next steps

Do I need advanced math?

No. You need comfort with high‑school algebra, basic probability, and a mental model of gradients. Learn the rest on demand. If a proof blocks you, skip it and keep building.

How much Python do I need?

Enough to write clean functions, read error messages, and handle data with pandas. Loops, list comprehensions, and dicts get you far. You can add classes later.

What about GPUs?

Use CPU for tabular work and small prototypes. Switch to Colab/Kaggle GPU when training deep models or doing image tasks. Don’t buy hardware until you truly hit a wall.

Which certificates matter?

They can help you learn, but a portfolio with three clear, useful projects beats a wall of badges. If you want one, pick something popular like the Machine Learning Specialization for structure.

How do I avoid tutorial hell?

For every hour of watching, spend an hour re‑building from memory. After two tutorials, create your own variant with new data or a new metric. Publish the result.

Where do I find datasets?

Kaggle, UCI ML Repository, and Hugging Face Datasets cover most needs. Or collect your own via exports from tools you use at work (with permission).

What if I’m switching careers?

Align projects with the industry you want. If it’s finance, do anomaly detection and time‑series. If it’s retail, do demand forecasting and recommender basics.

Is it too late to start in 2025?

No. The tools are better, docs are clearer, and deployment is simpler than ever. The market still rewards people who can frame a problem and ship a solution.

Next steps by persona

  • Busy professional (5 hrs/week): Follow the 90‑day plan as is. Focus on one strong tabular project that ties to your job. Ask your manager for a small pilot.
  • Student (10-15 hrs/week): Do the plan at 1.5x speed. Add a fourth project: a Kaggle competition where you aim for top 25%.
  • Career switcher (8-10 hrs/week): Replace Week 11 with a mock consulting engagement: interview a friend about their data and ship a demo.
  • Founder (variable time): Build a rough prototype in Weeks 5-7 and put it in front of users by Week 9. Prioritize UX and a clear metric.

Troubleshooting

  • I can’t remember anything I watch: Take handwritten notes; teach the idea in a paragraph; build a tiny demo before sleeping.
  • Models won’t improve: Freeze the pipeline. Verify splits, target leakage, and metric choice. Try a radically simpler model; then a radically different feature.
  • My code keeps breaking: Use a fresh venv; pin versions; test small pieces; add asserts to check shapes and NaNs.
  • I’m overwhelmed by tools: Lock your stack for 90 days. Ignore everything else. Re‑evaluate later.
  • No idea what to build: Automate a task you already do weekly. If it saves you 10 minutes, it’s a win.

A simple weekly review template

  • What did I ship? (link or file name)
  • What did I measure? (1-2 metrics)
  • What broke? (one issue, one fix)
  • What’s next? (one clear deliverable)

When you’re ready to go deeper

  • Mathematics: revisit linear algebra and optimization with targeted chapters from a good ML math book.
  • Systems: learn vector databases, retrieval‑augmented generation, and simple orchestration when you build LLM apps.
  • MLOps basics: data versioning, experiment tracking, and lightweight CI so others can run your work.

Final nudge: it’s less about intelligence and more about reps. Pick a small problem, ship a small solution, and repeat. Three shipped projects in 90 days will change how you see AI - and how others see your value.

Categories

Archives

© 2025. All rights reserved.