Python vs Ruby "Deep Learning von Grund auf neu" Kapitel 2 Logikschaltung von Perceptron

Überblick

Die Logikschaltung von Perceptron in Python und Ruby unter Bezugnahme auf den Code in Kapitel 2 des Buches "Deep Learning von Grund auf neu - Die Theorie und Implementierung des in Python gelernten Deep Learning" Implementieren (UND-Gatter, NAND-Gatter, ODER-Gatter, XOR-Gatter).

Bei der Berechnung wird eine externe Bibliothek verwendet. Verwenden Sie NumPy für Python und Numo :: NArray für Ruby.

Wenn Sie eine Umgebung erstellen müssen, lesen Sie hier. → Python vs Ruby "Deep Learning von Grund auf neu" Kapitel 1 Diagramm der Sin- und Cos-Funktion http://qiita.com/niwasawa/items/6d9aba43f3cdba5ca725

UND Tor

Gewichte und Vorspannungen sind manuell abgeleitete Werte.

Python

and_gate.py

import numpy as np

def AND(x1, x2):
  x = np.array([x1, x2])
  w = np.array([0.5, 0.5]) #Gewicht
  b = -0.7 #vorspannen
  tmp = np.sum(w*x) + b
  if tmp <= 0:
    return 0
  else:
    return 1

if __name__ == '__main__':
  for xs in [(0, 0), (1, 0), (0, 1), (1, 1)]:
    y = AND(xs[0], xs[1])
    print(str(xs) + " -> " + str(y))

Ruby

and_gate.rb

require 'numo/narray'

def AND(x1, x2)
  x = Numo::DFloat[x1, x2]
  w = Numo::DFloat[0.5, 0.5] #Gewicht
  b = -0.7 #vorspannen
  tmp = (w*x).sum + b
  if tmp <= 0
    0
  else
    1
  end
end

if __FILE__ == $0
  for xs in [[0, 0], [1, 0], [0, 1], [1, 1]]
    y = AND(xs[0], xs[1])
    puts "#{xs} -> #{y}"
  end
end

Ausführungsergebnis

Vergleichen Sie die Ausführungsergebnisse von Python und Ruby. Wenn die Eingänge den gleichen Wert haben, ist ersichtlich, dass der Ausgang auch den gleichen Wert hat.

$ python and_gate.py
(0, 0) -> 0
(1, 0) -> 0
(0, 1) -> 0
(1, 1) -> 1

$ ruby and_gate.rb
[0, 0] -> 0
[1, 0] -> 0
[0, 1] -> 0
[1, 1] -> 1

NAND-Tor

Die Implementierung von NAND-Gattern unterscheidet sich von UND-Gattern nur in Gewicht und Vorspannung.

Python

nand_gate.py

import numpy as np

def NAND(x1, x2):
  x = np.array([x1, x2])
  w = np.array([-0.5, -0.5])
  b = 0.7
  tmp = np.sum(w*x) + b
  if tmp <= 0:
    return 0
  else:
    return 1

if __name__ == '__main__':
  for xs in [(0, 0), (1, 0), (0, 1), (1, 1)]:
    y = NAND(xs[0], xs[1])
    print(str(xs) + " -> " + str(y))

Ruby

nand_gate.rb

require 'numo/narray'

def NAND(x1, x2)
  x = Numo::DFloat[x1, x2]
  w = Numo::DFloat[-0.5, -0.5]
  b = 0.7
  tmp = (w*x).sum + b
  if tmp <= 0
    0
  else
    1
  end
end

if __FILE__ == $0
  for xs in [[0, 0], [1, 0], [0, 1], [1, 1]]
    y = NAND(xs[0], xs[1])
    puts "#{xs} -> #{y}"
  end
end

Ausführungsergebnis

$ python nand_gate.py
(0, 0) -> 1
(1, 0) -> 1
(0, 1) -> 1
(1, 1) -> 0

$ ruby nand_gate.rb
[0, 0] -> 1
[1, 0] -> 1
[0, 1] -> 1
[1, 1] -> 0

ODER-Gatter

Die ODER-Gatter-Implementierung unterscheidet sich auch nur in Gewichts- und Vorspannungswerten.

Python

or_gate.py

import numpy as np

def OR(x1, x2):
  x = np.array([x1, x2])
  w = np.array([0.5, 0.5])
  b = -0.2
  tmp = np.sum(w*x) + b
  if tmp <= 0:
    return 0
  else:
    return 1

if __name__ == '__main__':
  for xs in [(0, 0), (1, 0), (0, 1), (1, 1)]:
    y = OR(xs[0], xs[1])
    print(str(xs) + " -> " + str(y))

Ruby

or_gate.rb

require 'numo/narray'

def OR(x1, x2)
  x = Numo::DFloat[x1, x2]
  w = Numo::DFloat[0.5, 0.5]
  b = -0.2
  tmp = (w*x).sum + b
  if tmp <= 0
    0
  else
    1
  end
end

if __FILE__ == $0
  for xs in [[0, 0], [1, 0], [0, 1], [1, 1]]
    y = OR(xs[0], xs[1])
    puts "#{xs} -> #{y}"
  end
end

Ausführungsergebnis

$ python or_gate.py
(0, 0) -> 0
(1, 0) -> 1
(0, 1) -> 1
(1, 1) -> 1

$ ruby or_gate.rb
[0, 0] -> 0
[1, 0] -> 1
[0, 1] -> 1
[1, 1] -> 1

XOR-Gatter

Die XOR-Gatterimplementierung verwendet ein mehrschichtiges Perzeptron mit gestapelten NAND-, ODER- und UND-Gattern.

Python

xor_gate.py

from and_gate  import AND
from or_gate   import OR
from nand_gate import NAND

def XOR(x1, x2):
  s1 = NAND(x1, x2)
  s2 = OR(x1, x2)
  y  = AND(s1, s2)
  return y

if __name__ == '__main__':
  for xs in [(0, 0), (1, 0), (0, 1), (1, 1)]:
    y = XOR(xs[0], xs[1])
    print(str(xs) + " -> " + str(y))

Ruby

xor_gate.rb

require './and_gate'
require './or_gate'
require './nand_gate'

def XOR(x1, x2)
  s1 = NAND(x1, x2)
  s2 = OR(x1, x2)
  y  = AND(s1, s2)
  return y
end

if __FILE__ == $0
  for xs in [[0, 0], [1, 0], [0, 1], [1, 1]]
    y = XOR(xs[0], xs[1])
    puts "#{xs} -> #{y}"
  end
end

Ausführungsergebnis

$ python xor_gate.py
(0, 0) -> 0
(1, 0) -> 1
(0, 1) -> 1
(1, 1) -> 0

$ ruby xor_gate.rb
[0, 0] -> 0
[1, 0] -> 1
[0, 1] -> 1
[1, 1] -> 0

Referenzmaterial

--Python vs Ruby "Deep Learning from Grund" Zusammenfassung --Qiita http://qiita.com/niwasawa/items/b8191f13d6dafbc2fede