A First Neural Network (Keras)

From one line to a network of lines

A neural network is, at heart, many tiny logistic-regression-like units — called neurons — wired together in layers. Each neuron takes the inputs, multiplies them by weights, adds them up, and passes the result through a simple curve (an activation function) that decides how strongly it “fires”. Stack enough of these and the network can learn patterns far too tangled for a single straight line.

Picture three stages stacked left to right:

• Input layer — one slot per feature (e.g. the 4 flower measurements).
• Hidden layers — the neurons in the middle that do the real work of finding patterns. “Deep learning” just means more than one hidden layer.
• Output layer — produces the final answer (a class or a number).

The network learns by the same engine you met earlier: it makes a prediction, measures the error with a loss function, and uses gradient descent to nudge every weight a little in the direction that lowers the error. Do that thousands of times and the weights settle on a good pattern. (The trick that spreads the error back through the layers is called backpropagation — Keras does it for you.)

Why a library does the heavy lifting

You will not hand-code neurons. Keras (which runs on TensorFlow) lets you describe a network in a few readable lines. Think of it as scikit-learn for neural networks. Install it with pip install tensorflow.

A worked example: classify iris flowers

We will build a small network for the 3-species iris problem. Read the comments — each line is one decision about the network’s shape.

import tensorflow as tf
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

X, y = load_iris(return_X_y=True)
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, random_state=0)

# neural nets train best on scaled inputs
scaler = StandardScaler().fit(Xtr)
Xtr, Xte = scaler.transform(Xtr), scaler.transform(Xte)

model = tf.keras.Sequential([
    tf.keras.layers.Dense(16, activation='relu', input_shape=(4,)),  # hidden layer
    tf.keras.layers.Dense(3, activation='softmax'),                  # 3 species out
])

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

model.fit(Xtr, ytr, epochs=50, verbose=0)     # train for 50 passes
loss, acc = model.evaluate(Xte, yte, verbose=0)
print('Test accuracy:', round(acc, 3))

The new words, in plain English

When is a neural network worth it?

Neural networks are powerful but they are not the right default. For ordinary spreadsheet-style (tabular) data, a random forest or gradient boosting usually matches or beats a neural net with far less fuss. Neural networks pull ahead on big, complex, unstructured data — images, audio, language — where their layers can build up patterns no tree can.