对正向传播、反向传播和精度检查的理解

1. 首先是概念，

	// 格式化节点，每个节点中包含的计算值和梯度值
  function Unit(value, grad) {
  // 这个值是正向传播的值
  this.value = value; 
  // 这个值是反向传播的值，
  this.grad = grad; 
}


   function multiplyGate(){ };//乘法门
multiplyGate.prototype = {
  forward: function(u0, u1) {
    // 正向传播的输入值
    this.u0 = u0; 
    this.u1 = u1; 
    this.utop = new Unit(u0.value * u1.value, 0.0);
    return this.utop;//正向传播的输出值
  },
  backward: function() {
    // u0 节点的梯度(导数）是输出节点的梯度（该梯度一个是反向传播计算来的，原理是链式法则）， 乘以该乘法函数对u0的导数 ， u0节点的梯度(导数）定义为 ax+bx+c 对 a 的求导
    this.u0.grad += this.u1.value * this.utop.grad;
	// u1 节点的梯度(导数）是输出节点的梯度（该梯度一个是反向传播计算来的，原理是链式法则）， 乘以该乘法函数对u1的导数 ， u1节点的梯度(导数）定义为 ax+bx+c 对 x 的求导
    this.u1.grad += this.u0.value * this.utop.grad;
  }
}


 function addGate(){ };
addGate.prototype = {
  forward: function(u0, u1) {
    this.u0 = u0; 
    this.u1 = u1; // 
    this.utop = new Unit(u0.value + u1.value, 0.0);
    return this.utop;
  },
  backward: function() {
    // 加法函数对任意元素的导数都为1 ,那么在整个反向传播中， u0 的导数等于对整个函数的求导即 1  乘以 输出节点的导数
    this.u0.grad += 1 * this.utop.grad;
    this.u1.grad += 1 * this.utop.grad;
  }
}

    
function Circuit() {
  // 创建各类门（或者叫公式）
  this.mulg0 = new multiplyGate();
  this.mulg1 = new multiplyGate();
  this.addg0 = new addGate();
  this.addg1 = new addGate();
};
Circuit.prototype = {
  forward: function(x,y,a,b,c) {
    this.ax = this.mulg0.forward(a, x); // a*x
    this.by = this.mulg1.forward(b, y); // b*y
    this.axpby = this.addg0.forward(this.ax, this.by); // a*x + b*y
    this.axpbypc = this.addg1.forward(this.axpby, c); // a*x + b*y + c
    return this.axpbypc;
  },
  backward: function(gradient_top) { // 最后输出的梯度
    this.axpbypc.grad = gradient_top;
    this.addg1.backward(); // sets gradient in axpby and c
    this.addg0.backward(); // sets gradient in ax and by
    this.mulg1.backward(); // sets gradient in b and y
    this.mulg0.backward(); // sets gradient in a and x
  }
  
}



// SVM class
function SVM() {
  
  // random initial parameter values
  this.a = new Unit(1.0, 0.0); 
  this.b = new Unit(-2.0, 0.0);
  this.c = new Unit(-1.0, 0.0);

  this.circuit = new Circuit();
};
SVM.prototype = {
  forward: function(x, y) { // assume x and y are Units
    this.unit_out = this.circuit.forward(x, y, this.a, this.b, this.c);
    return this.unit_out;
  },
  backward: function(label) { // label is +1 or -1

    // reset pulls on a,b,c
    this.a.grad = 0.0; 
    this.b.grad = 0.0; 
    this.c.grad = 0.0;

    // compute the pull based on what the circuit output was
    var pull = 0.0;
    if(label === 1 && this.unit_out.value < 1) { 
      pull = 1; // the score was too low: pull up
    }
    if(label === -1 && this.unit_out.value > -1) {
      pull = -1; // the score was too high for a positive example, pull down
    }
    this.circuit.backward(pull); // writes gradient into x,y,a,b,c
    
    // add regularization pull for parameters: towards zero and proportional to value
    this.a.grad += -this.a.value;
    this.b.grad += -this.b.value;
  },
  learnFrom: function(x, y, label) {
    this.forward(x, y); // forward pass (set .value in all Units)
    this.backward(label); // backward pass (set .grad in all Units)
    this.parameterUpdate(); // parameters respond to tug
  },
  parameterUpdate: function() {
    var step_size = 0.01;
    this.a.value += step_size * this.a.grad;
    this.b.value += step_size * this.b.grad;
    this.c.value += step_size * this.c.grad;
  },
  max:function(x){
    var unit_out=Math.max(0, x);
     
      return unit_out;
  }
};


var data = []; var labels = [];
data.push([1.2, 0.7]); labels.push(1);
data.push([-0.3, -0.5]); labels.push(-1);
data.push([3.0, 0.1]); labels.push(1);
data.push([-0.1, -1.0]); labels.push(-1);
data.push([-1.0, 1.1]); labels.push(-1);
data.push([2.1, -3]); labels.push(1);
data.push([4.1, -0.1]); labels.push(1);
var svm = new SVM();

// the learning loop
for(var iter = 0; iter < 410; iter++) {//
  // 随机取出数据点
  
  var i = Math.floor(Math.random() * data.length);
  var x = new Unit(data[i][0], 0.0);
  var y = new Unit(data[i][1], 0.0);
  var label = labels[i];
  svm.learnFrom(x, y, label);

  if(iter % 25 == 0) { // every 10 iterations... 
    console.log('training accuracy at iter ' + iter + ': ' + evalTrainingAccuracy(svm,data));
  }
}


// 计算调整  ax+by+c 中的a,b,c 的参数使得 每个数据集预测的标签和标记的标签一致，如果所有数据集标签和标记的标签是一样的那么精度为1 
function evalTrainingAccuracy (svm,data){//
  var num_correct = 0;
  for(var i = 0; i < data.length; i++) {
    var x = new Unit(data[i][0], 0.0);
    var y = new Unit(data[i][1], 0.0);
    var true_label = labels[i];

    // see if the prediction matches the provided label
    var predicted_label = svm.forward(x, y).value > 0 ? 1 : -1;
    if(predicted_label === true_label) {
      num_correct++;
    }
  }
  
  return num_correct / data.length;
};