libz 0.6__tar.gz → 0.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libz
-Version: 0.6
+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.6 → libz-0.7}/libz/DLG/__init__.py

@@ -8,8 +8,9 @@ TITLES = {
     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) (any text CSV / sample)",
-    9: "PCA vs linear autoencoder (any numeric CSV / synthetic)",
+    8: "Recursive neural network (tree)",
+    9: "PCA vs linear autoencoder",
 }
 
-register(__name__, globals(), TITLES)
+# prac8 and prac9 show the DL code (no dynamic version needed)
+register(__name__, globals(), TITLES, links={8: "DL", 9: "DL"})

{libz-0.6 → libz-0.7}/libz/DLG/prac1.py

@@ -1,8 +1,10 @@
 # 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
@@ -77,8 +79,14 @@ def ask_columns(df, target, dropped):
 
 
 # ---------- 1. Load dataset ----------
-path = input("Enter CSV file path: ").strip().strip('"')
-df = read_csv(path)
+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)
 

{libz-0.6 → libz-0.7}/libz/DLG/prac2.py

@@ -3,9 +3,11 @@
 # 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
@@ -103,8 +105,14 @@ EXPERIMENTS = [
 ]
 
 # ---------- 1. Load dataset ----------
-path = input("Enter CSV file path: ").strip().strip('"')
-df = read_csv(path)
+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)
 

{libz-0.6 → libz-0.7}/libz/DLG/prac3.py

@@ -3,6 +3,7 @@
 # (only predictions it is confident about) and retrains on the bigger dataset.
 # The text column (longest average text) and the label column are picked automatically.
 # If the semi-supervised accuracy is low, you are asked which columns to use and it retrains.
+# Press Enter instead of a path to use the built-in 20 Newsgroups data (downloaded once, cached).
 import numpy as np
 import pandas as pd
 from sklearn.model_selection import train_test_split
@@ -96,8 +97,20 @@ def train_model(X, y, n_classes):
 
 
 # ---------- 1. Load dataset ----------
-path = input("Enter CSV file path: ").strip().strip('"')
-df = read_csv(path)
+# Press Enter for the built-in 20 Newsgroups data (rec.autos vs sci.space).
+# It is downloaded once (~14 MB) and then cached by scikit-learn.
+path = input("Enter CSV file path or press Enter for built-in 20 Newsgroups data "
+             "(downloads once, ~14 MB): ").strip().strip('"')
+if path:
+    df = read_csv(path)
+else:
+    from sklearn.datasets import fetch_20newsgroups
+    news = fetch_20newsgroups(subset="all", categories=["rec.autos", "sci.space"],
+                              remove=("headers", "footers", "quotes"))
+    df = pd.DataFrame({"text": news.data,
+                       "label": [news.target_names[t] for t in news.target]})
+    df = df[df["text"].str.strip() != ""].reset_index(drop=True)  # drop empty posts
+    print("Using built-in 20 Newsgroups dataset (rec.autos vs sci.space)")
 print(df.head())
 print("Shape:", df.shape)
 

{libz-0.6 → libz-0.7}/libz/DLG/prac4.py

@@ -2,6 +2,7 @@
 # One shared network predicts several target columns at the same time.
 # The target columns and the feature columns are picked automatically.
 # If average accuracy is low, you are asked which columns to use and the model is retrained.
+# Press Enter instead of a path to use the built-in scikit-learn Breast Cancer data (offline).
 import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
@@ -78,8 +79,20 @@ def ask_columns(df, targets, dropped):
 
 
 # ---------- 1. Load dataset ----------
-path = input("Enter CSV file path: ").strip().strip('"')
-df = read_csv(path)
+path = input("Enter CSV file path or press Enter for built-in Breast Cancer data: ").strip().strip('"')
+if path:
+    df = read_csv(path)
+else:
+    # Built-in scikit-learn data (offline). Three tasks are derived from its columns;
+    # the source columns are then dropped so the targets are not leaked as features.
+    from sklearn.datasets import load_breast_cancer
+    cancer = load_breast_cancer(as_frame=True)
+    df = cancer.frame.copy()
+    df["diagnosis"] = [cancer.target_names[t] for t in df["target"]]  # malignant / benign
+    df["large_tumour"] = np.where(df["mean area"] >= df["mean area"].median(), "yes", "no")
+    df["smooth_surface"] = np.where(df["mean smoothness"] <= df["mean smoothness"].median(), "yes", "no")
+    df = df.drop(columns=["target", "mean area", "mean smoothness"])
+    print("Using built-in Breast Cancer dataset (tasks: diagnosis, large_tumour, smooth_surface)")
 print(df.head())
 print("Shape:", df.shape)
 

{libz-0.6 → libz-0.7}/libz/__init__.py

@@ -1,5 +1,8 @@
 """libz - a lightweight Python utility toolkit."""
 from libz import AWT, DL, DLG, BIO, BDA
+from libz._update import check_for_update
 
-__version__ = "0.6"
+__version__ = "0.7"
 __all__ = ["AWT", "DL", "DLG", "BIO", "BDA"]
+
+check_for_update(__version__)

{libz-0.6 → libz-0.7}/libz/_core.py

@@ -2,9 +2,14 @@ import os
 import re
 
 
-def register(module_name, namespace, titles=None):
-    """Register the functions of a module."""
+def register(module_name, namespace, titles=None, links=None):
+    """Register the functions of a module.
+
+    links maps a number to another subject's file, e.g. {8: "DL"} makes prac8
+    show DL/prac8.py, so both always print the same code.
+    """
     titles = titles or {}
+    links = links or {}
     folder = os.path.dirname(namespace["__file__"])
     subject = module_name.split(".")[-1]
     numbers = sorted(
@@ -12,9 +17,11 @@ def register(module_name, namespace, titles=None):
         for m in (re.fullmatch(r"prac(\d+)\.py", f) for f in os.listdir(folder))
         if m
     )
+    numbers = sorted(set(numbers) | set(links))
 
     def make(n):
-        path = os.path.join(folder, "prac{}.py".format(n))
+        source = os.path.join(os.path.dirname(folder), links[n]) if n in links else folder
+        path = os.path.join(source, "prac{}.py".format(n))
 
         def prac():
             with open(path, encoding="utf-8") as f:

libz-0.7/libz/_update.py

@@ -0,0 +1,47 @@
+"""Tell the user when a newer libz is on PyPI (checked at most once a day)."""
+import json
+import os
+import sys
+import time
+from urllib.request import urlopen
+
+PYPI_URL = "https://pypi.org/pypi/libz/json"
+CACHE_FILE = os.path.join(os.path.expanduser("~"), ".libz_update_check.json")
+CHECK_EVERY = 24 * 60 * 60  # seconds
+TIMEOUT = 1.5  # seconds to wait for PyPI
+
+
+def _as_tuple(version):
+    return tuple(int(part) for part in version.split(".") if part.isdigit())
+
+
+def _latest_version():
+    """Latest version on PyPI, using the saved answer if it is less than a day old."""
+    try:
+        with open(CACHE_FILE) as f:
+            cache = json.load(f)
+        if time.time() - cache["checked"] < CHECK_EVERY:
+            return cache["latest"]
+    except (OSError, ValueError, KeyError):
+        pass
+
+    with urlopen(PYPI_URL, timeout=TIMEOUT) as response:
+        latest = json.load(response)["info"]["version"]
+    try:
+        with open(CACHE_FILE, "w") as f:
+            json.dump({"checked": time.time(), "latest": latest}, f)
+    except OSError:
+        pass
+    return latest
+
+
+def check_for_update(current):
+    if os.environ.get("LIBZ_NO_UPDATE_CHECK"):
+        return
+    try:
+        latest = _latest_version()
+        if _as_tuple(latest) > _as_tuple(current):
+            print("libz {} is available (you have {}). Update with: pip install -U libz".format(latest, current),
+                  file=sys.stderr)
+    except Exception:
+        pass  # offline or PyPI unreachable: never get in the way

{libz-0.6 → libz-0.7}/libz.egg-info/PKG-INFO

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

{libz-0.6 → libz-0.7}/libz.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ README.md
 pyproject.toml
 libz/__init__.py
 libz/_core.py
+libz/_update.py
 libz.egg-info/PKG-INFO
 libz.egg-info/SOURCES.txt
 libz.egg-info/dependency_links.txt
@@ -56,6 +57,4 @@ libz/DLG/prac3.py
 libz/DLG/prac4.py
 libz/DLG/prac5.py
 libz/DLG/prac6.py
-libz/DLG/prac7.py
-libz/DLG/prac8.py
-libz/DLG/prac9.py
+libz/DLG/prac7.py

{libz-0.6 → libz-0.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "libz"
-version = "0.6"
+version = "0.7"
 description = "A lightweight Python utility toolkit."
 readme = "README.md"
 requires-python = ">=3.7"

libz-0.6/libz/DL/prac8.py

@@ -1,114 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.optim as optim
-
-# 1. DEFINE RECURSIVE NEURAL NETWORK
-class RecursiveNN(nn.Module):
-
-    def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes):
-        super().__init__()
-
-        # Convert word IDs into vectors
-        self.embedding = nn.Embedding(vocab_size, hidden_dim)
-
-        # Combine left and right child representations
-        self.composition = nn.Linear(hidden_dim * 2, hidden_dim)
-
-        # Classify the final tree representation
-        self.classifier = nn.Linear(hidden_dim, num_classes)
-
-    def forward(self, tree):
-
-        # If the node is a leaf (word ID)
-        if isinstance(tree, int):
-            word = torch.tensor(tree, dtype=torch.long)
-            return self.embedding(word)
-
-        # Recursively process left and right children
-        left_vector = self.forward(tree[0])
-        right_vector = self.forward(tree[1])
-
-        # Combine both child vectors
-        combined = torch.cat((left_vector, right_vector))
-
-        # Generate parent representation
-        parent_vector = torch.tanh(
-            self.composition(combined)
-        )
-        return parent_vector
-
-# 2. CREATE SAMPLE TREE DATA
-# Label 1 = Positive sentiment
-# Label 0 = Negative sentiment
-training_data = [
-    (((10, 25), (4, 82)), 1),  # Positive: "the movie was great"
-    (((10, 25), (4, 50)), 0),  # Negative: "the movie was terrible"
-    ((82, 25), 1),             # Positive: "great movie"
-    ((50, 25), 0)              # Negative: "terrible movie"
-]
-
-# 3. INITIALIZE MODEL
-model = RecursiveNN(
-    vocab_size=100,
-    embed_dim=16,
-    hidden_dim=16,
-    num_classes=2
-)
-
-# 4. DEFINE LOSS AND OPTIMIZER
-optimizer = optim.Adam(
-    model.parameters(),
-    lr=0.05
-)
-criterion = nn.CrossEntropyLoss()
-
-# 5. TRAIN THE MODEL
-print("Starting training...")
-for epoch in range(20):
-    total_loss = 0
-
-    for tree, label in training_data:
-        optimizer.zero_grad()
-
-        # Generate representation of the complete tree
-        root_vector = model(tree)
-
-        # Predict sentiment from the root vector
-        logits = model.classifier(root_vector).unsqueeze(0)
-
-        # Actual label
-        target = torch.tensor([label], dtype=torch.long)
-
-        # Calculate loss and update parameters
-        loss = criterion(logits, target)
-
-        loss.backward()
-        optimizer.step()
-
-        total_loss += loss.item()
-
-    if (epoch + 1) % 5 == 0:
-        print(
-            f"Epoch {epoch + 1:02d}/20 | "
-            f"Loss: {total_loss:.4f}"
-        )
-
-# 6. TEST THE TRAINED MODEL
-print("\nTesting trained model:")
-model.eval()
-
-with torch.no_grad():
-    for tree, label in training_data:
-
-        root_vector = model(tree)
-        logits = model.classifier(root_vector)
-
-        prediction = torch.argmax(logits, dim=-1).item()
-
-        actual = "Positive" if label == 1 else "Negative"
-        predicted = "Positive" if prediction == 1 else "Negative"
-
-        print("Tree:", tree)
-        print("Actual sentiment:", actual)
-        print("Predicted sentiment:", predicted)
-        print("-" * 40)

libz-0.6/libz/DL/prac9.py

@@ -1,158 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.optim as optim
-import numpy as np
-import matplotlib.pyplot as plt
-
-from sklearn.decomposition import PCA
-from sklearn.datasets import make_blobs
-
-# 1. GENERATE SYNTHETIC DATA
-X_np, _ = make_blobs(
-    n_samples=1000,
-    n_features=10,
-    centers=3,
-    random_state=42
-)
-
-X_tensor = torch.tensor(X_np, dtype=torch.float32)
-print("Original data shape:", X_np.shape)
-
-# 2. APPROACH A: PCA
-pca = PCA(n_components=3)
-X_pca = pca.fit_transform(X_np)
-
-print("\nPCA Output Shape:", X_pca.shape)
-print(
-    "PCA Explained Variance Ratio:",
-    pca.explained_variance_ratio_
-)
-
-print(
-    "Total Explained Variance:",
-    round(pca.explained_variance_ratio_.sum(), 4)
-)
-
-# 3. DEFINE LINEAR AUTOENCODER
-class LinearAutoencoder(nn.Module):
-    def __init__(self, input_dim, latent_dim):
-        super().__init__()
-
-        # Encoder reduces dimensions
-        self.encoder = nn.Linear(
-            input_dim,
-            latent_dim,
-            bias=False
-        )
-
-        # Decoder reconstructs original dimensions
-        self.decoder = nn.Linear(
-            latent_dim,
-            input_dim,
-            bias=True
-        )
-
-    def forward(self, x):
-        h = self.encoder(x)
-        x_recon = self.decoder(h)
-        return x_recon, h
-
-# 4. SET HYPERPARAMETERS
-input_dim = 10
-latent_dim = 3
-
-model = LinearAutoencoder(
-    input_dim,
-    latent_dim
-)
-
-criterion = nn.MSELoss()
-
-optimizer = optim.Adam(
-    model.parameters(),
-    lr=0.01
-)
-
-# 5. TRAIN THE AUTOENCODER
-model.train()
-for epoch in range(200):
-    optimizer.zero_grad()
-
-    reconstructions, latent_factors = model(X_tensor)
-    loss = criterion(
-        reconstructions,
-        X_tensor
-    )
-
-    loss.backward()
-    optimizer.step()
-
-    if (epoch + 1) % 50 == 0:
-        print(
-            f"Epoch [{epoch + 1}/200], "
-            f"Reconstruction MSE Loss: {loss.item():.4f}"
-        )
-
-# 6. EXTRACT LEARNED FACTORS
-model.eval()
-with torch.no_grad():
-    reconstructions, latent_factors = model(X_tensor)
-    latent_factors = latent_factors.numpy()
-    reconstructions = reconstructions.numpy()
-    W = model.decoder.weight.detach().numpy()
-
-print(
-    "\nAutoencoder Latent Shape:",
-    latent_factors.shape
-)
-
-print(
-    "Factor Loading Matrix Shape:",
-    W.shape
-)
-
-# 7. COMPARE RECONSTRUCTION ERROR
-pca_reconstructed = pca.inverse_transform(X_pca)
-pca_mse = np.mean(
-    (X_np - pca_reconstructed) ** 2
-)
-
-ae_mse = np.mean(
-    (X_np - reconstructions) ** 2
-)
-
-print(
-    "\nPCA Reconstruction MSE:",
-    round(pca_mse, 4)
-)
-
-print(
-    "Autoencoder Reconstruction MSE:",
-    round(ae_mse, 4)
-)
-
-# 8. PLOT PCA EXPLAINED VARIANCE
-plt.figure(figsize=(7, 4))
-plt.bar(
-    range(1, 4),
-    pca.explained_variance_ratio_
-)
-
-plt.title("PCA Explained Variance Ratio")
-plt.xlabel("Principal Component")
-plt.ylabel("Explained Variance Ratio")
-plt.xticks([1, 2, 3])
-plt.grid(axis="y")
-plt.show()
-
-# 9. PLOT RECONSTRUCTION ERROR COMPARISON
-plt.figure(figsize=(7, 4))
-plt.bar(
-    ["PCA", "Linear Autoencoder"],
-    [pca_mse, ae_mse]
-)
-
-plt.title("Reconstruction Error Comparison")
-plt.ylabel("Mean Squared Error")
-plt.grid(axis="y")
-plt.show()

libz-0.6/libz/DLG/prac8.py

@@ -1,231 +0,0 @@
-# Recursive Neural Network (tree structured) for sentence classification - any text CSV
-# Every sentence is turned into a binary tree automatically (split in halves),
-# and the network combines child vectors bottom-up until it reaches the root.
-# The text column (longest text) and the label column are picked automatically,
-# and the words kept per sentence adapt to the data (95th percentile, max 30).
-# If accuracy is low, you are asked which columns to use and the model is retrained.
-# Press Enter to use a small built-in sentiment dataset.
-import re
-import math
-import random
-
-import pandas as pd
-import torch
-import torch.nn as nn
-import torch.optim as optim
-
-random.seed(42)
-torch.manual_seed(42)
-
-SAMPLE = [
-    ("the movie was great", "Positive"),
-    ("the movie was terrible", "Negative"),
-    ("great movie", "Positive"),
-    ("terrible movie", "Negative"),
-    ("i loved the acting", "Positive"),
-    ("i hated the acting", "Negative"),
-    ("the story was wonderful and fun", "Positive"),
-    ("the story was boring and slow", "Negative"),
-    ("what a fantastic film", "Positive"),
-    ("what an awful film", "Negative"),
-    ("really enjoyed it", "Positive"),
-    ("really disliked it", "Negative"),
-]
-MAX_SAMPLES = 2000   # recursive training is slow, so large files are sampled
-MAX_WORDS = 30       # upper limit of words kept per sentence
-MIN_ACCURACY = 0.70  # below this you get to choose the columns yourself
-TARGET_NAMES = {"target", "label", "labels", "class", "output", "outcome", "result", "y",
-                "sentiment", "category"}
-EPOCHS = 20
-
-
-# ---------- 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 guess_text_label(df):
-    """Text = non-numeric column with the longest average text.
-    Label = a column named like a target, else one with 2..20 unique values, else the first other column."""
-    text_cols = [c for c in df.columns if not pd.api.types.is_numeric_dtype(df[c])]
-    if not text_cols:
-        return None, None
-    text = max(text_cols, key=lambda c: df[c].dropna().astype(str).str.len().mean())
-    others = [c for c in df.columns if c != text]
-    for c in others:
-        if str(c).lower() in TARGET_NAMES:
-            return text, c
-    for c in others:
-        if 2 <= df[c].nunique() <= 20:
-            return text, c
-    return text, others[0]
-
-
-def ask_columns(df, text, label):
-    print(f"\nAccuracy is below {MIN_ACCURACY:.0%}. You can choose the columns yourself.")
-    print("Columns:", list(df.columns))
-    new_text = input(f"Text column (Enter to keep '{text}'): ").strip() or text
-    if new_text not in df.columns:
-        print(f"'{new_text}' not found, keeping '{text}'.")
-        new_text = text
-    new_label = input(f"Label column (Enter to keep '{label}'): ").strip() or label
-    if new_label not in df.columns or new_label == new_text:
-        print(f"'{new_label}' cannot be used, keeping '{label}'.")
-        new_label = label
-    changed = new_text != text or new_label != label
-    return new_text, new_label, changed
-
-
-def tokenize(text, max_words=MAX_WORDS):
-    return re.findall(r"[a-z0-9']+", str(text).lower())[:max_words]
-
-
-def words_limit(texts):
-    """95th percentile of sentence lengths, but never more than MAX_WORDS."""
-    lengths = [len(tokenize(t, None)) for t in texts]
-    lengths = [n for n in lengths if n > 0] or [1]
-    p95 = math.ceil(pd.Series(lengths).quantile(0.95))
-    return max(1, min(MAX_WORDS, p95))
-
-
-def build_tree(ids):
-    """[w1, w2, w3, w4] -> ((w1, w2), (w3, w4))"""
-    if len(ids) == 1:
-        return ids[0]
-    mid = len(ids) // 2
-    return (build_tree(ids[:mid]), build_tree(ids[mid:]))
-
-
-# ---------- Recursive Neural Network ----------
-class RecursiveNN(nn.Module):
-    def __init__(self, vocab_size, hidden_dim, num_classes):
-        super().__init__()
-        self.embedding = nn.Embedding(vocab_size, hidden_dim)
-        self.composition = nn.Linear(hidden_dim * 2, hidden_dim)
-        self.classifier = nn.Linear(hidden_dim, num_classes)
-
-    def encode(self, tree):
-        if isinstance(tree, int):  # leaf = word
-            return self.embedding(torch.tensor(tree))
-        left = self.encode(tree[0])
-        right = self.encode(tree[1])
-        return torch.tanh(self.composition(torch.cat((left, right))))
-
-    def forward(self, tree):
-        return self.classifier(self.encode(tree))
-
-
-def predict(model, tree):
-    with torch.no_grad():
-        return model(tree).argmax().item()
-
-
-# ---------- 1. Load data ----------
-path = input("Enter CSV file path or press Enter for sample data: ").strip().strip('"')
-if path:
-    df = read_csv(path)
-    print(df.head())
-    print("Shape:", df.shape)
-    if df.shape[1] < 2:
-        raise SystemExit("The CSV needs at least a text column and a label column.")
-    text_col, label_col = guess_text_label(df)
-    if text_col is None:
-        print("\nNo text (non-numeric) column was found. Please choose the columns yourself.")
-        print("Columns:", list(df.columns))
-        text_col = input("Text column: ").strip()
-        if text_col not in df.columns:
-            print(f"'{text_col}' not found, using '{df.columns[0]}'.")
-            text_col = df.columns[0]
-        label_col = input("Label column: ").strip()
-        if label_col not in df.columns or label_col == text_col:
-            label_col = [c for c in df.columns if c != text_col][0]
-            print(f"Using '{label_col}' as label column.")
-
-# ---------- 2. Train (repeats if accuracy is low and you choose other columns) ----------
-while True:
-    if path:
-        sub = df[[text_col, label_col]].dropna()
-        pairs = list(zip(sub[text_col].astype(str), sub[label_col].astype(str)))
-        random.shuffle(pairs)
-        pairs = pairs[:MAX_SAMPLES]
-        print(f"\nText column: {text_col} | Label column: {label_col}")
-    else:
-        pairs = SAMPLE
-
-    max_words = words_limit([t for t, _ in pairs])
-    class_names = sorted(set(label for _, label in pairs))
-    data = [(tokenize(t, max_words), class_names.index(l)) for t, l in pairs]
-    data = [(words, l) for words, l in data if words]
-    print("Classes:", class_names)
-    print("Words kept per sentence:", max_words)
-
-    if not data:
-        print("No usable sentences in this column.")
-        text_col, label_col, changed = ask_columns(df, text_col, label_col)
-        if not changed:
-            raise SystemExit("Nothing to train on.")
-        continue
-
-    # Vocabulary and trees
-    vocab = {"<unk>": 0}
-    for words, _ in data:
-        for w in words:
-            vocab.setdefault(w, len(vocab))
-
-    trees = [(build_tree([vocab[w] for w in words]), label) for words, label in data]
-    split = int(len(trees) * 0.8)
-    train_data, test_data = (trees, trees) if len(trees) < 50 else (trees[:split], trees[split:])
-    print("Vocabulary size:", len(vocab), "| Train:", len(train_data), "| Test:", len(test_data))
-    print("Example tree:", train_data[0][0])
-
-    model = RecursiveNN(len(vocab), hidden_dim=32, num_classes=len(class_names))
-    optimizer = optim.Adam(model.parameters(), lr=0.01)
-    criterion = nn.CrossEntropyLoss()
-
-    for epoch in range(EPOCHS):
-        model.train()
-        random.shuffle(train_data)
-        total_loss = 0
-        for tree, label in train_data:
-            optimizer.zero_grad()
-            loss = criterion(model(tree).unsqueeze(0), torch.tensor([label]))
-            loss.backward()
-            optimizer.step()
-            total_loss += loss.item()
-        if (epoch + 1) % 5 == 0:
-            print(f"Epoch {epoch + 1:02d}/{EPOCHS} | Loss: {total_loss / len(train_data):.4f}")
-
-    model.eval()
-    test_acc = sum(predict(model, tree) == label for tree, label in test_data) / len(test_data)
-    print(f"Test Accuracy: {test_acc * 100:.2f}%")
-    if not path or test_acc >= MIN_ACCURACY:
-        break
-    text_col, label_col, changed = ask_columns(df, text_col, label_col)
-    if not changed:
-        break
-
-# ---------- 3. Final results ----------
-print(f"\nTest Accuracy: {test_acc * 100:.2f}%")
-
-print("\nSample predictions:")
-for tree, label in test_data[:5]:
-    print("Tree:", tree)
-    print("Actual:", class_names[label], "| Predicted:", class_names[predict(model, tree)])
-    print("-" * 40)
-
-# ---------- 4. Classify your own sentence ----------
-sentence = input("Type a sentence to classify (Enter to skip): ").strip()
-if sentence:
-    ids = [vocab.get(w, 0) for w in tokenize(sentence, max_words)] or [0]
-    tree = build_tree(ids)
-    print("Tree:", tree)
-    print("Predicted:", class_names[predict(model, tree)])

libz-0.6/libz/DLG/prac9.py

@@ -1,132 +0,0 @@
-# PCA vs Linear Autoencoder - works with any numeric CSV
-# Both reduce the data to k dimensions; a linear autoencoder learns the same
-# subspace as PCA, so their reconstruction errors should be almost equal.
-# The numeric columns are picked automatically (ID-like, constant and text columns
-# are dropped, missing values filled with the median), and k is chosen automatically
-# as the smallest number of components that explains at least 90% of the variance.
-# Press Enter to use synthetic data.
-import numpy as np
-import pandas as pd
-import matplotlib.pyplot as plt
-from sklearn.decomposition import PCA
-from sklearn.datasets import make_blobs
-from sklearn.preprocessing import StandardScaler
-from tensorflow.keras.models import Sequential
-from tensorflow.keras.layers import Input, Dense
-from tensorflow.keras.optimizers import Adam
-
-VARIANCE_TO_KEEP = 0.90  # k = fewest components explaining at least this much variance
-
-
-# ---------- 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 numeric_features(df):
-    """Keep numeric, non-ID, non-constant columns and fill missing values with the median."""
-    keep = [c for c in df.columns
-            if pd.api.types.is_numeric_dtype(df[c]) and not is_id(df[c]) and df[c].nunique() > 1]
-    X = df[keep].copy()
-    return X.fillna(X.median()), keep
-
-
-# 1. Load data
-path = input("Enter CSV file path or press Enter for synthetic data: ").strip().strip('"')
-if path:
-    df = read_csv(path)
-    print(df.head())
-    print("Shape:", df.shape)
-    df, used = numeric_features(df)
-    print("Numeric columns used:", used)
-    if len(used) < 2:
-        raise SystemExit("PCA needs at least 2 usable numeric columns - this CSV does not have them.")
-    X = df.values
-else:
-    X, _ = make_blobs(n_samples=1000, n_features=10, centers=3, random_state=42)
-
-X = StandardScaler().fit_transform(X).astype("float32")
-n_features = X.shape[1]
-
-# Choose k automatically from a full PCA
-cumulative = np.cumsum(PCA().fit(X).explained_variance_ratio_)
-k = int(np.searchsorted(cumulative, VARIANCE_TO_KEEP - 1e-9) + 1)
-k = max(1, min(k, n_features))
-print(f"Using {k} components (explains {cumulative[k - 1] * 100:.2f}% of variance)")
-print("Data shape:", X.shape, "| Components:", k)
-
-# 2. PCA
-pca = PCA(n_components=k)
-X_pca = pca.fit_transform(X)
-pca_mse = np.mean((X - pca.inverse_transform(X_pca)) ** 2)
-print("\nPCA Explained Variance Ratio:", pca.explained_variance_ratio_.round(4))
-print("Total Explained Variance:", round(pca.explained_variance_ratio_.sum(), 4))
-
-# 3. Linear autoencoder: n_features -> k -> n_features, no activation functions
-autoencoder = Sequential([
-    Input(shape=(n_features,)),
-    Dense(k, use_bias=False, name="encoder"),
-    Dense(n_features, name="decoder"),
-])
-autoencoder.compile(optimizer=Adam(learning_rate=0.01), loss="mse")
-history = autoencoder.fit(X, X, epochs=200, batch_size=64, verbose=0)
-
-encoder = Sequential([Input(shape=(n_features,)), autoencoder.get_layer("encoder")])
-latent = encoder.predict(X, verbose=0)
-ae_mse = np.mean((X - autoencoder.predict(X, verbose=0)) ** 2)
-print("\nAutoencoder latent shape:", latent.shape)
-print("Decoder weight (factor loading) shape:", autoencoder.get_layer("decoder").get_weights()[0].shape)
-
-# 4. Compare
-print(f"\nPCA Reconstruction MSE:         {pca_mse:.4f}")
-print(f"Autoencoder Reconstruction MSE: {ae_mse:.4f}")
-
-# 5. Plots
-plt.figure(figsize=(7, 4))
-plt.plot(history.history["loss"])
-plt.axhline(pca_mse, color="red", linestyle="--", label="PCA MSE")
-plt.title("Autoencoder Training Loss")
-plt.xlabel("Epoch")
-plt.ylabel("MSE")
-plt.legend()
-plt.grid(True)
-plt.show()
-
-plt.figure(figsize=(7, 4))
-plt.bar(range(1, k + 1), pca.explained_variance_ratio_)
-plt.title("PCA Explained Variance Ratio")
-plt.xlabel("Principal Component")
-plt.ylabel("Explained Variance Ratio")
-plt.grid(axis="y")
-plt.show()
-
-plt.figure(figsize=(7, 4))
-plt.bar(["PCA", "Linear Autoencoder"], [pca_mse, ae_mse])
-plt.title("Reconstruction Error Comparison")
-plt.ylabel("Mean Squared Error")
-plt.grid(axis="y")
-plt.show()
-
-if k >= 2:
-    fig, axes = plt.subplots(1, 2, figsize=(11, 4))
-    axes[0].scatter(X_pca[:, 0], X_pca[:, 1], s=8)
-    axes[0].set_title("PCA: first 2 components")
-    axes[1].scatter(latent[:, 0], latent[:, 1], s=8, color="orange")
-    axes[1].set_title("Autoencoder: first 2 latent factors")
-    plt.tight_layout()
-    plt.show()