Kohonen SOM

package test.example.two;

import java.math.BigDecimal;
import java.util.Random;

public class KohonenSOM2_BD
{
    private static final int MAX_CLUSTERS = 5;
    private static final int VEC_LEN = 7;
    private static final int INPUT_PATTERNS = 7;
    private static final int INPUT_TESTS = 6;
    private static final double DECAY_RATE = 0.99;                  //About 100 iterations.
    private static final double MIN_ALPHA = 0.01;
    private static final double RADIUS_REDUCTION_POINT = 0.023;     //Last 20% of iterations.

    private static double alpha = 1;
    private static BigDecimal d[] = new BigDecimal[MAX_CLUSTERS];
    private static double d_d[] = new double[MAX_CLUSTERS];

    //Weight matrix with randomly chosen values between 0.0 and 1.0
    private static BigDecimal[][] w;
    private static double[][] w_d;

    private static BigDecimal pattern[][];
    private static int pattern_d[][];

    private static BigDecimal tests[][];
    private static int tests_d[][];

    private static void gen(){
        w = new BigDecimal[MAX_CLUSTERS][VEC_LEN];
        w_d = new double[MAX_CLUSTERS][VEC_LEN];
        pattern = new BigDecimal[INPUT_PATTERNS][VEC_LEN];
        pattern_d = new int[INPUT_PATTERNS][VEC_LEN];
        tests = new BigDecimal[INPUT_TESTS][VEC_LEN];
        tests_d = new int[INPUT_TESTS][VEC_LEN];
        Random randy = new Random();
        for(int i=0;i<w.length;i++){
            for(int j=0;j<w[0].length;j++){
                w_d[i][j] = randy.nextDouble();
                w[i][j] = new BigDecimal(Double.toString(w_d[i][j]));
            }
        }
        for(int i=0;i<pattern.length;i++){
            for(int j=0;j<pattern[0].length;j++){
                pattern_d[i][j] = randy.nextInt(2);
                pattern[i][j] = new BigDecimal(Integer.toString(pattern_d[i][j]));
            }
        }
        for(int i=0;i<tests.length;i++){
            for(int j=0;j<tests[0].length;j++){
                tests_d[i][j] = randy.nextInt(2);
                tests[i][j] = new BigDecimal(Integer.toString(tests_d[i][j]));
            }
        }
    }
    private static void training()
    {
        int iterations = 0;
        boolean reductionFlag = false;
        int reductionPoint = 0;
        int dMin = 0,dMin_d=0;

        while(alpha > MIN_ALPHA)
        {
            iterations += 1;

            for(int vecNum = 0; vecNum <= (INPUT_PATTERNS - 1); vecNum++)
            {
                //Compute input for all nodes.
                computeInput(pattern,pattern_d, vecNum);

                //See which is smaller?
                dMin = minimum(d);
                dMin_d = minimum(d_d);

                //Update the weights on the winning unit.
                updateWeights(vecNum, dMin, dMin_d);

            } // VecNum

            //Reduce the learning rate.
            alpha = DECAY_RATE * alpha;

            //Reduce radius at specified point.
            if(alpha < RADIUS_REDUCTION_POINT){
                if(reductionFlag == false){
                    reductionFlag = true;
                    reductionPoint = iterations;
                }
            }
        }

        System.out.println("Iterations: " + iterations);

        System.out.println("Neighborhood radius reduced after " + reductionPoint + " iterations.");

        return;
    }

    private static void computeInput(BigDecimal[][] vectorArray,int[][] vectorArray_d, int vectorNumber)
    {
        clearArray(d,d_d);

        for(int i = 0; i <= (MAX_CLUSTERS - 1); i++){
            for(int j = 0; j <= (VEC_LEN - 1); j++){
                d_d[i] += Math.pow((w_d[i][j] - vectorArray_d[vectorNumber][j]), 2);
                d[i] = d[i].add(w[i][j].add(vectorArray[i][j].negate()).pow(2));
                //d[i] = d[i].pow(2);
            } // j
        } // i
        return;
    }

    private static void updateWeights(int vectorNumber, int dMin, int dMin_d)
    {
        for(int i = 0; i <= (VEC_LEN - 1); i++)
        {
            //Update the winner.
            w_d[dMin_d][i] = w_d[dMin_d][i] + (alpha * (pattern_d[vectorNumber][i] - w_d[dMin_d][i]));
            w[dMin][i] = w[dMin][i].add(new BigDecimal(Double.toString(alpha)).multiply(pattern[vectorNumber][i].add(w[dMin][i].negate())));
            w[dMin][i] = w[dMin][i].setScale(100, BigDecimal.ROUND_DOWN);

            //Only include neighbors before radius reduction point is reached.
            if(alpha > RADIUS_REDUCTION_POINT){
                if((dMin > 0) && (dMin < (MAX_CLUSTERS - 1))){
                    //Update neighbor to the left...
                    w[dMin-1][i] = w[dMin-1][i].add(new BigDecimal(Double.toString(alpha)).multiply(pattern[vectorNumber][i].add(w[dMin-1][i].negate())));
                    w[dMin-1][i] = w[dMin-1][i].setScale(100, BigDecimal.ROUND_DOWN);
                    //and update neighbor to the right.
                    w[dMin+1][i] = w[dMin+1][i].add(new BigDecimal(Double.toString(alpha)).multiply(pattern[vectorNumber][i].add(w[dMin+1][i].negate())));
                    w[dMin+1][i] = w[dMin+1][i].setScale(100, BigDecimal.ROUND_DOWN);
                } else {
                    if(dMin == 0){
                        //Update neighbor to the right.
                        w[dMin+1][i] = w[dMin+1][i].add(new BigDecimal(Double.toString(alpha)).multiply(pattern[vectorNumber][i].add(w[dMin+1][i].negate())));
                        w[dMin+1][i] = w[dMin+1][i].setScale(100, BigDecimal.ROUND_DOWN);
                    } else {
                        //Update neighbor to the left.
                        w[dMin-1][i] = w[dMin-1][i].add(new BigDecimal(Double.toString(alpha)).multiply(pattern[vectorNumber][i].add(w[dMin-1][i].negate())));
                        w[dMin-1][i] = w[dMin-1][i].setScale(100, BigDecimal.ROUND_DOWN);
                    }
                }
                if((dMin_d > 0) && (dMin_d < (MAX_CLUSTERS - 1))){
                    //Update neighbor to the left...
                    w_d[dMin_d - 1][i] = w_d[dMin_d - 1][i] + (alpha * (pattern_d[vectorNumber][i] - w_d[dMin_d - 1][i]));
                    //and update neighbor to the right.
                    w_d[dMin_d + 1][i] = w_d[dMin_d + 1][i] + (alpha * (pattern_d[vectorNumber][i] - w_d[dMin_d + 1][i]));
                } else {
                    if(dMin_d == 0){
                        //Update neighbor to the right.
                        w_d[dMin_d + 1][i] = w_d[dMin_d + 1][i] + (alpha * (pattern_d[vectorNumber][i] - w_d[dMin_d + 1][i]));
                    } else {
                        //Update neighbor to the left.
                        w_d[dMin_d - 1][i] = w_d[dMin_d - 1][i] + (alpha * (pattern_d[vectorNumber][i] - w_d[dMin_d - 1][i]));
                    }
                }
            }

        } // i
        return;
    }

    private static void clearArray(BigDecimal[] d, double[] d_d)
    {
        for(int i = 0; i <= (MAX_CLUSTERS - 1); i++)
        {
            d[i] = new BigDecimal("0");
            d_d[i] =0;
        } // i
        return;
    }

    private static int minimum(BigDecimal[] nodeArray)
    {
        int winner = 0;
        boolean foundNewWinner = false;
        boolean done = false;

        while(!done)
        {
            foundNewWinner = false;
            for(int i = 0; i <= (MAX_CLUSTERS - 1); i++)
            {
                if(i != winner){             //Avoid self-comparison.
                    if(nodeArray[i].compareTo(nodeArray[winner]) == -1){
                        winner = i;
                        foundNewWinner = true;
                    }
                }
            } // i

            if(foundNewWinner == false){
                done = true;
            }
        }
        return winner;
    }
    private static int minimum(double[] nodeArray)
    {
        int winner = 0;
        boolean foundNewWinner = false;
        boolean done = false;

        while(!done)
        {
            foundNewWinner = false;
            for(int i = 0; i <= (MAX_CLUSTERS - 1); i++)
            {
                if(i != winner){             //Avoid self-comparison.
                    if(nodeArray[i]<nodeArray[winner]){
                        winner = i;
                        foundNewWinner = true;
                    }
                }
            } // i

            if(foundNewWinner == false){
                done = true;
            }
        }
        return winner;
    }

    private static void printResults()
    {
        int dMin = 0, dMin_d=0;

        //Print clusters created.
            System.out.println("Clusters for training input:");
            for(int vecNum = 0; vecNum <= (INPUT_PATTERNS - 1); vecNum++)
            {
                //Compute input.
                computeInput(pattern,pattern_d, vecNum);

                //See which is smaller.
                dMin = minimum(d);
                dMin_d = minimum(d_d);

                System.out.print("Vector (");
                for(int i = 0; i <= (VEC_LEN - 1); i++)
                {
                    System.out.print(pattern[vecNum][i] + ", ");
                } // i
                System.out.print(") fits into category " + dMin + " ("+dMin_d+") \n");

            } // VecNum

        //Print weight matrix.
            System.out.println("------------------------------------------------------------------------");
            for(int i = 0; i <= (MAX_CLUSTERS - 1); i++)
            {
                System.out.println("Weights for Node " + i + " connections:");
                System.out.print("     ");
                for(int j = 0; j <= (VEC_LEN - 1); j++)
                {
                    String temp = String.format("%.3f", w[i][j]);
                    System.out.print(temp + ", ");
                } // j
                System.out.print("\n");
            } // i

        //Print post-training tests.
            System.out.println("------------------------------------------------------------------------");
            System.out.println("Categorized test input:");
            for(int vecNum = 0; vecNum <= (INPUT_TESTS - 1); vecNum++)
            {
                //Compute input for all nodes.
                computeInput(tests,tests_d, vecNum);

                //See which is smaller.
                dMin = minimum(d);
                dMin_d = minimum(d_d);

                System.out.print("Vector (");
                for(int i = 0; i <= (VEC_LEN - 1); i++)
                {
                    System.out.print(tests[vecNum][i] + ", ");
                } // i
                System.out.print(") fits into category " + dMin + " ("+dMin_d+") \n");

            } // VecNum
        return;
    }

    public static void main(String[] args)
    {
        gen();
        training();
        printResults();
        return;
    }

}