// GLOBAL ΜΕΤΑΒΛΗΤΕΣ
int inputNo = 21;    // πλήθος input nodes
int hidden1No = 64;  // πλήθος hidden 1 nodes
int hidden2No = 32;  // πλήθος hidden 2 nodes
int hidden3No = 16;  // πλήθος hidden 3 nodes
int outputNo = 3;    // πλήθος output nodes

int testDataNo = 1000;      // πλήθος δεδομένων (data rows) για αξιολόγηση

// ΔΕΔΟΜΕΝΑ
float[][] testData = new float[testDataNo][inputNo];
float[][] testTargets = new float[testDataNo][outputNo];

// Πίνακες για το normalization
float[] minVals = new float[inputNo];
float[] maxVals = new float[inputNo];

// ΚΟΜΒΟΙ ΤΟΥ ΝΕΥΡΩΝΙΚΟΥ (forward pass)

float[] inputs = new float[inputNo];       // πίνακας για τα input nodes
float[] hidden1 = new float[hidden1No];    // πίνακας για τα hidden 1 nodes
float[] hidden2 = new float[hidden2No];    // πίνακας για τα hidden 2 nodes
float[] hidden3 = new float[hidden3No];    // πίνακας για τα hidden 3 nodes
float[] outputs = new float[outputNo];     // πίνακας για τα ouput nodes

// ΒΑΡΗ ΜΕΤΑΞΥ LAYERS

// από input προς hidden1
float[][] wih1 = new float[hidden1No][inputNo];    // γραμμή i = βάρη προς τον hidden 1 node i (από όλα τα input nodes)
// στήλη j = βάρη από τον input node j (προς όλα τα hidden 1 nodes)
// από hidden1 προς hidden2
float[][] wh1h2 = new float[hidden2No][hidden1No];    // γραμμή i = βάρη προς τον hidden 2 node i (από όλα τα hidden 1 nodes)
// στήλη j = βάρη από τον hidden 1 node j (προς όλα τα hidden 2 nodes)
// από hidden2 προς hidden3
float[][] wh2h3 = new float[hidden3No][hidden2No];    // γραμμή i = βάρη προς τον hidden 3 node i (από όλα τα hidden 2 nodes)
// στήλη j = βάρη από τον hidden 2 node j (προς όλα τα hidden 3 nodes)
// από hidden3 προς output
float[][] wh3o = new float[outputNo][hidden3No];      // γραμμή i = βάρη προς τον output node i (από όλα τα hidden 3 nodes)
// γραμμή j = βάρη από τον hidden 3 node j (προς όλα τα output nodes)

// BIASES
float[] bh1 = new float[hidden1No];    // bias για κάθε hidden 1 node
float[] bh2 = new float[hidden2No];    // bias για κάθε hidden 2 node
float[] bh3 = new float[hidden3No];    // bias για κάθε hidden 3 node
float[] bo = new float[outputNo];      // bias για κάθε output node

// Πίνακες για τα derivatives όταν γίνεται το forward pass
float[] dout = new float[outputNo];
float[] dh3 = new float[hidden3No];
float[] dh2 = new float[hidden2No];
float[] dh1 = new float[hidden1No];



void setup()
{
  println("randomizing weights...");
  //randomizeWeights();
  
  //println("loading weights...");
  loadWeights("weights1.txt");

  int errors = 0;
  println("loading test data...");
  loadSDSS3b("SDSS_DR18T.csv");

  println("normalizing test data...");
  normalizeData(testData, 0);

  println("predicting...");
  for (int i=0; i<testDataNo; i++)
  {
    for (int k=0; k<inputNo; k++)
      inputs[k] = testData[i][k];

    // υπολογισμός των hidden 1 nodes
    calculateNextLayer(inputs, wih1, bh1, hidden1, 1, dh1);

    // υπολογισμός των hidden 2 nodes
    calculateNextLayer(hidden1, wh1h2, bh2, hidden2, 1, dh2);

    // υπολογισμός των hidden 3 nodes
    calculateNextLayer(hidden2, wh2h3, bh3, hidden3, 1, dh3);

    // υπολογισμός των output nodes
    calculateNextLayer(hidden3, wh3o, bo, outputs, 2, dout);
    errors += printTestResults(i);
  }

  println("ERRORS: ", (float)errors/testDataNo);
}


void draw()
{
}

/********** RANDOMIZE WEIGHTS ****************/
// Αρχικές τυχαίες τιμές σε όλα τα βάρη κ biases

void randomizeWeights()
{
  for (int i=0; i<hidden1No; i++)
  {
    bh1[i] = random(-0.5, 0.5);
    for (int j=0; j<inputNo; j++)
      wih1[i][j] = random(-0.5, 0.5);
  }

  for (int i=0; i<hidden2No; i++)
  {
    bh2[i] = random(-0.5, 0.5);
    for (int j=0; j<hidden1No; j++)
      wh1h2[i][j] = random(-0.5, 0.5);
  }

  for (int i=0; i<hidden3No; i++)
  {
    bh3[i] = random(-0.5, 0.5);
    for (int j=0; j<hidden2No; j++)
      wh2h3[i][j] = random(-0.5, 0.5);
  }

  for (int i=0; i<outputNo; i++)
  {
    bo[i] = random(-0.5, 0.5);
    for (int j=0; j<hidden3No; j++)
      wh3o[i][j] = random(-0.5, 0.5);
  }
}

/*************** CALCULATE NEXT LAYER ***************/
// l: μονοδιάστατος πίνακας των κόμβων ενός layer
// w: δισδιάστατoς πίνακες των βαρών προς το επόμενο layer
// b: μονοδιάστατος πίνακας των biases του επόμενου layer
// nl: μονοδιάστατος πίνακας των κόμβων του επόμενου layer
// flag: 1 για ReLU, 2 για softmax
// nd: μονοδιάστατος πίνακας για τα derivatives του επόμενου layer

void calculateNextLayer(float[] l, float[][] w, float[] b, float[] nl, int flag, float[] nd)
{
  int cols = l.length;    // πλήθος στηλών = πόσοι είναι οι κόμβοι του layer
  int rows = b.length;    // πλήθος γραμμών = πόσοι είναι οι κόμβοι του επόμενου layer

  float sum;              // βοηθητική μεταβλητή για άθροισμα

  // κάθε γραμμή είναι τα βάρη προς έναν επόμενο κόμβο
  // άρα πάμε κατά γραμμή στον πίνακα w
  for (int i=0; i<rows; i++)
  {
    sum = b[i];      // αρχικοποιούμε με το bias

    for (int j=0; j<cols; j++)
      sum += l[j] * w[i][j];    // υπολογίζουμε το άθροισμα γινομένων

    // η τελική τιμή του κόμβου προκύπτει από την κατάλληλη activation function
    if (flag == 1)
    {
      nl[i] = relu(sum);            // για τα hidden layers
      nd[i] = reluDerivative(sum);
    } else
      nl[i] = sum;    // για το output layer δεν υπολογίζουμε ακόμη την activation func
  }

  if (flag == 2)      // στο output layer δίνουμε όλες τις εξόδους μαζί στη softmax
    nl = softmax(nl);
}

/******* ACTIVATON FUNCTIONS *****************/
// Συνάρτηση ενεργοποίησης ReLU

float relu(float x)
{
  if (x >= 0)
    return x;
  else
    return 0;
}

// Παράγωγος της ReLU

float reluDerivative(float x)
{
  if (x > 0)
    return 1;
  else
    return 0;
}

// Συνάρτηση υπολογισμού softmax

float[] softmax(float[] x)
{
  float maxVal = x[0];
  for (float v : x) if (v > maxVal) maxVal = v;

  float sum = 0;
  float[] expVals = new float[x.length];

  for (int i = 0; i < x.length; i++) {
    expVals[i] = exp(x[i] - maxVal);
    sum += expVals[i];
  }

  for (int i = 0; i < x.length; i++) {
    expVals[i] /= sum;
  }

  return expVals;
}


/*********** SAVE and LOAD weights and minmax values to/from file ****************/
// Φόρτωση βαρών από αρχείο - μετά την εκπαίδευση

void loadWeights(String fileName)
{
  BufferedReader myFile = createReader(fileName);
  String line = null;

  try
  {
    // Input to Hidden 1 weights
    for (int i=0; i<hidden1No; i++)
      for (int j=0; j<inputNo; j++)
        if ((line = myFile.readLine()) != null)
          wih1[i][j] = float(line);

    // Hidden 1 to hidden 2 weights
    for (int i=0; i<hidden2No; i++)
      for (int j=0; j<hidden1No; j++)
        if ((line = myFile.readLine()) != null)
          wh1h2[i][j] = float(line);

    // Hidden 2 to hidden 3 weights
    for (int i=0; i<hidden3No; i++)
      for (int j=0; j<hidden2No; j++)
        if ((line = myFile.readLine()) != null)
          wh2h3[i][j] = float(line);


    // Hidden 3 to output weights
    for (int i=0; i<outputNo; i++)
      for (int j=0; j<hidden3No; j++)
        if ((line = myFile.readLine()) != null)
          wh3o[i][j] = float(line);

    // Hidden 1 biases
    for (int i=0; i<hidden1No; i++)
      if ((line = myFile.readLine()) != null)
        bh1[i] = float(line);

    // Hidden 2 biases
    for (int i=0; i<hidden2No; i++)
      if ((line = myFile.readLine()) != null)
        bh2[i] = float(line);

    // Hidden 3 biases
    for (int i=0; i<hidden3No; i++)
      if ((line = myFile.readLine()) != null)
        bh3[i] = float(line);

    // Output biases
    for (int i=0; i<outputNo; i++)
      if ((line = myFile.readLine()) != null)
        bo[i] = float(line);

    myFile.close();
  }
  catch (IOException e) {
    e.printStackTrace();
  }
}

// Αποθήκευση βαρών σε αρχείο - μετά την εκπαίδευση

void saveWeights(String fileName)
{
  PrintWriter myFile;

  myFile = createWriter(fileName);

  // Input to Hidden 1 weights
  for (int i=0; i<hidden1No; i++)
    for (int j=0; j<inputNo; j++)
      myFile.println(wih1[i][j]);

  // Hidden 1 to Hidden 2 weights
  for (int i=0; i<hidden2No; i++)
    for (int j=0; j<hidden1No; j++)
      myFile.println(wh1h2[i][j]);

  // Hidden 2 to Hidden 3 weights
  for (int i=0; i<hidden3No; i++)
    for (int j=0; j<hidden2No; j++)
      myFile.println(wh2h3[i][j]);

  // Hidden 3 to Output weights
  for (int i=0; i<outputNo; i++)
    for (int j=0; j<hidden3No; j++)
      myFile.println(wh3o[i][j]);

  // Hidden 1 biases
  for (int i=0; i<hidden1No; i++)
    myFile.println(bh1[i]);

  // Hidden 2 biases
  for (int i=0; i<hidden2No; i++)
    myFile.println(bh2[i]);

  // Hidden 3 biases
  for (int i=0; i<hidden3No; i++)
    myFile.println(bh3[i]);

  // Output biases
  for (int i=0; i<outputNo; i++)
    myFile.println(bo[i]);

  myFile.close();
}

// Αποθήκευση max min values μετά το πρώτο normalization

void saveMaxMinValues(String fileName)
{
  PrintWriter myFile;

  myFile = createWriter(fileName);

  for (int j=0; j<inputNo; j++)
  {
    myFile.println(maxVals[j]);
    myFile.println(minVals[j]);
  }

  myFile.close();
}

void loadMaxMinValues(String fileName)
{
  BufferedReader myFile = createReader(fileName);
  String line = null;

  try
  {
    for (int j=0; j<inputNo; j++)
    {
      if ((line = myFile.readLine()) != null)
        maxVals[j] = float(line);
      if ((line = myFile.readLine()) != null)
        minVals[j] = float(line);
    }

    myFile.close();
  }
  catch (IOException e) {
    e.printStackTrace();
  }
}

/************ PRINT TEST RESULTS ************/
int printTestResults(int k)
{
  int rc = 0;
  println(k, " STAR TARGET: ", testTargets[k][0], "  GALAXY TARGET: ", testTargets[k][1], "  QSO TARGET: ", testTargets[k][2]);
  println("STAR OUTPUT: ", outputs[0], "  GALAXY OUTPUT: ", outputs[1], "  QSO OUTPUT: ", outputs[2]);

  int m = 0;

  if (outputs[1] > outputs[m])
    m = 1;

  if (outputs[2] > outputs[m])
    m = 2;

  if ((m==0 && testTargets[k][0]==1) ||
    (m==1 && testTargets[k][1]==1) ||
    (m==2 && testTargets[k][2]==1))
    rc = 0;
  else
  {
    println("ERROR ");
    rc = 1;
  }

  return rc;
}

/************ LOAD TEST DATA ********************/
void loadSDSS3b(String filename) {

  Table table = loadTable(filename, "header");
  int inputSize = 42;

  for (int i = 0; i < testDataNo; i++) {
    TableRow row = table.getRow(i);
    int k = 0;

    for (int j = 0; j < inputSize; j++) {
      float val = row.getFloat(j);
      if (Float.isNaN(val)) val = 0;
      if ((j>=4 && j<=8) || (j>=26 && j<=41))
      {
        testData[i][k] = val;
        k++;
      }
    }

    // Load label (last column)
    String label = row.getString(inputSize);

    if (label.equals("STAR")) {
      testTargets[i][0] = 1;// = new float[]{1, 0};
      testTargets[i][1] = 0;
      testTargets[i][2] = 0;
    } else if (label.equals("GALAXY"))
    {
      testTargets[i][0] = 0; //new float[]{0, 1};
      testTargets[i][1] = 1;
      testTargets[i][2] = 0;
    } else
    {
      testTargets[i][0] = 0; //new float[]{0, 1};
      testTargets[i][1] = 0;
      testTargets[i][2] = 1;
    }
  }


  println("Loaded " + testDataNo + " samples.");
}

/***************** NORMALIZE DATA ***************/
void normalizeData(float[][] data, int flag) {
  int N = data.length;
  int D = data[0].length;

  if (flag == 1)
  {
    for (int j = 0; j < D; j++)
    {
      minVals[j] = 1000;
      maxVals[j] = -1000;
    }

    for (int j = 0; j < D; j++)
    {
      for (int i = 0; i < N; i++)
      {
        if (data[i][j] > maxVals[j])
          maxVals[j] = data[i][j];

        if (data[i][j] < minVals[j])
          minVals[j] = data[i][j];
      }
    }

    saveMaxMinValues("maxmin.txt");
  } // end if flag 1
  else
    loadMaxMinValues("maxmin.txt");

  //printMaxMinValues();

  // normalize
  for (int j = 0; j < D; j++)
    for (int i = 0; i < N; i++)
      data[i][j] = (data[i][j] - minVals[j]) / (maxVals[j] - minVals[j]);
}