Building Networks with Keras

6.1What are TensorFlow and Keras?

TensorFlow is a free deep learning library created by Google. It does the heavy lifting: fast maths on CPUs and GPUs, and automatic backpropagation (Module 5). Keras is the friendly layer on top. It lets you describe a network in plain, readable code, like stacking building blocks.

We use Keras in this track because it's the easiest way to learn. The ideas transfer directly to PyTorch: layers, activations, losses, optimisers and epochs are exactly the same.

6.2Getting set up

Then, at the top of your code:

import keras
from keras import layers
print(keras.__version__)

6.3The five-step Keras workflow

Almost every Keras project follows the same five steps. Once you know them, you can build almost anything.

If you've used scikit-learn in the Machine Learning track, this will feel familiar: it's the same fit-and-predict idea, with an extra "compile" step to choose how the network learns.

6.4Step 1: define the model

A Sequential model is a simple stack of layers, where data flows straight through from top to bottom. The most common layer is Dense: a fully connected layer, where every neuron connects to every neuron in the layer before (Module 1).

model = keras.Sequential([
    keras.Input(shape=(30,)),               # input: 30 features
    layers.Dense(16, activation="relu"),    # 16 neurons, ReLU
    layers.Dense(8, activation="relu"),     # 8 neurons, ReLU
    layers.Dense(1, activation="sigmoid"),  # 1 output, sigmoid
])

Counting the parameters

Each Dense layer has (inputs × neurons) weights plus one bias per neuron:

You can check this any time with model.summary(), as you'll see in the Python example.

6.5Step 2: compile, and choosing the right setup

Compiling tells Keras how to learn. You choose three things:

The output layer and the loss must match your task. Getting this wrong is one of the most common beginner mistakes. Use the builder below to generate the right code for any task.

6.6Step 3: fit, and reading the training history

history = model.fit(X_train, y_train,
                    epochs=50,             # passes through the data
                    batch_size=32,         # examples per weight update
                    validation_split=0.2)  # keep 20% aside to check

fit() returns a history: the loss and metrics after every epoch. Always plot it.

6.7A complete Keras project

Here are all five steps together, plus saving the model, on the breast cancer dataset you know from the Machine Learning track. Notice that we still scale the features first: neural networks, like KNN and SVMs, train much better on scaled data.

import os
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import keras
from keras import layers

keras.utils.set_random_seed(42)

# 1. Prepare the data (just like the Machine Learning track)
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y)
scaler = StandardScaler().fit(X_train)
X_train, X_test = scaler.transform(X_train), scaler.transform(X_test)

# 2. DEFINE the network
model = keras.Sequential([
    keras.Input(shape=(30,)),                  # 30 features per tumour
    layers.Dense(16, activation="relu"),       # hidden layer 1
    layers.Dense(8, activation="relu"),        # hidden layer 2
    layers.Dense(1, activation="sigmoid"),     # output: probability
])

# 3. COMPILE: choose the optimiser, loss and metrics
model.compile(optimizer="adam", loss="binary_crossentropy",
              metrics=["accuracy"])
model.summary(line_length=60)

# 4. FIT: train, keeping 20% of the training data aside for validation
history = model.fit(X_train, y_train, epochs=50, batch_size=32,
                    validation_split=0.2, verbose=0)
for e in [0, 9, 49]:
    h = history.history
    print(f"Epoch {e+1:2}: loss={h['loss'][e]:.3f}  "
          f"val_loss={h['val_loss'][e]:.3f}  val_accuracy={h['val_accuracy'][e]:.3f}")

# 5. EVALUATE on the test set
test_loss, test_acc = model.evaluate(X_test, y_test, verbose=0)
print(f"Test accuracy: {test_acc:.3f}")

# 6. PREDICT probabilities for new tumours
probs = model.predict(X_test[:3], verbose=0).ravel()
print("Probabilities (benign):", [f"{p:.4f}" for p in probs], "| true labels:", y_test[:3])

# 7. SAVE and reload
model.save("cancer_model.keras")
reloaded = keras.models.load_model("cancer_model.keras")
print("Reloaded model accuracy:", round(reloaded.evaluate(X_test, y_test, verbose=0)[1], 3))

Model: "sequential"
┏━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━┓
┃ Layer (type)             ┃ Output Shape      ┃   Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━┩
│ dense (Dense)            │ (None, 16)        │       496 │
├──────────────────────────┼───────────────────┼───────────┤
│ dense_1 (Dense)          │ (None, 8)         │       136 │
├──────────────────────────┼───────────────────┼───────────┤
│ dense_2 (Dense)          │ (None, 1)         │         9 │
└──────────────────────────┴───────────────────┴───────────┘
 Total params: 641 (2.50 KB)
 Trainable params: 641 (2.50 KB)
 Non-trainable params: 0 (0.00 B)
Epoch  1: loss=0.626  val_loss=0.566  val_accuracy=0.824
Epoch 10: loss=0.167  val_loss=0.168  val_accuracy=0.934
Epoch 50: loss=0.038  val_loss=0.040  val_accuracy=0.989
Test accuracy: 0.956
Probabilities (benign): ['0.0000', '0.9999', '0.0003'] | true labels: [0 1 0]
Reloaded model accuracy: 0.956

What the output tells us

• The summary confirms our hand calculation: 496 + 136 + 9 = 641 trainable parameters.
• The history shows loss falling from 0.63 to 0.04, while validation accuracy rises from 82% to 99%. Training and validation loss stay close, so there's no sign of overfitting.
• Test accuracy is 95.6% on tumours the network has never seen.
• predict() returns probabilities from the sigmoid output. Here the network is very confident, and all three are correct.
• Saving with model.save() stores the architecture, weights and settings in one .keras file. The reloaded model scores exactly the same.

6.8Beyond Sequential

Sequential models are a straight stack. For networks with multiple inputs, multiple outputs or branches, Keras has the Functional API, where you connect layers like building a pipeline:

inputs = keras.Input(shape=(30,))
x = layers.Dense(16, activation="relu")(inputs)
x = layers.Dense(8, activation="relu")(x)
outputs = layers.Dense(1, activation="sigmoid")(x)
model = keras.Model(inputs, outputs)       # same network as before

You'll use it for more advanced designs later in the track, like transfer learning (Module 11).

SummaryKey takeaways

Check your understanding

Your neural networks roadmap

1. 01
   Introduction to Neural NetworksWhat neural networks are and how they work
2. 02
   The Perceptron and the Artificial NeuronBuild a single neuron from scratch
3. 03
   Activation FunctionsSigmoid, tanh, ReLU and softmax
4. 04
   Loss Functions and Gradient DescentHow networks measure and reduce error
5. 05
   BackpropagationHow every weight learns its share of the blame
6. 06
   Building Networks with KerasYou are here
7. 07
   Training Better NetworksOverfitting, dropout, batch normalisation, early stopping
8. 08
   Convolutional Neural NetworksTeaching computers to see
9. 09
   Recurrent Neural Networks and LSTMsWorking with sequences
10. 10
    Transformers and AttentionThe architecture behind ChatGPT and Claude
11. 11
    Transfer Learning and Pretrained ModelsStanding on the shoulders of giants
12. 12
    Capstone ProjectBuild and present a deep learning project