NOT関数のブールパーセプトロン

私は基本的なブール式の単純なパーセプトロンを実装しようとしています。しかし、私は正しくパーセプトロンを訓練することができませんでした。NOT関数のブールパーセプトロン

私は正常に与えられた入力セットの正しい値を返すためにととORパーセプトロンをtraineすることができました。しかし、私が訓練しようとするときNOT。

私はそれをやっている方法です：

ととORパーセプトロンは2つの入力、2つの重みと（バイアス入力に固定して）一つバイアスを持っています。

すべてのパーセプトロンは、で始まり、すべてウェイトで始まります。次に、パーセプトロンを訓練するためにランダムな値（0と1の間の値）を生成し、正しく推測するまでループに保持します。

彼らは、これはトレーニングプロセスである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

このプロセスでは、およびおよびまたはパーセプトロンを正常に習得できます。

と/ ORとませパーセプトロンの唯一の違いはある

（のための唯一の1ではない）入力の数

しかし、単に成長を維持パーセプトロンはありません学習率の数値で重み付けする。

いくつかの回、ませパーセプトロンそれは0.5を打ったとき、それは正しく値を取得の訓練順序に依存します。

私は帰宅してコードを投稿すると、コード（html、javascript）があります。私は実際にそのバグを見つけました。 体重を返す必要がありますCALC機能は、*入力は重量+入力を返していました、そして、それは実際にとと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の暗示以下は、私は再び質問を更新しました。そして、ここに解決策があります。

問題は、入力の値に重みを掛けなければならないCALC関数で問題でした。しかし私はそれを追加していた。

残念ながら私はシグモイド関数やその他の関数を使用して、学習率と線形関数と非線形関数を調べてみると、私はこのミスを見ていないと考えていました。

そして、本当に間違った方向に私を土気とと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関数のブールパーセプトロン

答えて

関連する問題