libz 0.2__tar.gz → 0.4__tar.gz

{libz-0.2 → libz-0.4}/PKG-INFO

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

libz-0.4/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.4/libz/DL/prac1.py

@@ -0,0 +1,127 @@
+
+# 1. Import Libraries
+import pandas as pd
+
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import classification_report, confusion_matrix
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Dense, Dropout
+from tensorflow.keras.callbacks import EarlyStopping
+
+# 2. Load Dataset
+df = pd.read_csv("/content/Depression Student Dataset.csv")
+
+# 3. Data Preprocessing
+# Remove unnamed columns
+df = df.loc[:, ~df.columns.str.contains("^Unnamed")]
+
+# Drop ID column if it exists
+df.drop(columns=["id"], inplace=True, errors="ignore")
+
+# Handle missing values
+for col in df.columns:
+    if df[col].isnull().any():
+        if pd.api.types.is_numeric_dtype(df[col]):
+            df[col] = df[col].fillna(df[col].median())
+        else:
+            df[col] = df[col].fillna(df[col].mode()[0])
+
+# Encode target variable
+df["Depression"] = df["Depression"].map({
+    "No": 0,
+    "Yes": 1
+})
+
+# Encode categorical input features
+X = pd.get_dummies(
+    df.drop("Depression", axis=1),
+    drop_first=True,
+    dtype=int
+)
+y = df["Depression"]
+
+# 4. Train-Test Split
+X_train, X_test, y_train, y_test = train_test_split(
+    X,
+    y,
+    test_size=0.20,
+    random_state=42,
+    stratify=y
+)
+
+# 5. Feature Scaling
+scaler = StandardScaler()
+X_train = scaler.fit_transform(X_train)
+X_test = scaler.transform(X_test)
+
+# 6. Build Feedforward Neural Network
+model = Sequential([
+    Dense(
+        128,
+        activation="relu",
+        input_shape=(X_train.shape[1],)
+    ),
+    Dropout(0.30),
+    Dense(64, activation="relu"),
+    Dropout(0.20),
+    Dense(32, activation="relu"),
+    Dense(1, activation="sigmoid")
+])
+
+# 7. Compile Model
+model.compile(
+    optimizer="adam",
+    loss="binary_crossentropy",
+    metrics=["accuracy"]
+)
+
+# 8. Early Stopping
+early_stop = EarlyStopping(
+    monitor="val_loss",
+    patience=5,
+    restore_best_weights=True
+)
+
+# 9. Train Model
+history = model.fit(
+    X_train,
+    y_train,
+    epochs=50,
+    batch_size=32,
+    validation_split=0.20,
+    callbacks=[early_stop],
+    verbose=1
+)
+
+
+# 10. Evaluate Model
+test_loss, test_accuracy = model.evaluate(
+    X_test,
+    y_test,
+    verbose=0
+)
+
+# Predict probabilities and classes
+y_pred_prob = model.predict(X_test, verbose=0)
+y_pred = (
+    y_pred_prob >= 0.5
+).astype(int).ravel()
+
+# 11. Display Results
+# Calculate training accuracy
+train_accuracy = model.evaluate(
+    X_train,
+    y_train,
+    verbose=0
+)[1]
+print(f"Training Accuracy: {train_accuracy * 100:.2f}%")
+print(f"Testing Accuracy: {test_accuracy * 100:.2f}%")
+
+# Classification Report
+print("\nClassification Report:")
+print(classification_report(y_test, y_pred))
+
+# Confusion Matrix
+print("Confusion Matrix:")
+print(confusion_matrix(y_test, y_pred))

libz-0.4/libz/DL/prac2.py

@@ -0,0 +1,149 @@
+# 1. Import Libraries
+import warnings
+warnings.filterwarnings("ignore")
+
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+import tensorflow as tf
+
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder, StandardScaler, OneHotEncoder
+from sklearn.impute import SimpleImputer
+from sklearn.compose import ColumnTransformer
+from sklearn.pipeline import Pipeline
+from sklearn.metrics import (
+    accuracy_score,
+    classification_report,
+    confusion_matrix
+)
+
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Input, Dense, Dropout
+from tensorflow.keras.optimizers import Adam
+from tensorflow.keras.regularizers import l2
+from tensorflow.keras.callbacks import EarlyStopping
+
+# 2. Import SMOTE (Optional)
+try:
+    from imblearn.over_sampling import SMOTE
+    SMOTE_AVAILABLE = True
+except ImportError:
+    SMOTE_AVAILABLE = False
+
+# 3. Load Dataset
+file_path = input(
+    "Enter CSV file path (example: dataset.csv): "
+).strip().strip('"')
+
+try:
+    df = pd.read_csv(file_path)
+except Exception as error:
+    raise SystemExit(f"Could not read CSV: {error}")
+
+# 4. Initial Data Cleaning
+df.columns = [str(col).strip() for col in df.columns]
+
+# Remove completely empty rows and columns
+df = df.dropna(axis=0, how="all")
+df = df.dropna(axis=1, how="all")
+
+# Remove duplicate rows
+df = df.drop_duplicates().reset_index(drop=True)
+if df.empty:
+    raise SystemExit("Dataset is empty.")
+
+# 5. Display Dataset Information
+print("\nDataset shape:", df.shape)
+print("\nColumns:")
+for col in df.columns:
+    print(" -", col)
+print("\nMissing values:\n", df.isnull().sum())
+
+# 6. Select Target Column
+target_col = input(
+    "\nEnter the target/output column to predict: "
+).strip()
+
+if target_col not in df.columns:
+    raise SystemExit(
+        f"Target column '{target_col}' was not found."
+    )
+
+# 7. Clean Target Column
+df = df.dropna(subset=[target_col])
+df = df.drop_duplicates().copy()
+
+if df[target_col].nunique() < 2:
+    raise SystemExit(
+        "Target must contain at least two classes."
+    )
+
+# 8. Clean String Values
+for col in df.select_dtypes(
+    include=["object", "string"]
+).columns:
+    df[col] = df[col].map(
+        lambda value: value.strip()
+        if isinstance(value, str)
+        else value
+    )
+
+# 9. Display Target Distribution
+print("\nTarget distribution:\n")
+print(df[target_col].value_counts())
+plt.figure(figsize=(8, 4))
+df[target_col].astype(str).value_counts().plot(
+    kind="bar"
+)
+
+plt.title(f"Class Distribution: {target_col}")
+plt.xlabel("Class")
+plt.ylabel("Count")
+plt.tight_layout()
+plt.show()
+
+# 10. Separate Features and Target
+X = df.drop(columns=[target_col]).copy()
+y_original = df[target_col].copy()
+
+if X.shape[1] == 0:
+    raise SystemExit("No feature columns remain.")
+
+# 11. Process Date Columns
+for col in list(X.columns):
+    if pd.api.types.is_datetime64_any_dtype(X[col]):
+        X[f"{col}_year"] = X[col].dt.year
+        X[f"{col}_month"] = X[col].dt.month
+        X[f"{col}_day"] = X[col].dt.day
+        X = X.drop(columns=[col])
+
+# 12. Convert Numeric-Like Object Columns
+for col in X.select_dtypes(
+    include=["object", "string"]
+).columns:
+    converted = pd.to_numeric(
+        X[col],
+        errors="coerce"
+    )
+    if converted.notna().mean() >= 0.90:
+        X[col] = converted
+
+# Remove columns containing only missing values
+X = X.dropna(axis=1, how="all")
+
+# 13. Encode Target Labels
+encoder = LabelEncoder()
+y = encoder.fit_transform(
+    y_original.astype(str)
+)
+
+class_names = [
+    str(value) for value in encoder.classes_
+]
+n_classes = len(class_names)
+
+print("\nTarget class encoding:")
+for index, class_name in enumerate(class_names):
+    print(f"{class_name} -> {index}")

libz-0.4/libz/DL/prac3.py

@@ -0,0 +1,252 @@
+# 1. Import Libraries
+import numpy as np
+import pandas as pd
+
+from sklearn.model_selection import train_test_split
+from sklearn.feature_extraction.text import TfidfVectorizer
+
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Dense, Dropout
+from tensorflow.keras.callbacks import EarlyStopping
+
+# 2. Load and Clean Dataset
+df = pd.read_csv(
+    "/content/spam (1).csv",
+    encoding="latin-1"
+)
+df = df[["v1", "v2"]].copy()
+df.columns = ["label", "text"]
+
+# Remove missing values and duplicate rows
+df.dropna(inplace=True)
+df.drop_duplicates(inplace=True)
+
+# Encode target labels: ham = 0, spam = 1
+df["label"] = df["label"].map({
+    "ham": 0,
+    "spam": 1
+})
+df.dropna(subset=["label"], inplace=True)
+df["label"] = df["label"].astype(int)
+
+# Display dataset information
+print("Dataset Shape:", df.shape)
+print(df.head())
+print("Class Counts:\n", df["label"].value_counts())
+
+# 3. Train-Test Split
+X_train, X_test, y_train, y_test = train_test_split(
+    df["text"],
+    df["label"],
+    test_size=0.20,
+    random_state=42,
+    stratify=df["label"]
+)
+print("Training Samples:", len(X_train))
+print("Testing Samples:", len(X_test))
+
+# 4. TF-IDF Vectorization
+vectorizer = TfidfVectorizer(
+    max_features=5000,
+    stop_words="english"
+)
+
+X_train_nn = vectorizer.fit_transform(
+    X_train
+).toarray().astype(np.float32)
+
+X_test_nn = vectorizer.transform(
+    X_test
+).toarray().astype(np.float32)
+
+# Convert labels to NumPy arrays
+y_train = y_train.to_numpy(dtype=np.float32)
+y_test = y_test.to_numpy(dtype=np.float32)
+print("Training Shape:", X_train_nn.shape)
+print("Testing Shape:", X_test_nn.shape)
+
+# 5. Function to Build Neural Network
+def build_model(dropout=0.5, input_size=None):
+    model = Sequential([
+        Dense(
+            64,
+            activation="relu",
+            input_shape=(input_size,)
+        ),
+        Dropout(dropout),
+
+        Dense(32, activation="relu"),
+        Dropout(dropout),
+
+        Dense(1, activation="sigmoid")
+    ])
+
+    model.compile(
+        optimizer="adam",
+        loss="binary_crossentropy",
+        metrics=["accuracy"]
+    )
+    return model
+
+# Early Stopping Callback
+early_stop = EarlyStopping(
+    monitor="val_loss",
+    patience=3,
+    restore_best_weights=True
+)
+
+# 6. Train Baseline Model on All Labelled Training Data
+model = build_model(
+    dropout=0.5,
+    input_size=X_train_nn.shape[1]
+)
+
+model.fit(
+    X_train_nn,
+    y_train,
+    epochs=20,
+    batch_size=32,
+    validation_split=0.20,
+    callbacks=[early_stop],
+    verbose=1
+)
+
+# Evaluate baseline model
+baseline_loss, baseline_accuracy = model.evaluate(
+    X_test_nn,
+    y_test,
+    verbose=0
+)
+print("Baseline Test Loss:", round(baseline_loss, 4))
+print(
+    "Baseline Test Accuracy:",
+    round(baseline_accuracy * 100, 2),
+    "%"
+)
+
+# 7. Split Training Data into Labelled and Unlabelled
+X_labeled, X_unlabeled, y_labeled, y_unlabeled = train_test_split(
+    X_train_nn,
+    y_train,
+    test_size=0.70,
+    random_state=42,
+    stratify=y_train
+)
+print("Labelled Samples:", len(X_labeled))
+print("Unlabelled Samples:", len(X_unlabeled))
+
+# 8. Weak Augmentation and Train SSL Model
+X_labeled_weak = X_labeled + np.random.normal(
+    loc=0,
+    scale=0.02,
+    size=X_labeled.shape
+).astype(np.float32)
+
+ssl_model = build_model(
+    dropout=0.3,
+    input_size=X_labeled.shape[1]
+)
+
+ssl_model.fit(
+    X_labeled_weak,
+    y_labeled,
+    epochs=20,
+    batch_size=32,
+    validation_split=0.20,
+    callbacks=[early_stop],
+    verbose=1
+)
+
+# 9. Generate Pseudo-Labels for Unlabelled Data
+pseudo_probs = ssl_model.predict(
+    X_unlabeled,
+    verbose=0
+).flatten()
+threshold = 0.90
+
+# Select high-confidence predictions
+mask = (
+    (pseudo_probs >= threshold)
+    | (pseudo_probs <= 1 - threshold)
+)
+
+X_pseudo = X_unlabeled[mask]
+y_pseudo = (
+    pseudo_probs[mask] >= 0.5
+).astype(np.float32)
+
+print("Unlabelled Samples:", len(X_unlabeled))
+print(
+    "High-Confidence Pseudo-Labelled Samples:",
+    len(X_pseudo)
+)
+print(
+    "Remaining Unused Unlabelled Samples:",
+    len(X_unlabeled) - len(X_pseudo)
+)
+
+# 10. Strong Augmentation and Combine Data
+X_pseudo_strong = X_pseudo + np.random.normal(
+    loc=0,
+    scale=0.05,
+    size=X_pseudo.shape
+).astype(np.float32)
+
+# Combine labelled and pseudo-labelled samples
+X_final = np.vstack((
+    X_labeled,
+    X_pseudo_strong
+))
+
+y_final = np.concatenate((
+    y_labeled,
+    y_pseudo
+))
+print("Final Training Samples:", len(X_final))
+print("Final Label Shape:", y_final.shape)
+
+# 11. Train Final Model
+final_model = build_model(
+    dropout=0.3,
+    input_size=X_final.shape[1]
+)
+
+final_model.fit(
+    X_final,
+    y_final,
+    epochs=20,
+    batch_size=32,
+    validation_split=0.20,
+    callbacks=[early_stop],
+    verbose=1
+)
+
+# 12. Evaluate and Compare Models
+ssl_loss, ssl_accuracy = final_model.evaluate(
+    X_test_nn,
+    y_test,
+    verbose=0
+)
+
+print("SSL Test Loss:", round(ssl_loss, 4))
+print(
+    "SSL Test Accuracy:",
+    round(ssl_accuracy * 100, 2),
+    "%"
+)
+
+print(
+    "Baseline Accuracy:",
+    round(baseline_accuracy * 100, 2),
+    "%"
+)
+
+# 13. Compare Model Performance
+if ssl_accuracy > baseline_accuracy:
+    print("Semi-Supervised Learning Improved the Model.")
+
+elif ssl_accuracy < baseline_accuracy:
+    print("Baseline Model Performed Better.")
+
+else:
+    print("Both Models Performed Equally.")