let c1;

let c2;

let ex = [];

let wk = new Float32Array(256);

let repeats = 30;

let neuralNetwork;

let rate = 0.10;

​

function setup() {

  createCanvas(400, 400);

  neuralNetwork = new FFBNetBP(256, 4, 4, 2);

  c1 = color("gold");

  c2 = color("rgb(179,228,179)");

  for (let i = 0; i < 8; i++) {

    ex[i] = new Float32Array(256);

  }

  for (let i = 0; i < 127; i++) {

    // Training data

    let t = (i * 2 * PI) / 127;

    ex[0][2 * i] = sin(t);

    ex[0][2 * i + 1] = sin(2 * t);

    ex[1][2 * i] = sin(2 * t);

    ex[1][2 * i + 1] = sin(t);

    ex[2][2 * i] = sin(2 * t);

    ex[2][2 * i + 1] = sin(3 * t);

    ex[3][2 * i] = sin(3 * t);

    ex[3][2 * i + 1] = sin(2 * t);

    ex[4][2 * i] = sin(3 * t);

    ex[4][2 * i + 1] = sin(4 * t);

    ex[5][2 * i] = sin(4 * t);

    ex[5][2 * i + 1] = sin(3 * t);

    ex[6][2 * i] = sin(2 * t);

    ex[6][2 * i + 1] = sin(5 * t);

    ex[7][2 * i] = sin(5 * t);

    ex[7][2 * i + 1] = sin(2 * t);

  }

  textSize(16);

}

​

function draw() {

  background(0);

  loadPixels();

  for (let i = 0; i < repeats; i++) {

    for (let j = 0; j < ex.length; j++) {

      neuralNetwork.train(ex[j], ex[j], rate);

    }

  }

  fill(c1);

  for (let i = 0; i < 8; i++) {

    for (let j = 0; j < 255; j += 2) {

      set(25 + i * 40 + 18 * ex[i][j], 44 + 18 * ex[i][j + 1], c1);

    }

  }

  for (let i = 0; i < 8; i++) {

    neuralNetwork.recall(wk, ex[i]);

    for (let j = 0; j < 255; j += 2) {

      set(25 + i * 40 + 18 * wk[j], 104 + 18 * wk[j + 1], c2);

    }

  }

  updatePixels();

  text("Training Data", 5, 20);

  text("Recall Autoassociative", 5, 80);

  text("Iterations: " + frameCount * repeats, 5, 150);

}

class FFBNetBP {

  // vecLen must be 4,8,16,32.....

  // widthBy must be 1,2,4,8....

  // depth 1 to ...

  // hardLimit is around 2, less for deep nets

  constructor(vecLen, widthBy, depth, hardLimit) {

    this.vecLen = vecLen;

    this.widthBy = widthBy;

    this.depth = depth;

    this.hardLimit = hardLimit;

    this.n = vecLen * widthBy;

    this.params = new Float32Array(2 * this.n * depth);

    this.surface = new Float32Array(this.n * depth);

    this.flips = new Float32Array(this.n);

    this.work = new Float32Array(this.n);

    for (let i = 0; i < this.n; i++) {

      this.flips[i] = random(-1, 1) < 0 ? -1 : 1;

    }

    for (let i = 0; i < this.params.length; i++) {

      this.params[i] = random(-2,2);

    }

  }

​

  recall(result, inputvec) {

    for (let i = 0; i < this.n; i++) {

      this.work[i] = this.flips[i] * inputvec[i & (this.vecLen - 1)]; //vecLen-1 acts as a binary mask

    }

    let paramIdx = 0; // parameter index

    whtN(this.work); // Walsh Hadamard transform 

    for (let i = 0; i < this.depth; i++) {

      for (let j = 0; j < this.n; j++) {

        const signBit = this.work[j] < 0 ? 0 : 1;

        this.work[j] *= this.params[paramIdx + signBit];

        paramIdx += 2;

      }

      whtN(this.work);

    }

    for (let i = 0; i < this.vecLen; i++) {

      result[i] = this.work[i];

    }

  }

​

  train(target, inputvec, rate) {

    for (let i = 0; i < this.n; i++) {

      this.work[i] = this.flips[i] * inputvec[i & (this.vecLen - 1)]; //vecLen-1 acts as a binary mask

    }

    let paramIdx = 0; // parameter index

    whtN(this.work); // Walsh Hadamard transform

    for (let i = 0; i < this.depth; i++) {

      for (let j = 0; j < this.n; j++) {

        this.surface[j + i * this.n] = this.work[j]; // save WHT outputs

      }

      for (let j = 0; j < this.n; j++) {

        const signBit = this.work[j] < 0 ? 0 : 1;

        this.work[j] *= this.params[paramIdx + signBit];

        paramIdx += 2;

      }

      whtN(this.work);

    }

    for (let i = 0; i < this.vecLen; i++) {

      this.work[i] = (target[i] - this.work[i]) * rate; //error by learning rate

    }

    for (let i = this.vecLen; i < this.n; i++) {

      // clear upper section

      this.work[i] = 0;

    }

    for (let i = this.depth - 1; i >= 0; i--) {

      whtN(this.work); // invert error back

      const surIdx = i * this.n;

      paramIdx=2*i*this.n;

      for (let j = 0; j < this.n; j++) {

        let x = this.surface[surIdx + j];

        let adjust = x * this.work[j]; // weight update

        const signBit = x < 0 ? 0 : 1;

        let w = this.params[paramIdx + signBit];

        w += adjust;

        if (w > this.hardLimit) w = this.hardLimit;

        if (w < -this.hardLimit) w = -this.hardLimit;

        this.params[paramIdx + signBit] = w;

        if (w < 0) this.work[j] = -this.work[j]; //Back Propagation!

        paramIdx+=2;

      }

    }

  }

}

​

  // Walsh Hadamard transform scaled to leave vector magnitued unchanged

 function whtN(vec) {

    const n=vec.length;

    const sc=1.0/sqrt(n);

    for(let i=0;i<n;i+=2){

      const a=vec[i];

      const b=vec[i+1];

      vec[i]=(a+b)*sc;

      vec[i+1]=(a-b)*sc;

    }

    let hs = 2;

    while (hs < n) {

      let i = 0;

      while (i < n) {

        const j = i + hs;

        while (i < j) {

          const a = vec[i];

          const b = vec[i + hs];

          vec[i] = a + b;

          vec[i + hs] = a - b;

          i += 1;

        }

        i += hs;

      }

      hs += hs;

    }

  }

​