seracio / kohonen

A basic implementation of a Kohonen map in JavaScript

kohonen

A basic implementation of a Kohonen map in JavaScript

Disclaimer: this is a toy implementation of the SOM algorithm, you should probably consider using a more solid library in R or Python.

Usage

Import lib

npm i d3-array d3-scale d3-random lodash ml-pca @seracio/kohonen --save

Then, in your JS script :

import { Kohonen, generateGrid } from '@seracio/kohonen';

API

Kohonen

The Kohonen class is the main class.

Constructor

param name	definition	type	mandatory	default
neurons	grid of neurons	Array	yes
data	dataset	Array of Array	yes
maxStep	step max to clamp	Number	no	1000
maxLearningCoef		Number	no	.4
minLearningCoef		Number	no	.1
maxNeighborhood		Number	no	1
minNeighborhood		Number	no	.3

// instanciate your Kohonen map
const k = new Kohonen({ data, neurons });

// you can use the grid helper to generate a grid with 10x10 hexagons
const k = new Kohonen({ data, neurons: generateGrid(10, 10) });

neurons parameter should be a flat array of { pos: [x,y] }. pos array being the coordinate on the grid.

data parameter is an array of the vectors you want to display. There is no need to standardize your data, that will be done internally by scaling each feature to the [0,1] range.

Basically the constructor do :

• standardize the given data set
• initialize random weights for neurons using PCA's largests eigenvectors

training method

param name	definition	type	mandatory	default
log	func called after each step of learning process	Function	no	(neurons, step)=>{}

k.training();

training method iterates on random vectors picked on normalized data. If a log function is provided as a parameter, it will receive instance neurons and step as params.

mapping method

mapping method returns grid position for each data provided on the constructor.

const myPositions = k.mapping();

umatrix method

umatrix method returns the U-Matrix of the grid (currently only with standardized vectors).

const umatrix = k.umatrix();

errors

There are some heavy calculations in those 2 methods ; if you use them in the training callback (log), it's better not to use it on every step.

k.topographicError();
k.quantizationError();

k.training((neurons, step) => {
    if (step % 20 === 0) {
        k.topographicError();
        k.quantizationError();
    }
});

Example

We've developed a full example on a dedicated repository

(Re)sources

• The Self-Organizing Map (SOM)
• d3
• lodash/fp
• ml-pca
• Loadings vs eigenvector in PCA
• SOM tutorial
• Shyam M. Guthikonda

kohonen's Issues

Dist

Min coeffs should be parameters too

Training step

Iterate over the given datas will be more efficient than attempting to generate close data

What about U-matrix ?

upgrade ml-pca

kohonen/src/Kohonen.ts

Line 4 in 6eaf975

import PCA from 'ml-pca';

Replace this line to import { PCA } from 'ml-pca'; please.
mljs/pca uses named export

Quality measures

Readme

Add this as a resource

use [email protected]

Neurons' vectors init

in v0.7.0, we've fixed an issue, but this deserves more tests

Doc on readme

When calculating BMU, euclidian distance is not necessary

We can improve performance by removing sqrt

Weight initialisation

The weights of the neurons are initialized either to small random values or sampled evenly from the subspace spanned by the two largest principal component eigenvectors

https://en.wikipedia.org/wiki/Principal_component_analysis

Add yarn

Refactoring on the API : use training and mapping

Hydrate / dehydrate map

math functions should be removed as d3 already provided them

Convergence on single neuron with large vectors

I've been playing with this a bit more and it works well for the canonical example of mapping colours. However, when I feed data with more variables (~40) into the SOM, all of the inputs tend to converge on a single neuron.

You seem to have had this issue before with: #17, I'm wondering if it is again related to normalisation?

Should probably have:

• options for normalisation and re evaluate normalisation strategy
• more extensive tests for data with larger vectors

expose a function to get the value of a single datum

Actually, you can use findBestMatchingUnit, but it assums that your vector is already normalized...

This will be useful to get vector positions from data others than the training set

First draft

• with hexagons

cb parameter in run should be called log

Issue when data dimensions is bigger than dataset cardinality

The API must be more modular and optional,
As @cbanbury noted in #43, this library is probably buggy, it's time to reconsider the design options

Random training data should be in the data range

Input normaization

We should use a [0,1] normalization I guess

Performance with large arrays

Hi,

Are you still actively working on this? I've been playing with this package using spectral data and seems to hang with very large arrays (3000).

How far would you reasonably expect this to scale?

Calculation with decimal.js or Numeric JavaScript ?

API redesign

The API should be more modular, basically, I think that every process step should be overridable thanks to a sub class

Should we really use a gaussian normalization ?

It shouldn't use babel-runtime

Is it possible to provide k.mapping() during training?

I'm just trying out this library (thanks for sharing!), and would like to create a demonstrator of the algorithm.

For this I would like to be able to "pause" every few steps and display the current state of the system. log() seems to get the state of the neurons only.

Here's a (very simple and unfinished) demo
http://bl.ocks.org/Fil/ae11126ae728cb2af627db6a3dfa756b

Do not expose grid helper and merge constructor, training and mapping

As we use the same datas in the constructor, training and mapping phase...

It doesn't work at all...

First tests and all datas are converging to the same neuron...