Building a portfolio and research roadmap

The Core Philosophy: Portfolio as Evidence, Roadmap as Strategy

What is a Research Portfolio?

Why does it work?

• Credibility through specificity: "I work on NLP" is vague. "I replicated BERT from scratch, found a 15% speedup by fusing LayerNorm, documented every bug—here's the repo" is concrete.
• Learning forcing function: Building in public forces you to understand deeply (you can't fake a working implementation or a clear explanation).
• Network effects: Quality artifacts attract mentors, collaborators, and opportunities.

What is a Research Roadmap?

Why does it work?

• Prevents drift: Without a roadmap, you jump between shiny topics and never go deep.
• Manages scope: Research is infinite; a roadmap forces80/20 prioritization (which 20% of skills unlock 80% of research capability?).
• Builds momentum: Small wins (finishing a paper reproduction) compound into confidence and skill.

The Portfolio: What to Build and How

The Three Pillars of a Strong Portfolio

1. Reproductions: Prove You Can Implement State-of-the-Art

What: Take a recent paper (< 2 years old), reimplement it from scratch, verify you match the reported results.

Why this is hard:

• Papers omit "obvious" details (learning rate schedules, initialization, data preprocessing quirks).
• Debugging requires deep understanding: a 0.5% accuracy gap might be a subtle bug or a fundamental misunderstanding.

How to do it right:

1. Pick strategically: Choose a paper in your target area that's influential but not overly complex (e.g., a ResNet variant before tackling a Vision Transformer).
2. Document obsessively: Track every hyperparameter choice, plot training curves, note discrepancies.
3. Open-source with a narrative README:
   • "What I learned" section (e.g., "Batch size matters more than I thought—here's why")
   • Comparisons to the original (table of your results vs. paper's)
   • Known issues and how you debuged them

2. Extensions: Prove You Can Generate Novel Insights

What: Take an existing method, modify it based on a hypothesis, and empirically test if it's better/faster/more interpretable.

Why this matters: Extensions show you can do science—formulate a question, design an experiment, interpret negative results.

How to generate ideas:

• Efficiency angle: "Can I replace this O(n²) attention with a sparse pattern and keep95% of performance?"
• Data angle: "This model works on ImageNet. Does it fail on low-resource medical images? Why?"
• Interpretability angle: "Can I visualize what this GAN's generator learned at each layer?"

3. Explanations: Prove You Can Teach

What: Write blog posts, tutorials, or videos that explain a concept better than existing resources.

Why: Teaching deepens understanding (Feynman technique) and builds your reputation. If someone Googles "how does CLIP work" and finds your post, you're now a known expert.

How to stand out:

• Interactive: Provide a Colab notebook where readers can tweak hyperparameters.
• Visual: Use diagrams (tensor shapes, attention patterns, loss landscapes).
• Mistakes-first: "Here's what I got wrong when I first learned this, and why the correct view makes sense."

Portfolio Maintenance: It's Alive, Not Static

• Update regularly: Add new projects every 2-3 months. Archive old work that no longer represents your best.
• Narrative over chronology: On your portfolio site, lead with your best work (not your oldest). Group by theme ("Efficient Architectures," "Multimodal Learning") rather than date.
• Get feedback: Share with peers, ask "What's unclear? What would make this more impressive?" Iterate.

The Roadmap: From "Interested in ML" to "Publishable Researcher"

Roadmap Template (12-Month Example)

Phase 1 (Months 1-3): Foundations + First Reproduction

Goal: Go from "I can train a model in Keras" to "I can implement a paper from scratch in PyTorch."

Deliverable: Reproduce ResNet-50 on CIFAR-10, document all bugs, open-source.

Skills to master:

1. PyTorch internals: nn.Module, autograd, custom datasets, learning rate schedulers
2. Debugging: How to use pdb, torch.autograd.set_detect_anomaly, visualize gradients
3. Experiment tracking: Log hyperparameters, metrics with Weights & Biases or TensorBoard

Daily practice (80/20):

• Spend 70% of time coding (implement one ResNet block per week, write unit tests)
• 20% reading (ResNet paper, PyTorch docs, blog posts on training tricks)
• 10% writing (daily log of "Today I learned X, tomorrow I'll tackle Y")

Success metric: Your ResNet achieves ≥ 93% CIFAR-10 accuracy (within 1% of reported), and your repo has ≥ 10 GitHub stars (signals others find it useful).

Common mistake: Skipping unit tests. "The model trains, so it must be correct." Wrong—gradient flow might be broken in a subtle way. Test each layer in isolation.

Phase 2 (Months 4-6): Specialization + Extension

Goal: Become dangerous in one subfield (say, computer vision) by extending a method.

Deliverable: Paper-style writeup of your extension, submitted to a workshop (e.g., CVPR workshop track).

Skills to master:

1. Literature review: Use arXiv-sanity, Semantic Scholar to find related work
2. Hypothesis formulation: "If I change X, I predict Y because Z"
3. Statistical rigor: Run experiments 3+ times, report mean± std, use t-tests to check significance

Project idea: "Data-efficient Vision Transformers via early-stopping and aggressive augmentation."

• Hypothesis: ViTs overfit on small datasets; combining AutoAugment + early stopping by validation loss gives better accuracy/compute tradeoff than CNs.
• Experiments: CIFAR-10 with 10%, 50%, 100% of training data. CompareViT-Tiny vs. ResNet-18.
• Expected insight: ViTs need more data OR better regularization. If your method works, you've found a practical trick; if not, you've characterized a failure mode (also valuable).

Success metric: Submit to a workshop (acceptance isn't required yet—submitting forces you to write clearly). Get feedback from 2+ researchers (email authors of related papers, post on Twitter/Reddit).

Phase 3 (Months 7-9): Depth + Collaboration

Goal: Work on a harder problem, ideally with a mentor or lab.

Deliverable: A preprint on arXiv + a blog post explaining your method to practitioners.

Skills to master:

1. Scaling up: Train on multi-GPU, debug distributed training bugs (deadlocks, gradient synchronization)
2. Code review: Have someone critique your code—learn professional standards (docstrings, type hints, tests)
3. Scientific writing: Follow ICML/NeurIPS paper structure (intro with motivation, related work, method, experiments, discussion)

How to find collaborators:

• Join a research lab (university or industry; even part-time/remote)
• Cold-email professors whose papers you've reproduced ("I loved your work on X, reimplemented it, found an interesting edge case—could we explore this together?")
• Participate in community efforts (open-source projects like Hugging Face, EleutherAI)

Success metric: Publish a preprint with ≥ 1 co-author. Get ≥ 50 citations in the first year (realistic for a solid workshop paper in a hot area).

Phase 4 (Months 10-12): Visibility + Next Steps

Goal: Establish yourself as a credible voice in your subfield.

Deliverable: Give a talk at a local meetup or online seminar, write 2-3 blog posts on "lessons from my research year."

Skills to master:

1. Public speaking: Practice explaining your work in 5 min (elevator pitch), 20 min (conference talk), 60 min (invited lecture)
2. Networking: Engage on Twitter/Mastodon, comment on others' preprints, attend conferences (virtual or in-person)
3. Career planning: Apply to PhD programs, or research engineer roles, or start a startup—your portfolio is now the proof

Success metric: ≥ 500 Twitter followers in your niche, or ≥ 3 invitations to speak/collaborate, or acceptance to a top PhD program.

Adjusting the Roadmap: Forecast-then-Verify

The 80/20 of Research Skills

Focus on these high-leverage skills (they appear in 80% of projects):

1. Reading papers efficiently: Skip to experiments first (do results justify the hype?), then read method, then intro.
2. Writing clean code: Use version control (Git), modularize (one function = one job), document (future-you will thank present-you).
3. Debugging scientifically: Binary search (does the bug appear with random data? With a tiny model?), ablate one change at a time.
4. Communicating results: A great figure is worth 1000 words. Learn matplotlib, seaborn, tikz for diagrams.

Ignore (for now):

• Advanced math that doesn't appear in papers you care about (you don't need measure theory to train a ResNet).
• Tools you don't use (don't learn JAX if all your target labs use PyTorch).
• Perfectionism ("My repo needs a logo and CI pipeline before I share it"—no, ship it now, iterate later).

Common Mistakes (Steel-man + Fix)

Active Recall Checkpoints

Practical Checklist: Your First 30 Days

• Day 1-7: Pick a paper to reproduce (not too easy, not too hard—something you're 60% confident you can do). Read it 3 times, annotate every math symbol.
• Day 8-14: Set up your environment (PyTorch, Git, a public repo, a logging tool). Implement the simplest component (e.g., a single Transformer layer). Write a unit test.
• Day 15-21: Assemble the full model, start training on a toy dataset (to catch bugs fast). Debug. Expect 5-10 bugs—document each one.
• Day 22-28: Train on the real dataset, compare to paper's results. Write a README with your findings.
• Day 29-30: Share on Twitter/Reddit/Discord: "I reproduced paper X, here's what I learned. Feedback welcome!" Expect criticism—it's how you improve.

Connections

• 6.5.1-Interpretability-and-explainability – Interpretability projects make great portfolio pieces (clear value proposition)
• 6.5.2-Fairness-and-bias-in-AI – Extending fairness metrics to new domains is a publishable extension
• 6.5.3-Federated-learning – Reproducing a federated learning paper requires both ML + systems skills (high-value signal)
• 6.5.8-AI-safetyand-alignment – Safety research roadmaps follow the same structure (identify risk → design evaluation → propose mitigation)
• 6.5.10-Open-problemsin-AI-research – Your roadmap should target open problems (where novelty is possible)

Flashcards

#flashcards/ai-ml

What are the three pillars of a strong ML research portfolio? :: 1) Reproductions (prove you can implement state-of-the-art), 2) Extensions (prove you can generate novel insights), 3) Explanations (prove you can teach)

Concept Map

Hinglish (regional understanding)