# User:Chase-san/KohonenMap

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)

This is my implementation of a Self-organizing map.

This and all my other code in which I display on the robowiki falls under the ZLIB License.

### How to use

//Create the map, 16 nodes, 2 input, 1 output
KohonenMap map = new KohonenMap(new int[]{16},2,1);

//Initializing gives every input and output a random value, which allows the Kohonen map to work.
map.initialize();

//For example a KohonenMap can be used for binary values
//A larger map is recommended for better output

//XOR
//0 0	0
//0 1	1
//1 0	1
//1 1	0

double[][] input = new double[][] {
{0,0}, {0,1}, {1,0}, {1,1}
};

double[][] output = new double[][] {
{0}, {1}, {1}, {0}
};
for(int i = 0; i < input.length; ++i) {
//find the BMU you want to train
map.findInputBMU(input[i]);
//and then tell the main to train on that BMU
map.train(input[i], output[i]);
}

//to get meaningful data from the map
for(int i = 0; i < input.length; ++i) {
//find the BMU
map.findInputBMU(input[i]);

//get the output for that BMU
double out = map.getOutput();

//You can simply round to get the desired binary output
System.out.println(Arrays.toString(input[i]) + " " + Math.round(out) + " " + out);
}

### org.csdgn.maru.util.KohonenMap

package org.csdgn.maru.util;

import java.util.Random;

/**
* A Self-Organizing Map implementation.
*
* Requires: <br>
* org.csdgn.nn.DensityFunction<br>
* org.csdgn.nn.DistanceFunction<br>
* org.csdgn.nn.density.StandardDensity<br>
* org.csdgn.nn.distance.EulerDistanceSquared<br><br>
*
* Train The Map<br>
* findInputBMU(double[])<br>
* train(double[])<br><br>
* Find Output<br>
* findInputBMU(double[])<br>
* getOutput()
*
*/
public class KohonenMap {
/**
* Holds the neighborhood layout;
*/
private final Node[] map;
private final int[] mapSize;
private double learningRate = 0.8;
private Density density;
private Distance distance;
private Distance neighborhood;
private boolean wrap = false;
private int BMU;

private double cutoff = 1e-4;

/**
* @param mapSize
*            Size of the neighborhood. Example: {10,10} produces a 2
*            dimensional map, each dimension having 10 nodes. Total nodes
*            would be 100.
* @param input
*            The length of the input vector (1D only)
* @param output
*            The length of the output vector (1D only)
*/
public KohonenMap(int[] mapSize, int input, int output) {
/* Setup the map */
int size = 1;
for (int m : mapSize)
size *= m;

this.map = new Node[size];

this.mapSize = mapSize.clone();

this.density = new Density.Simple();
this.distance = new Distance.EulerSq();
this.neighborhood = new Distance.Manhattan();

int[] pos = new int[mapSize.length];
for (int i = 0; i < map.length; ++i) {
this.map[i] = new Node(mapSize.length, input, output);
/* Setup the location of each node, for speed reasons. */
System.arraycopy(pos, 0, this.map[i].position, 0, pos.length);

/* Update the position marker */
++pos;
for (int j = 0; j < pos.length - 1; ++j) {
if (pos[j] >= mapSize[j]) {
++pos[j + 1];
pos[j] = 0;
}
}
}
}

/**
* Initializes the map to random values
*/
public void initialize() {
Random r = new Random();
initialize(r);
}

/**
* Initializes the map with the given random function. Uses the nextDouble
* function.
*/
public void initialize(Random random) {
for (Node n : map) {
for (int i = 0; i < n.input.length; ++i)
n.input[i] = random.nextDouble();
for (int i = 0; i < n.output.length; ++i)
n.output[i] = random.nextDouble();
}
}

/**
* Finds the Best Matching Unit for the given input.
*
* @return the BMUs identifier
*/
public int findInputBMU(double[] input) {
BMU = 0;

double distance = Double.MAX_VALUE;
for (int i = 0; i < map.length; ++i) {
double dist = this.distance.distance(map[i].input, input);

if (dist < distance) {
distance = dist;
BMU = i;
}
}
return BMU;
}

/**
* Finds the Best Matching Unit for the given output.
*
* @return the BMUs identifier
*/
public int findOutputBMU(double[] output) {
BMU = 0;
double distance = Double.MAX_VALUE;
for (int i = 0; i < map.length; ++i) {
double dist = this.distance.distance(map[i].output, output);
if (dist < distance) {
distance = dist;
BMU = i;
}
}
return BMU;
}

/**
* Finds the Worst Matching Unit for the given input
*
* @return the WMUs identifier
*/
public int findInputWMU(double[] input) {
BMU = 0;
double distance = Double.MIN_VALUE;
for (int i = 0; i < map.length; ++i) {
double dist = this.distance.distance(map[i].input, input);
if (dist > distance) {
distance = dist;
BMU = i;
}
}
return BMU;
}

/**
* Finds the Worst Matching Unit for the given output
*
* @return the WMUs identifier
*/
public int findOutputWMU(double[] output) {
BMU = 0;
double distance = Double.MIN_VALUE;
for (int i = 0; i < map.length; ++i) {
double dist = this.distance.distance(map[i].output, output);
if (dist > distance) {
distance = dist;
BMU = i;
}
}
return BMU;
}

/**
* Sets the Matched index to the set value.
*
* @param index
*/
public void setMatchIndex(int index) {
BMU = Math.max(0, Math.min(index, map.length - 1));
}

/**
* This returns the input of the last found BMU or WMU.
*
* @return the input vector
*/
public double[] getInput() {
return this.map[BMU].input;
}

/**
* This returns the output of the last found BMU or WMU.
*
* @return the output vector
*/
public double[] getOutput() {
return this.map[BMU].output;
}

/**
* This returns the input of the given ID.
*
* @return the input vector
*/
public double[] getInput(int id) {
if (id >= 0 && id < map.length)
return this.map[id].input;
return null;
}

/**
* This returns the output of the given ID.
*
* @return the output vector
*/
public double[] getOutput(int id) {
if (id >= 0 && id < map.length)
return this.map[id].output;
return null;
}

/**
* Sets the learning rate of this KohonenMap
*
* @param rate
*            value between 0 and 1
*/
public void setLearningRate(double rate) {
learningRate = Math.max(Math.min(rate, 1), 0);
}

/**
* Returns the current rate of learning
*
* @return the learning rate
*/
public double getLearningRate() {
return learningRate;
}

/**
* Sets the map to wrap its updates (slightly more costly)
*/
public void setWraps(boolean doesWrap) {
wrap = doesWrap;
}

/**
* Returns if the current map wraps
*
* @return
*/
public boolean isWrapping() {
return wrap;
}

/**
* Gets the current cutoff density.
*/
public double getCutoff() {
return cutoff;
}

/**
* The cutoff density in which under a node will not be trained.
* @param cutoff
*/
public void setCutoff(double cutoff) {
this.cutoff = cutoff;
}

/**
* Sets the density function this map uses for updating nearby nodes. If
* unset it uses the StandardDensity class.
*
* @param func
*            the Density Function
*/
public void setDensityFunction(Density func) {
this.density = func;
}

/**
* Sets the distance function used to find the best or worst matching unit.
* If unset, this map uses the EulerDistanceSquared class.<br>
* The neighborhood distance is Manhattan Distance.
*
* @param func
*/
public void setDistanceFunction(Distance func) {
this.distance = func;
}

/**
* Sets the distance function used to calculate the neighborhood distance between nodes.
* @param func
*/
public void setNeighborhoodDistanceFunction(Distance func) {
this.neighborhood = func;
}

/**
* Updates the map with the given data. Uses the last found BMU or WMU.
*
* @param input
*            input vector
* @param output
*            expected output vector
*/
public void train(double input[], double output[]) {
Node bmu = map[BMU];
for (int i = 0; i < map.length; ++i) {
map[i].update(bmu.position, input, output);
}
}

private class Node {
/** Location in the neighborhood */
private final int[] position;
/** Input vector */
private final double[] input;
/** Output vector */
private final double[] output;

public Node(int mapSize, int inputSize, int outputSize) {
position = new int[mapSize];
input = new double[inputSize];
output = new double[outputSize];
}

private double train(double c, double t, double n) {
return c + n * (t - c) * learningRate;
}

private void update(int[] pos, double[] in, double[] out) {
double distance = neighborhood.distance(pos, position);
if (wrap) {
int[] tpos = pos.clone();
int[] npos = position.clone();
for (int i = 0; i < tpos.length; ++i) {
tpos[i] += mapSize[i] / 2;
npos[i] += mapSize[i] / 2;
if (tpos[i] > mapSize[i])
tpos[i] -= mapSize[i];
if (npos[i] > mapSize[i])
npos[i] -= mapSize[i];
}
double ndist = neighborhood.distance(tpos, npos);
if (ndist < distance)
distance = ndist;
}

double neighborhood = density.density(distance);

/* Changes below this point benefits are negligible */
if (neighborhood < cutoff)
return;

for (int i = 0; i < input.length; ++i)
input[i] = train(input[i], in[i], neighborhood);

for (int i = 0; i < output.length; ++i)
output[i] = train(output[i], out[i], neighborhood);
}

}

public static abstract class Density {
/**
* Calculates the density at the given point, where x is a certain distance from the center of the distribution.
*/
public abstract double density(double x);

public static class Normal extends Density {
private final double multi;
private final double variance;
private final double mean;
public Normal() {
this(1,0);
}
public Normal(double variance, double mean) {
this.multi = 1.0 / Math.sqrt(2*Math.PI*variance);
this.variance = 2.0*variance;
this.mean = mean;
}
@Override
public double density(double x) {
double e = ((x - mean)*(x - mean)) / variance;
return multi*Math.exp(-e);
}
}

public static class Simple extends Density {
/**
* $density(x) = 2^{-x^2}$
*/
@Override
public double density(double x) {
return Math.pow(2, -(x*x));
}
}
}

public static abstract class Distance {
public abstract double distance(double[] p, double[] q);
public double distance(int[] p, int[] q) {
double[] dp = new double[p.length];
double[] dq = new double[q.length];
for(int i=0;i<p.length;++i)
dp[i] = p[i];
for(int i=0;i<p.length;++i)
dq[i] = q[i];
return distance(dp,dq);
}

public static class Manhattan extends Distance {
/**
* Calculates the manhatten distance between the two points.
*/
@Override
public double distance(double[] p, double[] q) {
if (p == null || q == null)
return 0;
int len = Math.min(p.length, q.length);
int output = 0;
for (int i = 0; i < len; ++i)
output += Math.abs(p[i] - q[i]);
return output;
}
}

public static class EulerSq extends Distance {
/**
* $distSqr(p,q) = \sum_{i=0}^n (p_i - q_i)^2$ where
* $n$ is the size of the smaller of $p$ or
* $q$
*/
@Override
public double distance(double[] p, double[] q) {
if (p == null || q == null)
return 0;
int len = Math.min(p.length, q.length);
double k, output = 0;
for (int i = 0; i < len; ++i)
output += (k = (p[i] - q[i])) * k;
return output;
}
}

public static class Euler extends EulerSq {
/**
* $dist(p,q) = \sqrt_{\sum_{i=0}^n (p_i - q_i)^2}$ where
* $n$ is the size of the smaller of $p$ or
* $q$
*/
@Override
public double distance(double[] p, double[] q) {
return Math.sqrt(super.distance(p, q));
}
}
}
}