Network.java

import java.util.LinkedList;
import java.util.Iterator;
import java.io.FileWriter;
import java.io.IOException;
public class Network {

    LinkedList<Layer> network;
    double[] output;
    public Network(int[] numNodes, double[] initialNodes){
        network = new LinkedList<>();
        for(int i = 0; i < numNodes.length-1; i++){
            network.add(new Layer(numNodes[i], numNodes[i+1],i));
        }
        network.get(0).nodes=initialNodes;
    }

    public void setInitialNodes(double[] vals){
        network.get(0).nodes = vals;
    }

    public void forwardProp(){
        Iterator<Layer> it = network.iterator();
        Layer currLayer = it.next();
        double[] newNodes = currLayer.feedForward();
        while(it.hasNext()){
            Layer nextLayer = it.next();
            nextLayer.prev_unactivatedNodes = newNodes;
            nextLayer.nodes = Layer.reLU(newNodes);
            currLayer = nextLayer;
            newNodes = currLayer.feedForward();
        }
        output = softMax(newNodes);
    }

    private double[] softMax(double[] raw){
        double[] output = new double[raw.length];
        double max = raw[0];
        for (double d : raw) {
            if (d > max) max = d;
        }
        double sum = 0;
        for (int i = 0; i < raw.length; i++) {
            output[i] = Math.exp(raw[i] - max);
            sum += output[i];
        }
        for (int i = 0; i < raw.length; i++) {
            output[i] /= sum;
        }
        return output;
    }

    public double classify(double[] map){
        // Used during inference/testing (not during training)
        int maxIndex = 0;
        double maxVal = Double.MIN_VALUE;
        for(int i = 0; i < output.length; i++){
            if(output[i] > maxVal){
                maxIndex = i;
                maxVal = output[i];
            }
        }
        return map[maxIndex];
    }

    public void error(double[] expected){
        double sum = 0;
        for(int i = 0; i < expected.length; i++){
            sum+=0.5*Math.pow((expected[i]-output[i]),2);
        }
        // try (FileWriter writer = new FileWriter("output.txt", true)) { // true for append mode
        //     writer.write(""+sum+"\n");
        // } catch (IOException e) {
        //     e.printStackTrace();
        // }
    }

    public void backProp(double[] expected, double alpha){
        // Calculate the error:
        double[] dCdZ = Layer.addVectors(output, expected, -1.0); // Calculate the output layers's cost gradient
        Iterator<Layer> it = network.descendingIterator();
        Layer currLayer = it.next(); // Get output layer.
        currLayer.dCdZ_before = dCdZ;
        while(true){
            System.out.println("Backpropagating Layer: " + currLayer.numLayer);
            currLayer.backProp(alpha);
            if(currLayer.numLayer == 0){
                break;
            }
            if(it.hasNext()){
            Layer nextLayer = it.next();
            nextLayer.dCdZ_before = currLayer.dCdZ;
            currLayer = nextLayer;
            }
        }
        
    }
}