dl-experiment-code 1.0.0__py3-none-any.whl

dl_experiment_code/templates/exp7_online.py

@@ -0,0 +1,66 @@
+"""
+Experiment 7 - Autoencoder dimensionality reduction using Keras MNIST.
+"""
+
+import numpy as np
+import tensorflow as tf
+from tensorflow import keras
+import matplotlib.pyplot as plt
+
+(x_train, _), (x_test, _) = keras.datasets.mnist.load_data()
+
+x_train = x_train.astype("float32") / 255.0
+x_test = x_test.astype("float32") / 255.0
+
+x_train = x_train.reshape(len(x_train), -1)
+x_test = x_test.reshape(len(x_test), -1)
+
+input_dim = x_train.shape[1]
+encoding_dim = 32
+
+encoder = keras.Sequential([
+    keras.layers.Input(shape=(input_dim,)),
+    keras.layers.Dense(128, activation="relu"),
+    keras.layers.Dense(encoding_dim, activation="relu"),
+], name="encoder")
+
+decoder = keras.Sequential([
+    keras.layers.Input(shape=(encoding_dim,)),
+    keras.layers.Dense(128, activation="relu"),
+    keras.layers.Dense(input_dim, activation="sigmoid"),
+], name="decoder")
+
+autoencoder = keras.Sequential([encoder, decoder])
+
+autoencoder.compile(
+    optimizer="adam",
+    loss="binary_crossentropy",
+)
+
+autoencoder.fit(
+    x_train,
+    x_train,
+    epochs=10,
+    batch_size=256,
+    validation_data=(x_test, x_test),
+)
+
+encoded = encoder.predict(x_test, verbose=0)
+decoded = autoencoder.predict(x_test, verbose=0)
+
+print("Original dimension:", input_dim)
+print("Reduced dimension :", encoded.shape[1])
+
+plt.figure(figsize=(10, 4))
+
+for i in range(5):
+    plt.subplot(2, 5, i + 1)
+    plt.imshow(x_test[i].reshape(28, 28), cmap="gray")
+    plt.axis("off")
+
+    plt.subplot(2, 5, i + 6)
+    plt.imshow(decoded[i].reshape(28, 28), cmap="gray")
+    plt.axis("off")
+
+plt.suptitle("Original (top) vs Reconstructed (bottom)")
+plt.show()

dl_experiment_code/templates/exp8_local.py

@@ -0,0 +1,135 @@
+"""
+Experiment 8 - Educational single-object detector using a LOCAL Pascal VOC dataset.
+
+Expected structure:
+data/object_dataset/
+    images/
+    annotations/
+
+Each XML annotation should contain at least one object.
+This experiment predicts one object class and one bounding box.
+"""
+
+import os
+import xml.etree.ElementTree as ET
+import numpy as np
+import tensorflow as tf
+from tensorflow import keras
+from sklearn.model_selection import train_test_split
+from PIL import Image
+
+IMAGE_DIR = "data/object_dataset/images"
+ANNOTATION_DIR = "data/object_dataset/annotations"
+IMAGE_SIZE = (128, 128)
+
+def parse_annotation(xml_path):
+    root = ET.parse(xml_path).getroot()
+    size = root.find("size")
+    width = float(size.find("width").text)
+    height = float(size.find("height").text)
+
+    obj = root.find("object")
+    label = obj.find("name").text
+    box = obj.find("bndbox")
+
+    xmin = float(box.find("xmin").text) / width
+    ymin = float(box.find("ymin").text) / height
+    xmax = float(box.find("xmax").text) / width
+    ymax = float(box.find("ymax").text) / height
+
+    return label, [xmin, ymin, xmax, ymax]
+
+image_files, labels, boxes = [], [], []
+
+for filename in os.listdir(ANNOTATION_DIR):
+    if not filename.endswith(".xml"):
+        continue
+
+    xml_path = os.path.join(ANNOTATION_DIR, filename)
+    image_name = os.path.splitext(filename)[0]
+
+    for extension in [".jpg", ".jpeg", ".png"]:
+        candidate = os.path.join(IMAGE_DIR, image_name + extension)
+        if os.path.exists(candidate):
+            label, box = parse_annotation(xml_path)
+            image_files.append(candidate)
+            labels.append(label)
+            boxes.append(box)
+            break
+
+classes = sorted(set(labels))
+class_to_id = {name: i for i, name in enumerate(classes)}
+
+X, y_class, y_box = [], [], []
+
+for image_path, label, box in zip(image_files, labels, boxes):
+    image = Image.open(image_path).convert("RGB").resize(IMAGE_SIZE)
+    X.append(np.asarray(image, dtype="float32") / 255.0)
+    y_class.append(class_to_id[label])
+    y_box.append(box)
+
+X = np.array(X)
+y_class = np.array(y_class)
+y_box = np.array(y_box, dtype="float32")
+
+X_train, X_test, yc_train, yc_test, yb_train, yb_test = train_test_split(
+    X, y_class, y_box,
+    test_size=0.2,
+    random_state=42,
+    stratify=y_class,
+)
+
+inputs = keras.Input(shape=(128, 128, 3))
+
+x = keras.layers.Conv2D(32, 3, activation="relu")(inputs)
+x = keras.layers.MaxPooling2D()(x)
+x = keras.layers.Conv2D(64, 3, activation="relu")(x)
+x = keras.layers.MaxPooling2D()(x)
+x = keras.layers.Conv2D(128, 3, activation="relu")(x)
+x = keras.layers.MaxPooling2D()(x)
+x = keras.layers.Flatten()(x)
+x = keras.layers.Dense(128, activation="relu")(x)
+
+class_output = keras.layers.Dense(
+    len(classes),
+    activation="softmax",
+    name="class_output",
+)(x)
+
+box_output = keras.layers.Dense(
+    4,
+    activation="sigmoid",
+    name="box_output",
+)(x)
+
+model = keras.Model(inputs=inputs, outputs=[class_output, box_output])
+
+model.compile(
+    optimizer="adam",
+    loss={
+        "class_output": "sparse_categorical_crossentropy",
+        "box_output": "mse",
+    },
+    metrics={
+        "class_output": "accuracy",
+        "box_output": "mae",
+    },
+)
+
+model.summary()
+
+model.fit(
+    X_train,
+    {"class_output": yc_train, "box_output": yb_train},
+    validation_split=0.2,
+    epochs=10,
+    batch_size=16,
+)
+
+results = model.evaluate(
+    X_test,
+    {"class_output": yc_test, "box_output": yb_test},
+)
+
+print("\nClasses:", classes)
+print("Evaluation:", results)

dl_experiment_code/templates/exp8_online.py

@@ -0,0 +1,118 @@
+"""
+Experiment 8 - Educational single-object detector using Pascal VOC via TFDS.
+
+Dataset is downloaded automatically from the TensorFlow Datasets catalogue.
+
+Note:
+This is intentionally a simple one-object educational detector, matching
+the original experiment concept. It uses the first annotated object per image.
+It is NOT a production multi-object detector like YOLO/SSD/Faster R-CNN.
+"""
+
+import numpy as np
+import tensorflow as tf
+from tensorflow import keras
+import tensorflow_datasets as tfds
+
+IMAGE_SIZE = (128, 128)
+MAX_SAMPLES = 3000
+
+(ds, info) = tfds.load(
+    "voc",
+    split="train",
+    with_info=True,
+)
+
+class_names = info.features["objects"]["label"].names
+X, y_class, y_box = [], [], []
+
+for example in tfds.as_numpy(ds):
+    objects = example["objects"]
+    if len(objects["label"]) == 0:
+        continue
+
+    image = tf.image.resize(example["image"], IMAGE_SIZE).numpy()
+    image = image.astype("float32") / 255.0
+
+    # Use the first object for this educational single-object experiment.
+    label = int(objects["label"][0])
+    ymin = float(objects["bbox"]["ymin"][0])
+    xmin = float(objects["bbox"]["xmin"][0])
+    ymax = float(objects["bbox"]["ymax"][0])
+    xmax = float(objects["bbox"]["xmax"][0])
+
+    X.append(image)
+    y_class.append(label)
+    y_box.append([xmin, ymin, xmax, ymax])
+
+    if len(X) >= MAX_SAMPLES:
+        break
+
+X = np.array(X, dtype="float32")
+y_class = np.array(y_class, dtype="int32")
+y_box = np.array(y_box, dtype="float32")
+
+# Keep only classes represented in the selected sample.
+used_classes = sorted(np.unique(y_class))
+class_remap = {old: new for new, old in enumerate(used_classes)}
+y_class = np.array([class_remap[x] for x in y_class])
+
+X_train, X_test, yc_train, yc_test, yb_train, yb_test = (
+    __import__("sklearn.model_selection", fromlist=["train_test_split"])
+    .train_test_split(
+        X, y_class, y_box,
+        test_size=0.2,
+        random_state=42,
+        stratify=y_class,
+    )
+)
+
+inputs = keras.Input(shape=(128, 128, 3))
+x = keras.layers.Conv2D(32, 3, activation="relu")(inputs)
+x = keras.layers.MaxPooling2D()(x)
+x = keras.layers.Conv2D(64, 3, activation="relu")(x)
+x = keras.layers.MaxPooling2D()(x)
+x = keras.layers.Conv2D(128, 3, activation="relu")(x)
+x = keras.layers.MaxPooling2D()(x)
+x = keras.layers.Flatten()(x)
+x = keras.layers.Dense(128, activation="relu")(x)
+
+class_output = keras.layers.Dense(
+    len(used_classes), activation="softmax", name="class_output"
+)(x)
+
+box_output = keras.layers.Dense(
+    4, activation="sigmoid", name="box_output"
+)(x)
+
+model = keras.Model(inputs, [class_output, box_output])
+
+model.compile(
+    optimizer="adam",
+    loss={
+        "class_output": "sparse_categorical_crossentropy",
+        "box_output": "mse",
+    },
+    metrics={
+        "class_output": "accuracy",
+        "box_output": "mae",
+    },
+)
+
+model.summary()
+
+model.fit(
+    X_train,
+    {"class_output": yc_train, "box_output": yb_train},
+    validation_split=0.2,
+    epochs=10,
+    batch_size=16,
+)
+
+results = model.evaluate(
+    X_test,
+    {"class_output": yc_test, "box_output": yb_test},
+)
+
+print("\nUsed VOC classes:", [class_names[i] for i in used_classes])
+print("Evaluation:", results)

dl_experiment_code/templates/exp9_local.py

@@ -0,0 +1,84 @@
+"""
+Experiment 9 - LSTM sentiment analysis using a LOCAL CSV.
+
+CSV format:
+text,label
+"I loved this movie",positive
+"The movie was terrible",negative
+"""
+
+import tensorflow as tf
+from tensorflow import keras
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder
+
+CSV_PATH = "data/sentiment.csv"
+TEXT_COLUMN = "text"
+LABEL_COLUMN = "label"
+MAX_WORDS = 10000
+MAX_LENGTH = 150
+
+df = pd.read_csv(CSV_PATH)[[TEXT_COLUMN, LABEL_COLUMN]].dropna()
+
+texts = df[TEXT_COLUMN].astype(str).values
+encoder = LabelEncoder()
+labels = encoder.fit_transform(df[LABEL_COLUMN])
+
+X_train, X_test, y_train, y_test = train_test_split(
+    texts,
+    labels,
+    test_size=0.2,
+    random_state=42,
+    stratify=labels,
+)
+
+vectorizer = keras.layers.TextVectorization(
+    max_tokens=MAX_WORDS,
+    output_sequence_length=MAX_LENGTH,
+)
+vectorizer.adapt(X_train)
+
+model = keras.Sequential([
+    keras.layers.Input(shape=(), dtype=tf.string),
+    vectorizer,
+    keras.layers.Embedding(
+        input_dim=MAX_WORDS,
+        output_dim=128,
+        mask_zero=True,
+    ),
+    keras.layers.LSTM(64),
+    keras.layers.Dense(32, activation="relu"),
+    keras.layers.Dropout(0.4),
+    keras.layers.Dense(len(encoder.classes_), activation="softmax"),
+])
+
+model.compile(
+    optimizer="adam",
+    loss="sparse_categorical_crossentropy",
+    metrics=["accuracy"],
+)
+
+model.summary()
+
+model.fit(
+    X_train,
+    y_train,
+    validation_split=0.2,
+    epochs=10,
+    batch_size=32,
+)
+
+loss, accuracy = model.evaluate(X_test, y_test)
+print("\nTest accuracy:", round(accuracy, 4))
+
+sample_texts = [
+    "This product is excellent",
+    "I hate this product",
+]
+
+predictions = model.predict(sample_texts, verbose=0)
+
+for text, prediction in zip(sample_texts, predictions):
+    index = prediction.argmax()
+    print(f"{text} -> {encoder.inverse_transform([index])[0]}")

dl_experiment_code/templates/exp9_online.py

@@ -0,0 +1,49 @@
+"""
+Experiment 9 - LSTM sentiment analysis using the Keras IMDB dataset.
+"""
+
+import numpy as np
+import tensorflow as tf
+from tensorflow import keras
+
+MAX_WORDS = 10000
+MAX_LENGTH = 150
+
+(x_train, y_train), (x_test, y_test) = keras.datasets.imdb.load_data(
+    num_words=MAX_WORDS
+)
+
+x_train = keras.preprocessing.sequence.pad_sequences(
+    x_train, maxlen=MAX_LENGTH
+)
+x_test = keras.preprocessing.sequence.pad_sequences(
+    x_test, maxlen=MAX_LENGTH
+)
+
+model = keras.Sequential([
+    keras.layers.Input(shape=(MAX_LENGTH,)),
+    keras.layers.Embedding(MAX_WORDS, 128),
+    keras.layers.LSTM(64),
+    keras.layers.Dense(32, activation="relu"),
+    keras.layers.Dropout(0.4),
+    keras.layers.Dense(1, activation="sigmoid"),
+])
+
+model.compile(
+    optimizer="adam",
+    loss="binary_crossentropy",
+    metrics=["accuracy"],
+)
+
+model.summary()
+
+history = model.fit(
+    x_train,
+    y_train,
+    validation_split=0.2,
+    epochs=10,
+    batch_size=32,
+)
+
+loss, accuracy = model.evaluate(x_test, y_test)
+print("\nTest accuracy:", round(accuracy, 4))

dl_experiment_code/templates/rnn_scratch.py

@@ -0,0 +1,130 @@
+"""
+Additional Experiment - Vanilla RNN implemented from scratch with NumPy.
+
+No TensorFlow/Keras recurrent layer is used.
+
+Task:
+Predict the next value of a sine-wave sequence.
+
+The RNN equations implemented manually are:
+
+h_t = tanh(Wxh x_t + Whh h_(t-1) + bh)
+y_t = Why h_t + by
+
+Training uses manually implemented backpropagation through time (BPTT).
+"""
+
+import numpy as np
+
+np.random.seed(42)
+
+# Generate a simple sequence dataset.
+t = np.linspace(0, 100, 2000)
+sequence = np.sin(t).astype(np.float32)
+
+SEQ_LEN = 20
+HIDDEN_SIZE = 32
+LEARNING_RATE = 0.01
+EPOCHS = 20
+
+X = []
+Y = []
+
+for i in range(len(sequence) - SEQ_LEN):
+    X.append(sequence[i:i + SEQ_LEN])
+    Y.append(sequence[i + SEQ_LEN])
+
+X = np.array(X)
+Y = np.array(Y)
+
+split = int(0.8 * len(X))
+X_train, X_test = X[:split], X[split:]
+Y_train, Y_test = Y[:split], Y[split:]
+
+# Parameters.
+Wxh = np.random.randn(HIDDEN_SIZE, 1) * 0.1
+Whh = np.random.randn(HIDDEN_SIZE, HIDDEN_SIZE) * 0.1
+Why = np.random.randn(1, HIDDEN_SIZE) * 0.1
+
+bh = np.zeros((HIDDEN_SIZE, 1))
+by = np.zeros((1, 1))
+
+def forward(sequence):
+    h = np.zeros((HIDDEN_SIZE, 1))
+    states = [(None, h)]
+    outputs = []
+
+    for value in sequence:
+        x = np.array([[value]], dtype=np.float32)
+        h = np.tanh(Wxh @ x + Whh @ h + bh)
+        y = Why @ h + by
+        states.append((x, h))
+        outputs.append(y.item())
+
+    return np.array(outputs), states
+
+def train_step(sequence, target):
+    global Wxh, Whh, Why, bh, by
+
+    predictions, states = forward(sequence)
+
+    # Loss is based on the final prediction.
+    error = predictions[-1] - target
+    loss = 0.5 * error ** 2
+
+    dWxh = np.zeros_like(Wxh)
+    dWhh = np.zeros_like(Whh)
+    dWhy = np.zeros_like(Why)
+    dbh = np.zeros_like(bh)
+    dby = np.array([[error]])
+
+    # Gradient from the final output.
+    dWhy += error * states[-1][1]
+
+    dh = Why.T * error
+
+    # Backpropagation through time.
+    for step in reversed(range(1, len(states))):
+        x, h = states[step]
+        h_prev = states[step - 1][1]
+
+        dh_raw = (1 - h * h) * dh
+
+        dWxh += dh_raw @ x.T
+        dWhh += dh_raw @ h_prev.T
+        dbh += dh_raw
+
+        dh = Whh.T @ dh_raw
+
+    # Clip gradients for stability.
+    for grad in [dWxh, dWhh, dWhy, dbh, dby]:
+        np.clip(grad, -1, 1, out=grad)
+
+    Wxh -= LEARNING_RATE * dWxh
+    Whh -= LEARNING_RATE * dWhh
+    Why -= LEARNING_RATE * dWhy
+    bh -= LEARNING_RATE * dbh
+    by -= LEARNING_RATE * dby
+
+    return loss
+
+for epoch in range(EPOCHS):
+    total_loss = 0.0
+
+    for sequence, target in zip(X_train, Y_train):
+        total_loss += train_step(sequence, target)
+
+    average_loss = total_loss / len(X_train)
+    print(f"Epoch {epoch + 1:02d}/{EPOCHS} - loss: {average_loss:.6f}")
+
+test_losses = []
+
+for sequence, target in zip(X_test[:200], Y_test[:200]):
+    prediction, _ = forward(sequence)
+    test_losses.append(0.5 * (prediction[-1] - target) ** 2)
+
+print("\nMean test loss:", np.mean(test_losses))
+
+sample_prediction, _ = forward(X_test[0])
+print("Actual next value   :", Y_test[0])
+print("Predicted next value:", sample_prediction[-1])