python-som 0.1.1__tar.gz

python_som-0.1.1/.gitignore

@@ -0,0 +1,129 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/

python_som-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 André Moreira Souza
+
+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.

python_som-0.1.1/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: python-som
+Version: 0.1.1
+Summary: Python implementation of the Self-Organizing Map
+Project-URL: Homepage, https://github.com/andremsouza/python-som
+Project-URL: Issues, https://github.com/andremsouza/python-som/issues
+Author-email: André Moreira Souza <msouza.andre@hotmail.com>
+License-Expression: MIT
+License-File: LICENSE
+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: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# python-som
+
+Implementation of the 2D self-organizing map, with support for NumPy arrays and Pandas DataFrames.
+Most features were implemented using NumPy, with Scikit-learn for standardization and PCA operations.
+
+## Features
+
+* Stepwise and batch training
+* Random weight initialization
+* Random sampling weight initialization
+* Linear weight initialization (with PCA)
+* Automatic selection of map size ratio (with PCA)
+* Support for cyclic arrays, for toroidal or spherical maps
+* Gaussian and Bubble neighborhood functions
+* Support for custom decay functions
+* Support for visualization (U-matrix, activation matrix)
+* Support for supervised learning (label map)
+* Support for NumPy arrays, Pandas DataFrames and regular lists of values
+
+## Usage
+In the following code excerpt (also available in [test.py](./test.py)) is an example of instantiation and training of a SOM with the Iris dataset:
+```python
+# Import python_som
+import python_som
+# Import NumPy and Pandas for storing data
+import numpy as np
+import pandas as pd
+# Import libraries for plotting results
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+# Load Iris dataset and columns of features and labels
+iris = sns.load_dataset('iris')
+target = iris.iloc[:, -1].to_numpy()
+iris = iris.iloc[:, :-1].to_numpy()
+# Transform labels into numeric codes for plotting
+tg = np.zeros(len(target), dtype=int)
+tg[target == 'setosa'] = 0
+tg[target == 'versicolor'] = 1
+tg[target == 'virginica'] = 2
+
+# Instantiate SOM from  python_som
+# Selecting shape automatically (providing dataset for constructor)
+# Using default decay and distance functions
+# Using gaussian neighborhood function
+# Using cyclic arrays in the vertical and horizontal directions
+som = python_som.SOM(x=20, y=None, input_len=iris.shape[1], learning_rate=0.5, neighborhood_radius=1.0,
+        neighborhood_function='gaussian', cyclic_x=True, cyclic_y=True, data=iris)
+
+# Initialize weights of the SOM with linear initialization
+som.weight_initialization(mode='linear', data=iris)
+
+# Training SOM with default number of iterations
+# Using batch learning process
+som.train(data=iris, n_iteration=len(iris), mode='batch', verbose=True)
+
+# Calculating distance matrix for plotting
+umatrix = som.distance_matrix().T
+
+# Plotting U-matrix with seaborn/matplotlib
+plt.figure(figsize=som.get_shape())
+plt.pcolor(umatrix, cmap='bone_r')
+
+markers = ['o', 's', 'D']
+colors = ['C0', 'C1', 'C2']
+for cnt, xx in enumerate(iris):
+    w = som.winner(xx)  # getting the winner
+    plt.plot(w[0] + .5, w[1] + .5, markers[tg[cnt]], markerfacecolor='None',
+             markeredgecolor=colors[tg[cnt]], markersize=12, markeredgewidth=2)
+plt.axis([0, som.get_shape()[0], 0, som.get_shape()[1]])
+plt.show()
+
+```
+
+### Test output
+The following image is generated from the previous test code, with the U-matrix of the trained SOM, and the distribution of the instances from the Iris dataset.
+In this graph, the instances are mapped to the self-organizing map, with color codes for each different label:
+* Setosa: blue circle
+* Versicolor: orange square
+* Virginica: green diamond
+
+![Test code output](./test_output_iris.png?raw=true)
+
+## Public methods and functions
+The following are lists of public methods and functions currently available in the SOM class. The full documentation of each method can be found in the [source code](./python_som/__init__.py):
+
+### Utility functions
+* _asymptotic_decay
+* _linear_decay
+* _exponential_decay
+* _inverse_decay
+* _euclidean_distance
+
+### SOM public methods
+* SOM
+* SOM.get_shape
+* SOM.get_weights
+* SOM.set_learning_rate
+* SOM.set_neighborhood_radius
+* SOM.activate
+* SOM.winner
+* SOM.quantization
+* SOM.quantization_error
+* SOM.distance_matrix
+* SOM.activation_matrix
+* SOM.winner_map
+* SOM.label_map
+* SOM.train
+* SOM.weight_initialization
+
+## References
+This implemetation was based on the following paper, by Professor Teuvo Kohonen:
+
+Teuvo Kohonen,
+Essentials of the self-organizing map,
+Neural Networks,
+Volume 37,
+2013,
+Pages 52-65,
+ISSN 0893-6080,
+https://doi.org/10.1016/j.neunet.2012.09.018.

python_som-0.1.1/README.md

@@ -0,0 +1,121 @@
+# python-som
+
+Implementation of the 2D self-organizing map, with support for NumPy arrays and Pandas DataFrames.
+Most features were implemented using NumPy, with Scikit-learn for standardization and PCA operations.
+
+## Features
+
+* Stepwise and batch training
+* Random weight initialization
+* Random sampling weight initialization
+* Linear weight initialization (with PCA)
+* Automatic selection of map size ratio (with PCA)
+* Support for cyclic arrays, for toroidal or spherical maps
+* Gaussian and Bubble neighborhood functions
+* Support for custom decay functions
+* Support for visualization (U-matrix, activation matrix)
+* Support for supervised learning (label map)
+* Support for NumPy arrays, Pandas DataFrames and regular lists of values
+
+## Usage
+In the following code excerpt (also available in [test.py](./test.py)) is an example of instantiation and training of a SOM with the Iris dataset:
+```python
+# Import python_som
+import python_som
+# Import NumPy and Pandas for storing data
+import numpy as np
+import pandas as pd
+# Import libraries for plotting results
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+# Load Iris dataset and columns of features and labels
+iris = sns.load_dataset('iris')
+target = iris.iloc[:, -1].to_numpy()
+iris = iris.iloc[:, :-1].to_numpy()
+# Transform labels into numeric codes for plotting
+tg = np.zeros(len(target), dtype=int)
+tg[target == 'setosa'] = 0
+tg[target == 'versicolor'] = 1
+tg[target == 'virginica'] = 2
+
+# Instantiate SOM from  python_som
+# Selecting shape automatically (providing dataset for constructor)
+# Using default decay and distance functions
+# Using gaussian neighborhood function
+# Using cyclic arrays in the vertical and horizontal directions
+som = python_som.SOM(x=20, y=None, input_len=iris.shape[1], learning_rate=0.5, neighborhood_radius=1.0,
+        neighborhood_function='gaussian', cyclic_x=True, cyclic_y=True, data=iris)
+
+# Initialize weights of the SOM with linear initialization
+som.weight_initialization(mode='linear', data=iris)
+
+# Training SOM with default number of iterations
+# Using batch learning process
+som.train(data=iris, n_iteration=len(iris), mode='batch', verbose=True)
+
+# Calculating distance matrix for plotting
+umatrix = som.distance_matrix().T
+
+# Plotting U-matrix with seaborn/matplotlib
+plt.figure(figsize=som.get_shape())
+plt.pcolor(umatrix, cmap='bone_r')
+
+markers = ['o', 's', 'D']
+colors = ['C0', 'C1', 'C2']
+for cnt, xx in enumerate(iris):
+    w = som.winner(xx)  # getting the winner
+    plt.plot(w[0] + .5, w[1] + .5, markers[tg[cnt]], markerfacecolor='None',
+             markeredgecolor=colors[tg[cnt]], markersize=12, markeredgewidth=2)
+plt.axis([0, som.get_shape()[0], 0, som.get_shape()[1]])
+plt.show()
+
+```
+
+### Test output
+The following image is generated from the previous test code, with the U-matrix of the trained SOM, and the distribution of the instances from the Iris dataset.
+In this graph, the instances are mapped to the self-organizing map, with color codes for each different label:
+* Setosa: blue circle
+* Versicolor: orange square
+* Virginica: green diamond
+
+![Test code output](./test_output_iris.png?raw=true)
+
+## Public methods and functions
+The following are lists of public methods and functions currently available in the SOM class. The full documentation of each method can be found in the [source code](./python_som/__init__.py):
+
+### Utility functions
+* _asymptotic_decay
+* _linear_decay
+* _exponential_decay
+* _inverse_decay
+* _euclidean_distance
+
+### SOM public methods
+* SOM
+* SOM.get_shape
+* SOM.get_weights
+* SOM.set_learning_rate
+* SOM.set_neighborhood_radius
+* SOM.activate
+* SOM.winner
+* SOM.quantization
+* SOM.quantization_error
+* SOM.distance_matrix
+* SOM.activation_matrix
+* SOM.winner_map
+* SOM.label_map
+* SOM.train
+* SOM.weight_initialization
+
+## References
+This implemetation was based on the following paper, by Professor Teuvo Kohonen:
+
+Teuvo Kohonen,
+Essentials of the self-organizing map,
+Neural Networks,
+Volume 37,
+2013,
+Pages 52-65,
+ISSN 0893-6080,
+https://doi.org/10.1016/j.neunet.2012.09.018.