Example 22.1. Scoring code with transformations based on the K-means algorithm

import java.util.HashMap;

public class ScoringCode {

        /** Temporary map used by prepareData method */
        private HashMap tempInput = new HashMap();

        /** Temporary map used by prepareData method */
        private HashMap tempOutput = null;

        /** Transformation object */
        private Transformation0 trans0 = new Transformation0();

        /** scoreData is main scoring method. Input data have to be provided in correct order.
         * Please refer to InputSignature to see which data types are supported and how to provide data in correct order.
         * Transformation (if apply) is done by prepareData method. PrepareData method also deals with categorical data encoding
         * @param input - input data to score
         * @param output - OutputStructure - will contain scoring output
         */
        public void scoreData(Object [] input, OutputStructure output) {
                processRow(prepareData(input), output);
        }

         /** getCategoricalValueCode - gets codeded double value for corresponding 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 - prepares data for processRow method. 
          * It does all necesary mapping, transformation and categorical 
          * attributes encoding. 
          * @param inputData - provided in correct order data for scoring - according to InputSignature
          * @return - array of double consits of ready to score data 
          */
        public double [] prepareData(Object [] inputData) { 

                tempInput.clear();

                //Input attributes mapping
                tempInput.put("x", inputData[0]);
                tempInput.put("y", inputData[1]);
                tempInput.put("z", inputData[2]);

                tempOutput =  trans0.transformRow(tempInput);

                //Output attributes mapping
                double [] output = new double[3];

                //Initialize output array with 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 class contains data signature, which has to be passed to scoreData method.
        * This structure shows attributes in name-type pairs and their correct order in input data
        */
        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 - this class describes how data should be passed to method processRow 
        * by Transformation. If there is no transformation this is the same as InputSignature. 
        * This structure shows attributes in pairs name-type and their correct order in input data
        * It also presents the set of categorical values set.
        */
        public static class Signature {

                /** INPUT_ATTRIBUTES - this array contains names-types pairs which describes input attrubutes
                 * The Number in comment represents valid position of particular attribute in input data
                 */
                 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 contains information about the encoding of categorical attributes
                 * Codes for values are assigned according to order of attributes in array. First attribute has code equal to 0, 
                 * second atribute has code equal to 1, and so on.
                 */
                 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 encloses information about names and types which can be obtained from processRow method
 * This structure can contain the following types: double, int, String, double [], int [].
 * OutputStructure is used by AdvancedMiner to determine the output.
 */
        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 - this method is used to calculate distances between
         * sample coordinaties and cluster determined by clusterID
         * @param sampleCoordinates - array of sample coordinates
         * @param clusterID - cluster identifier
         * @return distance between cluster and sample
         */
        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 - works with a single data row.
         * Data returned by processRow method is placed in OutputStructure output
         * <b>Remarks:<b>
         *    Do not use this function, it uses mapped, and coded values in double array. Better use scoreData method.
         * @param input - array of double data
         * @param output - this structure will be the scoring output.
         */
        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 - transformation.
         * Transformation uses HashMaps so no mapping of attributes is needed.
         */
        public static class Transformation0 {
                public Transformation0(){}

                /** transformRow - transforms one data row
                 * @param inputRow - input data row in HashMap
                 * @return transformed data row in 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;
        }
}