dl-experiment-code 1.0.0__tar.gz

dl_experiment_code-1.0.0/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: dl-experiment-code
+Version: 1.0.0
+Summary: Ready-to-use Deep Learning experiment code for experiments 5-10 and a NumPy RNN from scratch
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Deep Learning Experiment Code Package
+
+This package provides ready-to-use code for:
+
+- Experiment 5: CNN image classification
+- Experiment 6: CNN hyperparameter tuning
+- Experiment 7: Autoencoder dimensionality reduction
+- Experiment 8: Educational single-object detection
+- Experiment 9: LSTM sentiment analysis
+- Experiment 10: LSTM hyperparameter tuning
+- Additional: Vanilla RNN implemented from scratch with NumPy
+
+For experiments 5-10 there are two versions:
+
+1. `local` - uses a local CSV/image/Pascal VOC dataset.
+2. `online` - uses a Keras dataset or an online TensorFlow Datasets dataset.
+
+The code follows the structure and concepts of the supplied original experiments.
+
+## Installation
+
+From this folder:
+
+```bash
+pip install .
+```
+
+For development/editable installation:
+
+```bash
+pip install -e .
+```
+
+## List experiments
+
+```bash
+dlab-code list
+```
+
+## Get code
+
+Online/Keras dataset version:
+
+```bash
+dlab-code get 5 --dataset online
+```
+
+Local dataset version:
+
+```bash
+dlab-code get 5 --dataset local
+```
+
+Experiments 6-10 work the same way:
+
+```bash
+dlab-code get 6 --dataset online
+dlab-code get 7 --dataset local
+dlab-code get 8 --dataset online
+dlab-code get 9 --dataset local
+dlab-code get 10 --dataset online
+```
+
+## Save directly to a Python file
+
+```bash
+dlab-code get 5 --dataset online --save exp5.py
+```
+
+Then:
+
+```bash
+python exp5.py
+```
+
+## RNN from scratch
+
+```bash
+dlab-code get rnn-scratch
+```
+
+Or save it:
+
+```bash
+dlab-code get rnn-scratch --save rnn_from_scratch.py
+```
+
+The RNN uses NumPy only for the recurrent computation and manually implements:
+
+- hidden-state calculation
+- output calculation
+- loss
+- backpropagation through time
+- gradient clipping
+- parameter updates
+
+## Dataset notes
+
+### Experiment 5
+- Online: Keras CIFAR-10
+- Local: image directory with one folder per class
+
+### Experiment 6
+- Online: Keras CIFAR-10
+- Local: image directory with one folder per class
+
+### Experiment 7
+- Online: Keras MNIST
+- Local: numeric CSV
+
+### Experiment 8
+- Online: Pascal VOC through TensorFlow Datasets
+- Local: Pascal VOC-style images + XML annotations
+
+The object detector is deliberately educational and predicts the first object in an image. It is not a production multi-object detector.
+
+### Experiment 9
+- Online: Keras IMDB
+- Local: `text,label` CSV
+
+### Experiment 10
+- Online: Keras IMDB
+- Local: `text,label` CSV
+
+## Dependencies for running generated code
+
+Install the common ML stack:
+
+```bash
+pip install tensorflow scikit-learn pandas numpy matplotlib pillow
+```
+
+Experiment 8 online additionally needs:
+
+```bash
+pip install tensorflow-datasets
+```
+
+The package itself has no heavy ML dependency because it only generates/prints the code.

dl_experiment_code-1.0.0/README.md

@@ -0,0 +1,139 @@
+# Deep Learning Experiment Code Package
+
+This package provides ready-to-use code for:
+
+- Experiment 5: CNN image classification
+- Experiment 6: CNN hyperparameter tuning
+- Experiment 7: Autoencoder dimensionality reduction
+- Experiment 8: Educational single-object detection
+- Experiment 9: LSTM sentiment analysis
+- Experiment 10: LSTM hyperparameter tuning
+- Additional: Vanilla RNN implemented from scratch with NumPy
+
+For experiments 5-10 there are two versions:
+
+1. `local` - uses a local CSV/image/Pascal VOC dataset.
+2. `online` - uses a Keras dataset or an online TensorFlow Datasets dataset.
+
+The code follows the structure and concepts of the supplied original experiments.
+
+## Installation
+
+From this folder:
+
+```bash
+pip install .
+```
+
+For development/editable installation:
+
+```bash
+pip install -e .
+```
+
+## List experiments
+
+```bash
+dlab-code list
+```
+
+## Get code
+
+Online/Keras dataset version:
+
+```bash
+dlab-code get 5 --dataset online
+```
+
+Local dataset version:
+
+```bash
+dlab-code get 5 --dataset local
+```
+
+Experiments 6-10 work the same way:
+
+```bash
+dlab-code get 6 --dataset online
+dlab-code get 7 --dataset local
+dlab-code get 8 --dataset online
+dlab-code get 9 --dataset local
+dlab-code get 10 --dataset online
+```
+
+## Save directly to a Python file
+
+```bash
+dlab-code get 5 --dataset online --save exp5.py
+```
+
+Then:
+
+```bash
+python exp5.py
+```
+
+## RNN from scratch
+
+```bash
+dlab-code get rnn-scratch
+```
+
+Or save it:
+
+```bash
+dlab-code get rnn-scratch --save rnn_from_scratch.py
+```
+
+The RNN uses NumPy only for the recurrent computation and manually implements:
+
+- hidden-state calculation
+- output calculation
+- loss
+- backpropagation through time
+- gradient clipping
+- parameter updates
+
+## Dataset notes
+
+### Experiment 5
+- Online: Keras CIFAR-10
+- Local: image directory with one folder per class
+
+### Experiment 6
+- Online: Keras CIFAR-10
+- Local: image directory with one folder per class
+
+### Experiment 7
+- Online: Keras MNIST
+- Local: numeric CSV
+
+### Experiment 8
+- Online: Pascal VOC through TensorFlow Datasets
+- Local: Pascal VOC-style images + XML annotations
+
+The object detector is deliberately educational and predicts the first object in an image. It is not a production multi-object detector.
+
+### Experiment 9
+- Online: Keras IMDB
+- Local: `text,label` CSV
+
+### Experiment 10
+- Online: Keras IMDB
+- Local: `text,label` CSV
+
+## Dependencies for running generated code
+
+Install the common ML stack:
+
+```bash
+pip install tensorflow scikit-learn pandas numpy matplotlib pillow
+```
+
+Experiment 8 online additionally needs:
+
+```bash
+pip install tensorflow-datasets
+```
+
+The package itself has no heavy ML dependency because it only generates/prints the code.

dl_experiment_code-1.0.0/dl_experiment_code/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

dl_experiment_code-1.0.0/dl_experiment_code/cli.py

@@ -0,0 +1,94 @@
+import argparse
+from pathlib import Path
+import shutil
+
+TEMPLATE_DIR = Path(__file__).parent / "templates"
+
+EXPERIMENTS = {
+    "5": {
+        "local": ("exp5_local.py", "CNN image classification - local dataset"),
+        "online": ("exp5_online.py", "CNN image classification - Keras CIFAR-10"),
+    },
+    "6": {
+        "local": ("exp6_local.py", "CNN hyperparameter tuning - local dataset"),
+        "online": ("exp6_online.py", "CNN hyperparameter tuning - Keras CIFAR-10"),
+    },
+    "7": {
+        "local": ("exp7_local.py", "Autoencoder dimensionality reduction - local CSV"),
+        "online": ("exp7_online.py", "Autoencoder dimensionality reduction - Keras MNIST"),
+    },
+    "8": {
+        "local": ("exp8_local.py", "Educational object detection - local Pascal VOC XML"),
+        "online": ("exp8_online.py", "Educational object detection - Pascal VOC via TFDS"),
+    },
+    "9": {
+        "local": ("exp9_local.py", "LSTM sentiment analysis - local CSV"),
+        "online": ("exp9_online.py", "LSTM sentiment analysis - Keras IMDB"),
+    },
+    "10": {
+        "local": ("exp10_local.py", "LSTM hyperparameter tuning - local CSV"),
+        "online": ("exp10_online.py", "LSTM hyperparameter tuning - Keras IMDB"),
+    },
+}
+
+def read_template(filename):
+    return (TEMPLATE_DIR / filename).read_text(encoding="utf-8")
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="dlab-code",
+        description="Get ready-to-use Deep Learning experiment code.",
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    get = sub.add_parser("get", help="Print or save experiment code")
+    get.add_argument("experiment", help="Experiment number: 5-10 or rnn-scratch")
+    get.add_argument(
+        "--dataset",
+        choices=["local", "online"],
+        default="online",
+        help="Dataset variant for experiments 5-10 (default: online)",
+    )
+    get.add_argument(
+        "--save",
+        metavar="FILE",
+        help="Save the generated code to a .py file instead of only printing it",
+    )
+
+    ls = sub.add_parser("list", help="List available experiments")
+
+    args = parser.parse_args()
+
+    if args.command == "list":
+        print("Available experiments:")
+        for number, variants in EXPERIMENTS.items():
+            print(f"\nExperiment {number}:")
+            for dataset, (_, description) in variants.items():
+                print(f"  {dataset:7s} - {description}")
+        print("\nAdditional:")
+        print("  rnn-scratch - Vanilla RNN from scratch using NumPy")
+        return
+
+    exp = args.experiment.lower()
+
+    if exp in {"rnn-scratch", "rnn_scratch", "rnn"}:
+        code = read_template("rnn_scratch.py")
+        default_name = "rnn_from_scratch.py"
+    elif exp in EXPERIMENTS:
+        filename, _ = EXPERIMENTS[exp][args.dataset]
+        code = read_template(filename)
+        default_name = filename
+    else:
+        raise SystemExit(
+            "Unknown experiment. Use 'dlab-code list' to see available options."
+        )
+
+    if args.save:
+        output = Path(args.save)
+        output.write_text(code, encoding="utf-8")
+        print(f"Code saved to: {output.resolve()}")
+    else:
+        print(code)
+
+if __name__ == "__main__":
+    main()

dl_experiment_code-1.0.0/dl_experiment_code/templates/exp10_local.py

@@ -0,0 +1,120 @@
+"""
+Experiment 10 - LSTM hyperparameter tuning using a LOCAL CSV.
+
+CSV format:
+text,label
+"""
+
+import pandas as pd
+import tensorflow as tf
+from tensorflow import keras
+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)
+
+def build_model(embedding_dim, lstm_units, dropout, learning_rate):
+    model = keras.Sequential([
+        keras.layers.Input(shape=(), dtype=tf.string),
+        vectorizer,
+        keras.layers.Embedding(
+            input_dim=MAX_WORDS,
+            output_dim=embedding_dim,
+            mask_zero=True,
+        ),
+        keras.layers.LSTM(lstm_units),
+        keras.layers.Dropout(dropout),
+        keras.layers.Dense(
+            len(encoder.classes_),
+            activation="softmax",
+        ),
+    ])
+
+    model.compile(
+        optimizer=keras.optimizers.Adam(learning_rate=learning_rate),
+        loss="sparse_categorical_crossentropy",
+        metrics=["accuracy"],
+    )
+    return model
+
+best_accuracy = -1
+best_config = None
+
+embedding_dims = [64, 128]
+lstm_units_list = [32, 64]
+dropouts = [0.3, 0.5]
+learning_rates = [0.001, 0.0005]
+
+for embedding_dim in embedding_dims:
+    for lstm_units in lstm_units_list:
+        for dropout in dropouts:
+            for learning_rate in learning_rates:
+                print(
+                    f"\nembedding={embedding_dim}, "
+                    f"LSTM={lstm_units}, dropout={dropout}, "
+                    f"lr={learning_rate}"
+                )
+
+                model = build_model(
+                    embedding_dim,
+                    lstm_units,
+                    dropout,
+                    learning_rate,
+                )
+
+                model.fit(
+                    X_train,
+                    y_train,
+                    validation_split=0.2,
+                    epochs=5,
+                    batch_size=32,
+                    verbose=0,
+                )
+
+                _, accuracy = model.evaluate(
+                    X_test,
+                    y_test,
+                    verbose=0,
+                )
+
+                print("Test accuracy:", round(accuracy, 4))
+
+                if accuracy > best_accuracy:
+                    best_accuracy = accuracy
+                    best_config = (
+                        embedding_dim,
+                        lstm_units,
+                        dropout,
+                        learning_rate,
+                    )
+
+print("\nBest LSTM configuration:")
+print("Embedding dimension:", best_config[0])
+print("LSTM units         :", best_config[1])
+print("Dropout            :", best_config[2])
+print("Learning rate      :", best_config[3])
+print("Test accuracy      :", round(best_accuracy, 4))

dl_experiment_code-1.0.0/dl_experiment_code/templates/exp10_online.py

@@ -0,0 +1,95 @@
+"""
+Experiment 10 - LSTM hyperparameter tuning 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
+)
+
+def build_model(embedding_dim, lstm_units, dropout, learning_rate):
+    model = keras.Sequential([
+        keras.layers.Input(shape=(MAX_LENGTH,)),
+        keras.layers.Embedding(MAX_WORDS, embedding_dim),
+        keras.layers.LSTM(lstm_units),
+        keras.layers.Dropout(dropout),
+        keras.layers.Dense(1, activation="sigmoid"),
+    ])
+
+    model.compile(
+        optimizer=keras.optimizers.Adam(learning_rate=learning_rate),
+        loss="binary_crossentropy",
+        metrics=["accuracy"],
+    )
+    return model
+
+best_accuracy = -1
+best_config = None
+
+embedding_dims = [64, 128]
+lstm_units_list = [32, 64]
+dropouts = [0.3, 0.5]
+learning_rates = [0.001, 0.0005]
+
+for embedding_dim in embedding_dims:
+    for lstm_units in lstm_units_list:
+        for dropout in dropouts:
+            for learning_rate in learning_rates:
+                print(
+                    f"\nembedding={embedding_dim}, "
+                    f"LSTM={lstm_units}, dropout={dropout}, "
+                    f"lr={learning_rate}"
+                )
+
+                model = build_model(
+                    embedding_dim,
+                    lstm_units,
+                    dropout,
+                    learning_rate,
+                )
+
+                model.fit(
+                    x_train,
+                    y_train,
+                    validation_split=0.2,
+                    epochs=5,
+                    batch_size=32,
+                    verbose=0,
+                )
+
+                _, accuracy = model.evaluate(
+                    x_test,
+                    y_test,
+                    verbose=0,
+                )
+
+                print("Test accuracy:", round(accuracy, 4))
+
+                if accuracy > best_accuracy:
+                    best_accuracy = accuracy
+                    best_config = (
+                        embedding_dim,
+                        lstm_units,
+                        dropout,
+                        learning_rate,
+                    )
+
+print("\nBest LSTM configuration:")
+print("Embedding dimension:", best_config[0])
+print("LSTM units         :", best_config[1])
+print("Dropout            :", best_config[2])
+print("Learning rate      :", best_config[3])
+print("Test accuracy      :", round(best_accuracy, 4))

dl_experiment_code-1.0.0/dl_experiment_code/templates/exp5_local.py

@@ -0,0 +1,87 @@
+"""
+Experiment 5 - CNN image classification using a LOCAL image directory.
+
+Expected structure:
+dataset/
+    class_a/
+        image1.jpg
+        image2.jpg
+    class_b/
+        image3.jpg
+        ...
+
+Change DATASET_PATH if required.
+"""
+
+import tensorflow as tf
+from tensorflow import keras
+import matplotlib.pyplot as plt
+
+DATASET_PATH = "dataset"
+IMAGE_SIZE = (128, 128)
+BATCH_SIZE = 32
+EPOCHS = 10
+
+train_ds = keras.utils.image_dataset_from_directory(
+    DATASET_PATH,
+    image_size=IMAGE_SIZE,
+    batch_size=BATCH_SIZE,
+    validation_split=0.2,
+    subset="training",
+    seed=42,
+)
+
+val_ds = keras.utils.image_dataset_from_directory(
+    DATASET_PATH,
+    image_size=IMAGE_SIZE,
+    batch_size=BATCH_SIZE,
+    validation_split=0.2,
+    subset="validation",
+    seed=42,
+)
+
+class_names = train_ds.class_names
+num_classes = len(class_names)
+
+normalization = keras.layers.Rescaling(1.0 / 255)
+train_ds = train_ds.map(lambda x, y: (normalization(x), y))
+val_ds = val_ds.map(lambda x, y: (normalization(x), y))
+
+model = keras.Sequential([
+    keras.layers.Input(shape=(*IMAGE_SIZE, 3)),
+    keras.layers.Conv2D(32, 3, activation="relu"),
+    keras.layers.MaxPooling2D(),
+    keras.layers.Conv2D(64, 3, activation="relu"),
+    keras.layers.MaxPooling2D(),
+    keras.layers.Conv2D(128, 3, activation="relu"),
+    keras.layers.MaxPooling2D(),
+    keras.layers.Flatten(),
+    keras.layers.Dense(128, activation="relu"),
+    keras.layers.Dropout(0.5),
+    keras.layers.Dense(num_classes, activation="softmax"),
+])
+
+model.compile(
+    optimizer="adam",
+    loss="sparse_categorical_crossentropy",
+    metrics=["accuracy"],
+)
+
+model.summary()
+
+history = model.fit(
+    train_ds,
+    validation_data=val_ds,
+    epochs=EPOCHS,
+)
+
+loss, accuracy = model.evaluate(val_ds)
+print(f"\nValidation accuracy: {accuracy:.4f}")
+
+plt.plot(history.history["accuracy"], label="Training")
+plt.plot(history.history["val_accuracy"], label="Validation")
+plt.xlabel("Epoch")
+plt.ylabel("Accuracy")
+plt.legend()
+plt.title("CNN Image Classification - Local Dataset")
+plt.show()