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

bm_preprocessing-0.9.0/.gitignore

@@ -0,0 +1,221 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+.idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+.vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml
+
+*.png
+*.jpg
+*.pdf
+*.jpeg

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

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

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

@@ -15,7 +15,8 @@ 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, metrics, preprocessing
+from bm_preprocessing.DM import adaboost, apriori, bagging, hash, hunts, hunts_test, id3, id3_test, lib_doc, metrics, preprocessing
+from bm_preprocessing.DM import all, all_vis
 
 # Print the source code
 print("=== IR All Module ===")
@@ -107,6 +108,8 @@ Then in the Python REPL:
 
 ```bash
 python -c "from bm_preprocessing.IR import all; print(all)"
+python -c "from bm_preprocessing.DM import all; print(all)"
+python -c "from bm_preprocessing.DM import all_vis; print(all_vis)"
 python -c "from bm_preprocessing.DM import apriori; print(apriori)"
 python -c "from bm_preprocessing.DM import adaboost; print(adaboost)"
 python -c "from bm_preprocessing.DM import bagging; print(bagging)"
@@ -116,6 +119,7 @@ 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 lib_doc; print(lib_doc)"
 python -c "from bm_preprocessing.DM import preprocessing; print(preprocessing)"
 ```
 
@@ -126,7 +130,8 @@ python -c "from bm_preprocessing.DM import preprocessing; print(preprocessing)"
 | Import | Description |
 |--------|-------------|
 | `from bm_preprocessing.IR import all` | Information Retrieval (BM25, TF-IDF, Boolean) |
-| `from bm_preprocessing.DM import all` | Data Mining algorithms |
+| `from bm_preprocessing.DM import all` | All DM algorithms (Hunt's, ID3, Bagging, AdaBoost, metrics) |
+| `from bm_preprocessing.DM import all_vis` | All DM algorithms + graphviz & full visualization |
 | `from bm_preprocessing.DM import apriori` | Apriori algorithm |
 | `from bm_preprocessing.DM import adaboost` | Bagging & AdaBoost ensemble classifiers |
 | `from bm_preprocessing.DM import bagging` | Bagging ensemble classifier |
@@ -136,4 +141,5 @@ python -c "from bm_preprocessing.DM import preprocessing; print(preprocessing)"
 | `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 lib_doc` | Pandas/NumPy/Sklearn/DM/IR cheat sheet |
 | `from bm_preprocessing.DM import preprocessing` | Data preprocessing utilities |

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

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

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

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

bm_preprocessing-0.9.0/src/bm_preprocessing/DM/all_vis.py

@@ -0,0 +1,30 @@
+"""Source code loader for DM/all_vis.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" / "all_vis.py"
+all_vis = SourceCodeModule("DM.all_vis", _source_file)

bm_preprocessing-0.9.0/src/bm_preprocessing/DM/lib_doc.py

@@ -0,0 +1,30 @@
+"""Source code loader for DM/lib_doc.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" / "lib_doc.py"
+lib_doc = SourceCodeModule("DM.lib_doc", _source_file)

bm_preprocessing-0.9.0/src/bm_preprocessing/DM/sources/all.py

@@ -0,0 +1,308 @@
+import pandas as pd
+import numpy as np
+import random
+import os
+from collections import Counter
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.ensemble import BaggingClassifier, AdaBoostClassifier
+from sklearn.metrics import (
+    accuracy_score, confusion_matrix, f1_score,
+    precision_score, recall_score, classification_report,
+)
+import matplotlib.pyplot as plt
+
+
+# ===========================================================
+# 1. DATA LOADING & PREPROCESSING
+# ===========================================================
+
+# --- Load CSV data for Hunt's and ID3 ---
+data_path = os.path.join(os.path.dirname(__file__), "data.csv")
+df = pd.read_csv(data_path)
+df["Annual Income"] = (
+    df["Annual Income"]
+    .astype(str)
+    .str.replace("K", "", regex=False)
+    .str.replace(" ", "", regex=False)
+    .astype(int)
+    * 1000
+)
+
+# --- Load Iris for Bagging, AdaBoost, Metrics ---
+iris = load_iris()
+X, y = iris.data, iris.target
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.3, random_state=42, stratify=y
+)
+
+print("=" * 60)
+print("DATA PREPROCESSING")
+print("=" * 60)
+print(f"CSV Dataset shape: {df.shape}")
+print(f"CSV Columns: {df.columns.tolist()}")
+print(f"Missing values:\n{df.isnull().sum()}")
+print(f"\nIris Dataset: {X.shape[0]} samples, {X.shape[1]} features, {len(iris.target_names)} classes")
+print(f"Train/Test split: {len(X_train)}/{len(X_test)}")
+
+
+# ===========================================================
+# 2. HUNT'S ALGORITHM (Random Feature Selection)
+# ===========================================================
+
+class HuntsNode:
+    def __init__(self, feature=None, median_value=None, label=None):
+        self.feature = feature
+        self.median_value = median_value
+        self.children = {}
+        self.label = label
+
+    def is_leaf(self):
+        return self.label is not None
+
+
+def hunts_build_tree(df, target_column, feature_columns):
+    if len(df[target_column].unique()) == 1:
+        return HuntsNode(label=df[target_column].mode()[0])
+    if not feature_columns:
+        return HuntsNode(label=df[target_column].mode()[0])
+
+    feature = random.choice(feature_columns)
+    node = HuntsNode(feature=feature)
+    remaining_features = [col for col in feature_columns if col != feature]
+
+    if pd.api.types.is_numeric_dtype(df[feature]):
+        median_value = df[feature].median()
+        node.median_value = median_value
+        node.children["<= " + str(median_value)] = hunts_build_tree(
+            df[df[feature] <= median_value], target_column, remaining_features
+        )
+        node.children["> " + str(median_value)] = hunts_build_tree(
+            df[df[feature] > median_value], target_column, remaining_features
+        )
+    else:
+        for val in df[feature].unique():
+            node.children[val] = hunts_build_tree(
+                df[df[feature] == val], target_column, remaining_features
+            )
+    return node
+
+
+def print_tree(node, indent=""):
+    if node.is_leaf():
+        print(f"{indent}Leaf: {node.label}")
+        return
+    if node.median_value is not None:
+        print(f"{indent}[Numeric Split] {node.feature} <= {node.median_value}")
+    else:
+        print(f"{indent}[Categorical Split] {node.feature}")
+    for val, child in node.children.items():
+        print(f"{indent}--> {val}:")
+        print_tree(child, indent + "    ")
+
+
+print("\n" + "=" * 60)
+print("HUNT'S ALGORITHM - Decision Tree")
+print("=" * 60)
+
+hunts_features = [col for col in df.columns if col not in ["Default id", "Tid"]]
+hunts_tree = hunts_build_tree(df, target_column="Default id", feature_columns=hunts_features)
+print_tree(hunts_tree)
+
+
+# ===========================================================
+# 3. ID3 ALGORITHM (Entropy-based Feature Selection)
+# ===========================================================
+
+# Entropy: H(S) = -Σ p(x) * log2(p(x))
+def entropy(df, target_column):
+    counts = df[target_column].value_counts()
+    probs = counts / len(df)
+    return -sum(probs * np.log2(probs))
+
+
+# Information Gain: IG(S, A) = H(S) - Σ (|Sv|/|S|) * H(Sv)
+def information_gain(df, feature, target_column):
+    total_entropy = entropy(df, target_column)
+    weighted_entropy = 0
+    for value in df[feature].unique():
+        subset = df[df[feature] == value]
+        weighted_entropy += (len(subset) / len(df)) * entropy(subset, target_column)
+    return total_entropy - weighted_entropy
+
+
+def best_feature(df, feature_columns, target_column):
+    gains = {f: information_gain(df, f, target_column) for f in feature_columns}
+    return max(gains, key=gains.get)
+
+
+class ID3Node:
+    def __init__(self, feature=None, value=None, label=None):
+        self.feature = feature
+        self.value = value
+        self.children = {}
+        self.label = label
+
+    def is_leaf(self):
+        return self.label is not None
+
+
+def id3(df, target_column, feature_columns):
+    if len(df[target_column].unique()) == 1:
+        return ID3Node(label=df[target_column].mode()[0])
+    if not feature_columns:
+        return ID3Node(label=df[target_column].mode()[0])
+
+    feature = best_feature(df, feature_columns, target_column)
+    node = ID3Node(feature=feature)
+    remaining_features = [col for col in feature_columns if col != feature]
+
+    if pd.api.types.is_numeric_dtype(df[feature]):
+        median_value = df[feature].median()
+        node.value = f"{feature} <= {median_value}"
+        node.children["<= " + str(median_value)] = id3(
+            df[df[feature] <= median_value], target_column, remaining_features
+        )
+        node.children["> " + str(median_value)] = id3(
+            df[df[feature] > median_value], target_column, remaining_features
+        )
+    else:
+        for val in df[feature].unique():
+            node.children[val] = id3(
+                df[df[feature] == val], target_column, remaining_features
+            )
+    return node
+
+
+def print_id3_tree(node, indent=""):
+    if node.is_leaf():
+        print(f"{indent}Leaf: {node.label}")
+        return
+    if node.value:
+        print(f"{indent}[Numeric Split] {node.value}")
+    else:
+        print(f"{indent}[Categorical Split] {node.feature}")
+    for val, child in node.children.items():
+        print(f"{indent}--> {val}:")
+        print_id3_tree(child, indent + "    ")
+
+
+print("\n" + "=" * 60)
+print("ID3 ALGORITHM - Decision Tree (data.csv)")
+print("=" * 60)
+
+id3_features = [col for col in df.columns if col not in ["Default id", "Tid"]]
+id3_tree = id3(df, target_column="Default id", feature_columns=id3_features)
+print_id3_tree(id3_tree)
+
+# Tennis dataset
+tennis_path = os.path.join(os.path.dirname(__file__), "tennis.csv")
+if os.path.exists(tennis_path):
+    tennis_df = pd.read_csv(tennis_path)
+    tennis_features = [col for col in tennis_df.columns if col != "Play"]
+    tennis_tree = id3(tennis_df, target_column="Play", feature_columns=tennis_features)
+    print("\n" + "=" * 60)
+    print("ID3 ALGORITHM - Decision Tree (tennis.csv)")
+    print("=" * 60)
+    print_id3_tree(tennis_tree)
+
+
+# ===========================================================
+# 4. BAGGING CLASSIFIER
+# ===========================================================
+
+print("\n" + "=" * 60)
+print("BAGGING CLASSIFIER (Iris)")
+print("=" * 60)
+
+bagging_model = BaggingClassifier(
+    estimator=DecisionTreeClassifier(random_state=42),
+    n_estimators=10, random_state=42,
+)
+bagging_model.fit(X_train, y_train)
+y_pred_bag = bagging_model.predict(X_test)
+print(f"Accuracy: {accuracy_score(y_test, y_pred_bag):.4f}")
+print(f"First 10 Predictions: {y_pred_bag[:10]}")
+
+
+# ===========================================================
+# 5. ADABOOST CLASSIFIER
+# ===========================================================
+
+print("\n" + "=" * 60)
+print("ADABOOST CLASSIFIER (Iris)")
+print("=" * 60)
+
+adaboost_model = AdaBoostClassifier(
+    estimator=DecisionTreeClassifier(max_depth=1, random_state=42),
+    n_estimators=50, learning_rate=1.0, random_state=42,
+)
+adaboost_model.fit(X_train, y_train)
+y_pred_ada = adaboost_model.predict(X_test)
+print(f"Accuracy: {accuracy_score(y_test, y_pred_ada):.4f}")
+print(f"First 10 Predictions: {y_pred_ada[:10]}")
+
+
+# ===========================================================
+# 6. METRICS & COMPARISON
+# ===========================================================
+
+print("\n" + "=" * 60)
+print("METRICS - BAGGING")
+print("=" * 60)
+# Accuracy = (TP + TN) / (TP + TN + FP + FN)
+print(f"Accuracy:  {accuracy_score(y_test, y_pred_bag):.4f}")
+# Precision = TP / (TP + FP)
+print(f"Precision: {precision_score(y_test, y_pred_bag, average='weighted'):.4f}")
+# Recall = TP / (TP + FN)
+print(f"Recall:    {recall_score(y_test, y_pred_bag, average='weighted'):.4f}")
+# F1 = 2 * (Precision * Recall) / (Precision + Recall)
+print(f"F1 Score:  {f1_score(y_test, y_pred_bag, average='weighted'):.4f}")
+print(f"\nConfusion Matrix:\n{confusion_matrix(y_test, y_pred_bag)}")
+print(f"\n{classification_report(y_test, y_pred_bag, target_names=iris.target_names)}")
+
+print("=" * 60)
+print("METRICS - ADABOOST")
+print("=" * 60)
+print(f"Accuracy:  {accuracy_score(y_test, y_pred_ada):.4f}")
+print(f"Precision: {precision_score(y_test, y_pred_ada, average='weighted'):.4f}")
+print(f"Recall:    {recall_score(y_test, y_pred_ada, average='weighted'):.4f}")
+print(f"F1 Score:  {f1_score(y_test, y_pred_ada, average='weighted'):.4f}")
+print(f"\nConfusion Matrix:\n{confusion_matrix(y_test, y_pred_ada)}")
+print(f"\n{classification_report(y_test, y_pred_ada, target_names=iris.target_names)}")
+
+print("=" * 60)
+print("COMPARISON")
+print("=" * 60)
+print(f"Bagging Accuracy:  {accuracy_score(y_test, y_pred_bag):.4f}")
+print(f"AdaBoost Accuracy: {accuracy_score(y_test, y_pred_ada):.4f}")
+
+
+# ===========================================================
+# 7. VISUALIZATION (Confusion Matrix Plot - matplotlib)
+# ===========================================================
+
+fig, axes = plt.subplots(1, 2, figsize=(14, 5))
+
+for ax, y_pred, title in zip(
+    axes, [y_pred_bag, y_pred_ada], ["Bagging", "AdaBoost"]
+):
+    cm = confusion_matrix(y_test, y_pred)
+    im = ax.imshow(cm, interpolation="nearest", cmap=plt.cm.Blues)
+    ax.set_title(f"{title} - Confusion Matrix", fontsize=12, fontweight="bold")
+    plt.colorbar(im, ax=ax)
+    ticks = np.arange(len(iris.target_names))
+    ax.set_xticks(ticks); ax.set_xticklabels(iris.target_names, rotation=45, ha="right")
+    ax.set_yticks(ticks); ax.set_yticklabels(iris.target_names)
+    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"); ax.set_xlabel("Predicted Label")
+
+plt.tight_layout()
+plt.savefig("all_confusion_matrices.png", dpi=150)
+plt.show()
+print("\nConfusion matrix plots saved as 'all_confusion_matrices.png'")