Encog XOR string input

package nrp.nrp;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
import java.util.Scanner;

import org.encog.ConsoleStatusReportable;
import org.encog.Encog;
import org.encog.engine.network.activation.ActivationBipolarSteepenedSigmoid;
import org.encog.engine.network.activation.ActivationClippedLinear;
import org.encog.engine.network.activation.ActivationCompetitive;
import org.encog.engine.network.activation.ActivationElliott;
import org.encog.engine.network.activation.ActivationGaussian;
import org.encog.engine.network.activation.ActivationSigmoid;
import org.encog.engine.network.activation.ActivationSoftMax;
import org.encog.engine.network.activation.ActivationSteepenedSigmoid;
import org.encog.engine.network.activation.ActivationStep;
import org.encog.ml.MLRegression;
import org.encog.ml.data.MLData;
import org.encog.ml.data.MLDataPair;
import org.encog.ml.data.MLDataSet;
import org.encog.ml.data.basic.BasicMLDataSet;
import org.encog.ml.data.versatile.NormalizationHelper;
import org.encog.ml.data.versatile.VersatileMLDataSet;
import org.encog.ml.data.versatile.columns.ColumnDefinition;
import org.encog.ml.data.versatile.columns.ColumnType;
import org.encog.ml.data.versatile.sources.CSVDataSource;
import org.encog.ml.data.versatile.sources.VersatileDataSource;
import org.encog.ml.factory.MLMethodFactory;
import org.encog.ml.model.EncogModel;
import org.encog.neural.networks.BasicNetwork;
import org.encog.neural.networks.layers.BasicLayer;
import org.encog.neural.networks.training.propagation.back.Backpropagation;
import org.encog.neural.networks.training.propagation.quick.QuickPropagation;
import org.encog.neural.networks.training.propagation.resilient.ResilientPropagation;
import org.encog.util.csv.CSVFormat;
import org.encog.util.csv.ReadCSV;
import org.encog.util.simple.EncogUtility;

public class App {

    public static String VRIJEDNOSTI[][] = { { "pas", "pas" },
            { "cucak", "pas" }, { "pesek", "pas" }, { "pes", "pas" },
            { "peso", "pas" }, { "macka", "macka" }, { "maca", "macka" },
            { "mica", "macka" }, { "traktor", "traktor" },
            { "trakac", "traktor" }, { "deutz", "traktor" },
            { "john deere", "traktor" } };

    /**
     * The input necessary for XOR.
     */
    public static double ULAZNI_POJMOVI[][];

    /**
     * The ideal data necessary for XOR.
     */
    public static double IDEALNI_IZLAZI[][];

    public static int NAJVECI;

    public static void main(final String args[]) {

        NAJVECI = 0;
        for (int i = 0; i < VRIJEDNOSTI.length; i++) {
            if (VRIJEDNOSTI[i][0].length() > NAJVECI)
                NAJVECI = VRIJEDNOSTI[i][0].length();
        }

        // System.out.println(najveci);

        ULAZNI_POJMOVI = new double[VRIJEDNOSTI.length][NAJVECI];
        IDEALNI_IZLAZI = new double[VRIJEDNOSTI.length][1];

        // dodavanje ulaza (slova) i normalizacija
        for (int i = 0; i < VRIJEDNOSTI.length; i++) {
            Arrays.fill(ULAZNI_POJMOVI[i], 0);
            ULAZNI_POJMOVI[i] = toAscii(VRIJEDNOSTI[i][0], NAJVECI);
            for (int j = 0; j < ULAZNI_POJMOVI[i].length; j++) {
                // System.out.print(ULAZNI_POJMOVI[i][j] + ", ");
            }
            System.out.println("Prosjeci ideal:");

            IDEALNI_IZLAZI[i][0] = average(toAscii(VRIJEDNOSTI[i][1], NAJVECI));
            System.out.println(IDEALNI_IZLAZI[i][0]);
        }

        // kreiranje neuronske mreze
        BasicNetwork network = new BasicNetwork();
        network.addLayer(new BasicLayer(null, true, NAJVECI));
        network.addLayer(new BasicLayer(new ActivationSoftMax(), true, 3));
        //network.addLayer(new BasicLayer(new ActivationSigmoid(), false, 3));
        network.addLayer(new BasicLayer(new ActivationSoftMax(), false, 1));
        network.getStructure().finalizeStructure();
        network.reset();

        // set za treniranje
        MLDataSet trainingSet = new BasicMLDataSet(ULAZNI_POJMOVI,
                IDEALNI_IZLAZI);

        // treniranje
        final QuickPropagation train = new QuickPropagation(network, trainingSet);

        int epoch = 1;

        do {
            train.iteration();
            System.out
                    .println("Epoch #" + epoch + " Error:" + train.getError());
            epoch++;
        } while (train.getError() > 0.00001);
        train.finishTraining();

        double tocni = 0;

        // testiranje neuronske mreze
        System.out.println("Neural Network Results:");
        for (MLDataPair pair : trainingSet) {
            final MLData output = network.compute(pair.getInput());

            System.out.println(pair.getInput().getData(0) + ", actual="
                    + output.getData(0) + " , "
                    + denormaliziraj(output.getData(0)) + " ,ideal="
                    + pair.getIdeal().getData(0) + " , "
                    + denormaliziraj(pair.getIdeal().getData(0)));

            if(denormaliziraj(output.getData(0)) == denormaliziraj(pair.getIdeal().getData(0)))
            tocni++;
        }

        System.out.println("Uspješnost: " + (tocni/IDEALNI_IZLAZI.length)*100 + "%");

        Encog.getInstance().shutdown();

    }

    public static double average(double[] ascii) {
        double sum = 0;
        for (double val : ascii)
            sum += val;
        return sum / ascii.length;
    }

    // zbraja ascii vrijednosti svakog slova u stringu
    public static double[] toAscii(String s, int najveci) {
        double[] ascii = new double[najveci];
        try {
            byte[] bytes = s.getBytes("US-ASCII");
            for (int i = 0; i < bytes.length; i++) {
                ascii[i] = 90.0 / bytes[i];
            }

        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return ascii;
    }

    // denormalizira double vrijednosti u string
    public static String denormaliziraj(double trenutna) {
        double najmanjaRazlika = 1;
        int indeks = 0;
        for (int i = 0; i < IDEALNI_IZLAZI.length; i++) {
            if (Math.abs(IDEALNI_IZLAZI[i][0] - trenutna) < najmanjaRazlika) {
                najmanjaRazlika = Math.abs(IDEALNI_IZLAZI[i][0] - trenutna);
                indeks = i;
            }
        }
        return VRIJEDNOSTI[indeks][1];
    }
}