bm-preprocessing 0.6.0__tar.gz → 0.7.0__tar.gz

{bm_preprocessing-0.6.0 → bm_preprocessing-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bm-preprocessing
-Version: 0.6.0
+Version: 0.7.0
 Summary: A package to preprocess text data
 Requires-Python: >=3.8
 Requires-Dist: build>=1.2.2.post1

{bm_preprocessing-0.6.0 → bm_preprocessing-0.7.0}/USAGE.md

@@ -15,7 +15,7 @@ Create a file `example.py`:
 ```python
 # Import modules
 from bm_preprocessing.IR import all
-from bm_preprocessing.DM import adaboost, apriori, bagging, hash, hunts, hunts_test, id3, id3_test, preprocessing
+from bm_preprocessing.DM import adaboost, apriori, bagging, hash, hunts, hunts_test, id3, id3_test, metrics, preprocessing
 
 # Print the source code
 print("=== IR All Module ===")
@@ -45,6 +45,9 @@ print(id3)
 print("\n=== DM ID3 Test Module ===")
 print(id3_test)
 
+print("\n=== DM Metrics Module ===")
+print(metrics)
+
 print("\n=== DM Preprocessing Module ===")
 print(preprocessing)
 ```
@@ -92,6 +95,10 @@ Then in the Python REPL:
 # Prints entire DM/id3.py source code
 >>> print(id3_test)
 # Prints entire DM/id3_test.py source code
+
+>>> from bm_preprocessing.DM import metrics
+>>> print(metrics)
+# Prints entire DM/metrics.py source code
 ```
 
 ---
@@ -108,6 +115,7 @@ python -c "from bm_preprocessing.DM import hunts; print(hunts)"
 python -c "from bm_preprocessing.DM import hunts_test; print(hunts_test)"
 python -c "from bm_preprocessing.DM import id3; print(id3)"
 python -c "from bm_preprocessing.DM import id3_test; print(id3_test)"
+python -c "from bm_preprocessing.DM import metrics; print(metrics)"
 python -c "from bm_preprocessing.DM import preprocessing; print(preprocessing)"
 ```
 
@@ -127,4 +135,5 @@ python -c "from bm_preprocessing.DM import preprocessing; print(preprocessing)"
 | `from bm_preprocessing.DM import hunts_test` | Hunt's decision tree with visualization |
 | `from bm_preprocessing.DM import id3` | ID3 decision tree algorithm |
 | `from bm_preprocessing.DM import id3_test` | ID3 decision tree with visualization |
+| `from bm_preprocessing.DM import metrics` | Classification metrics & curves |
 | `from bm_preprocessing.DM import preprocessing` | Data preprocessing utilities |

{bm_preprocessing-0.6.0 → bm_preprocessing-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bm-preprocessing"
-version = "0.6.0"
+version = "0.7.0"
 description = "A package to preprocess text data"
 readme = "README.md"
 requires-python = ">=3.8"

{bm_preprocessing-0.6.0 → bm_preprocessing-0.7.0}/src/bm_preprocessing/DM/__init__.py

@@ -9,7 +9,8 @@ from .hunts import hunts
 from .hunts_test import hunts_test
 from .id3 import id3
 from .id3_test import id3_test
+from .metrics import metrics
 from .preprocessing import preprocessing
 
-__all__ = ["adaboost", "all", "apriori", "bagging", "hash", "hunts", "hunts_test", "id3", "id3_test", "preprocessing"]
+__all__ = ["adaboost", "all", "apriori", "bagging", "hash", "hunts", "hunts_test", "id3", "id3_test", "metrics", "preprocessing"]
 

bm_preprocessing-0.7.0/src/bm_preprocessing/DM/metrics.py

@@ -0,0 +1,30 @@
+"""Source code loader for DM/metrics.py"""
+
+from pathlib import Path
+
+
+class SourceCodeModule:
+    """A class that displays source code when printed."""
+
+    def __init__(self, name: str, source_path: Path):
+        self.name = name
+        self._source_path = source_path
+        self._source_code = None
+
+    @property
+    def source_code(self) -> str:
+        """Lazily load source code."""
+        if self._source_code is None:
+            self._source_code = self._source_path.read_text(encoding="utf-8")
+        return self._source_code
+
+    def __repr__(self) -> str:
+        return self.source_code
+
+    def __str__(self) -> str:
+        return self.source_code
+
+
+# Get the path to the source file
+_source_file = Path(__file__).parent / "sources" / "metrics.py"
+metrics = SourceCodeModule("DM.metrics", _source_file)

bm_preprocessing-0.7.0/src/bm_preprocessing/DM/sources/metrics.py

@@ -0,0 +1,240 @@
+import numpy as np
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.metrics import (
+    accuracy_score,
+    confusion_matrix,
+    f1_score,
+    precision_score,
+    recall_score,
+    roc_curve,
+    auc,
+    precision_recall_curve,
+    classification_report,
+)
+from sklearn.preprocessing import label_binarize
+import matplotlib.pyplot as plt
+
+# ==========================================
+# Load dataset and train a classifier
+# ==========================================
+
+iris = load_iris()
+X = iris.data
+y = iris.target
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.3, random_state=42, stratify=y
+)
+
+clf = DecisionTreeClassifier(random_state=42)
+clf.fit(X_train, y_train)
+y_pred = clf.predict(X_test)
+y_proba = clf.predict_proba(X_test)
+
+# ==========================================
+# 1. ACCURACY
+# ==========================================
+# Formula:
+#   Accuracy = (TP + TN) / (TP + TN + FP + FN)
+#   OR equivalently:
+#   Accuracy = Number of Correct Predictions / Total Number of Predictions
+#
+# Where:
+#   TP = True Positives  (correctly predicted positive)
+#   TN = True Negatives  (correctly predicted negative)
+#   FP = False Positives (incorrectly predicted positive, Type I error)
+#   FN = False Negatives (incorrectly predicted negative, Type II error)
+
+acc = accuracy_score(y_test, y_pred)
+print("=" * 50)
+print("1. ACCURACY")
+print("=" * 50)
+print(f"Accuracy: {acc:.4f}")
+
+# ==========================================
+# 2. CONFUSION MATRIX
+# ==========================================
+# The confusion matrix is a table that describes the performance of a classifier.
+# For binary classification:
+#
+#                  Predicted Positive   Predicted Negative
+#   Actual Positive       TP                  FN
+#   Actual Negative       FP                  TN
+#
+# For multiclass: C[i][j] = number of samples with true label i predicted as label j
+
+cm = confusion_matrix(y_test, y_pred)
+print("\n" + "=" * 50)
+print("2. CONFUSION MATRIX")
+print("=" * 50)
+print(f"\n{cm}")
+print(f"\nLabels: {iris.target_names}")
+
+# Plot Confusion Matrix
+fig, ax = plt.subplots(figsize=(8, 6))
+im = ax.imshow(cm, interpolation="nearest", cmap=plt.cm.Blues)
+ax.set_title("Confusion Matrix", fontsize=14, fontweight="bold")
+plt.colorbar(im, ax=ax)
+tick_marks = np.arange(len(iris.target_names))
+ax.set_xticks(tick_marks)
+ax.set_xticklabels(iris.target_names, rotation=45, ha="right")
+ax.set_yticks(tick_marks)
+ax.set_yticklabels(iris.target_names)
+
+# Add text annotations to the confusion matrix
+thresh = cm.max() / 2.0
+for i in range(cm.shape[0]):
+    for j in range(cm.shape[1]):
+        ax.text(
+            j, i, format(cm[i, j], "d"),
+            ha="center", va="center",
+            color="white" if cm[i, j] > thresh else "black",
+        )
+
+ax.set_ylabel("True Label", fontsize=12)
+ax.set_xlabel("Predicted Label", fontsize=12)
+plt.tight_layout()
+plt.savefig("confusion_matrix.png", dpi=150)
+plt.show()
+print("Confusion matrix plot saved as 'confusion_matrix.png'")
+
+# ==========================================
+# 3. PRECISION
+# ==========================================
+# Formula:
+#   Precision = TP / (TP + FP)
+#
+# Precision answers: "Of all instances predicted as positive, how many are actually positive?"
+# High precision = low false positive rate
+
+prec = precision_score(y_test, y_pred, average="weighted")
+prec_per_class = precision_score(y_test, y_pred, average=None)
+print("\n" + "=" * 50)
+print("3. PRECISION")
+print("=" * 50)
+print(f"Weighted Precision: {prec:.4f}")
+for i, name in enumerate(iris.target_names):
+    print(f"  {name}: {prec_per_class[i]:.4f}")
+
+# ==========================================
+# 4. RECALL (Sensitivity / True Positive Rate)
+# ==========================================
+# Formula:
+#   Recall = TP / (TP + FN)
+#
+# Recall answers: "Of all actual positive instances, how many did we correctly predict?"
+# Also known as Sensitivity or True Positive Rate (TPR)
+# High recall = low false negative rate
+
+rec = recall_score(y_test, y_pred, average="weighted")
+rec_per_class = recall_score(y_test, y_pred, average=None)
+print("\n" + "=" * 50)
+print("4. RECALL (Sensitivity / TPR)")
+print("=" * 50)
+print(f"Weighted Recall: {rec:.4f}")
+for i, name in enumerate(iris.target_names):
+    print(f"  {name}: {rec_per_class[i]:.4f}")
+
+# ==========================================
+# 5. F1 SCORE
+# ==========================================
+# Formula:
+#   F1 = 2 * (Precision * Recall) / (Precision + Recall)
+#
+# F1 Score is the harmonic mean of Precision and Recall.
+# It provides a balance between Precision and Recall.
+# Range: 0 (worst) to 1 (best)
+# Use F1 when you need a balance between Precision and Recall,
+# especially with imbalanced datasets.
+
+f1 = f1_score(y_test, y_pred, average="weighted")
+f1_per_class = f1_score(y_test, y_pred, average=None)
+print("\n" + "=" * 50)
+print("5. F1 SCORE")
+print("=" * 50)
+print(f"Weighted F1 Score: {f1:.4f}")
+for i, name in enumerate(iris.target_names):
+    print(f"  {name}: {f1_per_class[i]:.4f}")
+
+# ==========================================
+# Full Classification Report
+# ==========================================
+print("\n" + "=" * 50)
+print("FULL CLASSIFICATION REPORT")
+print("=" * 50)
+print(classification_report(y_test, y_pred, target_names=iris.target_names))
+
+# ==========================================
+# 6. ROC CURVE (One-vs-Rest for multiclass)
+# ==========================================
+# ROC = Receiver Operating Characteristic
+#
+# The ROC curve plots:
+#   X-axis: False Positive Rate (FPR) = FP / (FP + TN)
+#   Y-axis: True Positive Rate (TPR) = TP / (TP + FN)  (same as Recall)
+#
+# AUC (Area Under the ROC Curve):
+#   AUC = 1.0 means perfect classifier
+#   AUC = 0.5 means random classifier (diagonal line)
+#   AUC < 0.5 means worse than random
+#
+# For multiclass, we use One-vs-Rest (OvR) strategy
+
+y_test_bin = label_binarize(y_test, classes=[0, 1, 2])
+n_classes = y_test_bin.shape[1]
+
+fig, ax = plt.subplots(figsize=(8, 6))
+colors = ["#e74c3c", "#2ecc71", "#3498db"]
+
+for i in range(n_classes):
+    fpr, tpr, _ = roc_curve(y_test_bin[:, i], y_proba[:, i])
+    roc_auc = auc(fpr, tpr)
+    ax.plot(fpr, tpr, color=colors[i], lw=2,
+            label=f"{iris.target_names[i]} (AUC = {roc_auc:.2f})")
+
+ax.plot([0, 1], [0, 1], "k--", lw=1, label="Random (AUC = 0.50)")
+ax.set_xlim([0.0, 1.0])
+ax.set_ylim([0.0, 1.05])
+ax.set_xlabel("False Positive Rate (FPR)", fontsize=12)
+ax.set_ylabel("True Positive Rate (TPR)", fontsize=12)
+ax.set_title("ROC Curve (One-vs-Rest)", fontsize=14, fontweight="bold")
+ax.legend(loc="lower right")
+plt.tight_layout()
+plt.savefig("roc_curve.png", dpi=150)
+plt.show()
+print("\nROC curve plot saved as 'roc_curve.png'")
+
+# ==========================================
+# 7. PRECISION-RECALL CURVE (One-vs-Rest for multiclass)
+# ==========================================
+# The Precision-Recall curve plots:
+#   X-axis: Recall = TP / (TP + FN)
+#   Y-axis: Precision = TP / (TP + FP)
+#
+# This curve is especially useful for imbalanced datasets
+# where the positive class is rare.
+#
+# A good classifier has a curve that stays close to the top-right corner
+# (high precision and high recall simultaneously).
+
+fig, ax = plt.subplots(figsize=(8, 6))
+
+for i in range(n_classes):
+    precision_vals, recall_vals, _ = precision_recall_curve(
+        y_test_bin[:, i], y_proba[:, i]
+    )
+    ax.plot(recall_vals, precision_vals, color=colors[i], lw=2,
+            label=f"{iris.target_names[i]}")
+
+ax.set_xlim([0.0, 1.0])
+ax.set_ylim([0.0, 1.05])
+ax.set_xlabel("Recall", fontsize=12)
+ax.set_ylabel("Precision", fontsize=12)
+ax.set_title("Precision-Recall Curve (One-vs-Rest)", fontsize=14, fontweight="bold")
+ax.legend(loc="lower left")
+plt.tight_layout()
+plt.savefig("precision_recall_curve.png", dpi=150)
+plt.show()
+print("\nPrecision-Recall curve plot saved as 'precision_recall_curve.png'")