Deep Learning (DL)

Try it Yourself — ANN with Keras (TensorFlow)

# A minimal Artificial Neural Network using TensorFlow/Keras
# Run in Google Colab or install: pip install tensorflow

import tensorflow as tf
import numpy as np

# Simple dataset: predict score (0-100) from hours studied
hours = np.array([1, 2, 3, 4, 5, 6, 7, 8], dtype=float)
scores = np.array([10, 25, 35, 48, 55, 68, 77, 90], dtype=float)

# Build a sequential ANN with 1 hidden layer
model = tf.keras.Sequential([
    # Input layer (1 neuron for 1 feature) + Hidden layer (8 neurons, ReLU)
    tf.keras.layers.Dense(8, activation='relu', input_shape=(1,)),
    # Output layer (1 neuron for the score prediction)
    tf.keras.layers.Dense(1)
])

# Compile: choose optimizer and loss function
model.compile(optimizer='adam', loss='mse')

# Train the network (epochs = passes over the data)
print("Training neural network...")
model.fit(hours, scores, epochs=300, verbose=0)
print("Training complete!")

# Predict: what score for 4.5 hours of study?
prediction = model.predict(np.array([4.5]), verbose=0)
print(f"Predicted score for 4.5 hours: {prediction[0][0]:.1f}%")
# Expected: around 55-65% (the network learned the pattern!)

Try it Yourself — CNN Pipeline with Conv2D & MaxPool2D

# Building a CNN feature extractor using TensorFlow/Keras
# Shows how Conv2D and MaxPool2D layers work together

import tensorflow as tf

# Build a CNN pipeline (just the feature extraction part)
cnn_pipeline = tf.keras.Sequential([
    # First Conv2D: 32 filters, each 3x3, looking for edges and textures
    tf.keras.layers.Conv2D(
        filters=32,
        kernel_size=(3, 3),
        activation='relu',
        input_shape=(64, 64, 1)
    ),
    # MaxPool2D: reduces size from 64x64 to 32x32, keeps strongest features
    tf.keras.layers.MaxPool2D(pool_size=(2, 2)),

    # Second Conv2D: 64 filters, detects more complex shapes
    tf.keras.layers.Conv2D(
        filters=64,
        kernel_size=(3, 3),
        activation='relu'
    ),
    # MaxPool2D: reduces from 32x32 to 16x16
    tf.keras.layers.MaxPool2D(pool_size=(2, 2)),

    # Flatten: converts 2D feature maps into a 1D vector for the classifier
    tf.keras.layers.Flatten(),

    # Dense layer: makes the final decision (e.g., "flooded" vs "not flooded")
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(1, activation='sigmoid')
])

# Print a summary of the architecture
cnn_pipeline.summary()

print("\n\u2705 CNN pipeline built! The model will automatically learn")
print("   to detect edges \u2192 shapes \u2192 objects from image data.")

Try it Yourself — LSTM for Sequence Prediction

# Setting up an LSTM model for time-series prediction
# Input: 10 timesteps, each with 1 feature (e.g., daily temperature)

import tensorflow as tf

# Define the LSTM model
model = tf.keras.Sequential([
    # LSTM layer: 50 memory units, expecting sequences of 10 steps
    # input_shape = (timesteps, features)
    tf.keras.layers.LSTM(50, activation='tanh', input_shape=(10, 1)),

    # Dense output layer: predict the next value
    tf.keras.layers.Dense(1)
])

# Compile the model
model.compile(optimizer='adam', loss='mse')

print("\u2705 LSTM model ready for sequence data!")
print(f"   Input shape: (batch_size, 10 timesteps, 1 feature)")
print(f"   Output: 1 value (next step prediction)")

# Show model architecture
model.summary()

# Example: simulate how you'd reshape raw sensor data
# Raw data: [25, 26, 27, 26, 25, 24, 23, 24, 25, 26, 27, 28]
# Sequences of 10 steps => predict the 11th value

print("\nData shape hint: reshape raw sensor logs to")
print("   (num_sequences, 10, 1) before training.")

Try it Yourself — Load Pre-trained MobileNetV2 & Remove Head

# Loading a pre-trained MobileNetV2 and customizing it for a new task
# Install: pip install tensorflow

import tensorflow as tf

# Load MobileNetV2 pre-trained on ImageNet (1000 classes)
# We exclude the top (classification head) to add our own
base_model = tf.keras.applications.MobileNetV2(
    input_shape=(224, 224, 3),   # standard image size
    include_top=False,            # drop the classification head
    weights='imagenet'            # use pre-trained ImageNet weights
)

# Freeze the base model layers (they already know how to "see")
base_model.trainable = False

# Add our own custom classification head
model = tf.keras.Sequential([
    base_model,                          # pre-trained feature extractor
    tf.keras.layers.GlobalAveragePooling2D(),  # reduce dimensions
    tf.keras.layers.Dense(128, activation='relu'),  # new learning layer
    tf.keras.layers.Dropout(0.3),        # prevent overfitting
    tf.keras.layers.Dense(1, activation='sigmoid')  # binary output (e.g., flooded/not flooded)
])

# Compile — only the new head layers will train
model.compile(optimizer='adam',
              loss='binary_crossentropy',
              metrics=['accuracy'])

print("\u2705 Pre-trained MobileNetV2 loaded with custom head!")
print(f"   Base model layers: {len(base_model.layers)} (frozen)")
print(f"   New head: GlobalAvgPool \u2192 Dense(128) \u2192 Dropout \u2192 Dense(1)")
print("\nTrain with your own images:")
print("   model.fit(train_images, train_labels, epochs=10)")
print("   For fine-tuning later, set base_model.trainable = True")

Try it Yourself — Loss Function & Optimizer Setup (PyTorch)

# Setting up loss function and optimizer in PyTorch
# Install: pip install torch

import torch
import torch.nn as nn
import torch.optim as optim

# --- Define a simple neural network ---
class SimpleNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(10, 32)   # input: 10 features
        self.fc2 = nn.Linear(32, 1)    # output: 1 value

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

model = SimpleNN()

# --- Step 1: Choose a loss function ---
# For binary classification (e.g., flooded / not flooded)
criterion = nn.BCEWithLogitsLoss()

# --- Step 2: Choose an optimizer ---
optimizer = optim.Adam(
    model.parameters(),
    lr=0.001  # learning rate: 0.001 is a great default for Adam
)

# --- Step 3: Optional learning rate scheduler ---
scheduler = optim.lr_scheduler.ReduceLROnPlateau(
    optimizer,
    mode='min',     # reduce when loss stops decreasing
    factor=0.5,     # cut learning rate in half
    patience=5      # wait 5 epochs before reducing
)

print("\u2705 Loss function: BCEWithLogitsLoss (binary classification)")
print("\u2705 Optimizer: Adam with lr=0.001")
print("\u2705 Scheduler: ReduceLROnPlateau (patience=5)")

# --- Simulate one training step ---
# Dummy data: batch of 8 samples, each with 10 features
inputs = torch.randn(8, 10)        # random input
labels = torch.randint(0, 2, (8, 1)).float()  # random labels (0 or 1)

# Forward pass
outputs = model(inputs)
loss = criterion(outputs, labels)

# Backward pass & optimization step
optimizer.zero_grad()  # clear previous gradients
loss.backward()        # compute gradients
optimizer.step()       # update weights

print(f"\nSample training step completed!")
print(f"   Loss: {loss.item():.4f} (should decrease over epochs)")
print(f"   Learning rate: {optimizer.param_groups[0]['lr']}")