# Lumenia Studio

> A step-by-step path from machine learning basics to responsible AI leadership: how computers learn, and how AI systems are built, tested, and led.

The site is one path, easiest first, published one waypoint at a time. Each area is a chain of questions: every answer raises the next question. Written by Jorge Contreras and Diego Enciso, from two perspectives: a senior technologist moving into AI, and a newcomer starting a career.

## 01 Foundations: How does a computer learn?

- [Foundations](https://lumenia.studio/path/foundations/): Learn the essentials: what it means for a machine to learn from examples.
  - 1. Vector representation: How does a computer see data? Text, images, sound: everything we give a computer has to become numbers first.
  - 2. Learn from examples: What does a computer actually learn? Some rules are too complex for anyone to write down.
  - 3. Loss: How does it know it was wrong? Computers learn from their mistakes, but only once we define what 'wrong' means.
  - 4. Optimization: How does it improve? Knowing you're wrong is half the problem. The other half is knowing what to change.
  - 5. Generalization: Did it learn, or just memorize? A perfect score can hide a serious problem.
  - 6. Regularization: How do we keep it from memorizing? Memorizing is the easiest way to a good score, but it's not the same as learning.
  - 7. Probability and uncertainty: How sure is it? Some answers are careful conclusions, and some are wild guesses.
  - 8. Metrics: How do we measure if it works? An AI can look impressive on paper and still fail at the job it was built for.
  - 9. Rare cases and Drift: When does it stop working? AI fails quietly, when the world where it learned from no longer exists.
- [Vector representation](https://lumenia.studio/path/foundations/embeddings/): A computer sees data as points in space: lists of numbers where alike things sit close together.
- [Learn from examples](https://lumenia.studio/path/foundations/functions/): A computer learns a function: a rule with knobs, fitted to examples.
- [Loss](https://lumenia.studio/path/foundations/loss/): The loss is one number for how wrong a guess is. Learning means making that number small.
- [Optimization](https://lumenia.studio/path/foundations/optimization/): The model takes small steps downhill on the loss. That walk is gradient descent.
- [Generalization](https://lumenia.studio/path/foundations/generalization/): A model generalizes when it holds up on examples it has never seen. The training loss cannot tell you that.
- [Regularization](https://lumenia.studio/path/foundations/regularization/): Add a price for large knobs, so the model prefers the simplest rule that still fits.
- [Probability and uncertainty](https://lumenia.studio/path/foundations/probability/): The model can tell us how sure it is, if it answers with a distribution instead of a single choice.
- [Metrics](https://lumenia.studio/path/foundations/metrics/): Pick a number that matches what matters. Precision and recall show which mistakes you're making, and the threshold trades one for the other.
- [Rare cases and Drift](https://lumenia.studio/path/foundations/drift/): When the data it meets stops looking like the data it learned from, the model can fail without warning.
- Resources: [Hands-On Machine Learning with Scikit-Learn and PyTorch, Aurélien Géron](https://www.oreilly.com/library/view/hands-on-machine-learning/9798341607972/); [Designing Machine Learning Systems, Chip Huyen](https://www.oreilly.com/library/view/designing-machine-learning/9781098107956/); [3Blue1Brown](https://www.youtube.com/@3blue1brown); [StatQuest](https://www.youtube.com/@statquest)
- People: [Andrew Ng](https://www.andrewng.org/), [Aurélien Géron](https://ageron.github.io/), [Sebastian Raschka](https://sebastianraschka.com/), [Chip Huyen](https://huyenchip.com/), [Rachel Thomas](https://rachel.fast.ai/)

## 02 Models: What happens inside a model?

- [Models](https://lumenia.studio/path/models/): Look inside a language model: how it reads text and writes an answer.
  - 1. Tokens: How does a model read text? Before a model can understand a single sentence, it has to decide how to cut it into pieces.
  - 2. Embeddings: How can numbers hold meaning? (being written now)
- [Tokens](https://lumenia.studio/path/models/tokens/): Text is cut into tokens: common words stay whole, rare words split into familiar pieces, and each piece is looked up as a vector.
- Resources: [Attention Is All You Need, Vaswani et al.](https://arxiv.org/abs/1706.03762); [The Illustrated Transformer, Jay Alammar](https://jalammar.github.io/illustrated-transformer/); [Neural Networks: Zero to Hero, Andrej Karpathy](https://karpathy.ai/zero-to-hero.html); [Stanford CS224N, Natural Language Processing with Deep Learning](https://web.stanford.edu/class/cs224n/)
- People: [Andrej Karpathy](https://karpathy.ai/), [Jay Alammar](https://jalammar.github.io/), [Christopher Olah](https://colah.github.io/), [Lilian Weng](https://lilianweng.github.io/), [Sebastian Raschka](https://sebastianraschka.com/)

## Optional

- [About](https://lumenia.studio/about/): who writes Lumenia Studio. Contact: equipo@lumenia.studio
- [Español](https://lumenia.studio/es/): the Spanish edition. Its own path, with its own examples and its own publishing pace, not a translation. Waypoints as JSON: https://lumenia.studio/es/waypoints.json