libz 0.3__tar.gz → 0.5__tar.gz

{libz-0.3 → libz-0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libz
-Version: 0.3
+Version: 0.5
 Summary: A lightweight Python utility toolkit.
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown

libz-0.5/libz/DL/__init__.py

@@ -0,0 +1,15 @@
+from libz._core import register
+
+TITLES = {
+    1: "Deep feed forward",
+    2: "Regularization and optimization",
+    3: "Semi-supervised learning",
+    4: "Multitasking",
+    5: "CNN-based handwriting recognition",
+    6: "CNN - unsupervised feature learning",
+    7: "Recurrent neural network",
+    8: "Recursive neural network (tree)",
+    9: "PCA vs linear autoencoder",
+}
+
+register(__name__, globals(), TITLES)

libz-0.5/libz/DLG/__init__.py

@@ -0,0 +1,15 @@
+from libz._core import register
+
+TITLES = {
+    1: "Deep feed forward (any CSV)",
+    2: "Regularization and optimization (any CSV)",
+    3: "Semi-supervised learning (any text CSV)",
+    4: "Multitasking (any CSV)",
+    5: "CNN-based handwriting recognition (any image folder / MNIST)",
+    6: "CNN - unsupervised feature learning (any image folder / digits)",
+    7: "Recurrent neural network (any text CSV / IMDB)",
+    8: "Recursive neural network (tree) (any text CSV / sample)",
+    9: "PCA vs linear autoencoder (any numeric CSV / synthetic)",
+}
+
+register(__name__, globals(), TITLES)

libz-0.5/libz/DLG/prac1.py

@@ -0,0 +1,71 @@
+# Deep Feed Forward Neural Network - works with any CSV classification dataset
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler, LabelEncoder
+from sklearn.metrics import classification_report, confusion_matrix
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Input, Dense, Dropout
+from tensorflow.keras.callbacks import EarlyStopping
+
+# 1. Load dataset
+path = input("Enter CSV file path: ").strip().strip('"')
+df = pd.read_csv(path)
+df = df.loc[:, ~df.columns.str.contains("^Unnamed")]
+print(df.head())
+print("Columns:", list(df.columns))
+target = input("Enter target column: ").strip()
+
+# 2. Preprocess
+df = df.dropna(subset=[target]).drop_duplicates()
+X = df.drop(columns=[target])
+X = X.drop(columns=[c for c in X.columns if c.lower() == "id"])
+for c in X.columns:
+    if pd.api.types.is_numeric_dtype(X[c]):
+        X[c] = X[c].fillna(X[c].median())
+    else:
+        X[c] = X[c].fillna(X[c].mode()[0])
+X = pd.get_dummies(X, drop_first=True, dtype=int)
+
+encoder = LabelEncoder()
+y = encoder.fit_transform(df[target].astype(str))
+n_classes = len(encoder.classes_)
+print("Classes:", list(encoder.classes_))
+
+# 3. Split and scale
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.2, random_state=42, stratify=y
+)
+scaler = StandardScaler()
+X_train = scaler.fit_transform(X_train)
+X_test = scaler.transform(X_test)
+
+# 4. Build deep feed forward network
+model = Sequential([
+    Input(shape=(X_train.shape[1],)),
+    Dense(128, activation="relu"),
+    Dropout(0.3),
+    Dense(64, activation="relu"),
+    Dropout(0.2),
+    Dense(32, activation="relu"),
+    Dense(n_classes, activation="softmax"),
+])
+model.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])
+model.summary()
+
+# 5. Train
+early_stop = EarlyStopping(monitor="val_loss", patience=5, restore_best_weights=True)
+model.fit(X_train, y_train, epochs=50, batch_size=32,
+          validation_split=0.2, callbacks=[early_stop], verbose=1)
+
+# 6. Evaluate
+train_acc = model.evaluate(X_train, y_train, verbose=0)[1]
+test_acc = model.evaluate(X_test, y_test, verbose=0)[1]
+y_pred = model.predict(X_test, verbose=0).argmax(axis=1)
+
+print(f"\nTraining Accuracy: {train_acc * 100:.2f}%")
+print(f"Testing Accuracy: {test_acc * 100:.2f}%")
+print("\nClassification Report:")
+print(classification_report(y_test, y_pred, target_names=encoder.classes_))
+print("Confusion Matrix:")
+print(confusion_matrix(y_test, y_pred))

libz-0.5/libz/DLG/prac2.py

@@ -0,0 +1,108 @@
+# Regularization and Optimization - works with any CSV classification dataset
+# Compares: no regularization vs L2 + Dropout + Early Stopping,
+# and the optimizers Adam, SGD and RMSprop.
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler, LabelEncoder
+from sklearn.metrics import classification_report, confusion_matrix
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Input, Dense, Dropout
+from tensorflow.keras.regularizers import l2
+from tensorflow.keras.callbacks import EarlyStopping
+
+# 1. Load dataset
+path = input("Enter CSV file path: ").strip().strip('"')
+df = pd.read_csv(path)
+df = df.loc[:, ~df.columns.str.contains("^Unnamed")]
+print(df.head())
+print("Columns:", list(df.columns))
+target = input("Enter target column: ").strip()
+
+# 2. Preprocess
+df = df.dropna(subset=[target]).drop_duplicates()
+X = df.drop(columns=[target])
+X = X.drop(columns=[c for c in X.columns if c.lower() == "id"])
+for c in X.columns:
+    if pd.api.types.is_numeric_dtype(X[c]):
+        X[c] = X[c].fillna(X[c].median())
+    else:
+        X[c] = X[c].fillna(X[c].mode()[0])
+X = pd.get_dummies(X, drop_first=True, dtype=int)
+
+encoder = LabelEncoder()
+y = encoder.fit_transform(df[target].astype(str))
+n_classes = len(encoder.classes_)
+print("Classes:", list(encoder.classes_))
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.2, random_state=42, stratify=y
+)
+scaler = StandardScaler()
+X_train = scaler.fit_transform(X_train)
+X_test = scaler.transform(X_test)
+
+
+# 3. Model builder
+def build_model(regularize, optimizer):
+    reg = l2(0.001) if regularize else None
+    drop = 0.3 if regularize else 0.0
+    model = Sequential([
+        Input(shape=(X_train.shape[1],)),
+        Dense(128, activation="relu", kernel_regularizer=reg),
+        Dropout(drop),
+        Dense(64, activation="relu", kernel_regularizer=reg),
+        Dropout(drop),
+        Dense(n_classes, activation="softmax"),
+    ])
+    model.compile(optimizer=optimizer, loss="sparse_categorical_crossentropy", metrics=["accuracy"])
+    return model
+
+
+# 4. Train every experiment
+experiments = [
+    ("No regularization (Adam)", False, "adam"),
+    ("L2 + Dropout + EarlyStop (Adam)", True, "adam"),
+    ("L2 + Dropout + EarlyStop (SGD)", True, "sgd"),
+    ("L2 + Dropout + EarlyStop (RMSprop)", True, "rmsprop"),
+]
+
+results = []
+histories = {}
+models = {}
+for name, regularize, optimizer in experiments:
+    print(f"\nTraining: {name}")
+    model = build_model(regularize, optimizer)
+    callbacks = [EarlyStopping(monitor="val_loss", patience=5, restore_best_weights=True)] if regularize else []
+    history = model.fit(X_train, y_train, epochs=50, batch_size=32,
+                        validation_split=0.2, callbacks=callbacks, verbose=0)
+    train_acc = model.evaluate(X_train, y_train, verbose=0)[1]
+    test_acc = model.evaluate(X_test, y_test, verbose=0)[1]
+    results.append([name, train_acc * 100, test_acc * 100, len(history.history["loss"])])
+    histories[name] = history
+    models[name] = model
+
+# 5. Compare results
+results_df = pd.DataFrame(results, columns=["Model", "Train Acc", "Test Acc", "Epochs"])
+print("\nComparison:")
+print(results_df.round(2).to_string(index=False))
+
+# 6. Plot validation loss of each experiment
+plt.figure(figsize=(9, 5))
+for name, history in histories.items():
+    plt.plot(history.history["val_loss"], label=name)
+plt.title("Validation Loss: Regularization and Optimizers")
+plt.xlabel("Epoch")
+plt.ylabel("Validation Loss")
+plt.legend()
+plt.grid(True)
+plt.show()
+
+# 7. Detailed report of the best model
+best = results_df.sort_values("Test Acc", ascending=False).iloc[0]["Model"]
+y_pred = models[best].predict(X_test, verbose=0).argmax(axis=1)
+print(f"\nBest model: {best}")
+print(classification_report(y_test, y_pred, target_names=encoder.classes_))
+print("Confusion Matrix:")
+print(confusion_matrix(y_test, y_pred))

libz-0.5/libz/DLG/prac3.py

@@ -0,0 +1,108 @@
+# Semi-Supervised Learning (self-training with pseudo-labels) - works with any text CSV
+# Only part of the training data keeps its labels. The model labels the rest itself
+# (only predictions it is confident about) and retrains on the bigger dataset.
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.preprocessing import LabelEncoder
+from sklearn.metrics import classification_report, confusion_matrix
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Input, Dense, Dropout
+from tensorflow.keras.callbacks import EarlyStopping
+
+# 1. Load dataset (example: spam.csv -> text column v2, label column v1)
+path = input("Enter CSV file path: ").strip().strip('"')
+try:
+    df = pd.read_csv(path)
+except UnicodeDecodeError:
+    df = pd.read_csv(path, encoding="latin-1")
+print(df.head())
+print("Columns:", list(df.columns))
+text_col = input("Enter text column: ").strip()
+label_col = input("Enter label column: ").strip()
+labeled_ratio = float(input("Fraction of training data that keeps labels (Enter for 0.3): ") or 0.3)
+
+# 2. Clean and encode
+df = df[[text_col, label_col]].dropna().drop_duplicates()
+encoder = LabelEncoder()
+y = encoder.fit_transform(df[label_col].astype(str))
+n_classes = len(encoder.classes_)
+print("Classes:", list(encoder.classes_))
+print(df[label_col].value_counts())
+
+X_train_text, X_test_text, y_train, y_test = train_test_split(
+    df[text_col].astype(str), y, test_size=0.2, random_state=42, stratify=y
+)
+
+# 3. TF-IDF features
+vectorizer = TfidfVectorizer(max_features=5000, stop_words="english")
+X_train = vectorizer.fit_transform(X_train_text).toarray().astype("float32")
+X_test = vectorizer.transform(X_test_text).toarray().astype("float32")
+
+# 4. Split training data into labelled and unlabelled parts
+X_lab, X_unlab, y_lab, _ = train_test_split(
+    X_train, y_train, train_size=labeled_ratio, random_state=42, stratify=y_train
+)
+print("Labelled samples:", len(X_lab))
+print("Unlabelled samples:", len(X_unlab))
+
+
+# 5. Model
+def train_model(X, y):
+    model = Sequential([
+        Input(shape=(X.shape[1],)),
+        Dense(64, activation="relu"),
+        Dropout(0.3),
+        Dense(32, activation="relu"),
+        Dropout(0.3),
+        Dense(n_classes, activation="softmax"),
+    ])
+    model.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])
+    model.fit(X, y, epochs=20, batch_size=32, validation_split=0.2, verbose=0,
+              callbacks=[EarlyStopping(monitor="val_loss", patience=3, restore_best_weights=True)])
+    return model
+
+
+# 6. Baseline: supervised model trained on the labelled part only
+baseline = train_model(X_lab, y_lab)
+baseline_acc = baseline.evaluate(X_test, y_test, verbose=0)[1]
+print(f"\nBaseline (labelled data only) Test Accuracy: {baseline_acc * 100:.2f}%")
+
+# 7. Self-training: add confident pseudo-labels and retrain
+threshold = 0.90
+model = baseline
+X_cur, y_cur, pool = X_lab, y_lab, X_unlab
+
+for round_no in range(1, 4):
+    probs = model.predict(pool, verbose=0)
+    confident = probs.max(axis=1) >= threshold
+    if confident.sum() == 0:
+        print("No more confident predictions.")
+        break
+
+    X_cur = np.vstack([X_cur, pool[confident]])
+    y_cur = np.concatenate([y_cur, probs[confident].argmax(axis=1)])
+    pool = pool[~confident]
+    print(f"Round {round_no}: added {confident.sum()} pseudo-labels "
+          f"(training size {len(X_cur)}, {len(pool)} unlabelled left)")
+
+    model = train_model(X_cur, y_cur)
+
+# 8. Compare
+ssl_acc = model.evaluate(X_test, y_test, verbose=0)[1]
+print(f"\nBaseline Test Accuracy:        {baseline_acc * 100:.2f}%")
+print(f"Semi-Supervised Test Accuracy: {ssl_acc * 100:.2f}%")
+
+if ssl_acc > baseline_acc:
+    print("Semi-supervised learning improved the model.")
+elif ssl_acc < baseline_acc:
+    print("Baseline model performed better.")
+else:
+    print("Both models performed equally.")
+
+y_pred = model.predict(X_test, verbose=0).argmax(axis=1)
+print("\nClassification Report (semi-supervised model):")
+print(classification_report(y_test, y_pred, target_names=encoder.classes_))
+print("Confusion Matrix:")
+print(confusion_matrix(y_test, y_pred))

libz-0.5/libz/DLG/prac4.py

@@ -0,0 +1,105 @@
+# Multitask Learning - works with any CSV dataset
+# One shared network predicts several target columns at the same time.
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler, LabelEncoder
+from sklearn.metrics import accuracy_score, f1_score, confusion_matrix
+from tensorflow.keras.models import Model
+from tensorflow.keras.layers import Input, Dense, Dropout
+
+# 1. Load dataset (use sep=";" for files like student-mat.csv)
+path = input("Enter CSV file path: ").strip().strip('"')
+sep = input("Column separator (press Enter for comma): ") or ","
+df = pd.read_csv(path, sep=sep)
+df = df.loc[:, ~df.columns.str.contains("^Unnamed")]
+print(df.head())
+print("Columns:", list(df.columns))
+targets = [t.strip() for t in input("Enter 2 or more target columns (comma separated): ").split(",")]
+
+# 2. Create one label per task
+df = df.dropna(subset=targets).drop_duplicates()
+Y = []
+encoders = []
+for t in targets:
+    col = df[t]
+    # Numeric column with many values -> High / Low (split at median)
+    if pd.api.types.is_numeric_dtype(col) and col.nunique() > 10:
+        col = np.where(col >= col.median(), "High", "Low")
+    enc = LabelEncoder()
+    Y.append(enc.fit_transform(pd.Series(col).astype(str)))
+    encoders.append(enc)
+    print(f"{t} classes:", list(enc.classes_))
+
+# 3. Prepare input features
+X = df.drop(columns=targets)
+X = X.drop(columns=[c for c in X.columns if c.lower() == "id"])
+for c in X.columns:
+    if pd.api.types.is_numeric_dtype(X[c]):
+        X[c] = X[c].fillna(X[c].median())
+    else:
+        X[c] = X[c].fillna(X[c].mode()[0])
+X = pd.get_dummies(X, drop_first=True, dtype=int).values
+
+train_idx, test_idx = train_test_split(np.arange(len(X)), test_size=0.2, random_state=42)
+scaler = StandardScaler()
+X_train = scaler.fit_transform(X[train_idx])
+X_test = scaler.transform(X[test_idx])
+Y_train = [y[train_idx] for y in Y]
+Y_test = [y[test_idx] for y in Y]
+
+# 4. Build multitask network: shared layers + one output head per task
+inputs = Input(shape=(X_train.shape[1],))
+shared = Dense(64, activation="relu")(inputs)
+shared = Dropout(0.2)(shared)
+shared = Dense(32, activation="relu")(shared)
+outputs = [
+    Dense(len(enc.classes_), activation="softmax", name=f"task{i + 1}")(shared)
+    for i, enc in enumerate(encoders)
+]
+
+model = Model(inputs, outputs)
+model.compile(
+    optimizer="adam",
+    loss=["sparse_categorical_crossentropy"] * len(targets),
+    metrics=[["accuracy"]] * len(targets),
+)
+model.summary()
+
+# 5. Train
+history = model.fit(X_train, Y_train, epochs=100, batch_size=32,
+                    validation_split=0.2, verbose=0)
+
+plt.figure(figsize=(8, 5))
+plt.plot(history.history["loss"], label="Training Loss")
+plt.plot(history.history["val_loss"], label="Validation Loss")
+plt.title("Multitask Training Loss")
+plt.xlabel("Epoch")
+plt.ylabel("Total Loss")
+plt.legend()
+plt.grid(True)
+plt.show()
+
+# 6. Evaluate every task
+preds = model.predict(X_test, verbose=0)
+if len(targets) == 1:
+    preds = [preds]
+
+results = []
+for i, t in enumerate(targets):
+    y_pred = preds[i].argmax(axis=1)
+    acc = accuracy_score(Y_test[i], y_pred)
+    f1 = f1_score(Y_test[i], y_pred, average="weighted", zero_division=0)
+    results.append([t, acc * 100, f1 * 100])
+    print(f"\n{t} Confusion Matrix:")
+    print(confusion_matrix(Y_test[i], y_pred))
+
+print("\nTask-wise Evaluation:")
+print(pd.DataFrame(results, columns=["Task", "Accuracy", "F1 Score"]).round(2).to_string(index=False))
+
+# 7. Predict all tasks for one sample
+print("\nSample prediction (first test row):")
+for i, t in enumerate(targets):
+    p = preds[i][0]
+    print(f"{t}: {encoders[i].classes_[p.argmax()]} (probability {p.max():.4f})")

libz-0.5/libz/DLG/prac5.py

@@ -0,0 +1,99 @@
+# CNN-Based Handwriting Recognition - works with any folder of handwriting images
+# Folder layout: one subfolder per class, e.g. data/A/*.png, data/B/*.png ...
+# Press Enter to use the built-in MNIST handwritten digits.
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+from PIL import Image
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import classification_report, confusion_matrix
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Input, Conv2D, MaxPooling2D, Flatten, Dense, Dropout
+from tensorflow.keras.callbacks import EarlyStopping
+
+IMG_SIZE = 28
+
+# 1. Load dataset
+folder = input("Enter image folder (one subfolder per class) or press Enter for MNIST: ").strip().strip('"')
+
+if folder:
+    class_names = sorted(d for d in os.listdir(folder) if os.path.isdir(os.path.join(folder, d)))
+    X, y = [], []
+    for label, name in enumerate(class_names):
+        for file in os.listdir(os.path.join(folder, name)):
+            try:
+                img = Image.open(os.path.join(folder, name, file)).convert("L")
+            except OSError:
+                continue  # skip files that are not images
+            X.append(np.array(img.resize((IMG_SIZE, IMG_SIZE))))
+            y.append(label)
+    X = np.array(X, dtype="float32") / 255.0
+    y = np.array(y)
+    # Scanned handwriting is dark ink on white paper: invert so ink is bright (like MNIST)
+    if X.mean() > 0.5:
+        X = 1.0 - X
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=42, stratify=y
+    )
+else:
+    from tensorflow.keras.datasets import mnist
+    (X_train, y_train), (X_test, y_test) = mnist.load_data()
+    X_train = X_train.astype("float32") / 255.0
+    X_test = X_test.astype("float32") / 255.0
+    class_names = [str(i) for i in range(10)]
+
+# Add channel dimension: (samples, height, width, 1)
+X_train = X_train[..., np.newaxis]
+X_test = X_test[..., np.newaxis]
+n_classes = len(class_names)
+print("Classes:", class_names)
+print("Training images:", X_train.shape, "Testing images:", X_test.shape)
+
+# 2. Build CNN
+model = Sequential([
+    Input(shape=(IMG_SIZE, IMG_SIZE, 1)),
+    Conv2D(32, 3, activation="relu", padding="same"),
+    MaxPooling2D(),
+    Conv2D(64, 3, activation="relu", padding="same"),
+    MaxPooling2D(),
+    Flatten(),
+    Dense(128, activation="relu"),
+    Dropout(0.3),
+    Dense(n_classes, activation="softmax"),
+])
+model.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])
+model.summary()
+
+# 3. Train
+history = model.fit(
+    X_train, y_train, epochs=10, batch_size=64, validation_split=0.1,
+    callbacks=[EarlyStopping(monitor="val_loss", patience=3, restore_best_weights=True)],
+)
+
+plt.figure(figsize=(8, 5))
+plt.plot(history.history["accuracy"], label="Training Accuracy")
+plt.plot(history.history["val_accuracy"], label="Validation Accuracy")
+plt.title("CNN Handwriting Recognition Accuracy")
+plt.xlabel("Epoch")
+plt.ylabel("Accuracy")
+plt.legend()
+plt.grid(True)
+plt.show()
+
+# 4. Evaluate
+test_loss, test_acc = model.evaluate(X_test, y_test, verbose=0)
+y_pred = model.predict(X_test, verbose=0).argmax(axis=1)
+print(f"\nTest Accuracy: {test_acc * 100:.2f}%")
+print(classification_report(y_test, y_pred, target_names=class_names))
+print("Confusion Matrix:")
+print(confusion_matrix(y_test, y_pred))
+
+# 5. Show some test images with predictions
+plt.figure(figsize=(12, 3))
+for i in range(min(8, len(X_test))):
+    plt.subplot(1, 8, i + 1)
+    plt.imshow(X_test[i].squeeze(), cmap="gray")
+    plt.title(f"Pred: {class_names[y_pred[i]]}\nTrue: {class_names[y_test[i]]}")
+    plt.axis("off")
+plt.tight_layout()
+plt.show()

libz-0.5/libz/DLG/prac6.py

@@ -0,0 +1,119 @@
+# CNN Unsupervised Feature Learning (Exemplar CNN + K-Means) - works with any image folder
+# Folder layout: one subfolder per class (class names are used ONLY for evaluation).
+# Press Enter to use sklearn's built-in handwritten digits.
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+from PIL import Image
+from sklearn.cluster import KMeans
+from sklearn.metrics import adjusted_rand_score, normalized_mutual_info_score
+from sklearn.preprocessing import StandardScaler, normalize
+from tensorflow.keras.models import Model
+from tensorflow.keras.layers import Input, Conv2D, MaxPooling2D, Flatten, Dense
+
+np.random.seed(42)
+IMG_SIZE = 28
+
+# 1. Load dataset
+folder = input("Enter image folder (one subfolder per class) or press Enter for digits: ").strip().strip('"')
+
+if folder:
+    class_names = sorted(d for d in os.listdir(folder) if os.path.isdir(os.path.join(folder, d)))
+    X, y = [], []
+    for label, name in enumerate(class_names):
+        for file in os.listdir(os.path.join(folder, name)):
+            try:
+                img = Image.open(os.path.join(folder, name, file)).convert("L")
+            except OSError:
+                continue
+            X.append(np.array(img.resize((IMG_SIZE, IMG_SIZE))))
+            y.append(label)
+    X = np.array(X, dtype="float32") / 255.0
+    y = np.array(y)
+else:
+    from sklearn.datasets import load_digits
+    digits = load_digits()
+    X = digits.images.astype("float32") / 16.0
+    y = digits.target
+    class_names = [str(i) for i in range(10)]
+
+X = X[..., np.newaxis]  # (samples, height, width, 1)
+print("Dataset shape:", X.shape)
+
+n_clusters = int(input(f"Number of clusters (Enter for {len(class_names)}): ") or len(class_names))
+
+# 2. Pretext task: exemplar learning
+# Each chosen image becomes its own "class"; the CNN learns to recognise
+# noisy / shifted views of it, which teaches it useful features without labels.
+NUM_EXEMPLARS = min(100, len(X))
+VIEWS = 8
+
+chosen = np.random.choice(len(X), NUM_EXEMPLARS, replace=False)
+views, view_labels = [], []
+for i, idx in enumerate(chosen):
+    for v in range(VIEWS):
+        img = X[idx].copy()
+        if v > 0:
+            img = np.roll(img, shift=np.random.randint(-1, 2), axis=np.random.randint(0, 2))
+            img = np.clip(img + np.random.normal(0, 0.05, img.shape), 0, 1)
+        views.append(img)
+        view_labels.append(i)
+views = np.array(views, dtype="float32")
+view_labels = np.array(view_labels)
+print("Exemplar training samples:", len(views))
+
+# 3. Exemplar CNN
+inputs = Input(shape=X.shape[1:])
+x = Conv2D(16, 3, activation="relu", padding="same")(inputs)
+x = MaxPooling2D()(x)
+x = Conv2D(32, 3, activation="relu", padding="same")(x)
+x = MaxPooling2D()(x)
+x = Flatten()(x)
+features = Dense(64, activation="relu", name="features")(x)
+outputs = Dense(NUM_EXEMPLARS, activation="softmax")(features)
+
+exemplar_cnn = Model(inputs, outputs)
+exemplar_cnn.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])
+history = exemplar_cnn.fit(views, view_labels, epochs=30, batch_size=32, shuffle=True, verbose=1)
+
+# 4. Extract learned features and cluster them
+feature_extractor = Model(inputs, features)
+learned = feature_extractor.predict(X, verbose=0)
+learned = normalize(StandardScaler().fit_transform(learned))  # scale features before clustering
+print("Extracted feature shape:", learned.shape)
+
+clusters = KMeans(n_clusters=n_clusters, n_init=10, random_state=42).fit_predict(learned)
+
+# 5. Evaluate (true labels used only here)
+print(f"\nAdjusted Rand Index (ARI): {adjusted_rand_score(y, clusters):.4f}")
+print(f"Normalized Mutual Information (NMI): {normalized_mutual_info_score(y, clusters):.4f}")
+
+print("\nMost common actual classes in each cluster:")
+for c in range(n_clusters):
+    counts = np.bincount(y[clusters == c], minlength=len(class_names))
+    top = np.argsort(counts)[::-1][:3]
+    print(f"Cluster {c}:", [(class_names[t], int(counts[t])) for t in top if counts[t] > 0])
+
+# 6. Plot pretext loss and sample images from each cluster
+plt.figure(figsize=(7, 4))
+plt.plot(history.history["loss"], marker="o")
+plt.title("Exemplar CNN Training Loss")
+plt.xlabel("Epoch")
+plt.ylabel("Loss")
+plt.grid(True)
+plt.show()
+
+per_row = 6
+fig, axes = plt.subplots(n_clusters, per_row, figsize=(per_row, n_clusters))
+axes = np.array(axes).reshape(n_clusters, per_row)
+for c in range(n_clusters):
+    members = np.where(clusters == c)[0][:per_row]
+    for j in range(per_row):
+        ax = axes[c, j]
+        ax.axis("off")
+        if j < len(members):
+            ax.imshow(X[members[j]].squeeze(), cmap="gray")
+    axes[c, 0].set_title(f"C{c}", fontsize=8, loc="left")
+plt.suptitle("Sample images in each cluster")
+plt.tight_layout()
+plt.show()