IS NN Kod novi

//Breast cancer

public class BrestCancer implements LearningEventListener,NeurophExam{

    int inputCount = 30;
    int outputCount = 1;
    DataSet trainData;
    DataSet testData;
    double[] learningRates = {0.2,0.4,0.6};
    int[] hiddenNeurons = {10,20,30};
    int hiddenNeuron;
    double learningRate;
    int trainingCount = 0;
    int totalIterations = 0;
    double momentumValue = 0.7;
    double testSplit = 0.35;
    double trainSplit = 0.65;

    ArrayList<Training> trainings = new ArrayList<>();

    public static void main(String[] args) {
        new BrestCancer().run();
    }

    public void run(){
        DataSet ds = loadDataSet();
        ds = preprocessDataSet(ds);
        DataSet[] trainTest = trainTestSplit(ds);
        trainData = trainTest[0];
        testData = trainTest[1];

        for (double lr : learningRates) {
            learningRate = lr;
            for (int hn : hiddenNeurons) {
                hiddenNeuron = hn;
                System.out.println("Hidden neurons::"+hiddenNeuron+"::Learning rate::"+learningRate);
                MultiLayerPerceptron mlp = createNeuralNetwork();
                mlp = trainNeuralNetwork(mlp, trainData);
                evaluate(mlp, testData);
            }
        }
        System.out.println("Average number of iterations per training is: "+(double) totalIterations/trainingCount);
        int i = 1;
        for (Training tr : trainings) {
            System.out.println("Model "+i+"::mse::"+tr.mse);
            i++;
        }
        System.out.println("");
        saveBestNetwork();

    }

    @Override
    public void handleLearningEvent(LearningEvent le) {
        MomentumBackpropagation mbp = (MomentumBackpropagation) le.getSource();
        System.out.println("interation:: "+mbp.getCurrentIteration()+":: total network error:: "+mbp.getTotalNetworkError());
    }

    @Override
    public DataSet loadDataSet() {
        return DataSet.createFromFile("breast_cancer_data.csv", inputCount, outputCount, ",");
    }

    @Override
    public DataSet preprocessDataSet(DataSet ds) {
        MaxNormalizer norm = new MaxNormalizer(ds);
        norm.normalize(ds);
        ds.shuffle();
        return ds;
    }

    @Override
    public DataSet[] trainTestSplit(DataSet ds) {
        return ds.split(trainSplit, testSplit);
    }

    @Override
    public MultiLayerPerceptron createNeuralNetwork() {
        return new MultiLayerPerceptron(inputCount,hiddenNeuron,outputCount);
    }

    @Override
    public MultiLayerPerceptron trainNeuralNetwork(MultiLayerPerceptron mlp, DataSet ds) {
        MomentumBackpropagation mbp = (MomentumBackpropagation) mlp.getLearningRule();
        //mbp.addListener(this);
        mbp.setLearningRate(learningRate);
        mbp.setMomentum(momentumValue);
        mbp.setMaxIterations(1000);
        mlp.learn(ds);

        trainingCount++;
        totalIterations+=mbp.getCurrentIteration();

        return mlp;
    }

    @Override
    public void evaluate(MultiLayerPerceptron mlp, DataSet ds) {
        double mse = 0;
        int total = 0;
        for (DataSetRow d : ds) {
            mlp.setInput(d.getInput());
            mlp.calculate();

            double[] actual = d.getDesiredOutput();
            double[] predicted = mlp.getOutput();


            mse += (double) Math.pow(actual[0]-predicted[0],2);
            total++;
        }
        mse = (double) mse / (2*testData.size());

        System.out.println("Mean Squared Error:: "+mse);

        Training tr = new Training(mlp, mse);
        trainings.add(tr);

    }


    @Override
    public void saveBestNetwork() {
       int minIndex = 0;

       for(int i=0;i<trainings.size();i++){
           if(trainings.get(i).mse<trainings.get(minIndex).mse){
               minIndex = i;
           }
       }
       trainings.get(minIndex).mlp.save("bestNN.nnet");
       System.out.println("Best NN is Model "+(minIndex+1)+" with mse of "+trainings.get(minIndex).mse);
       System.out.println("Best NN is saved.");
    }
}

//WINES

public class Winess implements LearningEventListener,NeurophExam{


    ArrayList<Training> trainings = new ArrayList<>();
    int inputCount = 13;
    int outputCount = 3;
    int hiddenCount = 22;
    double[] learningRates = {0.2,0.4,0.6};
    DataSet testData;
    DataSet trainData;
    int trainingCount = 0;
    int totalIterations = 0;
    double learningRate;

    public static void main(String[] args) {
       new Winess().run();
    }

    @Override
    public void handleLearningEvent(LearningEvent le) {
        BackPropagation bp = (BackPropagation) le.getSource();
        System.out.println("iteration::"+bp.getCurrentIteration()+" total network error::"+bp.getTotalNetworkError());
    }

    @Override
    public DataSet loadDataSet() {
        DataSet ds = DataSet.createFromFile("wines.csv", inputCount, outputCount, ",");
        return ds;
    }

    @Override
    public DataSet preprocessDataSet(DataSet ds) {
        MaxNormalizer norm = new MaxNormalizer(ds);
        norm.normalize(ds);
        ds.shuffle();
        return ds;
    }

    @Override
    public DataSet[] trainTestSplit(DataSet ds) {
        return ds.split(0.7,0.3);
    }

    @Override
    public MultiLayerPerceptron createNeuralNetwork() {
        return new MultiLayerPerceptron(inputCount,hiddenCount,outputCount);
    }

    @Override
    public MultiLayerPerceptron trainNeuralNetwork(MultiLayerPerceptron mlp, DataSet ds) {
        BackPropagation bp = (BackPropagation) mlp.getLearningRule();
        bp.addListener(this);
        bp.setLearningRate(learningRate);
        bp.setMaxError(0.02);
        bp.setMaxIterations(1000);
        mlp.learn(ds);

        trainingCount++;
        totalIterations+=bp.getCurrentIteration();
        return mlp;
    }

    @Override
    public void evaluate(MultiLayerPerceptron mlp, DataSet ds) {
        String[] classLabels = {"c1","c2","c3"};
        ConfusionMatrix cm = new ConfusionMatrix(classLabels);
        double accuracy = 0;

        for (DataSetRow d : ds) {
            mlp.setInput(d.getInput());
            mlp.calculate();
            double[] actual = d.getDesiredOutput();
            double[] predicted = mlp.getOutput();

            int maxActual = maxIndex(actual);
            int maxPredicted = maxIndex(predicted);

            cm.incrementElement(maxActual, maxPredicted);
        }
        for(int i=0;i<outputCount;i++){
            accuracy+=(double)(cm.getTruePositive(i)+cm.getTrueNegative(i))/cm.getTotal();
        }
        accuracy = (double) accuracy/outputCount;
        System.out.println(cm.toString());
        System.out.println("accuracy::"+accuracy);
        Training tr = new Training(mlp, accuracy);
        trainings.add(tr);

    }

    public int maxIndex(double[] array){
        int maxIndex = 0;
        double maxValue = 0;

        for(int i=0;i<array.length;i++){
            if(array[i]>maxValue){
                maxValue = array[i];
                maxIndex = i;
            }
        }

        return maxIndex;
    }

    @Override
    public void saveBestNetwork() {
        int maxIdx = 0;
        for (int i = 1; i < trainings.size(); i++) {
            if (trainings.get(i).getAccuracy() > trainings.get(maxIdx).getAccuracy()) {
                maxIdx = i;
            }
        }
        MultiLayerPerceptron bestNN = trainings.get(maxIdx).getMlp();
        if(bestNN!=null){
            bestNN.save("bestNN.nnet");
            System.out.println("Best NN is Model "+(maxIdx+1)+":: "+trainings.get(maxIdx).getAccuracy());
            System.out.println("Saving best NN!");
        }else
        {
            System.out.println("Error!");
        }

    }

    public void run(){
        DataSet ds = loadDataSet();
        ds = preprocessDataSet(ds);
        DataSet[] trainTest = trainTestSplit(ds);

        trainData = trainTest[0];
        testData = trainTest[1];

        for (double lr : learningRates) {
            learningRate = lr;
            MultiLayerPerceptron mlp = createNeuralNetwork();
            mlp = trainNeuralNetwork(mlp, trainData);

            System.out.println("Model learning rate::"+lr);
            evaluate(mlp, testData);

        }
        System.out.println("Average number of iterations per training::"+totalIterations/trainingCount);

        int i = 1;
        for(Training tr:trainings) {
            System.out.println("Model " +i+ " :: " + tr.accuracy);
            i++;
        }
        saveBestNetwork();
    }
}

//GLASS

public class Glasss implements NeurophExam,LearningEventListener{

    ArrayList<Training> trainings = new ArrayList<>();
    int inputCount = 9;
    int outputCount = 7;
    DataSet trainData;
    DataSet testData;
    int[] hiddenNeurons = {10,20,30};
    double[] learningRates = {0.2,0.4,0.6};
    int hiddenNeuron;
    double learningRate;
    int trainCount = 0;
    int totalIterations = 0;
    double tempAccuracy = 0;

    public static void main(String[] args) {
        Glasss glass = new Glasss();
        glass.run();
    }

    @Override
    public void handleLearningEvent(LearningEvent event) {
        MomentumBackpropagation mbp = (MomentumBackpropagation) event.getSource();
        System.out.println("interations: "+mbp.getCurrentIteration()+":total network error :"+mbp.getTotalNetworkError());
    }

    @Override
    public DataSet loadDataSet() {
        DataSet ds = DataSet.createFromFile("glass.csv", inputCount, outputCount, ",");

        return ds;
    }

    @Override
    public DataSet preprocessDataSet(DataSet ds) {
        MaxNormalizer norm = new MaxNormalizer(ds);
        norm.normalize(ds);
        ds.shuffle();
        return ds;
    }

    @Override
    public DataSet[] trainTestSplit(DataSet ds) {
        return ds.split(0.65,0.35);
    }

    @Override
    public MultiLayerPerceptron createNeuralNetwork() {
        return new MultiLayerPerceptron(inputCount,hiddenNeuron,outputCount);
    }

    @Override
    public MultiLayerPerceptron trainNeuralNetwork(MultiLayerPerceptron mlp, DataSet ds) {
        MomentumBackpropagation mbp = (MomentumBackpropagation) mlp.getLearningRule();

        mbp.addListener(this);
        mbp.setMomentum(0.6);
        mbp.setLearningRate(learningRate);
        mbp.setMaxIterations(1000);
        mlp.learn(ds);

        totalIterations += mbp.getCurrentIteration();
        trainCount++;

        return mlp;
    }

    @Override
    public void evaluate(MultiLayerPerceptron mlp, DataSet ds) {
        String[] classLabels = {"c1","c2","c3","c4","c5","c6","c7"};
        ConfusionMatrix cm = new ConfusionMatrix(classLabels);
        double accuracy = 0;

        for (DataSetRow row : ds) {
            mlp.setInput(row.getInput());
            mlp.calculate();

            double[] actual = row.getDesiredOutput();
            double[] predicted = mlp.getOutput();

            int classActual = returnMaxIndex(actual);
            int classPredicted = returnMaxIndex(predicted);

            cm.incrementElement(classActual, classPredicted);
        }

        for(int i=0;i<outputCount;i++){
            accuracy += (double) (cm.getTruePositive(i) + cm.getTrueNegative(i))/cm.getTotal();
        }
        accuracy = (double) accuracy/outputCount;
        System.out.println("NN::hidden neurons::"+hiddenNeuron+"::learning rate::"+learningRate);
        System.out.println(cm.toString());
        System.out.println("accuracy::"+accuracy);
        Training tr = new Training(mlp, accuracy);
        trainings.add(tr);
    }

    public int returnMaxIndex(double[] array){
        double maxValue = 0;
        int maxIndex = 0;

        for(int i=0;i<array.length;i++){
            if(array[i]>maxValue){
                maxValue = array[i];
                maxIndex = i;
            }
        }
        return maxIndex;
    }

    @Override
    public void saveBestNetwork() {
        double maxAcc = 0;
        MultiLayerPerceptron bestNN = null;
        for (Training tr : trainings) {
            if(tr.accuracy>maxAcc){
                maxAcc = tr.accuracy;
                bestNN = tr.mlp;
            }
        }
        if(bestNN!=null){
            bestNN.save("bestNN.nnet");
            System.out.println("Najbolja NN ima accuracy: "+maxAcc);
            System.out.println("Sacuvana je najbolja NN!");
        }else
        {
            System.out.println("Greska!");
        }

    }

    public void run(){
        DataSet ds = loadDataSet();
        ds = preprocessDataSet(ds);
        DataSet[] trainTest = trainTestSplit(ds);
        trainData = trainTest[0];
        testData = trainTest[1];

        for (double i: learningRates) {
            for (int j : hiddenNeurons) {
                learningRate = i;
                hiddenNeuron = j;
                MultiLayerPerceptron mlp = createNeuralNetwork();
                mlp = trainNeuralNetwork(mlp, trainData);

                evaluate(mlp, testData);

            }
        }

        System.out.println("Srednja vrednost iteracija potrebnih za trening svih mreza: "+totalIterations/trainCount);

        System.out.println("Modeli:");
        int i = 1;
        for(Training tr:trainings) {
            System.out.println("Model " +i+ " :: " + tr.accuracy);
            i++;
        }

        saveBestNetwork();

    }
}

//DIABETESS

public class MojZadatak implements NeurophExam, LearningEventListener {

    Map<Double, MultiLayerPerceptron> mapa = new HashMap<>();
    int inputCount = 8;
    int outputCount = 1;
    DataSet trainSet;
    DataSet testSet;
    double[] learningRates = {0.2, 0.3, 0.4};
    //ArrayList<Training> trainings = new ArrayList<>();

    /**
     * U ovoj metodi pozivati sve metode koje cete implementirati iz NeurophExam
     * interfejsa
     */
    private void run() {
        DataSet ds = loadDataSet();
        ds = preprocessDataSet(ds);
        DataSet[] trainAndTest = trainTestSplit(ds);
        trainSet = trainAndTest[0];
        testSet = trainAndTest[1];
        MultiLayerPerceptron neuralNet = createNeuralNetwork();
        trainNeuralNetwork(neuralNet, ds);
        saveBestNetwork();
        int i = 1;
        for (Map.Entry<Double, MultiLayerPerceptron> entry : mapa.entrySet()) {
            System.out.println("Model " +i+ " :: " + entry.getKey());
            i++;
        }
    }

    @Override
    public DataSet loadDataSet() {
        DataSet dataSet = DataSet.createFromFile("diabetes_data.csv", inputCount, outputCount, ",");
        return dataSet;
    }

    @Override
    public DataSet preprocessDataSet(DataSet ds) {
        Normalizer norm = new MaxNormalizer(ds);
        norm.normalize(ds);
        ds.shuffle();
        return ds;
    }

    @Override
    public DataSet[] trainTestSplit(DataSet ds) {
        return ds.split(0.6, 0.4);
    }

    @Override
    public MultiLayerPerceptron createNeuralNetwork() {
        return new MultiLayerPerceptron(inputCount, 20, 16, outputCount);
    }

    @Override
    public MultiLayerPerceptron trainNeuralNetwork(MultiLayerPerceptron mlp, DataSet ds) {

        int numOfIterations = 0;
        int numOfTrainings = 0;

        for (double lr : learningRates) {
            MomentumBackpropagation learningRule = (MomentumBackpropagation) mlp.getLearningRule();
            learningRule.addListener(this);

            learningRule.setLearningRate(lr);
            learningRule.setMaxError(0.07);
            learningRule.setMomentum(0.5);
            learningRule.setMaxIterations(1000);

            mlp.learn(trainSet);

            numOfTrainings++;
            numOfIterations += learningRule.getCurrentIteration();

            evaluate(mlp, testSet);
        }

        System.out.println("Srednja vrednost broja iteracija je: " + (double) numOfIterations / numOfTrainings);

        return mlp;

    }

    @Override
    public void evaluate(MultiLayerPerceptron mlp, DataSet ds) {

        // ova matrica ima 2 classLabela jer ima 1 output
        // matrica ne sme da bude 1x1
        String[] classLabels = new String[]{"c1", "c2"};
        ConfusionMatrix cm = new ConfusionMatrix(classLabels);
        double accuracy = 0;

        for (DataSetRow dataSetRow : ds) {
            mlp.setInput(dataSetRow.getInput());
            mlp.calculate();

            int actual = (int) Math.round(dataSetRow.getDesiredOutput()[0]);
            int predicted = (int) Math.round(mlp.getOutput()[0]);

            System.out.println("Actual: " + dataSetRow.getDesiredOutput()[0]
                    + "\t Predicted: " + mlp.getOutput()[0]);

            cm.incrementElement(actual, predicted);
        }

        accuracy = (double) (cm.getTruePositive(0) + cm.getTrueNegative(0)) / cm.getTotal();

        System.out.println(cm.toString());

        System.out.println("Moj accuracy: " + accuracy);

        mapa.put(accuracy,mlp);

        //Training t = new Training(mlp, accuracy);
        //trainings.add(t);
    }

    @Override
    public void saveBestNetwork() {

        Double maxKey = Collections.max(mapa.keySet());

        MultiLayerPerceptron bestModel = mapa.get(maxKey);

        bestModel.save("nn.nnet");
        System.out.println("BestNN::accuracy::"+maxKey);
        System.out.println("Mreza sa najvecom tacnoscu je serijalizovana!");
    }

    public static void main(String[] args) {
        new MojZadatak().run();
    }

    @Override
    public void handleLearningEvent(LearningEvent le) {
        MomentumBackpropagation bp = (MomentumBackpropagation) le.getSource();
        System.out.println("Iteration: " + bp.getCurrentIteration()
                + " Total network error: " + bp.getTotalNetworkError());
    }

    private int getMaxIndex(double[] output) {
        int max = 0;
        for (int i = 1; i < output.length; i++) {
            if (output[max] < output[i]) {
                max = i;
            }
        }
        return max;
    }
}