Przykład 10.1. Kod scoringowy z transformacjami oparty na algorytmie K-średnich

import java.util.HashMap;

public class ScoringCode {

        /** Tymczasowe mapowanie stosowane metodą prepareData */
        private HashMap tempInput = new HashMap();

        /** Tymczasowe mapowanie stosowane metodą prepareData */
        private HashMap tempOutput = null;

        /** Transformacja obiektu */
        private Transformation0 trans0 = new Transformation0();

        /** scoreData jest główną metodą scorowania. Dane wejściowe muszą być dostarczone w odpowiedniej kolejności.
         * Proszę zajrzeć do InputSignature aby zobaczyć, które typy danych są obsługiwane i jak zapewnić dane w odpowiedniej kolejności.
         * Transformacja (jeśli dotyczy) jest tworzona przez metodę prepareData. Metoda ta także zajmuje się kodowaniem kategorycznych zmiennych
         * @param input - zbió wejściowy do scorowania
         * @param output - OutputStructure - będzie zawierać wynik scoringu
         */
        public void scoreData(Object [] input, OutputStructure output) {
                processRow(prepareData(input), output);
        }

         /** getCategoricalValueCode - dostaje zakodowaną podwójną wartość odpowiadającą catgorical
        */
        public double getCategoricalValueCode(HashMap data, String attrName, int attrIndex) {
                double output=Double.NaN;                for(int i=0; i<Signature.INPUT_ATTRIBUTES_VALUE_SET[attrIndex].length; i++){
                        if(data.get(attrName).equals(Signature.INPUT_ATTRIBUTES_VALUE_SET[attrIndex][i])){
                                output=i;
                                break;
                        }
                }
                if( output==Double.NaN )
                        throw new RuntimeException("Value "+tempOutput.get(attrName).toString()+" is not in input attributes  value set");
                return output;
        }

         /** prepareData - przygotowuje dane dla metody processRow. 
		  * To wykonuje wszystkie niezbędne mapowanie, transformacje i kodowania 
	      * atrybutów kategorycznych.
          * @param inputData - dostarcza we właściwy sposób posortowane dane do scorowania - według InputSignature
          * @return - tablica podwójnych rezultatów
          */
        public double [] prepareData(Object [] inputData) { 

                tempInput.clear();

                //Mapowanie atrybutów wejściowych
                tempInput.put("x", inputData[0]);
                tempInput.put("y", inputData[1]);
                tempInput.put("z", inputData[2]);

                tempOutput =  trans0.transformRow(tempInput);

                //Mapowanie atrybutów wyjściowych
                double [] output = new double[3];

                //Wywołanie wyjściowej tabeli z Double.NaN's
                java.util.Arrays.fill(output, Double.NaN);

                if(tempOutput.get("x") != null )
                        if(tempOutput.get("x") instanceof Number)
                                output[0]=((Number)tempOutput.get("x")).doubleValue();
                        else
                                throw new RuntimeException("Data type doesn't match to data type specified in inputSignature. Can't continue. ");

                if(tempOutput.get("y") != null )
                        if(tempOutput.get("y") instanceof Number)
                                output[1]=((Number)tempOutput.get("y")).doubleValue();
                        else
                                throw new RuntimeException("Data type doesn't match to data type specified in inputSignature. Can't continue. ");

                if(tempOutput.get("z") != null )
                        if(tempOutput.get("z") instanceof Number)
                                output[2]=((Number)tempOutput.get("z")).doubleValue();
                        else
                                throw new RuntimeException("Data type doesn't match to data type specified in inputSignature. Can't continue. ");

                return output;
        }
        /** InputSignature zawiera sygnaturę danych, która ma być przekazana do metody scoreData.
        * Struktura ta pokazuje atrybuty w parach typu name i ich właściwej kolejności w danych wejściowych
        */
        public static class InputSignature {
                 public static Object [][] INPUT_ATTRIBUTES = new Object [][] {
                        {"x", Number.class },         // inputRow[0]
                        {"y", Number.class },         // inputRow[1]
                        {"z", Number.class }        // inputRow[2]
                };
        }

        /** Signature - klasa ta opisuje jak dane powinny być przekazywane do metody processRow 
        * przez Transformacje. Jeśli nie ma transformacji jest taki sam, jak InputSignature. 
        * Struktura ta pokazuje atrybuty w parach nazwa-typu i odpowiedniej kolejności w danych wejściowych
        *  Przedstawiono również zestaw ustawiania kategorycznych wartości:
        */
        public static class Signature {

                /** INPUT_ATTRIBUTES - tablica ta zawiera pary nazwa-typ, które opisują wejściowe atrybuty
                 * Liczba w komentarzu reprezentuje poprawną pozycję określonego atrybutu w danych wejściowych
                 */
                 public static Object [][] INPUT_ATTRIBUTES = new Object [][] {
                        {"x", double.class },         // inputRow[0]
                        {"y", double.class },         // inputRow[1]
                        {"z", double.class }        // inputRow[2]
                };


                /** INPUT_ATTRIBUTES_VALUE_SET zawiera informacje na temat kodowania atrybutów kategorycznych
                 * Kody dla wartości są przypisane według kolejności atrybutów w tablicy. Pierwszy atrybut ma kod równy 0,
                 * drugi atrybut ma kod równy 1, i tak dalej.
                 */
                 public static Object [][] INPUT_ATTRIBUTES_VALUE_SET = new Object [][] {
                        { null },         // x value set -> inputRow [0]
                        { null },         // y value set -> inputRow [1]
                        { null }        // z value set -> inputRow [2]
                };

        }


        /** OutputStructure załącza informacje o nazwach i typach, które mogą być uzyskane z metody processRow.
         * Struktura ta może zawierać następujące typy: double, int, string, double [], int [].
         * OutputStructure jest używane przez AdvancedMiner aby określić dane wyjściowe.
         */
        public static class OutputStructure
 {

                public int clusterID;
                public double[] distance = new double [3];

        }
        /////////////////////////// DATA TAKEN FROM AdvancedMiner MODEL //////////////////////////////////////
        public final int clustersCount = 3;
        public final int clustersCoordinatesCount = 3;
        protected double clustersCoordinates[][] = new double[clustersCount][clustersCoordinatesCount];

        /////////////////////////////////////  SCORING CODE ////////////////////////////////////////////
        /** calculateDistance - metoda ta jest stosowana do obliczenia odległości między
         * sampleCoordinates i klastrem określonym przez clusterID
         * @param sampleCoordinates - tablica sampleCoordinates
         * @param clusterID - klaster okreslony przez clusterID
         * zwraca odległość
         */
        protected double calculateDistance(double [] sampleCoordinates, int clusterID) {
                double distance=0;
                for(int i=0; i<clustersCoordinatesCount; i++) {
                        double dx = sampleCoordinates[i]-clustersCoordinates[clusterID][i];
                        distance+=(dx*dx);
                }
                return Math.sqrt(distance);
        }

        /** processRow - współpracuje z pojedynczym wierszem danych.
         * Dane zwracane przez metodę processRow są umieszczony na wyjściu OutputStructure
         * <b>Uwagi:<b>
	     * Nie należy używać tej funkcji, wykorzystuje odwzorowane i koduje wartości w podwójnej tablicy. Lepiej użyć metody scoreData.
         * @param input - tablica danych
         * @param output - struktura ta będzie wynikiem scoringu
         */
        public void processRow(double [] input, OutputStructure output) {
                //Input data checking
                for(int i=0; i<input.length; i++){
                        if(input[i]==Double.NaN)
                                throw new RuntimeException("Non numerical input data not supported");
                }
                if(input.length != clustersCoordinatesCount)
                        throw new RuntimeException("Input array size doesn't match clusters count ("+clustersCount+")");
                //Computing distances between input data and cluster coordinates
                double minDistance = 0;
                int bestClusterID = 0;
                for(int i=0; i<clustersCount; i++) {
                        double distance = calculateDistance(input, i);
                        if(i == 0)
                                minDistance = distance;
                        else
                                if(distance < minDistance) {
                                         minDistance = distance;
                                        bestClusterID = i;
                                }
                        output.distance[i]=distance;
                }
                //Calculated best cluster identifier is assigned to output
                output.clusterID = bestClusterID;
        }
        ///////////////////////////////////  END OF SCORING CODE //////////////////////////////////////////
        /**Transformation0 - transformacja.
         * Transformacja używa HashMaps więc mapowanie atrybutów nie jest potrzebne.
         */
        public static class Transformation0 {
                public Transformation0(){}

                /** transformRow - przekształca jeden wiersz danych
                 * @param inputRow - wejściowy wiersz danych w HashMap
                 * @zwraca mapowany wiersz danych w HashMap
                 */
                public HashMap transformRow(HashMap inputRow) {
                        HashMap outputRow = new HashMap();

                        outputRow.putAll(inputRow);

if (inputRow.get("z") == null) {
         outputRow.put("z", new Double(7.6));
}
else
        outputRow.put("z", inputRow.get("z"));

if (inputRow.get("y") == null) {
         outputRow.put("y", new Double(6.6));
}
else
        outputRow.put("y", inputRow.get("y"));

if (inputRow.get("x") == null) {
         outputRow.put("x", new Double(7.4));
}
else
        outputRow.put("x", inputRow.get("x"));

                        return outputRow;
                }
        }
        public ScoringCode() {
                clustersCoordinates[0][0] = 5.666666666666667;
                clustersCoordinates[0][1] = 3.3333333333333335;
                clustersCoordinates[0][2] = 4.333333333333333;
                clustersCoordinates[1][0] = 10.877564619118836;
                clustersCoordinates[1][1] = 9.53952535719102;
                clustersCoordinates[1][2] = 7.950674407041298;
                clustersCoordinates[2][0] = 10.0;
                clustersCoordinates[2][1] = 11.5;
                clustersCoordinates[2][2] = 12.5;
        }
}