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

dl_experiment_code/__init__.py

@@ -0,0 +1 @@
+__version__ = "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/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/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/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()

dl_experiment_code/templates/exp5_online.py

@@ -0,0 +1,60 @@
+"""
+Experiment 5 - CNN image classification using the Keras CIFAR-10 dataset.
+"""
+
+import tensorflow as tf
+from tensorflow import keras
+import matplotlib.pyplot as plt
+
+(x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data()
+
+class_names = [
+    "airplane", "automobile", "bird", "cat", "deer",
+    "dog", "frog", "horse", "ship", "truck"
+]
+
+x_train = x_train.astype("float32") / 255.0
+x_test = x_test.astype("float32") / 255.0
+y_train = y_train.flatten()
+y_test = y_test.flatten()
+
+model = keras.Sequential([
+    keras.layers.Input(shape=(32, 32, 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(10, activation="softmax"),
+])
+
+model.compile(
+    optimizer="adam",
+    loss="sparse_categorical_crossentropy",
+    metrics=["accuracy"],
+)
+
+model.summary()
+
+history = model.fit(
+    x_train,
+    y_train,
+    validation_split=0.2,
+    epochs=10,
+    batch_size=64,
+)
+
+loss, accuracy = model.evaluate(x_test, y_test)
+print(f"\nTest 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 - CIFAR-10")
+plt.show()

dl_experiment_code/templates/exp6_local.py

@@ -0,0 +1,97 @@
+"""
+Experiment 6 - CNN hyperparameter tuning using a LOCAL image directory.
+
+Expected structure:
+dataset/
+    class_a/
+    class_b/
+    ...
+
+The script performs a small manual grid search over filters,
+dropout, and learning rate.
+"""
+
+import tensorflow as tf
+from tensorflow import keras
+
+DATASET_PATH = "dataset"
+IMAGE_SIZE = (128, 128)
+BATCH_SIZE = 32
+EPOCHS = 5
+
+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,
+)
+
+num_classes = len(train_ds.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))
+
+def build_model(filters, dropout):
+    return keras.Sequential([
+        keras.layers.Input(shape=(*IMAGE_SIZE, 3)),
+        keras.layers.Conv2D(filters, 3, activation="relu", padding="same"),
+        keras.layers.MaxPooling2D(),
+        keras.layers.Conv2D(filters * 2, 3, activation="relu", padding="same"),
+        keras.layers.MaxPooling2D(),
+        keras.layers.Conv2D(filters * 4, 3, activation="relu", padding="same"),
+        keras.layers.MaxPooling2D(),
+        keras.layers.Flatten(),
+        keras.layers.Dense(128, activation="relu"),
+        keras.layers.Dropout(dropout),
+        keras.layers.Dense(num_classes, activation="softmax"),
+    ])
+
+best_accuracy = -1
+best_config = None
+
+for filters in [16, 32]:
+    for dropout in [0.3, 0.5]:
+        for learning_rate in [0.001, 0.0001]:
+            print(
+                f"\nTesting filters={filters}, dropout={dropout}, "
+                f"lr={learning_rate}"
+            )
+
+            model = build_model(filters, dropout)
+            model.compile(
+                optimizer=keras.optimizers.Adam(learning_rate=learning_rate),
+                loss="sparse_categorical_crossentropy",
+                metrics=["accuracy"],
+            )
+
+            model.fit(
+                train_ds,
+                validation_data=val_ds,
+                epochs=EPOCHS,
+                verbose=0,
+            )
+
+            _, accuracy = model.evaluate(val_ds, verbose=0)
+            print("Validation accuracy:", round(accuracy, 4))
+
+            if accuracy > best_accuracy:
+                best_accuracy = accuracy
+                best_config = (filters, dropout, learning_rate)
+
+print("\nBest CNN configuration:")
+print("Filters       :", best_config[0])
+print("Dropout       :", best_config[1])
+print("Learning rate :", best_config[2])
+print("Accuracy      :", round(best_accuracy, 4))

dl_experiment_code/templates/exp6_online.py

@@ -0,0 +1,68 @@
+"""
+Experiment 6 - CNN hyperparameter tuning using Keras CIFAR-10.
+"""
+
+import tensorflow as tf
+from tensorflow import keras
+
+(x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data()
+
+x_train = x_train.astype("float32") / 255.0
+x_test = x_test.astype("float32") / 255.0
+y_train = y_train.flatten()
+y_test = y_test.flatten()
+
+def build_model(filters, dropout):
+    return keras.Sequential([
+        keras.layers.Input(shape=(32, 32, 3)),
+        keras.layers.Conv2D(filters, 3, activation="relu", padding="same"),
+        keras.layers.MaxPooling2D(),
+        keras.layers.Conv2D(filters * 2, 3, activation="relu", padding="same"),
+        keras.layers.MaxPooling2D(),
+        keras.layers.Conv2D(filters * 4, 3, activation="relu", padding="same"),
+        keras.layers.MaxPooling2D(),
+        keras.layers.Flatten(),
+        keras.layers.Dense(128, activation="relu"),
+        keras.layers.Dropout(dropout),
+        keras.layers.Dense(10, activation="softmax"),
+    ])
+
+best_accuracy = -1
+best_config = None
+
+for filters in [16, 32]:
+    for dropout in [0.3, 0.5]:
+        for learning_rate in [0.001, 0.0001]:
+            print(
+                f"\nTesting filters={filters}, dropout={dropout}, "
+                f"lr={learning_rate}"
+            )
+
+            model = build_model(filters, dropout)
+            model.compile(
+                optimizer=keras.optimizers.Adam(learning_rate=learning_rate),
+                loss="sparse_categorical_crossentropy",
+                metrics=["accuracy"],
+            )
+
+            model.fit(
+                x_train,
+                y_train,
+                validation_split=0.1,
+                epochs=5,
+                batch_size=64,
+                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 = (filters, dropout, learning_rate)
+
+print("\nBest CNN configuration:")
+print("Filters       :", best_config[0])
+print("Dropout       :", best_config[1])
+print("Learning rate :", best_config[2])
+print("Test accuracy :", round(best_accuracy, 4))

dl_experiment_code/templates/exp7_local.py

@@ -0,0 +1,66 @@
+"""
+Experiment 7 - Autoencoder dimensionality reduction on a LOCAL CSV dataset.
+
+Expected CSV format:
+feature1,feature2,feature3,...
+numeric features only.
+
+Change CSV_PATH as required.
+"""
+
+import numpy as np
+import pandas as pd
+import tensorflow as tf
+from tensorflow import keras
+import matplotlib.pyplot as plt
+from sklearn.preprocessing import MinMaxScaler
+
+CSV_PATH = "data/features.csv"
+ENCODING_DIM = 2
+
+df = pd.read_csv(CSV_PATH)
+X = df.select_dtypes(include=[np.number]).dropna().values
+
+scaler = MinMaxScaler()
+X = scaler.fit_transform(X).astype("float32")
+
+input_dim = X.shape[1]
+
+encoder = keras.Sequential([
+    keras.layers.Input(shape=(input_dim,)),
+    keras.layers.Dense(128, activation="relu"),
+    keras.layers.Dense(32, activation="relu"),
+    keras.layers.Dense(ENCODING_DIM, activation="linear"),
+], name="encoder")
+
+decoder = keras.Sequential([
+    keras.layers.Input(shape=(ENCODING_DIM,)),
+    keras.layers.Dense(32, activation="relu"),
+    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="mse")
+
+autoencoder.fit(
+    X,
+    X,
+    epochs=20,
+    batch_size=32,
+    validation_split=0.2,
+)
+
+encoded = encoder.predict(X, verbose=0)
+decoded = autoencoder.predict(X, verbose=0)
+
+print("Original dimension:", input_dim)
+print("Reduced dimension :", encoded.shape[1])
+
+if ENCODING_DIM == 2:
+    plt.scatter(encoded[:, 0], encoded[:, 1], s=10)
+    plt.xlabel("Encoded feature 1")
+    plt.ylabel("Encoded feature 2")
+    plt.title("Autoencoder 2D Representation")
+    plt.show()