neural-feature-importance 0.5.0__tar.gz → 0.5.2__tar.gz

neural_feature_importance-0.5.2/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: neural-feature-importance
+Version: 0.5.2
+Summary: Variance-based feature importance for Neural Networks using callbacks for Keras and PyTorch
+Author: CR de Sá
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Provides-Extra: tensorflow
+Requires-Dist: tensorflow; extra == "tensorflow"
+Provides-Extra: torch
+Requires-Dist: torch; extra == "torch"
+
+# neural-feature-importance
+
+[![PyPI version](https://img.shields.io/pypi/v/neural-feature-importance.svg)](https://pypi.org/project/neural-feature-importance/)
+[![Python versions](https://img.shields.io/pypi/pyversions/neural-feature-importance.svg)](https://pypi.org/project/neural-feature-importance/)
+
+Variance-based feature importance for deep learning models.
+
+`neural-feature-importance` implements the method described in
+[CR de Sá, *Variance-based Feature Importance in Neural Networks*](https://doi.org/10.1007/978-3-030-33778-0_24).
+It tracks the variance of the first trainable layer using Welford's algorithm
+and produces normalized importance scores for each feature.
+
+## Features
+
+- `VarianceImportanceKeras` — drop-in callback for TensorFlow/Keras models
+- `VarianceImportanceTorch` — helper class for PyTorch training loops
+- `MetricThreshold` — early-stopping callback based on a monitored metric
+- Example scripts to reproduce the experiments from the paper
+
+## Installation
+
+```bash
+pip install "neural-feature-importance[tensorflow]"  # for Keras
+pip install "neural-feature-importance[torch]"       # for PyTorch
+```
+
+Retrieve the package version via:
+
+```python
+from neural_feature_importance import __version__
+print(__version__)
+```
+
+## Quick start
+
+### Keras
+
+```python
+from neural_feature_importance import VarianceImportanceKeras
+from neural_feature_importance.utils import MetricThreshold
+
+viann = VarianceImportanceKeras()
+monitor = MetricThreshold(monitor="val_accuracy", threshold=0.95)
+model.fit(X, y, validation_split=0.05, epochs=30, callbacks=[viann, monitor])
+print(viann.feature_importances_)
+```
+
+### PyTorch
+
+```python
+from neural_feature_importance import VarianceImportanceTorch
+
+tracker = VarianceImportanceTorch(model)
+tracker.on_train_begin()
+for epoch in range(num_epochs):
+    train_one_epoch(model, optimizer, dataloader)
+    tracker.on_epoch_end()
+tracker.on_train_end()
+print(tracker.feature_importances_)
+```
+
+## Example scripts
+
+Run `compare_feature_importance.py` to train a small network on the Iris dataset
+and compare the scores with a random forest baseline:
+
+```bash
+python compare_feature_importance.py
+```
+
+Run `full_experiment.py` to reproduce the experiments from the paper:
+
+```bash
+python full_experiment.py
+```
+
+## Development
+
+After making changes, run the following checks:
+
+```bash
+python -m py_compile neural_feature_importance/callbacks.py
+python -m py_compile "variance-based feature importance in artificial neural networks.ipynb" 2>&1 | head
+jupyter nbconvert --to script "variance-based feature importance in artificial neural networks.ipynb" --stdout | head
+```
+
+## Citation
+
+If you use this package in your research, please cite:
+
+```bibtex
+@inproceedings{DBLP:conf/dis/Sa19,
+  author       = {Cl{\'a}udio Rebelo de S{\'a}},
+  editor       = {Petra Kralj Novak and
+                  Tomislav Smuc and
+                  Saso Dzeroski},
+  title        = {Variance-Based Feature Importance in Neural Networks},
+  booktitle    = {Discovery Science - 22nd International Conference, {DS} 2019, Split,
+                  Croatia, October 28-30, 2019, Proceedings},
+  series       = {Lecture Notes in Computer Science},
+  volume       = {11828},
+  pages        = {306--315},
+  publisher    = {Springer},
+  year         = {2019},
+  url          = {https://doi.org/10.1007/978-3-030-33778-0\_24},
+  doi          = {10.1007/978-3-030-33778-0\_24},
+  timestamp    = {Thu, 07 Nov 2019 09:20:36 +0100},
+  biburl       = {https://dblp.org/rec/conf/dis/Sa19.bib},
+  bibsource    = {dblp computer science bibliography, https://dblp.org}
+}
+```
+
+We appreciate citations as they help the community discover this work.

neural_feature_importance-0.5.2/README.md

@@ -0,0 +1,113 @@
+# neural-feature-importance
+
+[![PyPI version](https://img.shields.io/pypi/v/neural-feature-importance.svg)](https://pypi.org/project/neural-feature-importance/)
+[![Python versions](https://img.shields.io/pypi/pyversions/neural-feature-importance.svg)](https://pypi.org/project/neural-feature-importance/)
+
+Variance-based feature importance for deep learning models.
+
+`neural-feature-importance` implements the method described in
+[CR de Sá, *Variance-based Feature Importance in Neural Networks*](https://doi.org/10.1007/978-3-030-33778-0_24).
+It tracks the variance of the first trainable layer using Welford's algorithm
+and produces normalized importance scores for each feature.
+
+## Features
+
+- `VarianceImportanceKeras` — drop-in callback for TensorFlow/Keras models
+- `VarianceImportanceTorch` — helper class for PyTorch training loops
+- `MetricThreshold` — early-stopping callback based on a monitored metric
+- Example scripts to reproduce the experiments from the paper
+
+## Installation
+
+```bash
+pip install "neural-feature-importance[tensorflow]"  # for Keras
+pip install "neural-feature-importance[torch]"       # for PyTorch
+```
+
+Retrieve the package version via:
+
+```python
+from neural_feature_importance import __version__
+print(__version__)
+```
+
+## Quick start
+
+### Keras
+
+```python
+from neural_feature_importance import VarianceImportanceKeras
+from neural_feature_importance.utils import MetricThreshold
+
+viann = VarianceImportanceKeras()
+monitor = MetricThreshold(monitor="val_accuracy", threshold=0.95)
+model.fit(X, y, validation_split=0.05, epochs=30, callbacks=[viann, monitor])
+print(viann.feature_importances_)
+```
+
+### PyTorch
+
+```python
+from neural_feature_importance import VarianceImportanceTorch
+
+tracker = VarianceImportanceTorch(model)
+tracker.on_train_begin()
+for epoch in range(num_epochs):
+    train_one_epoch(model, optimizer, dataloader)
+    tracker.on_epoch_end()
+tracker.on_train_end()
+print(tracker.feature_importances_)
+```
+
+## Example scripts
+
+Run `compare_feature_importance.py` to train a small network on the Iris dataset
+and compare the scores with a random forest baseline:
+
+```bash
+python compare_feature_importance.py
+```
+
+Run `full_experiment.py` to reproduce the experiments from the paper:
+
+```bash
+python full_experiment.py
+```
+
+## Development
+
+After making changes, run the following checks:
+
+```bash
+python -m py_compile neural_feature_importance/callbacks.py
+python -m py_compile "variance-based feature importance in artificial neural networks.ipynb" 2>&1 | head
+jupyter nbconvert --to script "variance-based feature importance in artificial neural networks.ipynb" --stdout | head
+```
+
+## Citation
+
+If you use this package in your research, please cite:
+
+```bibtex
+@inproceedings{DBLP:conf/dis/Sa19,
+  author       = {Cl{\'a}udio Rebelo de S{\'a}},
+  editor       = {Petra Kralj Novak and
+                  Tomislav Smuc and
+                  Saso Dzeroski},
+  title        = {Variance-Based Feature Importance in Neural Networks},
+  booktitle    = {Discovery Science - 22nd International Conference, {DS} 2019, Split,
+                  Croatia, October 28-30, 2019, Proceedings},
+  series       = {Lecture Notes in Computer Science},
+  volume       = {11828},
+  pages        = {306--315},
+  publisher    = {Springer},
+  year         = {2019},
+  url          = {https://doi.org/10.1007/978-3-030-33778-0\_24},
+  doi          = {10.1007/978-3-030-33778-0\_24},
+  timestamp    = {Thu, 07 Nov 2019 09:20:36 +0100},
+  biburl       = {https://dblp.org/rec/conf/dis/Sa19.bib},
+  bibsource    = {dblp computer science bibliography, https://dblp.org}
+}
+```
+
+We appreciate citations as they help the community discover this work.

neural_feature_importance-0.5.2/neural_feature_importance.egg-info/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: neural-feature-importance
+Version: 0.5.2
+Summary: Variance-based feature importance for Neural Networks using callbacks for Keras and PyTorch
+Author: CR de Sá
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Provides-Extra: tensorflow
+Requires-Dist: tensorflow; extra == "tensorflow"
+Provides-Extra: torch
+Requires-Dist: torch; extra == "torch"
+
+# neural-feature-importance
+
+[![PyPI version](https://img.shields.io/pypi/v/neural-feature-importance.svg)](https://pypi.org/project/neural-feature-importance/)
+[![Python versions](https://img.shields.io/pypi/pyversions/neural-feature-importance.svg)](https://pypi.org/project/neural-feature-importance/)
+
+Variance-based feature importance for deep learning models.
+
+`neural-feature-importance` implements the method described in
+[CR de Sá, *Variance-based Feature Importance in Neural Networks*](https://doi.org/10.1007/978-3-030-33778-0_24).
+It tracks the variance of the first trainable layer using Welford's algorithm
+and produces normalized importance scores for each feature.
+
+## Features
+
+- `VarianceImportanceKeras` — drop-in callback for TensorFlow/Keras models
+- `VarianceImportanceTorch` — helper class for PyTorch training loops
+- `MetricThreshold` — early-stopping callback based on a monitored metric
+- Example scripts to reproduce the experiments from the paper
+
+## Installation
+
+```bash
+pip install "neural-feature-importance[tensorflow]"  # for Keras
+pip install "neural-feature-importance[torch]"       # for PyTorch
+```
+
+Retrieve the package version via:
+
+```python
+from neural_feature_importance import __version__
+print(__version__)
+```
+
+## Quick start
+
+### Keras
+
+```python
+from neural_feature_importance import VarianceImportanceKeras
+from neural_feature_importance.utils import MetricThreshold
+
+viann = VarianceImportanceKeras()
+monitor = MetricThreshold(monitor="val_accuracy", threshold=0.95)
+model.fit(X, y, validation_split=0.05, epochs=30, callbacks=[viann, monitor])
+print(viann.feature_importances_)
+```
+
+### PyTorch
+
+```python
+from neural_feature_importance import VarianceImportanceTorch
+
+tracker = VarianceImportanceTorch(model)
+tracker.on_train_begin()
+for epoch in range(num_epochs):
+    train_one_epoch(model, optimizer, dataloader)
+    tracker.on_epoch_end()
+tracker.on_train_end()
+print(tracker.feature_importances_)
+```
+
+## Example scripts
+
+Run `compare_feature_importance.py` to train a small network on the Iris dataset
+and compare the scores with a random forest baseline:
+
+```bash
+python compare_feature_importance.py
+```
+
+Run `full_experiment.py` to reproduce the experiments from the paper:
+
+```bash
+python full_experiment.py
+```
+
+## Development
+
+After making changes, run the following checks:
+
+```bash
+python -m py_compile neural_feature_importance/callbacks.py
+python -m py_compile "variance-based feature importance in artificial neural networks.ipynb" 2>&1 | head
+jupyter nbconvert --to script "variance-based feature importance in artificial neural networks.ipynb" --stdout | head
+```
+
+## Citation
+
+If you use this package in your research, please cite:
+
+```bibtex
+@inproceedings{DBLP:conf/dis/Sa19,
+  author       = {Cl{\'a}udio Rebelo de S{\'a}},
+  editor       = {Petra Kralj Novak and
+                  Tomislav Smuc and
+                  Saso Dzeroski},
+  title        = {Variance-Based Feature Importance in Neural Networks},
+  booktitle    = {Discovery Science - 22nd International Conference, {DS} 2019, Split,
+                  Croatia, October 28-30, 2019, Proceedings},
+  series       = {Lecture Notes in Computer Science},
+  volume       = {11828},
+  pages        = {306--315},
+  publisher    = {Springer},
+  year         = {2019},
+  url          = {https://doi.org/10.1007/978-3-030-33778-0\_24},
+  doi          = {10.1007/978-3-030-33778-0\_24},
+  timestamp    = {Thu, 07 Nov 2019 09:20:36 +0100},
+  biburl       = {https://dblp.org/rec/conf/dis/Sa19.bib},
+  bibsource    = {dblp computer science bibliography, https://dblp.org}
+}
+```
+
+We appreciate citations as they help the community discover this work.

{neural_feature_importance-0.5.0 → neural_feature_importance-0.5.2}/pyproject.toml

@@ -6,8 +6,10 @@ build-backend = "setuptools.build_meta"
 name = "neural-feature-importance"
 description = "Variance-based feature importance for Neural Networks using callbacks for Keras and PyTorch"
 authors = [{name = "CR de Sá"}]
+readme = "README.md"
 dependencies = ["numpy"]
 dynamic = ["version"]
+requires-python = ">=3.10"
 
 [project.optional-dependencies]
 tensorflow = ["tensorflow"]

neural_feature_importance-0.5.0/PKG-INFO

@@ -1,10 +0,0 @@
-Metadata-Version: 2.4
-Name: neural-feature-importance
-Version: 0.5.0
-Summary: Variance-based feature importance for Neural Networks using callbacks for Keras and PyTorch
-Author: CR de Sá
-Requires-Dist: numpy
-Provides-Extra: tensorflow
-Requires-Dist: tensorflow; extra == "tensorflow"
-Provides-Extra: torch
-Requires-Dist: torch; extra == "torch"

neural_feature_importance-0.5.0/README.md

@@ -1,95 +0,0 @@
-# Variance-based Feature Importance in Neural Networks / Deep Learning
-
-This file provides a working example of how to measure the importance of features (inputs) in neural networks. 
-
-This method is a new method to measure the relative importance of features in Artificial Neural Networks (ANN) models. Its underlying principle assumes that the more important a feature is, the more the weights, connected to the respective input neuron, will change during the training of the model. To capture this behavior, a running variance of every weight connected to the input layer is measured during training. For that, an adaptation of Welford's online algorithm for computing the online variance is proposed.
-
-When the training is finished, for each input, the variances of the weights are combined with the final weights to obtain the measure of relative importance for each feature.
-
-The file **variance-based feature importance in artificial neural networks.ipynb** includes the code to fully replicate the results obtained in the paper:
-
-CR de Sá [**Variance-based Feature Importance in Neural Networks**](https://doi.org/10.1007/978-3-030-33778-0_24)  
-22st International Conference on Discovery Science (DS 2019) Split, Croatia, October 28-30, 2019
-
-
-## VIANN
-#### Variance-based Feature Importance of Artificial Neural Networks
-
-This repository exposes the feature importance callback as a small Python package named `neural-feature-importance`.
-It will automatically track the first layer that contains trainable weights so you can use it with models that start with an `InputLayer` or other preprocessing layers.
-There is also a helper for PyTorch models that follows the same API.
-
-Install with pip and select the extras that match your framework:
-
-```bash
-pip install "neural-feature-importance[tensorflow]"  # for Keras
-pip install "neural-feature-importance[torch]"       # for PyTorch
-```
-
-The package uses `setuptools_scm` to derive its version from Git tags. Access it
-via:
-
-```python
-from neural_feature_importance import __version__
-
-print(__version__)
-```
-
-```python
-from neural_feature_importance import VarianceImportanceCallback, AccuracyMonitor
-
-import logging
-
-logging.basicConfig(level=logging.INFO)
-
-VIANN = VarianceImportanceCallback()
-monitor = AccuracyMonitor(baseline=0.95)
-```
-
-For a PyTorch model, use ``VarianceImportanceTorch`` and call its
-``on_train_begin``, ``on_epoch_end`` and ``on_train_end`` methods inside your
-training loop:
-
-```python
-from neural_feature_importance import VarianceImportanceTorch
-
-tracker = VarianceImportanceTorch(model)
-tracker.on_train_begin()
-for epoch in range(num_epochs):
-    train_one_epoch(model, optimizer, data_loader)
-    tracker.on_epoch_end()
-tracker.on_train_end()
-print(tracker.var_scores)
-```
-
-Use this callback during model training:
-
-```python
-model = Sequential()
-model.add(Dense(50, input_dim=input_dim, activation='relu', kernel_initializer='normal', kernel_regularizer=l2(0.01)))
-model.add(Dense(100, activation='relu', kernel_initializer='normal', kernel_regularizer=l2(0.01)))
-model.add(Dense(50, activation='relu', kernel_initializer='normal', kernel_regularizer=l2(0.01)))
-model.add(Dense(5, activation='softmax', kernel_initializer='normal'))
-
-model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy'])
-model.fit(X, Y, validation_split=0.05, epochs=30, batch_size=64, shuffle=True,
-          verbose=1, callbacks=[VIANN, monitor])
-
-print(VIANN.var_scores)
-```
-
-## Comparing with Random Forest
-
-To verify the variance-based scores, run `compare_feature_importance.py`. The
-script trains a small neural network on the Iris dataset and compares the scores
-with those from a `RandomForestClassifier`.
-
-```bash
-python compare_feature_importance.py
-```
-
-For a larger experiment across several datasets, run `full_experiment.py`. The script builds a simple network for each dataset, applies the `AccuracyMonitor` for early stopping, and prints the correlation between neural network importances and a random forest baseline.
-
-```bash
-python full_experiment.py
-```

neural_feature_importance-0.5.0/neural_feature_importance.egg-info/PKG-INFO

@@ -1,10 +0,0 @@
-Metadata-Version: 2.4
-Name: neural-feature-importance
-Version: 0.5.0
-Summary: Variance-based feature importance for Neural Networks using callbacks for Keras and PyTorch
-Author: CR de Sá
-Requires-Dist: numpy
-Provides-Extra: tensorflow
-Requires-Dist: tensorflow; extra == "tensorflow"
-Provides-Extra: torch
-Requires-Dist: torch; extra == "torch"