Build a Tiny Neural Net with Keras

• Install TensorFlow/Keras; build a Sequential model.
• Add Dense layers with the right activations.
• compile with a loss + optimiser, then fit.
• Evaluate and read the training history.

pip install tensorflow

# (If install is heavy on your machine, run this lesson in
#  Google Colab — TensorFlow is pre-installed there, free GPU too.)

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
print(tf.__version__)

Build the architecture

from tensorflow import keras
from tensorflow.keras import layers

model = keras.Sequential([
    layers.Input(shape=(4,)),         # 4 input features (iris)
    layers.Dense(16, activation="relu"),
    layers.Dense(8,  activation="relu"),
    layers.Dense(3,  activation="softmax"),  # 3 classes
])
model.summary()

Sequential = a straight stack of layers. Dense(n) = a fully-connected layer of n neurons. The last layer's activation + size matches the task (Lesson 22).

Compile — how to learn

model.compile(
    optimizer="adam",                          # how to update weights
    loss="sparse_categorical_crossentropy",    # what to minimise (integer labels)
    metrics=["accuracy"],
)

Loss cheat sheet:
  binary:           binary_crossentropy        (sigmoid output)
  multiclass (ints):sparse_categorical_crossentropy (softmax)
  multiclass (1-hot):categorical_crossentropy
  regression:       mse / mae

Fit — run the training loop

history = model.fit(
    X_train, y_train,
    validation_split=0.2,   # watch generalisation as it trains
    epochs=50,              # passes over the data
    batch_size=16,
    verbose=0,
)

Evaluate & predict

loss, acc = model.evaluate(X_test, y_test, verbose=0)
print(f"test accuracy: {acc:.1%}")

probs = model.predict(X_test[:3])     # softmax probabilities
preds = probs.argmax(axis=1)          # pick the top class

# iris_keras.py — a 3-layer net on iris
import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from tensorflow import keras
from tensorflow.keras import layers

X, y = load_iris(return_X_y=True)
X = StandardScaler().fit_transform(X)        # nets train better on scaled data
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.2,
                                      stratify=y, random_state=0)

model = keras.Sequential([
    layers.Input(shape=(4,)),
    layers.Dense(16, activation="relu"),
    layers.Dense(8,  activation="relu"),
    layers.Dense(3,  activation="softmax"),
])
model.compile(optimizer="adam",
              loss="sparse_categorical_crossentropy",
              metrics=["accuracy"])

history = model.fit(Xtr, ytr, validation_split=0.2,
                    epochs=80, batch_size=8, verbose=0)

loss, acc = model.evaluate(Xte, yte, verbose=0)
print(f"test accuracy: {acc:.1%}")

# plot learning curves
import matplotlib.pyplot as plt
plt.plot(history.history["accuracy"], label="train")
plt.plot(history.history["val_accuracy"], label="val")
plt.xlabel("epoch"); plt.ylabel("accuracy"); plt.legend()
plt.savefig("learning_curve.png", dpi=150)

Sample output

test accuracy: 96.7%

Read the diff

Ten lines built and trained a real neural net. Two habits to keep: scale the features (nets are sensitive to scale) and plot train vs val accuracy — if val stops rising while train keeps climbing, you're overfitting (Lesson 25). For iris, a forest does this just as well in less time — neural nets shine on images and text, which is where we're headed.

Keras: Sequential stacks Dense layers; compile sets optimiser + loss + metrics; fit trains; evaluate scores. Scale your features, pick the loss by task, and always watch train-vs-val curves. EarlyStopping saves time and curbs overfitting. Next: what the optimiser and loss are actually doing.