NOT函數的布爾感知器

我正試圖爲基本布爾表達式實現一個簡單的感知器。但我無法正確訓練NOT感知器。NOT函數的布爾感知器

我是能夠成功地TRAINE的AND和OR感知到給定輸入集返回正確的價值觀。但是當我嘗試訓練不是。

這就是我正在做它：

的AND和OR感知器有兩個輸入，兩個權重和一個偏置（固定到偏置輸入）。

所有感知器始於全部重量。然後我生成隨機值（介於0和1之間）來訓練感知器，並將其保持在一個循環中，直到我得到10個正確的猜測。

他們的0.1

這是一個學習的速度訓練過程：

猜測值：
對於每個輸入我乘爲重的輸入，並和所有價值觀，包括偏見。

sum = (weight1 * input1) + (weight2 * input2) + (biasWeight * biasInput)--Bias input is fixed to 1 
return = if (sum > 0) then 1 else 0

要TRAINE感知：
我得到的猜測從感知

val = and.guess(1,0) --This will return 0 or 1 
error = answer - val

對於我執行這個計算

weight = weight + (input * error * rate)

然後每個輸入我做同樣的偏見

biasWeight = biasWeight + (input * error * rate)--Bias input is fixed to 1

通過此過程，我可以成功訓練感知器和和或感知器。

的和/或和NOT感知之間的唯一區別是輸入（只有1個爲不）的數量

但不感知只是保持增長的體重由學習率中的數字表示。

一些時間，這取決於的訓練，爲了不感知它得到正確的價值觀，當它擊中0.5。

當我回家發佈代碼時，有代碼（html，javascript）。我確實發現了這個錯誤。在CALC功能應該返回重量*輸入返航重量+輸入，它實際上曾爲AND和OR培訓。

<!DOCTYPE html> 

<html lang="en" xmlns="http://www.w3.org/1999/xhtml"> 
<head> 
    <meta charset="utf-8" /> 
    <title></title> 
    <script src="jquery-3.2.1.js"></script> 

    <script type="text/javascript"> 
     function Show(text) { 
      if (!text) { 
       text = ''; 
      } 

      document.writeln(text + '<br />'); 
     } 

     //return random value from 0 ~ 1 
     function getRandom() { 
      return Math.floor(Math.random() * 2); 
     }; 

     function PerceptronData(input, weight) { 
      this.input = input; 
      this.weight = weight; 
     } 
     PerceptronData.prototype.calc = function() { 
      var result = this.input + this.weight; 
      return result; 
     }; 
     PerceptronData.prototype.adjust = function (error, rate) { 
      this.weight += (this.input * error * rate); 
     }; 
     PerceptronData.prototype.print = function() { 
      return '(' + this.input + ', ' + this.weight + ')'; 
     } 

     function Perceptron(n) { 
      this.data = [];//Data array [input, weight] 
      this.bias = new PerceptronData(1, 0); 
      this.rate = 0.1;//learning rate 

      //initial data 
      for (var index = 0; index < n; index++) { 
       this.data.push(new PerceptronData(0, 0)); 
      } 
     } 
     //called from "guess" function in the final perceptron 
     Perceptron.prototype.process = function (inputs) { 
      var data = this.data; 

      if (inputs.length != data.length) { 
       throw "The number os inputs [" + inputs.length + "] doesn't match with the start value [" + data.length + "] of the Perceptron."; 
      } 

      var dataSum = 0; 
      for (var index = 0; index < data.length; index++) { 
       data[index].input = parseInt(inputs[index]); 
       dataSum += data[index].calc(); 
      } 

      dataSum += this.bias.calc(); 

      return dataSum; 
     }; 
     //twick the weight for every data 
     Perceptron.prototype.adjust = function (value, answer) { 
      var data = this.data; 
      var error = answer - value; 

      for (var index = 0; index < data.length; index++) { 
       data[index].adjust(error, this.rate); 
      } 

      this.bias.adjust(error, this.rate); 
     }; 
     Perceptron.prototype.print = function() { 
      var data = this.data; 
      var result = ''; 
      for (var index = 0; index < data.length; index++) { 
       result += 'data[' + index + ']' + data[index].print() + ' > '; 
      } 

      return result + 'bias' + this.bias.print(); 
     }; 

     function NotPerceptron() { 
      Perceptron.call(this, 1); 
     } 
     NotPerceptron.prototype = Object.create(Perceptron.prototype); 
     NotPerceptron.prototype.guess = function (value) { 
      var data = this.process([value]); 

      //activation function 
      return ((data > 0) ? 1 : 0); 
     }; 
     NotPerceptron.prototype.train = function (value, answer) { 
      var result = this.guess([value]); 
      this.adjust(result, answer); 
     }; 

     function AndPerceptron() { 
      Perceptron.call(this, 2); 
     } 
     AndPerceptron.prototype = Object.create(Perceptron.prototype); 
     AndPerceptron.prototype.guess = function (valueA, valueB) { 
      var data = this.process([valueA, valueB]); 

      //activation function 
      return ((data > 0) ? 1 : 0); 
     }; 
     AndPerceptron.prototype.train = function (valueA, valueB, answer) { 
      var result = this.guess(valueA, valueB); 

      this.adjust(result, answer); 
     }; 

     function OrPerceptron() { 
      Perceptron.call(this, 2); 
     } 
     OrPerceptron.prototype = Object.create(Perceptron.prototype); 
     OrPerceptron.prototype.guess = function (valueA, valueB) { 
      var data = this.process([valueA, valueB]); 

      //activation function 
      return ((data > 0) ? 1 : 0); 
     }; 
     OrPerceptron.prototype.train = function (valueA, valueB, answer) { 
      var result = this.guess(valueA, valueB); 

      this.adjust(result, answer); 
     }; 
    </script> 
</head> 
<body> 
    <script type="text/javascript"> 
     Show('Training AND...'); 
     Show(); 
     var and = new AndPerceptron(); 

     var count = 0; 
     var total = 0; 
     var max = 100; 

     while (count < 10 && total < max) { 
      total++; 
      var a = getRandom(); 
      var b = getRandom(); 
      var answer = ((a === 1 && b === 1) ? 1 : 0); 

      and.train(a, b, answer); 

      a = getRandom(); 
      b = getRandom(); 
      answer = ((a === 1 && b === 1) ? 1 : 0); 

      var guess = and.guess(a, b); 

      if (guess === answer) { 
       count++; 
      } else { 
       count = 0; 
      } 

      Show(' > AND(' + a + ', ' + b + ') = ' + guess + ' > [' + and.print() + ']'); 

      if (count == 10) { 
       //final test 
       if (and.guess(0, 0) == 1) { 
        count = 0; 
       } 

       if (and.guess(0, 1) == 1) { 
        count = 0; 
       } 

       if (and.guess(1, 0) == 1) { 
        count = 0; 
       } 

       if (and.guess(1, 1) == 0) { 
        count = 0; 
       } 
      } 
     } 
     Show(); 

     if (total >= max) { 
      Show('AND training failed...'); 
     } else { 
      Show('AND trained with [' + total + '] interactions. [' + and.print() + ']'); 
     } 

     Show(); 
     Show('AND(0, 0) = ' + and.guess(0, 0)); 
     Show('AND(0, 1) = ' + and.guess(0, 1)); 
     Show('AND(1, 0) = ' + and.guess(1, 0)); 
     Show('AND(1, 1) = ' + and.guess(1, 1)); 

     Show(); 
     Show('Training OR...'); 
     Show(); 
     var or = new OrPerceptron(); 

     count = 0; 
     total = 0; 
     max = 100; 

     while (count < 10 && total < max) { 
      total++; 
      var a = getRandom(); 
      var b = getRandom(); 
      var answer = ((a === 1 || b === 1) ? 1 : 0); 

      or.train(a, b, answer); 

      a = getRandom(); 
      b = getRandom(); 
      answer = ((a === 1 || b === 1) ? 1 : 0); 

      var guess = or.guess(a, b); 

      if (guess === answer) { 
       count++; 
      } else { 
       count = 0; 
      } 

      Show(' > OR(' + a + ', ' + b + ') = ' + guess + ' > [' + or.print() + ']'); 

      if (count == 10) { 
       //final test 
       if (or.guess(0, 0) == 1) { 
        count = 0; 
       } 

       if (or.guess(0, 1) == 0) { 
        count = 0; 
       } 

       if (or.guess(1, 0) == 0) { 
        count = 0; 
       } 

       if (or.guess(1, 1) == 0) { 
        count = 0; 
       } 
      } 
     } 
     Show(); 

     if (total >= max) { 
      Show('OR training failed...'); 
     } else { 
      Show('OR trained with [' + total + '] interactions. [' + or.print() + ']'); 
     } 

     Show(); 
     Show('OR(0, 0) = ' + or.guess(0, 0)); 
     Show('OR(0, 1) = ' + or.guess(0, 1)); 
     Show('OR(1, 0) = ' + or.guess(1, 0)); 
     Show('OR(1, 1) = ' + or.guess(1, 1)); 

     Show(); 
     Show('Training NOT...'); 
     Show(); 
     var not = new NotPerceptron(); 
     not.rate = 0.1; 

     count = 0; 
     total = 0; 
     max = 100; 

     while (count < 10 && total < max) { 
      total++; 
      var test = getRandom(); 
      var answer = ((test === 1) ? 0 : 1); 

      not.train(test, answer); 

      test = getRandom(); 
      answer = ((test === 1) ? 0 : 1); 

      var guess = not.guess(test); 

      if (guess === answer) { 
       count++; 
      } else { 
       count = 0; 
      } 

      Show(' > NOT(' + test + ') = ' + guess + ' > [' + not.print() + ']'); 

      if (count == 10) { 
       //final test 
       if (not.guess(0) == 0) { 
        count = 0; 
       } 

       if (not.guess(1) == 1) { 
        count = 0; 
       } 
      } 
     } 
     Show(); 

     if (total >= max) { 
      Show('NOT training failed...'); 
     } else { 
      Show('NOT trained with [' + total + '] interactions. [' + not.print() + ']'); 
     } 

     Show(); 
     Show('NOT(1) = ' + not.guess(1)); 
     Show('NOT(0) = ' + not.guess(0)); 
    </script> 
</body> 
</html>

輸出：

Training AND... 

> AND(1, 0) = 1 > [data[0](1, 0.1) > data[1](0, 0.1) > bias(1, 0.1)] 
> AND(1, 1) = 1 > [data[0](1, 0.1) > data[1](1, 0) > bias(1, 0)] 
> AND(1, 0) = 1 > [data[0](1, 0.1) > data[1](0, 0) > bias(1, 0)] 
> AND(1, 1) = 1 > [data[0](1, 0.1) > data[1](1, 0) > bias(1, 0)] 
> AND(1, 0) = 1 > [data[0](1, 0.1) > data[1](0, 0) > bias(1, 0)] 
> AND(0, 1) = 0 > [data[0](0, 0.1) > data[1](1, 0) > bias(1, 0)] 
> AND(0, 1) = 0 > [data[0](0, 0) > data[1](1, 0) > bias(1, -0.1)] 
> AND(0, 1) = 1 > [data[0](0, 0.1) > data[1](1, 0.1) > bias(1, 0)] 
> AND(0, 1) = 0 > [data[0](0, 0.1) > data[1](1, 0) > bias(1, -0.1)] 
> AND(1, 1) = 0 > [data[0](1, 0.1) > data[1](1, 0) > bias(1, -0.1)] 
> AND(1, 1) = 0 > [data[0](1, 0.1) > data[1](1, 0) > bias(1, -0.1)] 
> AND(1, 0) = 0 > [data[0](1, 0.1) > data[1](0, 0) > bias(1, -0.1)] 
> AND(1, 1) = 1 > [data[0](1, 0.2) > data[1](1, 0.1) > bias(1, 0)] 
> AND(0, 0) = 0 > [data[0](0, 0.1) > data[1](0, 0.1) > bias(1, -0.1)] 
> AND(1, 0) = 0 > [data[0](1, 0.1) > data[1](0, 0.1) > bias(1, -0.1)] 
> AND(1, 0) = 0 > [data[0](1, 0.1) > data[1](0, 0.1) > bias(1, -0.1)] 
> AND(1, 0) = 0 > [data[0](1, 0.1) > data[1](0, 0.1) > bias(1, -0.1)] 
> AND(1, 0) = 0 > [data[0](1, 0.1) > data[1](0, 0.1) > bias(1, -0.1)] 
> AND(0, 0) = 0 > [data[0](0, 0.1) > data[1](0, 0.1) > bias(1, -0.1)] 
> AND(1, 0) = 0 > [data[0](1, 0.1) > data[1](0, 0.1) > bias(1, -0.1)] 
> AND(0, 0) = 0 > [data[0](0, 0.1) > data[1](0, 0.1) > bias(1, -0.1)] 

AND trained with [21] interactions. [data[0](1, 0.1) > data[1](1, 0.1) > bias(1, -0.1)] 

AND(0, 0) = 0 
AND(0, 1) = 0 
AND(1, 0) = 0 
AND(1, 1) = 1 

Training OR... 

> OR(1, 0) = 1 > [data[0](1, 0.1) > data[1](0, 0.1) > bias(1, 0.1)] 
> OR(0, 1) = 1 > [data[0](0, 0.1) > data[1](1, 0.1) > bias(1, 0.1)] 
> OR(0, 1) = 1 > [data[0](0, 0.1) > data[1](1, 0.1) > bias(1, 0.1)] 
> OR(0, 0) = 1 > [data[0](0, 0.1) > data[1](0, 0.1) > bias(1, 0.1)] 
> OR(0, 0) = 1 > [data[0](0, 0.1) > data[1](0, 0.1) > bias(1, 0.1)] 
> OR(1, 0) = 1 > [data[0](1, 0.1) > data[1](0, 0.1) > bias(1, 0.1)] 
> OR(0, 1) = 1 > [data[0](0, 0.1) > data[1](1, 0.1) > bias(1, 0.1)] 
> OR(1, 0) = 1 > [data[0](1, 0.1) > data[1](0, 0.1) > bias(1, 0)] 
> OR(0, 0) = 0 > [data[0](0, 0.1) > data[1](0, 0.1) > bias(1, 0)] 
> OR(1, 0) = 1 > [data[0](1, 0.1) > data[1](0, 0.1) > bias(1, 0)] 
> OR(0, 0) = 0 > [data[0](0, 0.1) > data[1](0, 0.1) > bias(1, 0)] 
> OR(0, 0) = 0 > [data[0](0, 0.1) > data[1](0, 0.1) > bias(1, 0)] 
> OR(1, 1) = 1 > [data[0](1, 0.1) > data[1](1, 0.1) > bias(1, 0)] 
> OR(1, 0) = 1 > [data[0](1, 0.1) > data[1](0, 0.1) > bias(1, 0)] 
> OR(1, 0) = 1 > [data[0](1, 0.1) > data[1](0, 0.1) > bias(1, 0)] 

OR trained with [15] interactions. [data[0](1, 0.1) > data[1](1, 0.1) > bias(1, 0)] 

OR(0, 0) = 0 
OR(0, 1) = 1 
OR(1, 0) = 1 
OR(1, 1) = 1 

Training NOT... 

> NOT(0) = 0 > [data[0](0, 0) > bias(1, 0)] 
> NOT(1) = 1 > [data[0](1, 0) > bias(1, 0.1)] 
> NOT(0) = 1 > [data[0](0, 0) > bias(1, 0.1)] 
> NOT(1) = 1 > [data[0](1, 0) > bias(1, 0.1)] 
> NOT(0) = 0 > [data[0](0, -0.1) > bias(1, 0)] 
> NOT(1) = 1 > [data[0](1, -0.2) > bias(1, -0.1)] 
> NOT(1) = 1 > [data[0](1, -0.2) > bias(1, -0.1)] 
> NOT(0) = 1 > [data[0](0, -0.2) > bias(1, -0.1)] 
> NOT(0) = 1 > [data[0](0, -0.30000000000000004) > bias(1, -0.2)] 
> NOT(1) = 1 > [data[0](1, -0.30000000000000004) > bias(1, -0.2)] 
> NOT(0) = 1 > [data[0](0, -0.30000000000000004) > bias(1, -0.2)] 
> NOT(1) = 1 > [data[0](1, -0.4) > bias(1, -0.30000000000000004)] 
> NOT(1) = 1 > [data[0](1, -0.5) > bias(1, -0.4)] 
> NOT(1) = 1 > [data[0](1, -0.5) > bias(1, -0.4)] 
> NOT(1) = 1 > [data[0](1, -0.6) > bias(1, -0.5)] 
> NOT(1) = 1 > [data[0](1, -0.6) > bias(1, -0.5)] 
> NOT(1) = 1 > [data[0](1, -0.7) > bias(1, -0.6)] 
> NOT(1) = 1 > [data[0](1, -0.7999999999999999) > bias(1, -0.7)] 
> NOT(0) = 1 > [data[0](0, -0.8999999999999999) > bias(1, -0.7999999999999999)] 
> NOT(0) = 1 > [data[0](0, -0.8999999999999999) > bias(1, -0.7999999999999999)] 
> NOT(0) = 1 > [data[0](0, -0.9999999999999999) > bias(1, -0.8999999999999999)] 
> NOT(0) = 1 > [data[0](0, -0.9999999999999999) > bias(1, -0.8999999999999999)] 
> NOT(1) = 1 > [data[0](1, -0.9999999999999999) > bias(1, -0.8999999999999999)] 
> NOT(0) = 1 > [data[0](0, -0.9999999999999999) > bias(1, -0.8999999999999999)] 
> NOT(0) = 1 > [data[0](0, -1.0999999999999999) > bias(1, -0.9999999999999999)] 
> NOT(1) = 1 > [data[0](1, -1.2) > bias(1, -1.0999999999999999)] 
> NOT(0) = 1 > [data[0](0, -1.2) > bias(1, -1.0999999999999999)] 
> NOT(1) = 1 > [data[0](1, -1.2) > bias(1, -1.0999999999999999)] 
> NOT(0) = 1 > [data[0](0, -1.2) > bias(1, -1.0999999999999999)] 
> NOT(0) = 1 > [data[0](0, -1.2) > bias(1, -1.0999999999999999)] 
> NOT(1) = 1 > [data[0](1, -1.2) > bias(1, -1.0999999999999999)] 
> NOT(1) = 1 > [data[0](1, -1.3) > bias(1, -1.2)] 
> NOT(0) = 1 > [data[0](0, -1.4000000000000001) > bias(1, -1.3)] 
> NOT(0) = 1 > [data[0](0, -1.5000000000000002) > bias(1, -1.4000000000000001)] 
> NOT(1) = 1 > [data[0](1, -1.6000000000000003) > bias(1, -1.5000000000000002)] 
> NOT(1) = 1 > [data[0](1, -1.6000000000000003) > bias(1, -1.5000000000000002)] 
> NOT(0) = 1 > [data[0](0, -1.6000000000000003) > bias(1, -1.5000000000000002)] 
> NOT(0) = 1 > [data[0](0, -1.7000000000000004) > bias(1, -1.6000000000000003)] 
> NOT(0) = 1 > [data[0](0, -1.8000000000000005) > bias(1, -1.7000000000000004)] 
> NOT(1) = 1 > [data[0](1, -1.9000000000000006) > bias(1, -1.8000000000000005)] 
> NOT(1) = 1 > [data[0](1, -1.9000000000000006) > bias(1, -1.8000000000000005)] 
> NOT(1) = 1 > [data[0](1, -1.9000000000000006) > bias(1, -1.8000000000000005)] 
> NOT(1) = 1 > [data[0](1, -1.9000000000000006) > bias(1, -1.8000000000000005)] 
> NOT(0) = 1 > [data[0](0, -2.0000000000000004) > bias(1, -1.9000000000000006)] 
> NOT(1) = 1 > [data[0](1, -2.1000000000000005) > bias(1, -2.0000000000000004)] 
> NOT(1) = 1 > [data[0](1, -2.2000000000000006) > bias(1, -2.1000000000000005)] 
> NOT(1) = 1 > [data[0](1, -2.3000000000000007) > bias(1, -2.2000000000000006)] 
> NOT(0) = 1 > [data[0](0, -2.3000000000000007) > bias(1, -2.2000000000000006)] 
> NOT(0) = 1 > [data[0](0, -2.400000000000001) > bias(1, -2.3000000000000007)] 
> NOT(0) = 1 > [data[0](0, -2.500000000000001) > bias(1, -2.400000000000001)] 
> NOT(1) = 1 > [data[0](1, -2.600000000000001) > bias(1, -2.500000000000001)] 
> NOT(0) = 1 > [data[0](0, -2.700000000000001) > bias(1, -2.600000000000001)] 
> NOT(1) = 1 > [data[0](1, -2.800000000000001) > bias(1, -2.700000000000001)] 
> NOT(0) = 1 > [data[0](0, -2.9000000000000012) > bias(1, -2.800000000000001)] 
> NOT(1) = 1 > [data[0](1, -3.0000000000000013) > bias(1, -2.9000000000000012)] 
> NOT(1) = 1 > [data[0](1, -3.0000000000000013) > bias(1, -2.9000000000000012)] 
> NOT(1) = 1 > [data[0](1, -3.0000000000000013) > bias(1, -2.9000000000000012)] 
> NOT(0) = 1 > [data[0](0, -3.1000000000000014) > bias(1, -3.0000000000000013)] 
> NOT(0) = 1 > [data[0](0, -3.1000000000000014) > bias(1, -3.0000000000000013)] 
> NOT(1) = 1 > [data[0](1, -3.2000000000000015) > bias(1, -3.1000000000000014)] 
> NOT(0) = 1 > [data[0](0, -3.3000000000000016) > bias(1, -3.2000000000000015)] 
> NOT(1) = 1 > [data[0](1, -3.4000000000000017) > bias(1, -3.3000000000000016)] 
> NOT(0) = 1 > [data[0](0, -3.5000000000000018) > bias(1, -3.4000000000000017)] 
> NOT(0) = 1 > [data[0](0, -3.600000000000002) > bias(1, -3.5000000000000018)] 
> NOT(1) = 1 > [data[0](1, -3.700000000000002) > bias(1, -3.600000000000002)] 
> NOT(1) = 1 > [data[0](1, -3.700000000000002) > bias(1, -3.600000000000002)] 
> NOT(1) = 1 > [data[0](1, -3.800000000000002) > bias(1, -3.700000000000002)] 
> NOT(0) = 1 > [data[0](0, -3.800000000000002) > bias(1, -3.700000000000002)] 
> NOT(1) = 1 > [data[0](1, -3.900000000000002) > bias(1, -3.800000000000002)] 
> NOT(1) = 1 > [data[0](1, -4.000000000000002) > bias(1, -3.900000000000002)] 
> NOT(1) = 1 > [data[0](1, -4.000000000000002) > bias(1, -3.900000000000002)] 
> NOT(0) = 1 > [data[0](0, -4.000000000000002) > bias(1, -3.900000000000002)] 
> NOT(0) = 1 > [data[0](0, -4.000000000000002) > bias(1, -3.900000000000002)] 
> NOT(1) = 1 > [data[0](1, -4.100000000000001) > bias(1, -4.000000000000002)] 
> NOT(1) = 1 > [data[0](1, -4.100000000000001) > bias(1, -4.000000000000002)] 
> NOT(1) = 1 > [data[0](1, -4.200000000000001) > bias(1, -4.100000000000001)] 
> NOT(0) = 1 > [data[0](0, -4.300000000000001) > bias(1, -4.200000000000001)] 
> NOT(1) = 1 > [data[0](1, -4.300000000000001) > bias(1, -4.200000000000001)] 
> NOT(1) = 1 > [data[0](1, -4.4) > bias(1, -4.300000000000001)] 
> NOT(0) = 1 > [data[0](0, -4.5) > bias(1, -4.4)] 
> NOT(0) = 1 > [data[0](0, -4.5) > bias(1, -4.4)] 
> NOT(0) = 1 > [data[0](0, -4.5) > bias(1, -4.4)] 
> NOT(0) = 1 > [data[0](0, -4.6) > bias(1, -4.5)] 
> NOT(1) = 1 > [data[0](1, -4.699999999999999) > bias(1, -4.6)] 
> NOT(0) = 1 > [data[0](0, -4.799999999999999) > bias(1, -4.699999999999999)] 
> NOT(1) = 1 > [data[0](1, -4.799999999999999) > bias(1, -4.699999999999999)] 
> NOT(0) = 1 > [data[0](0, -4.899999999999999) > bias(1, -4.799999999999999)] 
> NOT(0) = 1 > [data[0](0, -4.999999999999998) > bias(1, -4.899999999999999)] 
> NOT(0) = 1 > [data[0](0, -5.099999999999998) > bias(1, -4.999999999999998)] 
> NOT(0) = 1 > [data[0](0, -5.1999999999999975) > bias(1, -5.099999999999998)] 
> NOT(0) = 1 > [data[0](0, -5.299999999999997) > bias(1, -5.1999999999999975)] 
> NOT(0) = 1 > [data[0](0, -5.299999999999997) > bias(1, -5.1999999999999975)] 
> NOT(0) = 1 > [data[0](0, -5.299999999999997) > bias(1, -5.1999999999999975)] 
> NOT(1) = 1 > [data[0](1, -5.299999999999997) > bias(1, -5.1999999999999975)] 
> NOT(0) = 1 > [data[0](0, -5.299999999999997) > bias(1, -5.1999999999999975)] 
> NOT(0) = 1 > [data[0](0, -5.299999999999997) > bias(1, -5.1999999999999975)] 
> NOT(0) = 1 > [data[0](0, -5.399999999999997) > bias(1, -5.299999999999997)] 
> NOT(0) = 1 > [data[0](0, -5.4999999999999964) > bias(1, -5.399999999999997)] 
> NOT(1) = 1 > [data[0](1, -5.599999999999996) > bias(1, -5.4999999999999964)] 
> NOT(0) = 1 > [data[0](0, -5.699999999999996) > bias(1, -5.599999999999996)] 
> NOT(1) = 1 > [data[0](1, -5.799999999999995) > bias(1, -5.699999999999996)] 
> NOT(0) = 1 > [data[0](0, -5.899999999999995) > bias(1, -5.799999999999995)] 
> NOT(0) = 1 > [data[0](0, -5.999999999999995) > bias(1, -5.899999999999995)] 
> NOT(0) = 1 > [data[0](0, -6.099999999999994) > bias(1, -5.999999999999995)] 
> NOT(1) = 1 > [data[0](1, -6.199999999999994) > bias(1, -6.099999999999994)] 
> NOT(0) = 1 > [data[0](0, -6.199999999999994) > bias(1, -6.099999999999994)] 
> NOT(1) = 1 > [data[0](1, -6.199999999999994) > bias(1, -6.099999999999994)] 
> NOT(1) = 1 > [data[0](1, -6.199999999999994) > bias(1, -6.099999999999994)] 
> NOT(0) = 1 > [data[0](0, -6.199999999999994) > bias(1, -6.099999999999994)] 
> NOT(1) = 1 > [data[0](1, -6.199999999999994) > bias(1, -6.099999999999994)] 
> NOT(0) = 1 > [data[0](0, -6.199999999999994) > bias(1, -6.099999999999994)] 
> NOT(1) = 1 > [data[0](1, -6.299999999999994) > bias(1, -6.199999999999994)] 
> NOT(0) = 1 > [data[0](0, -6.399999999999993) > bias(1, -6.299999999999994)]

來源

2017-08-11 P. Waksman

請添加代碼。 –

當我回家編輯問題併發布代碼時，我確實發現了這個錯誤。但是，謝謝任何方式。我用所有代碼更新了這個問題。 –

那麼問題是什麼？現在它運作良好。發佈您的答案並接受它。我認爲你的問題是非常具有啓發性的，不應該被視爲「由不能再現的問題或簡單的印刷錯誤引起的」。 –

繼@Stanislav Kralin sugestion，我又更新了問題，以便它顯示的問題。這是解決方案。

問題在於CALC函數應該乘以權值的輸入值。但我加入了它。

不幸的是，我非常關注如果我應該使用函數或其他函數，看看學習率和線性和非線性函數，我沒有看到這個錯誤。

以及與AND和OR感知效果很好的事實真土氣我錯了方向。

PerceptronData.prototype.calc = function() { 
    //var result = this.input + this.weight;//This was wrong... :(
    var result = this.input * this.weight; 
    return result; 
};

來源

2017-08-12 13:19:49

NOT函數的布爾感知器

回答

相關問題