exai67 0.1.0__tar.gz

exai67-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 EXAI Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

exai67-0.1.0/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.1
+Name: exai67
+Version: 0.1.0
+Summary: Lightweight, dependency-minimal Explainable AI (XAI) algorithms and laboratory experiments implemented from scratch.
+Author: EXAI Team
+License: MIT
+Project-URL: Homepage, https://github.com/exai-toolkit/exai-toolkit
+Project-URL: Repository, https://github.com/exai-toolkit/exai-toolkit
+Keywords: xai,explainable-ai,interpretability,shapley,lime,gradcam,lrp,ice,pdp,xrai,machine-learning
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: scikit-learn>=1.0.0
+
+# EXAI (`exai67`)
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+
+A lightweight, dependency-minimal Python library containing complete implementations of **10 foundational Explainable AI (XAI)** laboratory experiments from scratch. Calling any function prints the full Python code for that experiment directly to the screen.
+
+---
+
+## Features
+
+- **Instant Code Display**: Calling any function or experiment displays the complete, working Python source code.
+- **Pure / Minimal Dependencies**: Built with standard Python, `numpy`, `pandas`, and `scikit-learn`. Zero deep learning frameworks.
+- **Exact Formulations**: Follows published literature (Greenwell et al., Ribeiro et al. LIME, Selvaraju et al. Grad-CAM, Bach et al. LRP).
+- **Interactive CLI**: Display experiment codes directly from terminal with `exai run <1-10>` or `exai list`.
+
+---
+
+## Included XAI Algorithms
+
+| Experiment | Module / Function | Description |
+| :--- | :--- | :--- |
+| **Index** | `exai.index()` | Index of all 10 experiments with descriptions and commands |
+| **Exp 1** | `exai.exp1()`, `exai.compute_linear_regression_metrics()` | Linear ($R^2$, Adj $R^2$, $t$-stat, 95% CI) & Logistic Regression (Odds Ratio, % change) |
+| **Exp 2** | `exai.exp2()`, `exai.extract_if_then_rules()` | Decision Tree IF-THEN rules, MDI vs Permutation Importance; KNN local neighbor explanations |
+| **Exp 3** | `exai.exp3()`, `exai.approximate_shapley_sampling()` | Approximate Shapley Values via permutation sampling from scratch |
+| **Exp 4** | `exai.exp4()`, `exai.compute_pdp()` | Partial Dependence Plot (PDP) Feature Importance (Greenwell et al., 2018) |
+| **Exp 5** | `exai.exp5()`, `exai.compute_ice_scratch()` | Individual Conditional Expectation (ICE) curves and PDP average computation |
+| **Exp 6** | `exai.exp6()`, `exai.compute_xrai_fixed_regions()` | XRAI Region-based image attribution and visual intensity scoring |
+| **Exp 7** | `exai.exp7()`, `exai.compute_gradcam()` | Grad-CAM (Gradient-Weighted Class Activation Mapping) with ReLU heatmap generation |
+| **Exp 8** | `exai.exp8()`, `exai.fit_lime_surrogate()` | LIME from scratch via Weighted Least Squares (WLS) and exponential kernels |
+| **Exp 9** | `exai.exp9()`, `exai.compute_gradient_x_input()` | CBOW Word Embeddings from scratch & Gradient × Input sentiment attribution |
+| **Exp 10** | `exai.exp10()`, `exai.layerwise_relevance_propagation()` | Layer-Wise Relevance Propagation (LRP) for multi-layer neural networks |
+
+---
+
+## Installation
+
+### From PyPI
+```bash
+pip install exai67
+```
+
+### Local Development Install
+```bash
+pip install -e .
+```
+
+---
+
+## Python API Usage
+
+Calling any function displays the clean, complete, ready-to-run Python code for that experiment:
+
+```python
+import exai
+
+# 1. Print code by experiment number
+exai.get_code(1)     # Displays Experiment 1 code
+exai.get_code(8)     # Displays Experiment 8 code
+
+# 2. Print code using shortcut functions
+exai.exp1()          # Linear & Logistic Regression
+exai.exp2()          # Decision Trees & KNN
+exai.exp3()          # Shapley Values
+exai.exp4()          # PDP Feature Importance
+exai.exp5()          # ICE Plot
+exai.exp6()          # XRAI Attribution
+exai.exp7()          # Grad-CAM
+exai.exp8()          # LIME
+exai.exp9()          # CBOW & Gradient x Input
+exai.exp10()         # LRP
+
+# 3. Print code using algorithm names
+exai.compute_gradcam()
+exai.fit_lime_surrogate()
+exai.layerwise_relevance_propagation()
+```
+
+---
+
+## Command-Line Interface (CLI)
+
+```bash
+# List all 10 available experiments
+exai list
+
+# Display code for a specific experiment
+exai run 8
+
+# Display code for all experiments
+exai run all
+```
+
+---
+
+## Publishing to PyPI
+
+```bash
+# 1. Install build tools
+pip install --upgrade build twine
+
+# 2. Build the package
+python3 setup.py sdist
+
+# 3. Upload to PyPI
+twine upload dist/*
+```
+
+---
+
+## License
+
+This project is licensed under the [MIT License](LICENSE).

exai67-0.1.0/README.md

@@ -0,0 +1,114 @@
+# EXAI (`exai67`)
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+
+A lightweight, dependency-minimal Python library containing complete implementations of **10 foundational Explainable AI (XAI)** laboratory experiments from scratch. Calling any function prints the full Python code for that experiment directly to the screen.
+
+---
+
+## Features
+
+- **Instant Code Display**: Calling any function or experiment displays the complete, working Python source code.
+- **Pure / Minimal Dependencies**: Built with standard Python, `numpy`, `pandas`, and `scikit-learn`. Zero deep learning frameworks.
+- **Exact Formulations**: Follows published literature (Greenwell et al., Ribeiro et al. LIME, Selvaraju et al. Grad-CAM, Bach et al. LRP).
+- **Interactive CLI**: Display experiment codes directly from terminal with `exai run <1-10>` or `exai list`.
+
+---
+
+## Included XAI Algorithms
+
+| Experiment | Module / Function | Description |
+| :--- | :--- | :--- |
+| **Index** | `exai.index()` | Index of all 10 experiments with descriptions and commands |
+| **Exp 1** | `exai.exp1()`, `exai.compute_linear_regression_metrics()` | Linear ($R^2$, Adj $R^2$, $t$-stat, 95% CI) & Logistic Regression (Odds Ratio, % change) |
+| **Exp 2** | `exai.exp2()`, `exai.extract_if_then_rules()` | Decision Tree IF-THEN rules, MDI vs Permutation Importance; KNN local neighbor explanations |
+| **Exp 3** | `exai.exp3()`, `exai.approximate_shapley_sampling()` | Approximate Shapley Values via permutation sampling from scratch |
+| **Exp 4** | `exai.exp4()`, `exai.compute_pdp()` | Partial Dependence Plot (PDP) Feature Importance (Greenwell et al., 2018) |
+| **Exp 5** | `exai.exp5()`, `exai.compute_ice_scratch()` | Individual Conditional Expectation (ICE) curves and PDP average computation |
+| **Exp 6** | `exai.exp6()`, `exai.compute_xrai_fixed_regions()` | XRAI Region-based image attribution and visual intensity scoring |
+| **Exp 7** | `exai.exp7()`, `exai.compute_gradcam()` | Grad-CAM (Gradient-Weighted Class Activation Mapping) with ReLU heatmap generation |
+| **Exp 8** | `exai.exp8()`, `exai.fit_lime_surrogate()` | LIME from scratch via Weighted Least Squares (WLS) and exponential kernels |
+| **Exp 9** | `exai.exp9()`, `exai.compute_gradient_x_input()` | CBOW Word Embeddings from scratch & Gradient × Input sentiment attribution |
+| **Exp 10** | `exai.exp10()`, `exai.layerwise_relevance_propagation()` | Layer-Wise Relevance Propagation (LRP) for multi-layer neural networks |
+
+---
+
+## Installation
+
+### From PyPI
+```bash
+pip install exai67
+```
+
+### Local Development Install
+```bash
+pip install -e .
+```
+
+---
+
+## Python API Usage
+
+Calling any function displays the clean, complete, ready-to-run Python code for that experiment:
+
+```python
+import exai
+
+# 1. Print code by experiment number
+exai.get_code(1)     # Displays Experiment 1 code
+exai.get_code(8)     # Displays Experiment 8 code
+
+# 2. Print code using shortcut functions
+exai.exp1()          # Linear & Logistic Regression
+exai.exp2()          # Decision Trees & KNN
+exai.exp3()          # Shapley Values
+exai.exp4()          # PDP Feature Importance
+exai.exp5()          # ICE Plot
+exai.exp6()          # XRAI Attribution
+exai.exp7()          # Grad-CAM
+exai.exp8()          # LIME
+exai.exp9()          # CBOW & Gradient x Input
+exai.exp10()         # LRP
+
+# 3. Print code using algorithm names
+exai.compute_gradcam()
+exai.fit_lime_surrogate()
+exai.layerwise_relevance_propagation()
+```
+
+---
+
+## Command-Line Interface (CLI)
+
+```bash
+# List all 10 available experiments
+exai list
+
+# Display code for a specific experiment
+exai run 8
+
+# Display code for all experiments
+exai run all
+```
+
+---
+
+## Publishing to PyPI
+
+```bash
+# 1. Install build tools
+pip install --upgrade build twine
+
+# 2. Build the package
+python3 setup.py sdist
+
+# 3. Upload to PyPI
+twine upload dist/*
+```
+
+---
+
+## License
+
+This project is licensed under the [MIT License](LICENSE).

exai67-0.1.0/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "exai67"
+version = "0.1.0"
+description = "Lightweight, dependency-minimal Explainable AI (XAI) algorithms and laboratory experiments implemented from scratch."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [
+    { name = "EXAI Team" }
+]
+keywords = [
+    "xai",
+    "explainable-ai",
+    "interpretability",
+    "shapley",
+    "lime",
+    "gradcam",
+    "lrp",
+    "ice",
+    "pdp",
+    "xrai",
+    "machine-learning"
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Education",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "numpy>=1.20.0",
+    "pandas>=1.3.0",
+    "scikit-learn>=1.0.0"
+]
+
+[project.scripts]
+exai = "exai.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/exai-toolkit/exai-toolkit"
+Repository = "https://github.com/exai-toolkit/exai-toolkit"
+
+[tool.setuptools.packages.find]
+where = ["src"]

exai67-0.1.0/setup.cfg

@@ -0,0 +1,8 @@
+[sdist]
+owner = root
+group = wheel
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

exai67-0.1.0/setup.py

@@ -0,0 +1,29 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="exai67",
+    version="0.1.0",
+    description="Lightweight Explainable AI (XAI) algorithms from scratch without deep learning libraries.",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    author="EXAI Team",
+    license="MIT",
+    package_dir={"": "src"},
+    packages=find_packages(where="src"),
+    python_requires=">=3.8",
+    install_requires=[
+        "numpy>=1.20.0",
+        "pandas>=1.3.0",
+        "scikit-learn>=1.0.0"
+    ],
+    entry_points={
+        "console_scripts": [
+            "exai=exai.cli:main",
+        ],
+    },
+    classifiers=[
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    ],
+)

exai67-0.1.0/src/exai/__init__.py

@@ -0,0 +1,195 @@
+"""
+EXAI: Explainable AI Toolkit
+============================
+A Python library providing complete implementations of 10 foundational Explainable AI (XAI)
+laboratory experiments. Calling any function displays the complete Python code for that experiment.
+
+Usage:
+    import exai
+    exai.exp1()           # Prints code for Experiment 1
+    exai.experiment_8()   # Prints code for Experiment 8 (LIME)
+    exai.get_code(7)      # Prints code for Experiment 7 (Grad-CAM)
+"""
+
+__version__ = "0.1.0"
+
+from exai.linear_logistic import (
+    experiment_1,
+    run_experiment_1,
+    exp1,
+    compute_linear_regression_metrics,
+    interpret_logistic_regression,
+    CODE_EXPERIMENT_1,
+)
+
+from exai.tree_knn import (
+    experiment_2,
+    run_experiment_2,
+    exp2,
+    extract_if_then_rules,
+    compute_permutation_importance,
+    explain_knn_classification,
+    explain_knn_regression,
+    CODE_EXPERIMENT_2,
+)
+
+from exai.shapley import (
+    experiment_3,
+    run_experiment_3,
+    exp3,
+    linear_model,
+    compute_single_permutation_marginal_contribution,
+    approximate_shapley_sampling,
+    CODE_EXPERIMENT_3,
+)
+
+from exai.pdp import (
+    experiment_4,
+    run_experiment_4,
+    exp4,
+    compute_pdp,
+    compute_numerical_pdp_importance,
+    compute_categorical_pdp_importance,
+    CODE_EXPERIMENT_4,
+)
+
+from exai.ice import (
+    experiment_5,
+    run_experiment_5,
+    exp5,
+    compute_ice_scratch,
+    ascii_ice_plot,
+    CODE_EXPERIMENT_5,
+)
+
+from exai.xrai import (
+    experiment_6,
+    run_experiment_6,
+    exp6,
+    get_visual_intensity_bar,
+    compute_xrai_fixed_regions,
+    CODE_EXPERIMENT_6,
+)
+
+from exai.gradcam import (
+    experiment_7,
+    run_experiment_7,
+    exp7,
+    compute_gradcam,
+    print_ascii_heatmap,
+    CODE_EXPERIMENT_7,
+)
+
+from exai.lime import (
+    experiment_8,
+    run_experiment_8,
+    exp8,
+    compute_euclidean_distance,
+    exponential_kernel,
+    fit_lime_surrogate,
+    CODE_EXPERIMENT_8,
+)
+
+from exai.cbow_gradient import (
+    experiment_9,
+    run_experiment_9,
+    exp9,
+    tokenize,
+    build_vocabulary,
+    create_cbow_dataset,
+    softmax,
+    cosine_similarity,
+    SimpleCBOW,
+    sigmoid,
+    predict_sentiment,
+    compute_gradient_x_input,
+    CODE_EXPERIMENT_9,
+)
+
+from exai.lrp import (
+    experiment_10,
+    run_experiment_10,
+    exp10,
+    relu,
+    forward_propagation,
+    layerwise_relevance_propagation,
+    CODE_EXPERIMENT_10,
+)
+
+from exai.index import (
+    index,
+    show_index,
+    list_all,
+    INDEX_TEXT,
+)
+
+EXPERIMENTS = {
+    1: CODE_EXPERIMENT_1,
+    2: CODE_EXPERIMENT_2,
+    3: CODE_EXPERIMENT_3,
+    4: CODE_EXPERIMENT_4,
+    5: CODE_EXPERIMENT_5,
+    6: CODE_EXPERIMENT_6,
+    7: CODE_EXPERIMENT_7,
+    8: CODE_EXPERIMENT_8,
+    9: CODE_EXPERIMENT_9,
+    10: CODE_EXPERIMENT_10,
+}
+
+
+def get_code(experiment_number):
+    """
+    Displays the Python code for a given experiment number (1 to 10).
+    """
+    try:
+        num = int(experiment_number)
+        if num in EXPERIMENTS:
+            print(EXPERIMENTS[num])
+        else:
+            print(f"Error: Experiment {num} not found. Please choose between 1 and 10.")
+    except (ValueError, TypeError):
+        print(f"Error: Invalid experiment number '{experiment_number}'. Use an integer 1 to 10.")
+
+
+__all__ = [
+    "__version__",
+    "get_code",
+    "index",
+    "show_index",
+    "list_all",
+    "INDEX_TEXT",
+    # Exp 1
+    "experiment_1", "run_experiment_1", "exp1",
+    "compute_linear_regression_metrics", "interpret_logistic_regression",
+    # Exp 2
+    "experiment_2", "run_experiment_2", "exp2",
+    "extract_if_then_rules", "compute_permutation_importance",
+    "explain_knn_classification", "explain_knn_regression",
+    # Exp 3
+    "experiment_3", "run_experiment_3", "exp3",
+    "linear_model", "compute_single_permutation_marginal_contribution",
+    "approximate_shapley_sampling",
+    # Exp 4
+    "experiment_4", "run_experiment_4", "exp4",
+    "compute_pdp", "compute_numerical_pdp_importance", "compute_categorical_pdp_importance",
+    # Exp 5
+    "experiment_5", "run_experiment_5", "exp5",
+    "compute_ice_scratch", "ascii_ice_plot",
+    # Exp 6
+    "experiment_6", "run_experiment_6", "exp6",
+    "get_visual_intensity_bar", "compute_xrai_fixed_regions",
+    # Exp 7
+    "experiment_7", "run_experiment_7", "exp7",
+    "compute_gradcam", "print_ascii_heatmap",
+    # Exp 8
+    "experiment_8", "run_experiment_8", "exp8",
+    "compute_euclidean_distance", "exponential_kernel", "fit_lime_surrogate",
+    # Exp 9
+    "experiment_9", "run_experiment_9", "exp9",
+    "tokenize", "build_vocabulary", "create_cbow_dataset", "softmax",
+    "cosine_similarity", "SimpleCBOW", "sigmoid", "predict_sentiment",
+    "compute_gradient_x_input",
+    # Exp 10
+    "experiment_10", "run_experiment_10", "exp10",
+    "relu", "forward_propagation", "layerwise_relevance_propagation",
+]

exai67-0.1.0/src/exai/cbow_gradient.py

@@ -0,0 +1,37 @@
+"""Experiment 9: CBOW & Gradient x Input Explainability"""
+
+CODE_EXPERIMENT_9 = '"""\nCBOW Word Embeddings & Gradient × Input Attribution Module\n==========================================================\nPart A: Continuous Bag of Words (CBOW) embeddings trained from scratch.\nPart B: Gradient × Input attribution for sentiment neural networks.\n"""\n\nimport math\nimport numpy as np\nimport pandas as pd\n\n\ndef tokenize(text):\n    """Simple whitespace and lowercasing unigram tokenizer."""\n    return text.lower().strip().split()\n\n\ndef build_vocabulary(corpus):\n    """Builds a sorted unique vocabulary and index maps."""\n    words = []\n    for sentence in corpus:\n        words.extend(tokenize(sentence))\n    vocab = sorted(list(set(words)))\n    word2idx = {w: i for i, w in enumerate(vocab)}\n    idx2word = {i: w for i, w in enumerate(vocab)}\n    return vocab, word2idx, idx2word\n\n\ndef create_cbow_dataset(corpus, word2idx, window_size=1):\n    """Creates (context, target) pairs for CBOW."""\n    data = []\n    for sentence in corpus:\n        tokens = tokenize(sentence)\n        for t in range(len(tokens)):\n            context_indices = []\n            for delta in range(-window_size, window_size + 1):\n                if delta != 0 and 0 <= t + delta < len(tokens):\n                    context_indices.append(word2idx[tokens[t + delta]])\n            if context_indices:\n                data.append((context_indices, word2idx[tokens[t]]))\n    return data\n\n\ndef softmax(x):\n    """Numerically stable softmax."""\n    e_x = np.exp(x - np.max(x))\n    return e_x / np.sum(e_x)\n\n\ndef cosine_similarity(v1, v2):\n    """Computes cosine similarity between two vectors from scratch."""\n    dot = np.dot(v1, v2)\n    norm1 = np.linalg.norm(v1)\n    norm2 = np.linalg.norm(v2)\n    if norm1 == 0 or norm2 == 0:\n        return 0.0\n    return dot / (norm1 * norm2)\n\n\nclass SimpleCBOW:\n    """CBOW model implemented in pure NumPy without DL libraries."""\n    def __init__(self, vocab_size, embedding_dim=2, learning_rate=0.05, seed=42):\n        np.random.seed(seed)\n        self.vocab_size = vocab_size\n        self.embedding_dim = embedding_dim\n        self.lr = learning_rate\n        self.W_in = np.random.uniform(-0.5, 0.5, (vocab_size, embedding_dim))\n        self.W_out = np.random.uniform(-0.5, 0.5, (embedding_dim, vocab_size))\n        \n    def train(self, cbow_data, epochs=300):\n        losses = []\n        for _ in range(epochs):\n            total_loss = 0.0\n            for context_indices, target_idx in cbow_data:\n                h = np.mean(self.W_in[context_indices], axis=0)\n                u = np.dot(h, self.W_out)\n                y_hat = softmax(u)\n                loss = -np.log(y_hat[target_idx] + 1e-12)\n                total_loss += loss\n                \n                e = y_hat.copy()\n                e[target_idx] -= 1.0\n                grad_W_out = np.outer(h, e)\n                grad_h = np.dot(self.W_out, e)\n                \n                self.W_out -= self.lr * grad_W_out\n                for idx in context_indices:\n                    self.W_in[idx] -= (self.lr / len(context_indices)) * grad_h\n            losses.append(total_loss)\n        return losses\n\n\ndef sigmoid(z):\n    """Sigmoid activation function."""\n    return 1.0 / (1.0 + math.exp(-z))\n\n\ndef predict_sentiment(x, weights, bias=0.0):\n    """Single-neuron sentiment prediction."""\n    z = sum(x[i] * weights[i] for i in range(len(x))) + bias\n    return z, sigmoid(z)\n\n\ndef compute_gradient_x_input(x, weights, bias=0.0):\n    """Computes Gradient × Input attribution: A_i = x_i * [d(y_hat)/d(x_i)]."""\n    z, y_hat = predict_sentiment(x, weights, bias)\n    sigmoid_gradient = y_hat * (1.0 - y_hat)\n    gradients = [sigmoid_gradient * w for w in weights]\n    attributions = [x[i] * gradients[i] for i in range(len(x))]\n    return z, y_hat, sigmoid_gradient, gradients, attributions\n\n\ndef run_experiment_9():\n    print("=" * 80)\n    print("EXPERIMENT 9: CBOW EMBEDDINGS & GRADIENT × INPUT EXPLAINABILITY")\n    print("=" * 80)\n    vocab = ["the", "movie", "was", "good", "bad"]\n    weights = [0.1, 0.2, 0.1, 2.0, -2.0]\n    x = [1, 1, 1, 1, 0]\n    z, y_hat, sig_grad, grads, attrs = compute_gradient_x_input(x, weights)\n    print(f"Logit: {z:.2f}, Pred: {y_hat:.4f}")\n    df = pd.DataFrame({\'Token\': vocab, \'Weight\': weights, \'Attribution\': attrs})\n    print(df.to_string(index=False))\n'
+
+def experiment_9(*args, **kwargs):
+    """Displays the complete Python code for Experiment 9."""
+    print(CODE_EXPERIMENT_9)
+
+def tokenize(*args, **kwargs):
+    print(CODE_EXPERIMENT_9)
+
+def build_vocabulary(*args, **kwargs):
+    print(CODE_EXPERIMENT_9)
+
+def create_cbow_dataset(*args, **kwargs):
+    print(CODE_EXPERIMENT_9)
+
+def softmax(*args, **kwargs):
+    print(CODE_EXPERIMENT_9)
+
+def cosine_similarity(*args, **kwargs):
+    print(CODE_EXPERIMENT_9)
+
+def SimpleCBOW(*args, **kwargs):
+    print(CODE_EXPERIMENT_9)
+
+def sigmoid(*args, **kwargs):
+    print(CODE_EXPERIMENT_9)
+
+def predict_sentiment(*args, **kwargs):
+    print(CODE_EXPERIMENT_9)
+
+def compute_gradient_x_input(*args, **kwargs):
+    print(CODE_EXPERIMENT_9)
+
+run_experiment_9 = experiment_9
+exp9 = experiment_9

exai67-0.1.0/src/exai/cli.py

@@ -0,0 +1,94 @@
+"""
+EXAI Command-Line Interface (CLI)
+=================================
+Allows running any of the 10 XAI laboratory experiments directly from terminal:
+  exai list
+  exai run 1
+  exai run all
+"""
+
+import sys
+import argparse
+from exai.linear_logistic import run_experiment_1
+from exai.tree_knn import run_experiment_2
+from exai.shapley import run_experiment_3
+from exai.pdp import run_experiment_4
+from exai.ice import run_experiment_5
+from exai.xrai import run_experiment_6
+from exai.gradcam import run_experiment_7
+from exai.lime import run_experiment_8
+from exai.cbow_gradient import run_experiment_9
+from exai.lrp import run_experiment_10
+
+EXPERIMENTS = {
+    1: ("Linear & Logistic Regression Explainability", run_experiment_1),
+    2: ("Explainability of Decision Trees & KNN", run_experiment_2),
+    3: ("Approximate Shapley Value for Explainable AI", run_experiment_3),
+    4: ("PDP-Based Feature Importance", run_experiment_4),
+    5: ("ICE (Individual Conditional Expectation) from Scratch", run_experiment_5),
+    6: ("XRAI: Region-Based Image Attribution", run_experiment_6),
+    7: ("Grad-CAM (Gradient-Weighted Class Activation Mapping)", run_experiment_7),
+    8: ("LIME from Scratch using Weighted Least Squares", run_experiment_8),
+    9: ("CBOW Word Embeddings & Gradient × Input Explainability", run_experiment_9),
+    10: ("Layer-Wise Relevance Propagation (LRP) from Scratch", run_experiment_10),
+}
+
+
+def list_experiments():
+    print("=" * 80)
+    print("EXAI Toolkit: 10 Core Explainable AI (XAI) Laboratory Experiments")
+    print("=" * 80)
+    for num, (title, _) in EXPERIMENTS.items():
+        print(f"  [{num:2d}] {title}")
+    print("=" * 80)
+    print("Run a specific experiment: exai run <1-10>")
+    print("Run all experiments     : exai run all")
+
+
+def main(argv=None):
+    if argv is None:
+        argv = sys.argv[1:]
+        
+    parser = argparse.ArgumentParser(
+        prog="exai",
+        description="EXAI Toolkit: Core Explainable AI Algorithms & Experiments from Scratch"
+    )
+    subparsers = parser.add_subparsers(dest="command")
+    
+    # Subcommand: list
+    subparsers.add_parser("list", help="List all available XAI experiments")
+    
+    # Subcommand: run
+    run_parser = subparsers.add_parser("run", help="Run one or all experiments")
+    run_parser.add_argument("target", help="Experiment number (1-10) or 'all'")
+    
+    args = parser.parse_args(argv)
+    
+    if args.command == "list" or (args.command is None and len(argv) == 0):
+        list_experiments()
+    elif args.command == "run":
+        target = args.target.strip().lower()
+        if target == "all":
+            print("Running all 10 XAI experiments...")
+            for num in sorted(EXPERIMENTS.keys()):
+                title, fn = EXPERIMENTS[num]
+                fn()
+                print("\n")
+        else:
+            try:
+                exp_num = int(target)
+                if exp_num in EXPERIMENTS:
+                    title, fn = EXPERIMENTS[exp_num]
+                    fn()
+                else:
+                    print(f"Error: Experiment {exp_num} not found. Choose between 1 and 10.")
+                    sys.exit(1)
+            except ValueError:
+                print(f"Invalid experiment target: '{args.target}'. Use an integer 1-10 or 'all'.")
+                sys.exit(1)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

exai67-0.1.0/src/exai/gradcam.py

@@ -0,0 +1,16 @@
+"""Experiment 7: Grad-CAM"""
+
+CODE_EXPERIMENT_7 = '"""\nGrad-CAM: Gradient-Weighted Class Activation Mapping Module\n===========================================================\nGenerates class-discriminative localization heatmaps from convolutional feature maps.\n"""\n\nimport numpy as np\n\n\ndef compute_gradcam(feature_maps, gradients):\n    """\n    Computes Grad-CAM heatmap from scratch given feature maps and gradients.\n    \n    Parameters:\n    - feature_maps: numpy array of shape (K, H, W)\n    - gradients: numpy array of shape (K, H, W) representing d(y^c)/d(A)\n    \n    Returns:\n    - alpha_weights: 1D array of shape (K,) with importance weights\n    - weighted_sum: 2D array of shape (H, W) before ReLU\n    - gradcam_heatmap: 2D array of shape (H, W) after ReLU\n    - normalized_heatmap: 2D array of shape (H, W) scaled to [0, 1]\n    """\n    K, H, W = feature_maps.shape\n    Z = H * W\n    alpha_weights = np.sum(gradients, axis=(1, 2)) / Z\n    \n    weighted_sum = np.zeros((H, W), dtype=float)\n    for k in range(K):\n        weighted_sum += alpha_weights[k] * feature_maps[k]\n        \n    gradcam_heatmap = np.maximum(0.0, weighted_sum)\n    max_val = np.max(gradcam_heatmap)\n    min_val = np.min(gradcam_heatmap)\n    if max_val > min_val:\n        normalized_heatmap = (gradcam_heatmap - min_val) / (max_val - min_val)\n    else:\n        normalized_heatmap = np.zeros_like(gradcam_heatmap)\n        \n    return alpha_weights, weighted_sum, gradcam_heatmap, normalized_heatmap\n\n\ndef print_ascii_heatmap(heatmap, title="Grad-CAM Heatmap"):\n    """Renders a 2D heatmap in ASCII blocks for visual inspection."""\n    print(f"\\n{title}:")\n    H, W = heatmap.shape\n    chars = [\'  \', \'░░\', \'▒▒\', \'▓▓\', \'██\']\n    for r in range(H):\n        row_str = ""\n        for c in range(W):\n            val = heatmap[r, c]\n            idx = min(int(val * len(chars)), len(chars) - 1)\n            row_str += chars[idx] + " "\n        num_str = " ".join(f"{heatmap[r, c]:.2f}" for c in range(W))\n        print(f"  [{row_str.strip()}]   |  Values: [ {num_str} ]")\n\n\ndef run_experiment_7():\n    print("=" * 80)\n    print("EXPERIMENT 7: GRAD-CAM (GRADIENT-WEIGHTED CLASS ACTIVATION MAPPING)")\n    print("=" * 80)\n    K, H, W = 2, 4, 4\n    feature_maps = np.zeros((K, H, W))\n    feature_maps[0, :, :2] = 1.0  # Left object\n    feature_maps[1, :, 2:] = 1.0  # Right object\n    \n    # Target Class 1 (Left object)\n    grads_left = np.zeros((K, H, W))\n    grads_left[0] = 1.0\n    _, _, _, norm_hm = compute_gradcam(feature_maps, grads_left)\n    print_ascii_heatmap(norm_hm, "Heatmap for Left Object Target")\n'
+
+def experiment_7(*args, **kwargs):
+    """Displays the complete Python code for Experiment 7."""
+    print(CODE_EXPERIMENT_7)
+
+def compute_gradcam(*args, **kwargs):
+    print(CODE_EXPERIMENT_7)
+
+def print_ascii_heatmap(*args, **kwargs):
+    print(CODE_EXPERIMENT_7)
+
+run_experiment_7 = experiment_7
+exp7 = experiment_7

exai67-0.1.0/src/exai/ice.py

@@ -0,0 +1,16 @@
+"""Experiment 5: Individual Conditional Expectation (ICE) Plot"""
+
+CODE_EXPERIMENT_5 = '"""\nIndividual Conditional Expectation (ICE) Module\n===============================================\nImplements ICE curves and ASCII curve visualization from scratch.\n"""\n\nimport numpy as np\nimport pandas as pd\n\n\ndef compute_ice_scratch(dataset, target_feature_idx, grid_values, predict_fn):\n    """\n    Computes Individual Conditional Expectation (ICE) matrix and PDP average.\n    Returns:\n    - ice_matrix: shape (len(grid_values), len(dataset))\n    - pdp_curve: shape (len(grid_values),)\n    """\n    n_samples = len(dataset)\n    n_grid = len(grid_values)\n    ice_matrix = np.zeros((n_grid, n_samples))\n    \n    for row_idx, val in enumerate(grid_values):\n        for col_idx, sample in enumerate(dataset):\n            modified_sample = list(sample)\n            modified_sample[target_feature_idx] = val\n            pred = predict_fn(*modified_sample)\n            ice_matrix[row_idx, col_idx] = pred\n            \n    pdp_curve = np.mean(ice_matrix, axis=1)\n    return ice_matrix, pdp_curve\n\n\ndef ascii_ice_plot(grid_values, ice_matrix, pdp_curve, feature_name="X1"):\n    """Draws an ASCII representation of ICE curves and PDP average."""\n    print(f"\\n--- VISUALIZATION: ICE Plot for {feature_name} ---")\n    print(f"{\'Feature \' + feature_name:<10} | {\'Sample 1\':<10} | {\'Sample 2\':<10} | {\'Sample 3\':<10} | {\'PDP (Average)\':<14} | Curve Visualization")\n    print("-" * 80)\n    for i, g in enumerate(grid_values):\n        s1 = ice_matrix[i, 0]\n        s2 = ice_matrix[i, 1]\n        s3 = ice_matrix[i, 2]\n        pdp = pdp_curve[i]\n        bar = "█" * max(1, int((pdp - 20) * 1.5))\n        print(f"{g:<10.1f} | {s1:<10.1f} | {s2:<10.1f} | {s3:<10.1f} | {pdp:<14.1f} | {bar}")\n\n\ndef run_experiment_5():\n    print("=" * 80)\n    print("EXPERIMENT 5: IMPLEMENTING AN ICE PLOT FROM SCRATCH")\n    print("=" * 80)\n    dataset = [[5, 2], [6, 3], [7, 4]]\n    grid = [5, 6, 7]\n    def model(x1, x2): return 3.5 + 3.0 * x1 + 4.0 * x2\n    ice_mat, pdp = compute_ice_scratch(dataset, 0, grid, model)\n    ascii_ice_plot(grid, ice_mat, pdp)\n'
+
+def experiment_5(*args, **kwargs):
+    """Displays the complete Python code for Experiment 5."""
+    print(CODE_EXPERIMENT_5)
+
+def compute_ice_scratch(*args, **kwargs):
+    print(CODE_EXPERIMENT_5)
+
+def ascii_ice_plot(*args, **kwargs):
+    print(CODE_EXPERIMENT_5)
+
+run_experiment_5 = experiment_5
+exp5 = experiment_5

exai67-0.1.0/src/exai/index.py

@@ -0,0 +1,68 @@
+"""
+EXAI Toolkit: Index of Experiments
+==================================
+Calling index() or running this file displays the index of all 10 XAI experiments.
+"""
+
+INDEX_TEXT = r"""================================================================================
+EXAI Toolkit: Index of All 10 Laboratory Experiments
+================================================================================
+
+[ 1] Linear & Logistic Regression Explainability
+     Topics   : R², Adjusted R², t-statistic, 95% CI, Odds Ratio, Feature Ranking
+     Function : exai.exp1()  or  exai.get_code(1)  or  python experiment_1.py
+
+[ 2] Explainability of Decision Trees & K-Nearest Neighbors (KNN)
+     Topics   : Tree Rules (IF-THEN), Impurity (MDI), Permutation Importance, KNN
+     Function : exai.exp2()  or  exai.get_code(2)  or  python experiment_2.py
+
+[ 3] Approximate Shapley Value for Explainable AI
+     Topics   : Permutation Sampling from Scratch, Marginal Contributions, Efficiency
+     Function : exai.exp3()  or  exai.get_code(3)  or  python experiment_3.py
+
+[ 4] Partial Dependence Plot (PDP) Feature Importance
+     Topics   : Greenwell et al. Formulation, Sample Std Dev, Range/4 Categorical
+     Function : exai.exp4()  or  exai.get_code(4)  or  python experiment_4.py
+
+[ 5] Individual Conditional Expectation (ICE) Plot from Scratch
+     Topics   : Individual Prediction Curves, PDP Average Relationship, Slopes
+     Function : exai.exp5()  or  exai.get_code(5)  or  python experiment_5.py
+
+[ 6] XRAI — Region-Based Image Attribution
+     Topics   : Fixed Region Quadrants, Pixel Attribution Aggregation, Ranking
+     Function : exai.exp6()  or  exai.get_code(6)  or  python experiment_6.py
+
+[ 7] Grad-CAM (Gradient-Weighted Class Activation Mapping)
+     Topics   : Convolutional Feature Maps, Gradient Global Pooling, ReLU Heatmap
+     Function : exai.exp7()  or  exai.get_code(7)  or  python experiment_7.py
+
+[ 8] LIME from Scratch using Weighted Least Squares (WLS)
+     Topics   : Local Perturbations, Exponential Kernel Weights, Normal Equations
+     Function : exai.exp8()  or  exai.get_code(8)  or  python experiment_8.py
+
+[ 9] CBOW Word Embeddings & Gradient × Input Text Attribution
+     Topics   : CBOW from Scratch, Softmax, Cosine Similarity, Sigmoid Attribution
+     Function : exai.exp9()  or  exai.get_code(9)  or  python experiment_9.py
+
+[10] Layer-Wise Relevance Propagation (LRP) from Scratch
+     Topics   : Two-Layer ANN (ReLU, Sigmoid), LRP-epsilon Rule, Relevance Conservation
+     Function : exai.exp10() or  exai.get_code(10) or  python experiment_10.py
+
+================================================================================
+Quick Usage:
+  import exai
+  exai.index()       # Displays this index
+  exai.get_code(8)   # Displays Experiment 8 code
+  exai.exp8()        # Displays Experiment 8 code
+================================================================================
+"""
+
+def index(*args, **kwargs):
+    """Displays the index of all 10 XAI experiments."""
+    print(INDEX_TEXT)
+
+show_index = index
+list_all = index
+
+if __name__ == "__main__":
+    index()

exai67-0.1.0/src/exai/lime.py

@@ -0,0 +1,19 @@
+"""Experiment 8: LIME from Scratch using Weighted Least Squares"""
+
+CODE_EXPERIMENT_8 = '"""\nLocal Interpretable Model-Agnostic Explanations (LIME) Module\n=============================================================\nImplements LIME from scratch using Weighted Least Squares (WLS) and exponential kernel.\n"""\n\nimport numpy as np\nimport pandas as pd\n\n\ndef compute_euclidean_distance(x, z):\n    """Euclidean distance between original instance x and perturbation z."""\n    return np.linalg.norm(np.array(x) - np.array(z))\n\n\ndef exponential_kernel(distance, sigma=1.0):\n    """Exponential similarity kernel: w = exp(-d^2 / sigma^2)."""\n    return np.exp(- (distance ** 2) / (sigma ** 2))\n\n\ndef fit_lime_surrogate(perturbations, predictions, original_instance, sigma=1.0, feature_names=None):\n    """\n    Fits a local linear surrogate model via Weighted Least Squares (WLS).\n    Solves: beta = (X^T * W * X)^(-1) * X^T * W * y\n    """\n    N = len(perturbations)\n    p = len(original_instance)\n    if feature_names is None:\n        feature_names = [f"Feature_{j+1}" for j in range(p)]\n        \n    distances = np.array([compute_euclidean_distance(original_instance, z) for z in perturbations])\n    weights = np.array([exponential_kernel(d, sigma=sigma) for d in distances])\n    \n    X = np.hstack([np.ones((N, 1)), np.array(perturbations)])\n    W = np.diag(weights)\n    y = np.array(predictions).reshape(-1, 1)\n    \n    XTW = X.T @ W\n    XTWX = XTW @ X\n    XTWy = XTW @ y\n    \n    beta = np.linalg.solve(XTWX, XTWy).flatten()\n    intercept = beta[0]\n    coefficients = beta[1:]\n    \n    coef_df = pd.DataFrame({\n        \'Feature\': feature_names,\n        \'Coefficient (Local Importance)\': coefficients,\n        \'Abs Value\': np.abs(coefficients),\n        \'Sign\': [\'Positive (+)\' if c > 0 else \'Negative (-)\' for c in coefficients]\n    })\n    coef_df[\'Local Rank\'] = coef_df[\'Abs Value\'].rank(ascending=False, method=\'min\').astype(int)\n    coef_df = coef_df.sort_values(by=\'Local Rank\').reset_index(drop=True)\n    \n    perturbations_df = pd.DataFrame(perturbations, columns=feature_names)\n    perturbations_df[\'f(z) Prediction\'] = predictions\n    perturbations_df[\'Distance\'] = distances\n    perturbations_df[\'Similarity Weight\'] = weights\n    \n    return {\n        \'intercept\': intercept,\n        \'coefficients\': coefficients,\n        \'beta\': beta,\n        \'XTWX\': XTWX,\n        \'XTWy\': XTWy,\n        \'explanation_df\': coef_df,\n        \'perturbations_df\': perturbations_df\n    }\n\n\ndef run_experiment_8():\n    print("=" * 80)\n    print("EXPERIMENT 8: LIME FROM SCRATCH USING WEIGHTED LEAST SQUARES")\n    print("=" * 80)\n    x_orig = [1, 1]\n    perturbations = [[1, 1], [1, 0], [0, 1], [0, 0]]\n    predictions = [0.90, 0.70, 0.60, 0.20]\n    names = [\'Blood Pressure\', \'Cholesterol\']\n    res = fit_lime_surrogate(perturbations, predictions, x_orig, sigma=1.0, feature_names=names)\n    print(res[\'explanation_df\'].to_string(index=False))\n'
+
+def experiment_8(*args, **kwargs):
+    """Displays the complete Python code for Experiment 8."""
+    print(CODE_EXPERIMENT_8)
+
+def compute_euclidean_distance(*args, **kwargs):
+    print(CODE_EXPERIMENT_8)
+
+def exponential_kernel(*args, **kwargs):
+    print(CODE_EXPERIMENT_8)
+
+def fit_lime_surrogate(*args, **kwargs):
+    print(CODE_EXPERIMENT_8)
+
+run_experiment_8 = experiment_8
+exp8 = experiment_8

exai67-0.1.0/src/exai/linear_logistic.py

@@ -0,0 +1,16 @@
+"""Experiment 1: Linear and Logistic Regression Explainability"""
+
+CODE_EXPERIMENT_1 = '"""\nLinear and Logistic Regression Explainability Module\n====================================================\nImplements:\n- Linear Regression evaluation: R², Adjusted R², t-statistic, 95% Confidence Intervals\n- Logistic Regression coefficient interpretation: Odds Ratio, % change in odds, ranking\n"""\n\nimport math\nimport numpy as np\nimport pandas as pd\n\n\ndef compute_linear_regression_metrics(y_true, y_pred, coefficients, standard_errors, feature_names, intercept=0.0):\n    """\n    Computes Linear Regression evaluation metrics:\n    - SSE, SST, R², Adjusted R²\n    - t-statistic for each coefficient (t = coef / SE)\n    - 95% Confidence Interval for each coefficient (coef +/- 1.96 * SE)\n    - Feature importance ranking based on absolute t-statistic\n    """\n    y_true = np.array(y_true, dtype=float)\n    y_pred = np.array(y_pred, dtype=float)\n    coefficients = np.array(coefficients, dtype=float)\n    standard_errors = np.array(standard_errors, dtype=float)\n    \n    n = len(y_true)\n    p = len(coefficients)\n    \n    sse = np.sum((y_true - y_pred) ** 2)\n    y_mean = np.mean(y_true)\n    sst = np.sum((y_true - y_mean) ** 2)\n    r_squared = 1.0 - (sse / sst)\n    \n    if n - p - 1 > 0:\n        adj_r_squared = 1.0 - ((1.0 - r_squared) * (n - 1) / (n - p - 1))\n    else:\n        adj_r_squared = float(\'nan\')\n        \n    t_statistics = coefficients / standard_errors\n    z_critical = 1.96\n    ci_lower = coefficients - (z_critical * standard_errors)\n    ci_upper = coefficients + (z_critical * standard_errors)\n    \n    results_df = pd.DataFrame({\n        \'Feature\': feature_names,\n        \'Coefficient\': coefficients,\n        \'Std Error\': standard_errors,\n        \'t-Statistic\': t_statistics,\n        \'95% CI Lower\': ci_lower,\n        \'95% CI Upper\': ci_upper,\n        \'Significant (95%)\': [not (low <= 0 <= high) for low, high in zip(ci_lower, ci_upper)],\n        \'Absolute t-stat\': np.abs(t_statistics)\n    })\n    \n    results_df[\'Importance Rank\'] = results_df[\'Absolute t-stat\'].rank(ascending=False, method=\'min\').astype(int)\n    results_df = results_df.sort_values(by=\'Importance Rank\').reset_index(drop=True)\n    \n    return {\n        \'n_observations\': n,\n        \'n_predictors\': p,\n        \'SSE\': sse,\n        \'SST\': sst,\n        \'R_squared\': r_squared,\n        \'Adjusted_R_squared\': adj_r_squared,\n        \'coefficients_table\': results_df\n    }\n\n\ndef interpret_logistic_regression(features, coefficients, intercept=0.0):\n    """\n    Interprets Logistic Regression coefficients:\n    - Sign: positive increases odds of positive class, negative decreases odds\n    - Odds Ratio: exp(beta)\n    - Percentage change in odds: (OR - 1) * 100%\n    - Ranking based on coefficient magnitude\n    """\n    rows = []\n    for feat, beta in zip(features, coefficients):\n        odds_ratio = math.exp(beta)\n        pct_change = (odds_ratio - 1.0) * 100.0\n        direction = "Positive" if beta > 0 else ("Negative" if beta < 0 else "Neutral")\n        \n        if beta > 0:\n            interpretation = (f"Every 1-unit increase in \'{feat}\' multiplies odds by {odds_ratio:.2f} "\n                              f"(increases odds by {pct_change:.1f}%).")\n        elif beta < 0:\n            interpretation = (f"Every 1-unit increase in \'{feat}\' multiplies odds by {odds_ratio:.2f} "\n                              f"(decreases odds by {abs(pct_change):.1f}%).")\n        else:\n            interpretation = f"\'{feat}\' has no effect on the odds (OR = 1.0)."\n            \n        rows.append({\n            \'Feature\': feat,\n            \'Coefficient (Beta)\': beta,\n            \'Abs(Beta)\': abs(beta),\n            \'Direction\': direction,\n            \'Odds Ratio\': odds_ratio,\n            \'Pct Change in Odds (%)\': pct_change,\n            \'Interpretation\': interpretation\n        })\n        \n    df = pd.DataFrame(rows)\n    df[\'Influence Rank\'] = df[\'Abs(Beta)\'].rank(ascending=False, method=\'min\').astype(int)\n    df = df.sort_values(by=\'Influence Rank\').reset_index(drop=True)\n    return df\n\n\ndef run_experiment_1():\n    print("=" * 80)\n    print("EXPERIMENT 1: LINEAR & LOGISTIC REGRESSION EXPLAINABILITY")\n    print("=" * 80)\n    feature_names = [\'Size (100 sqft)\', \'Bedrooms\', \'Age (years)\']\n    coefficients = [18.5, 7.2, -1.8]\n    standard_errors = [2.1, 4.0, 1.2]\n    y_true = [250, 310, 190, 400, 220, 280, 350, 175, 420, 300]\n    y_pred = [245, 305, 198, 390, 228, 272, 342, 180, 412, 308]\n    \n    lin_reg = compute_linear_regression_metrics(y_true, y_pred, coefficients, standard_errors, feature_names)\n    print(f"R²: {lin_reg[\'R_squared\']:.4f}, Adj R²: {lin_reg[\'Adjusted_R_squared\']:.4f}")\n    print(lin_reg[\'coefficients_table\'].to_string(index=False))\n    \n    print("\\nLogistic Regression Interpretation:")\n    log_features = [\'Age\', \'Income\', \'Loan Amount\', \'Credit Score\']\n    log_coefficients = [0.06, 0.85, -0.40, 1.25]\n    log_df = interpret_logistic_regression(log_features, log_coefficients)\n    print(log_df[[\'Feature\', \'Coefficient (Beta)\', \'Odds Ratio\', \'Pct Change in Odds (%)\', \'Influence Rank\']].to_string(index=False))\n'
+
+def experiment_1(*args, **kwargs):
+    """Displays the complete Python code for Experiment 1."""
+    print(CODE_EXPERIMENT_1)
+
+def compute_linear_regression_metrics(*args, **kwargs):
+    print(CODE_EXPERIMENT_1)
+
+def interpret_logistic_regression(*args, **kwargs):
+    print(CODE_EXPERIMENT_1)
+
+run_experiment_1 = experiment_1
+exp1 = experiment_1

exai67-0.1.0/src/exai/lrp.py

@@ -0,0 +1,22 @@
+"""Experiment 10: Layer-Wise Relevance Propagation (LRP)"""
+
+CODE_EXPERIMENT_10 = '"""\nLayer-Wise Relevance Propagation (LRP) Module\n=============================================\nImplements LRP for a two-layer ANN with ReLU and sigmoid from scratch.\n"""\n\nimport math\nimport pandas as pd\n\n\ndef relu(a):\n    """ReLU activation function: max(0, a)."""\n    return max(0.0, float(a))\n\n\ndef sigmoid(s):\n    """Sigmoid activation function: 1 / (1 + exp(-s))."""\n    return 1.0 / (1.0 + math.exp(-s))\n\n\ndef forward_propagation(x1, x2, w11=1, w21=0, w12=0, w22=2, v1=1, v2=1, bias_h1=0, bias_h2=0, bias_o=0):\n    """Forward Propagation through 2-layer ANN."""\n    z1 = x1 * w11 + x2 * w21 + bias_h1\n    h1 = relu(z1)\n    \n    z2 = x1 * w12 + x2 * w22 + bias_h2\n    h2 = relu(z2)\n    \n    s = h1 * v1 + h2 * v2 + bias_o\n    prob = sigmoid(s)\n    \n    return {\n        \'x1\': x1, \'x2\': x2,\n        \'z1\': z1, \'h1\': h1,\n        \'z2\': z2, \'h2\': h2,\n        \'s\': s, \'prob\': prob\n    }\n\n\ndef layerwise_relevance_propagation(fwd, w11=1, w21=0, w12=0, w22=2, v1=1, v2=1):\n    """LRP Backward propagation from output logit down to input features."""\n    x1, x2 = fwd[\'x1\'], fwd[\'x2\']\n    h1, h2 = fwd[\'h1\'], fwd[\'h2\']\n    s = fwd[\'s\']\n    R_output = s\n    \n    denom_output = h1 * v1 + h2 * v2\n    if denom_output != 0:\n        R_h1 = (h1 * v1 / denom_output) * R_output\n        R_h2 = (h2 * v2 / denom_output) * R_output\n    else:\n        R_h1, R_h2 = 0.0, 0.0\n        \n    denom_h1 = x1 * w11 + x2 * w21\n    if denom_h1 != 0 and R_h1 != 0:\n        R_x1_from_h1 = (x1 * w11 / denom_h1) * R_h1\n        R_x2_from_h1 = (x2 * w21 / denom_h1) * R_h1\n    else:\n        R_x1_from_h1, R_x2_from_h1 = 0.0, 0.0\n        \n    denom_h2 = x1 * w12 + x2 * w22\n    if denom_h2 != 0 and R_h2 != 0:\n        R_x1_from_h2 = (x1 * w12 / denom_h2) * R_h2\n        R_x2_from_h2 = (x2 * w22 / denom_h2) * R_h2\n    else:\n        R_x1_from_h2, R_x2_from_h2 = 0.0, 0.0\n        \n    R_x1 = R_x1_from_h1 + R_x1_from_h2\n    R_x2 = R_x2_from_h1 + R_x2_from_h2\n    \n    conserved_hidden = math.isclose(R_h1 + R_h2, R_output, abs_tol=1e-5)\n    conserved_input = math.isclose(R_x1 + R_x2, R_output, abs_tol=1e-5)\n    \n    return {\n        \'R_output\': R_output,\n        \'R_h1\': R_h1,\n        \'R_h2\': R_h2,\n        \'R_x1\': R_x1,\n        \'R_x2\': R_x2,\n        \'conserved_hidden\': conserved_hidden,\n        \'conserved_input\': conserved_input\n    }\n\n\ndef run_experiment_10():\n    print("=" * 80)\n    print("EXPERIMENT 10: LAYER-WISE RELEVANCE PROPAGATION (LRP) FROM SCRATCH")\n    print("=" * 80)\n    fwd = forward_propagation(x1=1, x2=1)\n    lrp = layerwise_relevance_propagation(fwd)\n    print(f"Logit s: {fwd[\'s\']:.1f}, Prob: {fwd[\'prob\']:.4f}")\n    print(f"Input Relevance: R_x1 = {lrp[\'R_x1\']:.1f}, R_x2 = {lrp[\'R_x2\']:.1f}")\n    print(f"Relevance Conserved: {lrp[\'conserved_input\']}")\n'
+
+def experiment_10(*args, **kwargs):
+    """Displays the complete Python code for Experiment 10."""
+    print(CODE_EXPERIMENT_10)
+
+def relu(*args, **kwargs):
+    print(CODE_EXPERIMENT_10)
+
+def sigmoid(*args, **kwargs):
+    print(CODE_EXPERIMENT_10)
+
+def forward_propagation(*args, **kwargs):
+    print(CODE_EXPERIMENT_10)
+
+def layerwise_relevance_propagation(*args, **kwargs):
+    print(CODE_EXPERIMENT_10)
+
+run_experiment_10 = experiment_10
+exp10 = experiment_10

exai67-0.1.0/src/exai/pdp.py

@@ -0,0 +1,19 @@
+"""Experiment 4: PDP-Based Feature Importance"""
+
+CODE_EXPERIMENT_4 = '"""\nPartial Dependence Plot (PDP) Feature Importance Module\n=======================================================\nImplements PDP and PDP-based importance following Greenwell, Boehmke, & McCarthy (2018).\n"""\n\nimport math\n\n\ndef compute_pdp(dataset, feature_index, grid_values, predict_fn):\n    """Computes Partial Dependence Plot (PDP) values from scratch."""\n    n = len(dataset)\n    pdp_values = []\n    \n    for val in grid_values:\n        total_pred = 0.0\n        for sample in dataset:\n            modified_sample = list(sample)\n            modified_sample[feature_index] = val\n            total_pred += predict_fn(modified_sample)\n        pdp_values.append(total_pred / n)\n        \n    return pdp_values\n\n\ndef compute_numerical_pdp_importance(pdp_values):\n    """Computes sample standard deviation across K PDP values."""\n    K = len(pdp_values)\n    if K <= 1:\n        return "Numerical PDP importance cannot be calculated when there is only one unique value."\n    mean_pdp = sum(pdp_values) / K\n    sum_sq_diff = sum((val - mean_pdp) ** 2 for val in pdp_values)\n    variance = sum_sq_diff / (K - 1)\n    return math.sqrt(variance)\n\n\ndef compute_categorical_pdp_importance(pdp_values):\n    """Computes categorical importance: (max(PDP) - min(PDP)) / 4."""\n    if len(pdp_values) == 0:\n        return 0.0\n    return (max(pdp_values) - min(pdp_values)) / 4.0\n\n\ndef run_experiment_4():\n    print("=" * 80)\n    print("EXPERIMENT 4: PDP-BASED FEATURE IMPORTANCE")\n    print("=" * 80)\n    tc2 = [0.20, 0.30, 0.45, 0.60, 0.75]\n    tc3 = [0.25, 0.40, 0.60, 0.70]\n    print(f"Numerical Test Case: PDP = {tc2} -> Importance = {compute_numerical_pdp_importance(tc2):.4f}")\n    print(f"Categorical Test Case: PDP = {tc3} -> Importance = {compute_categorical_pdp_importance(tc3):.4f}")\n'
+
+def experiment_4(*args, **kwargs):
+    """Displays the complete Python code for Experiment 4."""
+    print(CODE_EXPERIMENT_4)
+
+def compute_pdp(*args, **kwargs):
+    print(CODE_EXPERIMENT_4)
+
+def compute_numerical_pdp_importance(*args, **kwargs):
+    print(CODE_EXPERIMENT_4)
+
+def compute_categorical_pdp_importance(*args, **kwargs):
+    print(CODE_EXPERIMENT_4)
+
+run_experiment_4 = experiment_4
+exp4 = experiment_4

exai67-0.1.0/src/exai/shapley.py

@@ -0,0 +1,19 @@
+"""Experiment 3: Approximate Shapley Value for Explainable AI"""
+
+CODE_EXPERIMENT_3 = '"""\nApproximate Shapley Value Module\n================================\nImplements permutation-sampling approximation of the Shapley value from scratch.\n"""\n\nimport random\n\n\ndef linear_model(x):\n    """Additive linear model from manual: f(x1, x2, x3) = 2*x1 + 3*x2 + 5*x3."""\n    return 2 * x[0] + 3 * x[1] + 5 * x[2]\n\n\ndef compute_single_permutation_marginal_contribution(x, z, permutation, target_feature_idx, model):\n    """Computes marginal contribution for a specific permutation ordering."""\n    current_vector = list(z)\n    before_vector = None\n    after_vector = None\n    \n    for feat_idx in permutation:\n        if feat_idx == target_feature_idx:\n            before_vector = list(current_vector)\n            current_vector[feat_idx] = x[feat_idx]\n            after_vector = list(current_vector)\n            break\n        else:\n            current_vector[feat_idx] = x[feat_idx]\n            \n    pred_before = model(before_vector)\n    pred_after = model(after_vector)\n    marginal_contrib = pred_after - pred_before\n    \n    return before_vector, after_vector, pred_before, pred_after, marginal_contrib\n\n\ndef approximate_shapley_sampling(x, background_dataset, model, M=1000, random_seed=42):\n    """Approximates Shapley values for all features using permutation sampling over M iterations."""\n    random.seed(random_seed)\n    p = len(x)\n    marginal_contributions = {i: [] for i in range(p)}\n    first_10_iterations = []\n    \n    for m in range(M):\n        z = random.choice(background_dataset)\n        perm = list(range(p))\n        random.shuffle(perm)\n        \n        iter_row = {\'iteration\': m + 1, \'z\': tuple(z), \'perm\': [f"X{k+1}" for k in perm]}\n        \n        for feat_idx in range(p):\n            _, _, _, _, contrib = compute_single_permutation_marginal_contribution(\n                x, z, perm, feat_idx, model\n            )\n            marginal_contributions[feat_idx].append(contrib)\n            iter_row[f"contrib_X{feat_idx+1}"] = contrib\n            \n        if m < 10:\n            first_10_iterations.append(iter_row)\n            \n    approx_shapley = {feat_idx: sum(vals) / len(vals) for feat_idx, vals in marginal_contributions.items()}\n    return approx_shapley, first_10_iterations\n\n\ndef run_experiment_3():\n    print("=" * 80)\n    print("EXPERIMENT 3: APPROXIMATE SHAPLEY VALUE FOR EXPLAINABLE AI")\n    print("=" * 80)\n    x = [4, 2, 3]\n    bg = [[5, 1, 4], [2, 5, 1], [3, 3, 2], [4, 1, 5], [1, 4, 3]]\n    shap_vals, _ = approximate_shapley_sampling(x, bg, linear_model, M=1000)\n    print("Estimated Shapley Values (M=1000):")\n    for feat_idx, val in shap_vals.items():\n        print(f"  X{feat_idx+1}: {val:.4f}")\n'
+
+def experiment_3(*args, **kwargs):
+    """Displays the complete Python code for Experiment 3."""
+    print(CODE_EXPERIMENT_3)
+
+def linear_model(*args, **kwargs):
+    print(CODE_EXPERIMENT_3)
+
+def compute_single_permutation_marginal_contribution(*args, **kwargs):
+    print(CODE_EXPERIMENT_3)
+
+def approximate_shapley_sampling(*args, **kwargs):
+    print(CODE_EXPERIMENT_3)
+
+run_experiment_3 = experiment_3
+exp3 = experiment_3

exai67-0.1.0/src/exai/tree_knn.py

@@ -0,0 +1,22 @@
+"""Experiment 2: Decision Tree and KNN Explainability"""
+
+CODE_EXPERIMENT_2 = '"""\nDecision Tree and K-Nearest Neighbors Explainability Module\n===========================================================\nImplements:\n- Decision Tree rule extraction, MDI importance, permutation importance\n- KNN classification explanation (distances, neighbors, majority voting)\n- KNN regression explanation (distances, neighbors, local manual averaging)\n"""\n\nimport numpy as np\nimport pandas as pd\nfrom sklearn.datasets import load_iris\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.tree import DecisionTreeClassifier, export_text\nfrom sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor\nfrom sklearn.metrics import accuracy_score\n\n\ndef extract_if_then_rules(tree_classifier, feature_names, class_names):\n    """Traverses tree structure and extracts human-readable IF-THEN rules."""\n    tree = tree_classifier.tree_\n    rules = []\n    \n    def recurse(node_id, current_rule):\n        if tree.children_left[node_id] == -1 and tree.children_right[node_id] == -1:\n            class_idx = np.argmax(tree.value[node_id][0])\n            predicted_class = class_names[class_idx]\n            samples = tree.n_node_samples[node_id]\n            gini = tree.impurity[node_id]\n            rule_str = " AND ".join(current_rule) if current_rule else "TRUE"\n            rules.append({\n                \'Rule\': f"IF {rule_str} THEN Predict: {predicted_class}",\n                \'Predicted Class\': predicted_class,\n                \'Samples\': samples,\n                \'Gini Impurity\': round(gini, 4)\n            })\n            return\n            \n        feature_idx = tree.feature[node_id]\n        threshold = tree.threshold[node_id]\n        feat_name = feature_names[feature_idx]\n        \n        left_cond = f"{feat_name} <= {threshold:.2f}"\n        recurse(tree.children_left[node_id], current_rule + [left_cond])\n        right_cond = f"{feat_name} > {threshold:.2f}"\n        recurse(tree.children_right[node_id], current_rule + [right_cond])\n        \n    recurse(0, [])\n    return pd.DataFrame(rules)\n\n\ndef compute_permutation_importance(model, X_val, y_val, feature_names, n_repeats=10, random_state=42):\n    """Computes Permutation Feature Importance by measuring drop in accuracy."""\n    rng = np.random.RandomState(random_state)\n    baseline_acc = accuracy_score(y_val, model.predict(X_val))\n    \n    perm_importances = []\n    for col_idx, col_name in enumerate(feature_names):\n        drops = []\n        for _ in range(n_repeats):\n            X_permuted = X_val.copy()\n            shuffled_col = X_permuted[:, col_idx].copy()\n            rng.shuffle(shuffled_col)\n            X_permuted[:, col_idx] = shuffled_col\n            \n            permuted_acc = accuracy_score(y_val, model.predict(X_permuted))\n            drop = baseline_acc - permuted_acc\n            drops.append(drop)\n            \n        perm_importances.append({\n            \'Feature\': col_name,\n            \'Permutation Importance (Mean Drop)\': np.mean(drops),\n            \'Std Dev\': np.std(drops)\n        })\n        \n    df = pd.DataFrame(perm_importances)\n    df = df.sort_values(by=\'Permutation Importance (Mean Drop)\', ascending=False).reset_index(drop=True)\n    return baseline_acc, df\n\n\ndef explain_knn_classification(X_train, y_train, test_instance, class_names, k=3):\n    """Step-by-step local explanation of KNN Classification."""\n    distances = np.linalg.norm(X_train - test_instance, axis=1)\n    nearest_indices = np.argsort(distances)[:k]\n    \n    neighbor_records = []\n    for rank, idx in enumerate(nearest_indices, start=1):\n        neighbor_records.append({\n            \'Rank\': rank,\n            \'Train Index\': idx,\n            \'Distance\': distances[idx],\n            \'Class Label\': y_train[idx],\n            \'Class Name\': class_names[y_train[idx]],\n            \'Features\': X_train[idx]\n        })\n    df_neighbors = pd.DataFrame(neighbor_records)\n    votes = df_neighbors[\'Class Name\'].value_counts()\n    predicted_class = votes.index[0]\n    \n    return {\n        \'test_instance\': test_instance,\n        \'k\': k,\n        \'neighbors_df\': df_neighbors,\n        \'vote_counts\': votes.to_dict(),\n        \'predicted_class\': predicted_class\n    }\n\n\ndef explain_knn_regression(X_train, y_train, test_instance, k=3):\n    """Step-by-step local explanation of KNN Regression."""\n    distances = np.linalg.norm(X_train - test_instance, axis=1)\n    nearest_indices = np.argsort(distances)[:k]\n    \n    neighbor_records = []\n    for rank, idx in enumerate(nearest_indices, start=1):\n        neighbor_records.append({\n            \'Rank\': rank,\n            \'Train Index\': idx,\n            \'Distance\': distances[idx],\n            \'Target Value\': y_train[idx],\n            \'Features\': X_train[idx]\n        })\n    df_neighbors = pd.DataFrame(neighbor_records)\n    manual_avg = np.mean(df_neighbors[\'Target Value\'])\n    \n    return {\n        \'test_instance\': test_instance,\n        \'k\': k,\n        \'neighbors_df\': df_neighbors,\n        \'manual_average\': manual_avg\n    }\n\n\ndef run_experiment_2():\n    print("=" * 80)\n    print("EXPERIMENT 2: EXPLAINABILITY OF DECISION TREES & KNN")\n    print("=" * 80)\n    iris = load_iris()\n    X, y = iris.data, iris.target\n    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)\n    \n    tree_clf = DecisionTreeClassifier(max_depth=3, random_state=42)\n    tree_clf.fit(X_train, y_train)\n    rules_df = extract_if_then_rules(tree_clf, iris.feature_names, iris.target_names)\n    print("Extracted IF-THEN Rules:")\n    print(rules_df[[\'Rule\', \'Samples\', \'Gini Impurity\']].to_string(index=False))\n    \n    knn_clf = KNeighborsClassifier(n_neighbors=3)\n    knn_clf.fit(X_train, y_train)\n    clf_exp = explain_knn_classification(X_train, y_train, X_test[0], iris.target_names, k=3)\n    print("\\nKNN Local Explanation:")\n    print(clf_exp[\'neighbors_df\'][[\'Rank\', \'Train Index\', \'Distance\', \'Class Name\']].to_string(index=False))\n'
+
+def experiment_2(*args, **kwargs):
+    """Displays the complete Python code for Experiment 2."""
+    print(CODE_EXPERIMENT_2)
+
+def extract_if_then_rules(*args, **kwargs):
+    print(CODE_EXPERIMENT_2)
+
+def compute_permutation_importance(*args, **kwargs):
+    print(CODE_EXPERIMENT_2)
+
+def explain_knn_classification(*args, **kwargs):
+    print(CODE_EXPERIMENT_2)
+
+def explain_knn_regression(*args, **kwargs):
+    print(CODE_EXPERIMENT_2)
+
+run_experiment_2 = experiment_2
+exp2 = experiment_2

exai67-0.1.0/src/exai/xrai.py

@@ -0,0 +1,16 @@
+"""Experiment 6: XRAI — Region-Based Image Attribution"""
+
+CODE_EXPERIMENT_6 = '"""\nXRAI: Region-Based Image Attribution Module\n===========================================\nAggregates pixel-level attributions into predefined spatial regions and ranks them.\n"""\n\nimport numpy as np\nimport pandas as pd\n\n\ndef get_visual_intensity_bar(score, min_score=0.0, max_score=1.0):\n    """Returns visual ASCII intensity bars matching the lab manual scale."""\n    if max_score == min_score:\n        norm = 0.5\n    else:\n        norm = (score - min_score) / (max_score - min_score)\n        \n    if norm >= 0.8:\n        return "█████ (Very High)"\n    elif norm >= 0.6:\n        return "████  (High)"\n    elif norm >= 0.4:\n        return "███   (Medium)"\n    elif norm >= 0.2:\n        return "██    (Low)"\n    else:\n        return "█     (Very Low)"\n\n\ndef compute_xrai_fixed_regions(attribution_matrix, region_definitions):\n    """\n    Aggregates pixel attributions into regions and ranks them.\n    Parameters:\n    - attribution_matrix: 2D numpy array of pixel attributions\n    - region_definitions: dict of region_name -> list of (row, col) coordinates\n    """\n    results = []\n    for r_name, coords in region_definitions.items():\n        pixels = [attribution_matrix[r, c] for r, c in coords]\n        total_sum = sum(pixels)\n        region_size = len(coords)\n        score = total_sum / region_size\n        results.append({\n            \'Region\': r_name,\n            \'Pixels\': [round(p, 2) for p in pixels],\n            \'Pixel Sum\': total_sum,\n            \'Size\': region_size,\n            \'Score\': score\n        })\n        \n    df = pd.DataFrame(results)\n    df[\'Rank\'] = df[\'Score\'].rank(ascending=False, method=\'min\').astype(int)\n    df = df.sort_values(by=[\'Rank\', \'Region\']).reset_index(drop=True)\n    \n    scores = df[\'Score\'].values\n    min_s, max_s = min(scores), max(scores)\n    df[\'Intensity\'] = [get_visual_intensity_bar(s, min_s, max_s) for s in scores]\n    return df\n\n\ndef run_experiment_6():\n    print("=" * 80)\n    print("EXPERIMENT 6: XRAI — REGION-BASED IMAGE ATTRIBUTION WITHOUT LIBRARIES")\n    print("=" * 80)\n    attribution_matrix = np.array([\n        [0.1, 0.2, 0.1, 0.0],\n        [0.2, 0.3, 0.2, 0.1],\n        [0.0, 0.1, 0.8, 0.7],\n        [0.1, 0.2, 0.9, 0.8]\n    ])\n    region_defs = {\n        \'R1\': [(0, 0), (0, 1), (1, 0), (1, 1)],\n        \'R2\': [(0, 2), (0, 3), (1, 2), (1, 3)],\n        \'R3\': [(2, 0), (2, 1), (3, 0), (3, 1)],\n        \'R4\': [(2, 2), (2, 3), (3, 2), (3, 3)]\n    }\n    df = compute_xrai_fixed_regions(attribution_matrix, region_defs)\n    print(df[[\'Rank\', \'Region\', \'Score\', \'Intensity\']].to_string(index=False))\n'
+
+def experiment_6(*args, **kwargs):
+    """Displays the complete Python code for Experiment 6."""
+    print(CODE_EXPERIMENT_6)
+
+def get_visual_intensity_bar(*args, **kwargs):
+    print(CODE_EXPERIMENT_6)
+
+def compute_xrai_fixed_regions(*args, **kwargs):
+    print(CODE_EXPERIMENT_6)
+
+run_experiment_6 = experiment_6
+exp6 = experiment_6

exai67-0.1.0/src/exai67.egg-info/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.1
+Name: exai67
+Version: 0.1.0
+Summary: Lightweight, dependency-minimal Explainable AI (XAI) algorithms and laboratory experiments implemented from scratch.
+Author: EXAI Team
+License: MIT
+Project-URL: Homepage, https://github.com/exai-toolkit/exai-toolkit
+Project-URL: Repository, https://github.com/exai-toolkit/exai-toolkit
+Keywords: xai,explainable-ai,interpretability,shapley,lime,gradcam,lrp,ice,pdp,xrai,machine-learning
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: scikit-learn>=1.0.0
+
+# EXAI (`exai67`)
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+
+A lightweight, dependency-minimal Python library containing complete implementations of **10 foundational Explainable AI (XAI)** laboratory experiments from scratch. Calling any function prints the full Python code for that experiment directly to the screen.
+
+---
+
+## Features
+
+- **Instant Code Display**: Calling any function or experiment displays the complete, working Python source code.
+- **Pure / Minimal Dependencies**: Built with standard Python, `numpy`, `pandas`, and `scikit-learn`. Zero deep learning frameworks.
+- **Exact Formulations**: Follows published literature (Greenwell et al., Ribeiro et al. LIME, Selvaraju et al. Grad-CAM, Bach et al. LRP).
+- **Interactive CLI**: Display experiment codes directly from terminal with `exai run <1-10>` or `exai list`.
+
+---
+
+## Included XAI Algorithms
+
+| Experiment | Module / Function | Description |
+| :--- | :--- | :--- |
+| **Index** | `exai.index()` | Index of all 10 experiments with descriptions and commands |
+| **Exp 1** | `exai.exp1()`, `exai.compute_linear_regression_metrics()` | Linear ($R^2$, Adj $R^2$, $t$-stat, 95% CI) & Logistic Regression (Odds Ratio, % change) |
+| **Exp 2** | `exai.exp2()`, `exai.extract_if_then_rules()` | Decision Tree IF-THEN rules, MDI vs Permutation Importance; KNN local neighbor explanations |
+| **Exp 3** | `exai.exp3()`, `exai.approximate_shapley_sampling()` | Approximate Shapley Values via permutation sampling from scratch |
+| **Exp 4** | `exai.exp4()`, `exai.compute_pdp()` | Partial Dependence Plot (PDP) Feature Importance (Greenwell et al., 2018) |
+| **Exp 5** | `exai.exp5()`, `exai.compute_ice_scratch()` | Individual Conditional Expectation (ICE) curves and PDP average computation |
+| **Exp 6** | `exai.exp6()`, `exai.compute_xrai_fixed_regions()` | XRAI Region-based image attribution and visual intensity scoring |
+| **Exp 7** | `exai.exp7()`, `exai.compute_gradcam()` | Grad-CAM (Gradient-Weighted Class Activation Mapping) with ReLU heatmap generation |
+| **Exp 8** | `exai.exp8()`, `exai.fit_lime_surrogate()` | LIME from scratch via Weighted Least Squares (WLS) and exponential kernels |
+| **Exp 9** | `exai.exp9()`, `exai.compute_gradient_x_input()` | CBOW Word Embeddings from scratch & Gradient × Input sentiment attribution |
+| **Exp 10** | `exai.exp10()`, `exai.layerwise_relevance_propagation()` | Layer-Wise Relevance Propagation (LRP) for multi-layer neural networks |
+
+---
+
+## Installation
+
+### From PyPI
+```bash
+pip install exai67
+```
+
+### Local Development Install
+```bash
+pip install -e .
+```
+
+---
+
+## Python API Usage
+
+Calling any function displays the clean, complete, ready-to-run Python code for that experiment:
+
+```python
+import exai
+
+# 1. Print code by experiment number
+exai.get_code(1)     # Displays Experiment 1 code
+exai.get_code(8)     # Displays Experiment 8 code
+
+# 2. Print code using shortcut functions
+exai.exp1()          # Linear & Logistic Regression
+exai.exp2()          # Decision Trees & KNN
+exai.exp3()          # Shapley Values
+exai.exp4()          # PDP Feature Importance
+exai.exp5()          # ICE Plot
+exai.exp6()          # XRAI Attribution
+exai.exp7()          # Grad-CAM
+exai.exp8()          # LIME
+exai.exp9()          # CBOW & Gradient x Input
+exai.exp10()         # LRP
+
+# 3. Print code using algorithm names
+exai.compute_gradcam()
+exai.fit_lime_surrogate()
+exai.layerwise_relevance_propagation()
+```
+
+---
+
+## Command-Line Interface (CLI)
+
+```bash
+# List all 10 available experiments
+exai list
+
+# Display code for a specific experiment
+exai run 8
+
+# Display code for all experiments
+exai run all
+```
+
+---
+
+## Publishing to PyPI
+
+```bash
+# 1. Install build tools
+pip install --upgrade build twine
+
+# 2. Build the package
+python3 setup.py sdist
+
+# 3. Upload to PyPI
+twine upload dist/*
+```
+
+---
+
+## License
+
+This project is licensed under the [MIT License](LICENSE).

exai67-0.1.0/src/exai67.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+LICENSE
+README.md
+pyproject.toml
+setup.cfg
+setup.py
+src/exai/__init__.py
+src/exai/cbow_gradient.py
+src/exai/cli.py
+src/exai/gradcam.py
+src/exai/ice.py
+src/exai/index.py
+src/exai/lime.py
+src/exai/linear_logistic.py
+src/exai/lrp.py
+src/exai/pdp.py
+src/exai/shapley.py
+src/exai/tree_knn.py
+src/exai/xrai.py
+src/exai67.egg-info/PKG-INFO
+src/exai67.egg-info/SOURCES.txt
+src/exai67.egg-info/dependency_links.txt
+src/exai67.egg-info/entry_points.txt
+src/exai67.egg-info/requires.txt
+src/exai67.egg-info/top_level.txt
+tests/test_library.py

exai67-0.1.0/src/exai67.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

exai67-0.1.0/src/exai67.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+exai = exai.cli:main

exai67-0.1.0/src/exai67.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy>=1.20.0
+pandas>=1.3.0
+scikit-learn>=1.0.0

exai67-0.1.0/src/exai67.egg-info/top_level.txt

@@ -0,0 +1 @@
+exai

exai67-0.1.0/tests/test_library.py

@@ -0,0 +1,72 @@
+"""
+Unit Test Suite for EXAI Library
+Verifies that calling any experiment or function outputs the code cleanly.
+"""
+
+import unittest
+import io
+import sys
+import os
+
+# Ensure src is in sys.path
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../src")))
+
+import exai
+
+
+class TestEXAILibrary(unittest.TestCase):
+    def test_version(self):
+        self.assertEqual(exai.__version__, "0.1.0")
+
+    def test_index(self):
+        captured = io.StringIO()
+        sys.stdout = captured
+        try:
+            exai.index()
+        finally:
+            sys.stdout = sys.__stdout__
+        output = captured.getvalue()
+        self.assertIn("Index of All 10 Laboratory Experiments", output)
+        self.assertIn("Linear & Logistic Regression", output)
+        self.assertIn("Layer-Wise Relevance Propagation", output)
+
+    def test_get_code_all_experiments(self):
+        for i in range(1, 11):
+            captured = io.StringIO()
+            sys.stdout = captured
+            try:
+                exai.get_code(i)
+            finally:
+                sys.stdout = sys.__stdout__
+            output = captured.getvalue()
+            self.assertTrue(len(output) > 100, f"Exp {i} output too short!")
+            self.assertIn("def ", output)
+
+    def test_individual_function_calls_print_code(self):
+        functions_to_test = [
+            exai.exp1,
+            exai.compute_linear_regression_metrics,
+            exai.extract_if_then_rules,
+            exai.approximate_shapley_sampling,
+            exai.compute_pdp,
+            exai.compute_ice_scratch,
+            exai.compute_xrai_fixed_regions,
+            exai.compute_gradcam,
+            exai.fit_lime_surrogate,
+            exai.compute_gradient_x_input,
+            exai.layerwise_relevance_propagation
+        ]
+        for fn in functions_to_test:
+            captured = io.StringIO()
+            sys.stdout = captured
+            try:
+                fn()
+            finally:
+                sys.stdout = sys.__stdout__
+            output = captured.getvalue()
+            self.assertTrue(len(output) > 100, f"{fn.__name__} did not print code!")
+            self.assertIn("def ", output)
+
+
+if __name__ == "__main__":
+    unittest.main()