Train a Neural Network in Your Browser (No Code Required)

What You Just Did (or Are About to Do)

When you train a model in the playground, here's the complete journey — the same journey every machine learning project follows:

1. Choose data — examples the network will learn from (Titanic passengers, vehicle specs, handwritten digits, or your own CSV)
2. Design the network — how many layers and neurons, which activation function, what learning rate
3. Train — the network repeatedly guesses, measures its errors, and corrects itself
4. Evaluate — test it on data it has never seen to measure honest performance
5. Use it — ask the trained model questions and get predictions with confidence scores

The rest of this guide explains what's actually happening at each step — in plain language, mapped directly to what you can see in the playground.

Step 1: Data Is the Teacher

A neural network learns only from examples. It has no built-in knowledge, no rules, no common sense. Everything it knows, it extracts from the rows of data you feed it.

Each row has two parts:

• Features — the inputs the network uses to make its guess (a passenger's age, sex, and ticket class)
• Label — the correct answer it's trying to predict (did they survive?)

Before training, the playground does two things to your data that every ML practitioner does:

Normalization. Numeric features get rescaled so they're all roughly the same size. Why? Because "fare paid" ranges from 0 to 512 while "number of siblings" ranges from 0 to 8 — without rescaling, the network would treat fare as hundreds of times more important simply because the numbers are bigger.

One-hot encoding. Categories like "1st class / 2nd class / 3rd class" become three separate inputs, each 0 or 1. Networks can only do math on numbers, not words.

The train/test split. The playground holds back 20% of the data and never lets the network train on it. This held-out test set is the only honest way to measure learning — anyone can get 100% accuracy on questions they've already seen the answers to.

Step 2: The Network Is a Formula With Millions of Knobs

Strip away the brain metaphors and a neural network is just a very long math formula with adjustable numbers in it. Those numbers are called weights, and they're what the network "knows."

The formula is organized into layers of neurons:

• The input layer receives your features (one neuron per input number)
• Hidden layers in the middle do the pattern-finding
• The output layer has one neuron per possible answer

Each neuron does something almost insultingly simple: multiply each input by its weight, add everything up, and pass the result through an activation function (usually ReLU, which just means "if negative, output zero"). One neuron can't do much. But layers of them, tuned together, can recognize handwriting.

In the playground's network diagram, the lines between neurons are the weights. Blue lines are positive weights (excitatory), red lines are negative (inhibitory), and thickness shows strength. Before training, they're random. Watch what happens to them during training.

Step 3: Training Is Just Error Correction, Repeated Millions of Times

Here's the entire training algorithm, no calculus required:

1. Forward pass — push a training example through the network and get a prediction
2. Loss — measure how wrong the prediction was
3. Backpropagation — work backwards through the network to compute each weight's share of the blame
4. Gradient descent — nudge every weight a tiny step in the direction that reduces the error

That's it. Repeat for every example, for many epochs (full passes through the data), and the network gets good. "Learning" is nothing more mystical than millions of tiny corrections.

The learning rate: deep learning's most important setting

How big should each correction step be? That's the learning rate, and it's the most consequential setting in all of deep learning:

• Too small (try 0.0001): learning crawls; the loss barely moves
• Too large (try 0.1 with SGD): the network overshoots wildly; the loss chart goes chaotic
• Just right (0.001–0.01): smooth, steady learning

The playground lets you set this yourself — breaking it on purpose is one of the best ways to build intuition.

Adam vs SGD: why optimizers matter

SGD (stochastic gradient descent) is the textbook algorithm: take the same size step for every weight. Adam is the modern default: it adapts the step size for each individual weight automatically. Train the same network with both and compare the loss curves — Adam usually converges noticeably faster. This is why virtually every model you've heard of (including the large language models) trains with Adam or one of its descendants.

Step 4: The Test Set Keeps the Network Honest

When training finishes, the playground reports test accuracy — performance on the 20% of data the network never saw. This is the number that matters.

It also shows a confusion matrix: a grid showing exactly which classes get confused with which. A digit recognizer might be great at 0s and 1s but regularly mistake 4s for 9s. A Titanic model will misclassify some survivors who "should" have died statistically — the data only explains so much.

Watch for overfitting

The gap between training accuracy and test accuracy is memorization, not learning. If the solid blue line (training) keeps climbing while the dashed orange line (test) stalls or falls, your network is overfitting. You can force this to happen: give the Titanic dataset a big network (three layers of 64 neurons) and 50 epochs. Real ML engineers fight this constantly with techniques like dropout, regularization, and early stopping.

Step 5: A Trained Model Answers Questions

After training, the playground gives you a question panel — sliders and dropdowns for tabular data, or a drawing canvas for handwritten digits. Every time you move a slider, your inputs run through the trained network (a single forward pass) and out comes a prediction with confidence percentages.

Two things worth noticing:

• The confidence numbers come from the network itself — the output layer's softmax values, not anything bolted on. When the model says "87% survived," that's literally what its output neurons computed.
• The model generalizes. Ask about a passenger who isn't in the dataset — some combination of age, class, and fare it never saw — and it still answers, because it learned patterns rather than memorizing rows.

From Playground to Production

Everything in the playground maps one-to-one onto real machine learning code. After training a model, click "Get this model as real Python code" to see your exact architecture written with TensorFlow/Keras — the same model.fit() workflow used in production at thousands of companies.

When you're ready to write the real thing:

• Building a Classifier Using Python and Scikit-Learn — our step-by-step guide to the same vehicle classification problem, in Python
• Machine Learning Guide: AI Fundamentals Explained — the broader landscape: supervised vs unsupervised learning, where deep learning fits, and real-world applications

Experiments Worth Trying

The playground rewards breaking things. Some experiments that teach more than any textbook chapter:

1. Set the learning rate to 0.1 with SGD on any dataset → watch the loss chart go unstable
2. Use a single hidden layer with 4 neurons on the digits dataset → watch it struggle (not enough capacity)
3. Use 3 layers of 64 neurons with 50 epochs on Titanic → watch the training/test accuracy gap open up (overfitting)
4. Train the same network twice → notice the results differ slightly (random weight initialization)
5. Compare Adam vs SGD with everything else identical → see why Adam became the default
6. Upload your own CSV — any spreadsheet with a category column works: customer churn data, sports statistics, survey results

The Same Math, All the Way Up

The networks you train in the playground have a few thousand weights. GPT-class language models have hundreds of billions. But the core loop — forward pass, loss, backpropagation, gradient descent — is identical. Once you've watched a small network learn to recognize your handwriting, you understand, mechanically, how the largest AI systems in the world learn too. Only the scale changes.