annoviko / pyclustering Goto Github PK

Improve algorithm for more precision fill data clusters.

Method that returns U-matrix should be implemented.

Unit-tests are required for the graph coloring algorithm based on Kuramoto model.

Initial values of phases should be customizable.

Add unit tests and compare tests with another clustering algorithms.

Special format should be used for graph representation.
Mandatory fields:

• Graph description (matrix or list representation).
  Optional fields:
• Graph representation in the space.

Unit-tests should be implemented for testing functions related to Runge-Kutta algorithms: rk4(), rkf45().

Unit-tests are required for hysteresis network applied for graph coloring problem.

Interface network_interface should be support by sync network.

Unit-tests should be created for testing ROCK algorithm.

Runge-Kutta 45 algorithm should be implemented.

Hang (infinite loop) has been detected in test 'testWinners(self)' that is created for the PLSOM (tests.py) and that is commented right now.

!NOTE. There are no contradictions with specification!

Fragment of the test:
sample = read_sample('../../../Samples/SampleSimple3.txt');
network = plsom(5, 5, sample, stucture);
network.train();

It's not possible to run examples for antmeans algorithm: [antmeans.examples].

Traceback (most recent call last):
File "C:\Archive Files\PhD\PyClustering\antmeans\examples.py", line 10, in
import ant_clustering_with_mean as ant_clustering
ImportError: No module named 'ant_clustering_with_mean'

Invoker should be implemented that will invoke all existed unit-tests in project.

Investigation of the equation Kuramoto and model should be performing. Modification of the model is required for improvement results of coloring. Shortcommings can be observed in the examples for that algorithm.

Method 'allocate_sync_ensembles' should be implemented.

Runge-Kutta 4 algorithm should be implemented.

Connections between oscillators are not displayed. Should be implemented like for 2D. Method show().

Method that returns P-matrix should be implemented.

Interface network_interface should be supported by LEGION.

There is only one test that doen't work. Should be fixed.

Hysteresis network should be successor of class 'network' and provides standard methods.

Module that will contain modules related to solving graph coloring problem should be implemented. The first step is implementation of the algorithm based on the oscillatory neural network that based on the Kuramoto model. Unit-tests and examples should be implemented.

• Unit-tests should be implemented at least for easiest samples from Sample/ (SampleSimple1, SampleSimple2, etc.).
• Existed unit-test should be implemented.

Stability of the network should be improved.

Algorithm based on node saturation 'DSATUR' should be implemented for solving graph coloring problem.

String contatnts for samples should be implemented for avoiding situation when path to sample should be specified manually.

Introduction
Clustering algorithm EMA (Expectation Maximization Algorithm) should be implemented. EMA is an iterative method to find maximum likelihood or maximum a posteriori (MAP) estimates of parameters in statistical models.

EMA should be based on GMM (Gaussian Mixture Model) that should be also implemented if it is not available in 'scipy' library.

Resources

1. Theory: http://idiom.ucsd.edu/~rlevy/pmsl_textbook/chapters/pmsl_3.pdf
2. Youtube: https://www.youtube.com/watch?v=qMTuMa86NzU
3. Article: http://www.ics.uci.edu/~smyth/courses/cs274/notes/EMnotes.pdf
4. Bilmes, Jeff. "A Gentle Tutorial of the EM Algorithm and its Application to Parameter Estimation for Gaussian Mixture and Hidden Markov Models".
5. EM algorithm and variants: an informal tutorial by Alexis Roche.

Description
Expectation maximization algorithm should be implemented with doxygen documentation:
pyclustering/cluster/ema.py

Unit-tests:
pyclustering/cluster/tests/unit/ut_ema.py

Examples:
pyclustering/cluster/examples/ema_examples.py

An example of interface of EMA algorithm:

class ema:
    def __init__(self, data, other_paeameters):
        # Initialization of the instance algorithm.

    def process(self):
        # Implementation.

    def get_clusters(self):
        # Returns clusters.

    def get_probabilities(self):
        # Returns belonging probabilities.

Unit-tests should be created for the hierarchical algorithm.

It's the slowest algorithms in the project, even than ROCK. Should be improved by lacking calculation of Euclidean distance on each step.

Method: allocate_sync_ensembles
When we have high disorder and high tolerance then we can allocate several clusters that can have shared oscillators.

New method or existed should be created/modified for representation dynamics. Separation should be configurable, for example, [0, 2, 6] on the first subplot, [1, 3, 5] on the second. If configuration is not specified then each dynamic of each object should be represented separately.

Unit-tests should be created for the k-means algorithm.

Algorithm use mean for calculation cluster quality

The problem is that noise is positive, but it should be negative. But in this case proper configuration for examples should be used (founded).

In some way network works properly, except self-oscillations, and the problem can be described as the contradiction with the articles. The fix should be committed when proper configuration will be founded.

The function should be implemented for graphs representation in the graphical plane.

Unit-test should be created for hysteresis oscillatory network.

Methods for obtaining colors for graph vertices should be implemented for hysteresis and for sync networks.

Final number of objects that are allocated into clusters (include points that has been marked as noise) can be less than real number of points.

Test scenario:
dbscan SampleSimple1.txt 0.5 4

• templateLengthProcessData('../Samples/SampleSimple1.txt', 0.5, 0, 10);
• templateLengthProcessData('../Samples/SampleSimple3.txt', 1, 0, 20);

The definitions shoud be used from the module [samples] in each module (tests, examples, etc.) in the project instead of exact string pathes.

Interface network_interface should be supported by the hysteresis network.

Hysteresis neural network should be implemented in line with articles:
"Oscillatory Hysteresis Associative Memory"
"Dynamic hysteresis neural networks for graph coloring problem"

Several unit-tests are not applicable for the PLSOM algorithm. The uni-tests are used for testing SOM. Implementation of PLSOM is performed in line article.

Clustering algorithm should be implemented.

• unit-tests are required (tests.py).
• examples are required (examples.py).

Unit-tests are required for the SYNC-SOM algorithm.

Contradiction with specification (article) has been detected. Refactoring should be peformed for the ROCK algorithm in line specification.

Module that represents hierarchical clustering algorithm based on Sync should be implemented.

Unit-tests for LEGION network should be implemented.

Local excitatory and global inhibitory oscillatory network should be implemented.

Order parameter should be specified as parameter that defines stop condition for simulating network, thus process of synchronization is simulated until required state of synchronization is reached.