artlib 0.1.0__tar.gz

artlib-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2024] [Niklas M. Melton]
+
+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.

artlib-0.1.0/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.1
+Name: artlib
+Version: 0.1.0
+Summary: A Python library for Adaptive Resonance Theory (ART) algorithms.
+Home-page: https://github.com/NiklasMelton/AdaptiveResonanceLib
+License: MIT
+Keywords: adaptive resonance theory,ART,machine learning,neural networks,clustering
+Author: Niklas M. Melton
+Author-email: niklasmelton@gmail.com
+Requires-Python: >=3.9,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Dist: matplotlib (>=3.3.3)
+Requires-Dist: numpy (>=1.19.4)
+Requires-Dist: scikit-learn (>=1.0)
+Requires-Dist: scipy (>=1.5.4)
+Project-URL: Documentation, https://github.com/NiklasMelton/AdaptiveResonanceLib
+Project-URL: Repository, https://github.com/NiklasMelton/AdaptiveResonanceLib
+Description-Content-Type: text/markdown
+
+
+# AdaptiveResonanceLib
+
+Welcome to AdaptiveResonanceLib, a comprehensive and modular Python library for Adaptive Resonance Theory (ART) algorithms. Based on scikit-learn, our library offers a wide range of ART models designed for both researchers and practitioners in the field of machine learning and neural networks. Whether you're working on classification, clustering, or pattern recognition, AdaptiveResonanceLib provides the tools you need to implement ART algorithms efficiently and effectively.
+
+## Available Models
+
+AdaptiveResonanceLib includes implementations for the following ART models:
+
+- ART1
+- ART2
+- Bayesian ART
+- Gaussian ART
+- Hypersphere ART
+- Ellipsoidal ART
+- Fuzzy ART
+- Quadratic Neuron ART
+- Dual Vigilance ART
+- Topo ART
+- Simple ARTMAP
+- ARTMAP
+- DeepARTMAP
+- SMART
+- Fusion ART
+- Biclustering ARTMAP
+
+## Installation
+
+To install AdaptiveResonanceLib, simply use pip:
+
+[comment]: <> (```bash)
+
+[comment]: <> (pip install AdaptiveResonanceLib)
+
+[comment]: <> (```)
+
+```bash
+pip install artlib
+```
+
+Ensure you have Python 3.9 or newer installed.
+
+## Quick Start
+
+Here's a quick example of how to use AdaptiveResonanceLib with the Fuzzy ART model:
+
+```python
+from artlib import FuzzyART
+import numpy as np
+
+# Your dataset
+train_X = np.array([...])
+test_X = np.array([...])
+
+# Initialize the Fuzzy ART model
+model = FuzzyART(rho=0.7, alpha = 0.0, beta=1.0)
+
+# Fit the model
+model.fit(train_X)
+
+# Predict new data points
+predictions = model.predict(test_X)
+```
+
+Replace `params` with the parameters appropriate for your use case.
+
+## Documentation
+
+For more detailed documentation, including the full list of parameters for each model, visit our [documentation page](https://github.com/NiklasMelton/AdaptiveResonanceLib).
+
+## Examples
+
+For examples of how to use each model in AdaptiveResonanceLib, check out the `/examples` directory in our repository.
+
+## Contributing
+
+We welcome contributions to AdaptiveResonanceLib! If you have suggestions for improvements, or if you'd like to add more ART models, please see our `CONTRIBUTING.md` file for guidelines on how to contribute.
+
+You can also join our [Discord server](https://discord.gg/45FjtRCt) and participate directly in the discussion.
+
+## License
+
+AdaptiveResonanceLib is open source and available under the MIT license. See the `LICENSE` file for more info.
+
+## Contact
+
+For questions and support, please open an issue in the GitHub issue tracker or message us on our [Discord server](https://discord.gg/45FjtRCt). We'll do our best to assist you.
+
+Happy Modeling with AdaptiveResonanceLib!
+

artlib-0.1.0/README.md

@@ -0,0 +1,89 @@
+
+# AdaptiveResonanceLib
+
+Welcome to AdaptiveResonanceLib, a comprehensive and modular Python library for Adaptive Resonance Theory (ART) algorithms. Based on scikit-learn, our library offers a wide range of ART models designed for both researchers and practitioners in the field of machine learning and neural networks. Whether you're working on classification, clustering, or pattern recognition, AdaptiveResonanceLib provides the tools you need to implement ART algorithms efficiently and effectively.
+
+## Available Models
+
+AdaptiveResonanceLib includes implementations for the following ART models:
+
+- ART1
+- ART2
+- Bayesian ART
+- Gaussian ART
+- Hypersphere ART
+- Ellipsoidal ART
+- Fuzzy ART
+- Quadratic Neuron ART
+- Dual Vigilance ART
+- Topo ART
+- Simple ARTMAP
+- ARTMAP
+- DeepARTMAP
+- SMART
+- Fusion ART
+- Biclustering ARTMAP
+
+## Installation
+
+To install AdaptiveResonanceLib, simply use pip:
+
+[comment]: <> (```bash)
+
+[comment]: <> (pip install AdaptiveResonanceLib)
+
+[comment]: <> (```)
+
+```bash
+pip install artlib
+```
+
+Ensure you have Python 3.9 or newer installed.
+
+## Quick Start
+
+Here's a quick example of how to use AdaptiveResonanceLib with the Fuzzy ART model:
+
+```python
+from artlib import FuzzyART
+import numpy as np
+
+# Your dataset
+train_X = np.array([...])
+test_X = np.array([...])
+
+# Initialize the Fuzzy ART model
+model = FuzzyART(rho=0.7, alpha = 0.0, beta=1.0)
+
+# Fit the model
+model.fit(train_X)
+
+# Predict new data points
+predictions = model.predict(test_X)
+```
+
+Replace `params` with the parameters appropriate for your use case.
+
+## Documentation
+
+For more detailed documentation, including the full list of parameters for each model, visit our [documentation page](https://github.com/NiklasMelton/AdaptiveResonanceLib).
+
+## Examples
+
+For examples of how to use each model in AdaptiveResonanceLib, check out the `/examples` directory in our repository.
+
+## Contributing
+
+We welcome contributions to AdaptiveResonanceLib! If you have suggestions for improvements, or if you'd like to add more ART models, please see our `CONTRIBUTING.md` file for guidelines on how to contribute.
+
+You can also join our [Discord server](https://discord.gg/45FjtRCt) and participate directly in the discussion.
+
+## License
+
+AdaptiveResonanceLib is open source and available under the MIT license. See the `LICENSE` file for more info.
+
+## Contact
+
+For questions and support, please open an issue in the GitHub issue tracker or message us on our [Discord server](https://discord.gg/45FjtRCt). We'll do our best to assist you.
+
+Happy Modeling with AdaptiveResonanceLib!

artlib-0.1.0/artlib/__init__.py

@@ -0,0 +1,47 @@
+from artlib.common.BaseART import BaseART
+from artlib.common.BaseARTMAP import BaseARTMAP
+from artlib.common.utils import normalize, compliment_code
+
+from artlib.elementary.ART1 import ART1
+from artlib.elementary.ART2 import ART2A
+from artlib.elementary.BayesianART import BayesianART
+from artlib.elementary.DualVigilanceART import DualVigilanceART
+from artlib.elementary.EllipsoidART import EllipsoidART
+from artlib.elementary.GaussianART import GaussianART
+from artlib.elementary.FuzzyART import FuzzyART
+from artlib.elementary.HypersphereART import HypersphereART
+from artlib.elementary.QuadraticNeuronART import QuadraticNeuronART
+
+from artlib.supervised.ARTMAP import ARTMAP, SimpleARTMAP
+
+from artlib.hierarchical.SMART import SMART
+from artlib.hierarchical.DeepARTMAP import DeepARTMAP
+
+from artlib.fusion.FusionART import FusionART
+
+from artlib.biclustering.BARTMAP import BARTMAP
+
+from artlib.topological.TopoART import TopoART
+
+__all__ = [
+    "BaseART",
+    "BaseARTMAP",
+    "normalize",
+    "compliment_code",
+    "ART1",
+    "ART2A",
+    "BayesianART",
+    "GaussianART",
+    "EllipsoidART",
+    "HypersphereART",
+    "QuadraticNeuronART",
+    "FuzzyART",
+    "TopoART",
+    "DualVigilanceART",
+    "ARTMAP",
+    "SimpleARTMAP",
+    "DeepARTMAP",
+    "SMART",
+    "FusionART",
+    "BARTMAP",
+]

artlib-0.1.0/artlib/biclustering/BARTMAP.py

@@ -0,0 +1,344 @@
+"""
+Xu, R., & Wunsch II, D. C. (2011).
+BARTMAP: A viable structure for biclustering.
+Neural Networks, 24, 709–716. doi:10.1016/j.neunet.2011.03.020.
+
+Xu, R., Wunsch II, D. C., & Kim, S. (2012).
+Methods and systems for biclustering algorithm.
+U.S. Patent 9,043,326 Filed January 28, 2012,
+claiming priority to Provisional U.S. Patent Application,
+January 28, 2011, issued May 26, 2015.
+"""
+
+import numpy as np
+from typing import Optional
+from collections import defaultdict
+from matplotlib.colors import Colormap
+from artlib.common.BaseART import BaseART
+from sklearn.base import BaseEstimator, BiclusterMixin
+from scipy.stats import pearsonr
+
+class BARTMAP(BaseEstimator, BiclusterMixin):
+    rows_: np.ndarray #bool
+    columns_: np.ndarray #bool
+
+    def __init__(self, module_a: BaseART, module_b: BaseART, eta: float):
+        """
+
+        Parameters:
+        - module_a: a-side ART module
+        - module_b: b-side ART module
+        - eta: minimum correlation
+
+        """
+        params: dict = {"eta": eta}
+        self.validate_params(params)
+        self.params = params
+        self.module_a = module_a
+        self.module_b = module_b
+
+    def __getattr__(self, key):
+        if key in self.params:
+            return self.params[key]
+        else:
+            # If the key is not in params, raise an AttributeError
+            raise AttributeError(f"'{type(self).__name__}' object has no attribute '{key}'")
+
+    def __setattr__(self, key, value):
+        if key in self.__dict__.get('params', {}):
+            # If key is in params, set its value
+            self.params[key] = value
+        else:
+            # Otherwise, proceed with normal attribute setting
+            super().__setattr__(key, value)
+
+    def get_params(self, deep: bool = True) -> dict:
+        """
+
+        Parameters:
+        - deep: If True, will return the parameters for this class and contained subobjects that are estimators.
+
+        Returns:
+            Parameter names mapped to their values.
+
+        """
+        out = self.params
+
+        deep_a_items = self.module_a.get_params().items()
+        out.update(("module_a" + "__" + k, val) for k, val in deep_a_items)
+        out["module_a"] = self.module_a
+
+        deep_b_items = self.module_b.get_params().items()
+        out.update(("module_b" + "__" + k, val) for k, val in deep_b_items)
+        out["module_b"] = self.module_b
+        return out
+
+    def set_params(self, **params):
+        """Set the parameters of this estimator.
+
+        Specific redefinition of sklearn.BaseEstimator.set_params for ART classes
+
+        Parameters:
+        - **params : Estimator parameters.
+
+        Returns:
+        - self : estimator instance
+        """
+
+        if not params:
+            # Simple optimization to gain speed (inspect is slow)
+            return self
+        valid_params = self.get_params(deep=True)
+        local_params = dict()
+
+        nested_params = defaultdict(dict)  # grouped by prefix
+        for key, value in params.items():
+            key, delim, sub_key = key.partition("__")
+            if key not in valid_params:
+                local_valid_params = list(valid_params.keys())
+                raise ValueError(
+                    f"Invalid parameter {key!r} for estimator {self}. "
+                    f"Valid parameters are: {local_valid_params!r}."
+                )
+
+            if delim:
+                nested_params[key][sub_key] = value
+            else:
+                setattr(self, key, value)
+                valid_params[key] = value
+                local_params[key] = value
+
+        for key, sub_params in nested_params.items():
+            valid_params[key].set_params(**sub_params)
+        self.validate_params(local_params)
+        return self
+
+    @staticmethod
+    def validate_params(params):
+        """
+        validate clustering parameters
+
+        Parameters:
+        - params: dict containing parameters for the algorithm
+
+        """
+        assert "eta" in params
+        assert isinstance(params["eta"], float)
+
+    @property
+    def column_labels_(self):
+        return self.module_b.labels_
+
+    @property
+    def row_labels_(self):
+        return self.module_a.labels_
+
+    @property
+    def n_row_clusters(self):
+        return self.module_a.n_clusters
+
+    @property
+    def n_column_clusters(self):
+        return self.module_b.n_clusters
+
+    def _get_x_cb(self, x: np.ndarray, c_b: int):
+        """
+        get the components of a vector belonging to a b-side cluster
+
+        Parameters:
+        - x: a sample vector
+        - c_b: b-side cluster label
+
+        Returns:
+            x filtered to features belonging to the b-side cluster c_b
+
+        """
+        b_components = self.module_b.labels_ == c_b
+        return x[b_components]
+
+    @staticmethod
+    def _pearsonr(a: np.ndarray, b: np.ndarray):
+        """
+        get the correlation between two vectors
+
+        Parameters:
+        - a: some vector
+        - b: some vector
+
+        Returns:
+            Pearson correlation
+
+        """
+        r, _ = pearsonr(a, b)
+        return r
+
+    def _average_pearson_corr(self, X: np.ndarray, k: int, c_b: int) -> float:
+        """
+        get the average correlation between for a sample for all features in cluster b
+
+        Parameters:
+        - X: data set A
+        - k: sample index
+        - c_b: b-side cluster to check
+
+        """
+        X_a = X[self.column_labels_ == c_b, :]
+        if len(X_a) == 0:
+            raise ValueError("HERE")
+        X_k_cb = self._get_x_cb(X[k,:], c_b)
+        mean_r = np.mean(
+            [
+                self._pearsonr(X_k_cb, self._get_x_cb(x_a_l, c_b))
+                for x_a_l in X_a
+            ]
+        )
+
+        return float(mean_r)
+
+    def validate_data(self, X_a: np.ndarray, X_b: np.ndarray):
+        """
+        validates the data prior to clustering
+
+        Parameters:
+        - X: data set A
+        - y: data set B
+
+        """
+        self.module_a.validate_data(X_a)
+        self.module_b.validate_data(X_b)
+
+    def match_criterion_bin(self, X: np.ndarray, k: int, c_b: int, params: dict) -> bool:
+        """
+        get the binary match criterion of the cluster
+
+        Parameters:
+        - X: data set
+        - k: sample index
+        - c_b: b-side cluster to check
+        - params: dict containing parameters for the algorithm
+
+        Returns:
+            cluster match criterion binary
+
+        """
+        M = self._average_pearson_corr(X, k, c_b)
+        return M >= self.params["eta"]
+
+    def match_reset_func(
+            self,
+            i: np.ndarray,
+            w: np.ndarray,
+            cluster_a,
+            params: dict,
+            extra: dict,
+            cache: Optional[dict] = None
+    ) -> bool:
+        """
+        Permits external factors to influence cluster creation.
+
+        Parameters:
+        - i: data sample
+        - w: cluster weight / info
+        - cluster_a: a-side cluster label
+        - params: dict containing parameters for the algorithm
+        - extra: additional parameters for the algorithm
+        - cache: dict containing values cached from previous calculations
+
+        Returns:
+            true if match is permitted
+
+        """
+        k = extra["k"]
+        for cluster_b in range(len(self.module_b.W)):
+            if self.match_criterion_bin(self.X, k, cluster_b, params):
+                return True
+        return False
+
+    def step_fit(self, X: np.ndarray, k: int) -> int:
+        """
+        fit the model to a single sample
+
+        Parameters:
+        - X: data set
+        - k: sample index
+
+        Returns:
+            cluster label of the input sample
+
+        """
+        match_reset_func = lambda i, w, cluster, params, cache: self.match_reset_func(
+            i, w, cluster, params=params, extra={"k": k}, cache=cache
+        )
+        c_a = self.module_a.step_fit(X[k, :], match_reset_func=match_reset_func)
+        return c_a
+
+    def fit(self, X: np.ndarray, max_iter=1):
+        """
+        Fit the model to the data
+
+        Parameters:
+        - X: data set
+        - max_iter: number of iterations to fit the model on the same data set
+
+        """
+        # Check that X and y have correct shape
+        self.X = X
+
+        n = X.shape[0]
+        X_a = self.module_b.prepare_data(X)
+        X_b = self.module_b.prepare_data(X.T)
+        self.validate_data(X_a, X_b)
+
+
+        self.module_b = self.module_b.fit(X_b, max_iter=max_iter)
+
+        # init module A
+        self.module_a.W = []
+        self.module_a.labels_ = np.zeros((X.shape[0],), dtype=int)
+
+        for _ in range(max_iter):
+            for k in range(n):
+                print(k, self.module_a.n_clusters)
+                self.module_a.pre_step_fit(X)
+                c_a = self.step_fit(X_a, k)
+                self.module_a.labels_[k] = c_a
+                self.module_a.post_step_fit(X)
+
+        self.rows_ = np.vstack(
+            [
+                self.row_labels_ == label
+                for label in range(self.module_a.n_clusters)
+                for _ in range(self.module_b.n_clusters)
+            ]
+        )
+        self.columns_ = np.vstack(
+            [
+                self.column_labels_ == label
+                for _ in range(self.module_a.n_clusters)
+                for label in range(self.module_b.n_clusters)
+            ]
+        )
+        return self
+
+
+    def visualize(
+            self,
+            cmap: Optional[Colormap] = None
+    ):
+        """
+        Visualize the clustering of the data
+
+        Parameters:
+        - cmap: some colormap
+
+        """
+        import matplotlib.pyplot as plt
+
+        if cmap is None:
+            from matplotlib.pyplot import cm
+            cmap=plt.cm.Blues
+
+        plt.matshow(
+            np.outer(np.sort(self.row_labels_) + 1, np.sort(self.column_labels_) + 1),
+            cmap=cmap,
+        )