Deep Learning for Beginners Tools, Skills and Resources

import numpy as np

# A batch of 32 RGB images, 64x64 pixels (channels first)
batch = np.random.rand(32, 3, 64, 64)
print(batch.shape)            # (32, 3, 64, 64)

# Flatten each image for a simple dense layer
flat = batch.reshape(32, -1)
print(flat.shape)             # (32, 12288)

# Broadcasting: subtract per-channel mean
mean = batch.mean(axis=(0, 2, 3), keepdims=True)
print(mean.shape)             # (1, 3, 1, 1)
normalised = batch - mean

import numpy as np

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

# One neuron: weighted sum + activation
x = np.array([0.5, 1.5, -0.2])
w = np.array([0.8, -0.4, 0.3])
b = 0.1

z = x @ w + b
print("output:", round(float(sigmoid(z)), 4))

# A neural network stacks many of these,
# and training adjusts w and b to reduce the loss.

import torch
from torch import nn

device = "cuda" if torch.cuda.is_available() else "cpu"

model = nn.Sequential(
    nn.Flatten(),
    nn.Linear(28 * 28, 128),
    nn.ReLU(),
    nn.Linear(128, 10),
).to(device)

loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

def train_step(x, y):
    model.train()
    x, y = x.to(device), y.to(device)
    optimizer.zero_grad()
    loss = loss_fn(model(x), y)
    loss.backward()
    optimizer.step()
    return loss.item()

print(model)

from tensorflow import keras

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

model = keras.Sequential([
    keras.Input(shape=(28, 28)),
    keras.layers.Flatten(),
    keras.layers.Dense(128, activation="relu"),
    keras.layers.Dense(10, activation="softmax"),
])
model.compile(optimizer="adam",
              loss="sparse_categorical_crossentropy",
              metrics=["accuracy"])
model.fit(x_train, y_train, epochs=3, validation_split=0.1)
print(model.evaluate(x_test, y_test))

import torch
from torch import nn
from torchvision import models

# Load a pretrained ResNet-18 and freeze its layers
weights = models.ResNet18_Weights.DEFAULT
model = models.resnet18(weights=weights)
for p in model.parameters():
    p.requires_grad = False

# Replace the final layer for 3 classes (e.g. your own categories)
model.fc = nn.Linear(model.fc.in_features, 3)

# Only the new layer will be trained
optimizer = torch.optim.Adam(model.fc.parameters(), lr=1e-3)
preprocess = weights.transforms()   # correct resizing + normalisation

# pip install transformers
from transformers import pipeline

# Downloads a small pretrained sentiment model on first run
classifier = pipeline("sentiment-analysis")

reviews = [
    "The course projects were really practical.",
    "The app keeps crashing when I upload a file.",
]
for r, result in zip(reviews, classifier(reviews)):
    print(result["label"], round(result["score"], 3), "-", r)

Project: _______________________
Data type: images / text / sequences
Dataset + licence: ______________

Step 1  Explore data: sizes, classes, examples
Step 2  Baseline: classic ML or very small network
Step 3  Framework model: start small
Step 4  Train with validation split, plot curves
Step 5  Fix over/underfitting (augmentation, dropout)
Step 6  Evaluate on test set once
Step 7  Error analysis: 20 wrong predictions
Step 8  README + simple demo

Run | Model      | LR    | Epochs | Train loss | Val loss | Val metric | Notes
----|------------|-------|--------|------------|----------|------------|------
1   |            |       |        |            |          |            |
2   |            |       |        |            |          |            |

Change ONE thing per run so you know what helped.

When training does not work:

[ ] Print input and output shapes
[ ] Check labels match images or texts
[ ] Try to overfit a tiny batch (should reach ~0 loss)
[ ] Lower the learning rate
[ ] Confirm data is normalised
[ ] Make sure model.train() / model.eval() are used correctly
[ ] Verify the loss function matches the output layer