libz 0.5__tar.gz → 0.7__tar.gz

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

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

libz-0.7/libz/DL/prac8.py

@@ -0,0 +1,73 @@
+# Recursive Neural Networks
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class RecursiveNN(nn.Module):
+
+def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes):
+super().__init__()
+
+self.embedding = nn.Embedding(vocab_size, embed_dim)
+self.combine = nn.Linear(embed_dim * 2, hidden_dim)
+self.classifier = nn.Linear(hidden_dim, num_classes)
+
+def forward(self, tree):
+
+# Leaf node
+if isinstance(tree, int):
+return self.embedding(torch.tensor(tree))
+
+# Recursive case
+left, right = tree
+
+left_vec = self.forward(left)
+right_vec = self.forward(right)
+
+combined = torch.cat([left_vec, right_vec])
+
+return torch.tanh(self.combine(combined))
+
+
+# Parameters
+VOCAB_SIZE = 100
+EMBED_DIM = 16
+HIDDEN_DIM = 16
+NUM_CLASSES = 2
+
+# Create model
+model = RecursiveNN(
+VOCAB_SIZE,
+EMBED_DIM,
+HIDDEN_DIM,
+NUM_CLASSES
+)
+
+# Word IDs
+vocab = {
+"the": 10,
+"movie": 25,
+"was": 4,
+"great": 82
+}
+
+# Tree: ((the, movie), (was, great))
+tree = (
+(vocab["the"], vocab["movie"]),
+(vocab["was"], vocab["great"])
+)
+
+# Get root vector
+root = model(tree)
+
+# Classify root
+logits = model.classifier(root)
+
+# Convert scores to probabilities
+probabilities = F.softmax(logits, dim=0)
+
+print("Root:", root)
+print("Logits:", logits)
+print("Probabilities:", probabilities)

libz-0.7/libz/DL/prac9.py

@@ -0,0 +1,73 @@
+# Linear Factor Models
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from sklearn.datasets import make_blobs
+from sklearn.decomposition import PCA
+
+
+# 1. Create data
+X, _ = make_blobs(
+n_samples=1000,
+n_features=10,
+centers=3,
+random_state=42
+)
+
+X = torch.tensor(X, dtype=torch.float32)
+
+
+# 2. Linear Factor Model using PCA
+pca = PCA(n_components=3)
+factors = pca.fit_transform(X.numpy())
+
+print("PCA Variance:", pca.explained_variance_ratio_)
+
+
+# 3. Linear Autoencoder
+class LinearAutoencoder(nn.Module):
+
+def __init__(self, input_dim, factor_dim):
+super().__init__()
+
+self.encoder = nn.Linear(input_dim, factor_dim)
+self.decoder = nn.Linear(factor_dim, input_dim)
+
+def forward(self, x):
+factors = self.encoder(x)
+output = self.decoder(factors)
+
+return output, factors
+
+
+# 4. Create model
+model = LinearAutoencoder(10, 3)
+
+loss_fn = nn.MSELoss()
+optimizer = optim.Adam(model.parameters(), lr=0.01)
+
+
+# 5. Train model
+for epoch in range(200):
+
+optimizer.zero_grad()
+
+output, factors = model(X)
+
+loss = loss_fn(output, X)
+
+loss.backward()
+optimizer.step()
+
+if (epoch + 1) % 50 == 0:
+print(
+"Epoch:", epoch + 1,
+"Loss:", loss.item()
+)
+
+
+# 6. Get factor loading matrix
+W = model.decoder.weight.detach()
+
+print("Factor Loading Matrix Shape:", W.shape)

{libz-0.5 → libz-0.7}/libz/DLG/__init__.py

@@ -1,15 +1,16 @@
-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)
+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 / CSV / MNIST)",
+    6: "CNN - unsupervised feature learning (any image folder / CSV / digits)",
+    7: "Recurrent neural network (any text CSV / IMDB)",
+    8: "Recursive neural network (tree)",
+    9: "PCA vs linear autoencoder",
+}
+
+# prac8 and prac9 show the DL code (no dynamic version needed)
+register(__name__, globals(), TITLES, links={8: "DL", 9: "DL"})

libz-0.7/libz/DLG/prac1.py

@@ -0,0 +1,145 @@
+# Deep Feed Forward Neural Network - works with any CSV classification dataset
+# The target column and the feature columns are picked automatically.
+# If accuracy is low, you are asked which columns to use and the model is retrained.
+# Press Enter to use the built-in Breast Cancer dataset (from scikit-learn, no download).
+import numpy as np
+import pandas as pd
+from sklearn.datasets import load_breast_cancer
+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
+
+MIN_ACCURACY = 0.70  # below this you get to choose the columns yourself
+TARGET_NAMES = {"target", "label", "labels", "class", "output", "outcome", "result", "y"}
+
+
+# ---------- helpers ----------
+def read_csv(path):
+    """Read a CSV with any separator (, ; tab |) and encoding."""
+    with open(path, encoding="latin-1") as f:
+        first_line = f.readline()
+    sep = max([",", ";", "\t", "|"], key=first_line.count)
+    try:
+        df = pd.read_csv(path, sep=sep)
+    except UnicodeDecodeError:
+        df = pd.read_csv(path, sep=sep, encoding="latin-1")
+    df = df.loc[:, ~df.columns.astype(str).str.startswith("Unnamed")]
+    return df.dropna(axis=1, how="all")
+
+
+def is_id(col):
+    name = str(col.name).lower()
+    return (name in ("id", "index") or name.endswith("_id")
+            or (pd.api.types.is_integer_dtype(col) and col.nunique() == len(col)))
+
+
+def guess_target(df):
+    for c in df.columns:
+        if str(c).lower() in TARGET_NAMES:
+            return c
+    return [c for c in df.columns if not is_id(df[c]) and df[c].nunique() >= 2][-1]
+
+
+def make_labels(col):
+    """Numeric columns with many values become High / Low (split at the median)."""
+    if pd.api.types.is_numeric_dtype(col) and col.nunique() > 10:
+        col = pd.Series(np.where(col >= col.median(), "High", "Low"), index=col.index)
+    encoder = LabelEncoder()
+    return encoder.fit_transform(col.astype(str)), [str(c) for c in encoder.classes_]
+
+
+def make_features(X):
+    """Drop ID / constant / free-text columns, fill missing values, one-hot encode."""
+    keep = [c for c in X.columns
+            if not is_id(X[c]) and X[c].nunique() > 1
+            and (pd.api.types.is_numeric_dtype(X[c]) or X[c].nunique() <= 50)]
+    X = X[keep].copy()
+    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])
+    return pd.get_dummies(X, drop_first=True, dtype=int), keep
+
+
+def ask_columns(df, target, dropped):
+    print(f"\nAccuracy is below {MIN_ACCURACY:.0%}. You can choose the columns yourself.")
+    print("Columns:", list(df.columns))
+    new_target = input(f"Target column (Enter to keep '{target}'): ").strip() or target
+    if new_target not in df.columns:
+        print(f"'{new_target}' not found, keeping '{target}'.")
+        new_target = target
+    drop = [c.strip() for c in input("Columns to leave out, comma separated (Enter for none): ").split(",")]
+    drop = [c for c in drop if c in df.columns and c != new_target]
+    changed = new_target != target or set(drop) != set(dropped)
+    return new_target, drop, changed
+
+
+# ---------- 1. Load dataset ----------
+path = input("Enter CSV file path or press Enter for built-in Breast Cancer data: ").strip().strip('"')
+if path:
+    df = read_csv(path)
+else:
+    data = load_breast_cancer(as_frame=True)
+    df = data.frame.copy()
+    df["target"] = data.target_names[data.target]
+    print("Using built-in Breast Cancer dataset")
+print(df.head())
+print("Shape:", df.shape)
+
+target = guess_target(df)
+dropped = []
+
+# ---------- 2. Train (repeats if accuracy is low and you choose other columns) ----------
+while True:
+    data = df.dropna(subset=[target]).drop_duplicates()
+    y, class_names = make_labels(data[target])
+    X, used = make_features(data.drop(columns=[target] + dropped))
+    print(f"\nTarget column: {target} -> classes {class_names}")
+    print("Feature columns used:", used)
+
+    stratify = y if np.bincount(y).min() >= 2 else None
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=42, stratify=stratify
+    )
+    scaler = StandardScaler()
+    X_train = scaler.fit_transform(X_train)
+    X_test = scaler.transform(X_test)
+
+    # 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(len(class_names), activation="softmax"),
+    ])
+    model.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])
+    model.fit(X_train, y_train, epochs=50, batch_size=32, validation_split=0.2, verbose=0,
+              callbacks=[EarlyStopping(monitor="val_loss", patience=5, restore_best_weights=True)])
+
+    test_acc = model.evaluate(X_test, y_test, verbose=0)[1]
+    print(f"Testing Accuracy: {test_acc * 100:.2f}%")
+    if test_acc >= MIN_ACCURACY:
+        break
+    target, dropped, changed = ask_columns(df, target, dropped)
+    if not changed:
+        break
+
+# ---------- 3. Final results ----------
+model.summary()
+train_acc = model.evaluate(X_train, y_train, 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, labels=range(len(class_names)),
+                            target_names=class_names, zero_division=0))
+print("Confusion Matrix:")
+print(confusion_matrix(y_test, y_pred))

libz-0.7/libz/DLG/prac2.py

@@ -0,0 +1,180 @@
+# Regularization and Optimization - works with any CSV classification dataset
+# Compares: no regularization vs L2 + Dropout + Early Stopping,
+# and the optimizers Adam, SGD and RMSprop.
+# The target column and the feature columns are picked automatically.
+# If accuracy is low, you are asked which columns to use and the models are retrained.
+# Press Enter to use the built-in Wine dataset (from scikit-learn, no download).
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from sklearn.datasets import load_wine
+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
+
+MIN_ACCURACY = 0.70  # below this you get to choose the columns yourself
+TARGET_NAMES = {"target", "label", "labels", "class", "output", "outcome", "result", "y"}
+
+
+# ---------- helpers ----------
+def read_csv(path):
+    """Read a CSV with any separator (, ; tab |) and encoding."""
+    with open(path, encoding="latin-1") as f:
+        first_line = f.readline()
+    sep = max([",", ";", "\t", "|"], key=first_line.count)
+    try:
+        df = pd.read_csv(path, sep=sep)
+    except UnicodeDecodeError:
+        df = pd.read_csv(path, sep=sep, encoding="latin-1")
+    df = df.loc[:, ~df.columns.astype(str).str.startswith("Unnamed")]
+    return df.dropna(axis=1, how="all")
+
+
+def is_id(col):
+    name = str(col.name).lower()
+    return (name in ("id", "index") or name.endswith("_id")
+            or (pd.api.types.is_integer_dtype(col) and col.nunique() == len(col)))
+
+
+def guess_target(df):
+    for c in df.columns:
+        if str(c).lower() in TARGET_NAMES:
+            return c
+    return [c for c in df.columns if not is_id(df[c]) and df[c].nunique() >= 2][-1]
+
+
+def make_labels(col):
+    """Numeric columns with many values become High / Low (split at the median)."""
+    if pd.api.types.is_numeric_dtype(col) and col.nunique() > 10:
+        col = pd.Series(np.where(col >= col.median(), "High", "Low"), index=col.index)
+    encoder = LabelEncoder()
+    return encoder.fit_transform(col.astype(str)), [str(c) for c in encoder.classes_]
+
+
+def make_features(X):
+    """Drop ID / constant / free-text columns, fill missing values, one-hot encode."""
+    keep = [c for c in X.columns
+            if not is_id(X[c]) and X[c].nunique() > 1
+            and (pd.api.types.is_numeric_dtype(X[c]) or X[c].nunique() <= 50)]
+    X = X[keep].copy()
+    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])
+    return pd.get_dummies(X, drop_first=True, dtype=int), keep
+
+
+def ask_columns(df, target, dropped):
+    print(f"\nBest accuracy is below {MIN_ACCURACY:.0%}. You can choose the columns yourself.")
+    print("Columns:", list(df.columns))
+    new_target = input(f"Target column (Enter to keep '{target}'): ").strip() or target
+    if new_target not in df.columns:
+        print(f"'{new_target}' not found, keeping '{target}'.")
+        new_target = target
+    drop = [c.strip() for c in input("Columns to leave out, comma separated (Enter for none): ").split(",")]
+    drop = [c for c in drop if c in df.columns and c != new_target]
+    changed = new_target != target or set(drop) != set(dropped)
+    return new_target, drop, changed
+
+
+def build_model(n_inputs, n_classes, regularize, optimizer):
+    reg = l2(0.001) if regularize else None
+    drop = 0.3 if regularize else 0.0
+    model = Sequential([
+        Input(shape=(n_inputs,)),
+        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
+
+
+EXPERIMENTS = [
+    ("No regularization (Adam)", False, "adam"),
+    ("L2 + Dropout + EarlyStop (Adam)", True, "adam"),
+    ("L2 + Dropout + EarlyStop (SGD)", True, "sgd"),
+    ("L2 + Dropout + EarlyStop (RMSprop)", True, "rmsprop"),
+]
+
+# ---------- 1. Load dataset ----------
+path = input("Enter CSV file path or press Enter for built-in Wine data: ").strip().strip('"')
+if path:
+    df = read_csv(path)
+else:
+    data = load_wine(as_frame=True)
+    df = data.frame.copy()
+    df["target"] = data.target_names[data.target]
+    print("Using built-in Wine dataset")
+print(df.head())
+print("Shape:", df.shape)
+
+target = guess_target(df)
+dropped = []
+
+# ---------- 2. Train all experiments (repeats if accuracy is low and you choose other columns) ----------
+while True:
+    data = df.dropna(subset=[target]).drop_duplicates()
+    y, class_names = make_labels(data[target])
+    X, used = make_features(data.drop(columns=[target] + dropped))
+    print(f"\nTarget column: {target} -> classes {class_names}")
+    print("Feature columns used:", used)
+
+    stratify = y if np.bincount(y).min() >= 2 else None
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=42, stratify=stratify
+    )
+    scaler = StandardScaler()
+    X_train = scaler.fit_transform(X_train)
+    X_test = scaler.transform(X_test)
+
+    results, histories, models = [], {}, {}
+    for name, regularize, optimizer in EXPERIMENTS:
+        print("Training:", name)
+        model = build_model(X_train.shape[1], len(class_names), 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
+
+    results_df = pd.DataFrame(results, columns=["Model", "Train Acc", "Test Acc", "Epochs"])
+    best_acc = results_df["Test Acc"].max() / 100
+    print(f"Best Test Accuracy: {best_acc * 100:.2f}%")
+    if best_acc >= MIN_ACCURACY:
+        break
+    target, dropped, changed = ask_columns(df, target, dropped)
+    if not changed:
+        break
+
+# ---------- 3. Compare results ----------
+print("\nComparison:")
+print(results_df.round(2).to_string(index=False))
+
+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()
+
+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, labels=range(len(class_names)),
+                            target_names=class_names, zero_division=0))
+print("Confusion Matrix:")
+print(confusion_matrix(y_test, y_pred))