Lesson 6 — Recap and FAQ
The five lessons in one page
Lesson 1 — why Python. It won by delegating every heavy computation to compiled libraries, so readable code drives native machinery. NumPy's shared array type let tools compose instead of compete, and the feedback loop closed the question by around 2015.
Lesson 2 — NumPy and pandas. NumPy replaces scattered objects with one contiguous typed block, making whole-array operations ten to a hundred times faster. pandas adds named columns and missing-value handling, and holds everything in memory, so Polars, DuckDB or Spark take over at scale.
Lesson 3 — notebooks. They fit AI work by keeping expensive state and putting output beside code. Their persistent session lets cells run out of order, so restarting and running from the top is the only way to trust a result. Logic reused a third time belongs in a module.
Lesson 4 — scikit-learn. One interface for every model makes comparison cheap. Pipelines guarantee identical treatment in production and keep cross-validation honest. Data leakage is the failure that raises your score and destroys your result.
Lesson 5 — frameworks and environments. Start with PyTorch, adapt pre-trained models rather than training from scratch, and use one isolated environment per project with pinned versions, because library updates change numbers and not just interfaces.
Which tool for which job
| You need to | Reach for |
|---|---|
| Load and clean a CSV or Excel file | pandas |
| Do the same on tens of gigabytes | Polars or DuckDB |
| Numerical computation on arrays | NumPy |
| Plot something to understand your data | Matplotlib, or Seaborn for statistical plots |
| Train a model on a table | scikit-learn, with XGBoost or LightGBM as the estimator |
| Train a neural network | PyTorch |
| Use an existing language or vision model | Hugging Face Transformers |
| Explore interactively | Jupyter or Google Colab |
| Isolate a project's dependencies | uv, or conda when CUDA is involved |
| Turn a model into an API | FastAPI |
| Build a quick interface for a demo | Streamlit or Gradio |
A sensible learning order
The step people skip is E, and it is the one that matters most. A finished project on messy real data teaches you things no course covers: that the data is worse than you expected, that the metric you chose was wrong, and that the last ten percent takes as long as the first ninety.
The 12 questions people actually ask
1. How long before I can train a model?
If you already know some Python, two to three weeks of consistent work gets you to a working scikit-learn model on a clean public dataset. Being able to do it on your own messy data, and to explain whether the result is trustworthy, is a matter of months rather than weeks — and that second skill is the employable one.
2. Should I use Colab or install Python locally?
Colab while learning: nothing to install, free GPU, no version conflicts. Locally once you have projects to keep: you need version control, files on disk, and code you can run from a terminal. Most practitioners end up using both, exploring in a hosted notebook and building in a local repository.
3. pandas or Polars?
Learn pandas first, because every tutorial, answer and existing codebase uses it. Move to Polars when your data gets large or your pipelines get slow: same mental model, far better memory behaviour, genuine multi-core execution. Knowing pandas makes Polars easy; the reverse is less true.
4. Do I need to know SQL?
Yes, and more than most beginners expect. Real data lives in databases, and being able to aggregate and join before pulling anything into Python is often the difference between a query that returns in two seconds and a script that runs for an hour. SQL is also a smaller language than Python and repays the effort quickly.
5. Which editor should I use?
VS Code is the pragmatic answer: it runs notebooks inline, has strong Python support and is free. PyCharm is more powerful for large codebases. JupyterLab is fine if you work almost entirely in notebooks. This choice matters far less than people argue about it.
6. How do I get better at debugging?
Read the bottom of the stack trace first: that is your error. Then read upward to find the last line that belongs to your own code. Print the shape and type of everything before the failing line, because a large share of errors in this field are shape mismatches. Learning breakpoint() and stepping through interactively will do more for you than any amount of adding print statements.
7. Why does my code work in the notebook but not as a script?
Almost always hidden state, from lesson 3. The notebook session still holds a variable defined by a cell you edited or deleted. Restart the kernel, run everything from the top, and the real error appears immediately.
8. How much data do I need before starting?
For a classical model on a table, a few hundred to a few thousand rows is a genuine starting point. For deep learning from scratch on images, think thousands per class. For fine-tuning a pre-trained model, a few hundred to a few thousand examples is often enough, which is exactly why fine-tuning changed what small teams can attempt.
9. What is the difference between a library and a framework here?
You call a library; a framework calls you. NumPy and pandas are libraries: you decide the flow. PyTorch sits between the two, giving you building blocks and a training loop you write yourself. Keras and Lightning are closer to frameworks: you fill in the model and they run the loop.
10. Is it worth learning C++ for AI?
Not to start, and eventually maybe. It becomes relevant if you write custom high-performance operations, work on the frameworks themselves, or deploy to constrained hardware. For years of applied work, Python plus an understanding of why the fast path is fast will serve you completely.
11. How do I keep up without drowning?
Ignore most of it. The fundamentals in this course change on a scale of years; the announcements change weekly and the overwhelming majority will not affect your work. Pick two or three trustworthy sources, read release notes for the libraries you actually use, and let the rest pass. Depth in the basics beats breadth in the news.
12. Where should I go after this course?
Mathematics for AI for the intuition behind what these libraries compute, then Machine Learning to build models with scikit-learn, then Deep Learning for neural networks. Somewhere in there, finish a project on data you chose yourself.
This course was the map. The premium catalogue is the terrain: runnable notebooks, real datasets, projects you finish, and a verifiable certificate after a 40-question examination. Included in every paid plan.
Last step — Take the quiz and see your attestation →