Python vs Ruby «Deep Learning from scratch» Chapitre 2 Circuit logique par Perceptron

Aperçu

Le circuit logique de Perceptron en Python et Ruby en référence au code du chapitre 2 du livre "Deep Learning from scratch-The Theory and implementation of deep learning learn in Python" Implémenter (porte ET, porte NAND, porte OU, porte XOR).

Une bibliothèque externe est utilisée dans le processus de calcul. Utilisez NumPy pour Python et Numo :: NArray pour Ruby.

Si vous avez besoin de créer un environnement, cliquez ici. → Python vs Ruby "Deep Learning from scratch" Chapitre 1 Graphique de la fonction sin et de la fonction cos http://qiita.com/niwasawa/items/6d9aba43f3cdba5ca725

ET porte

Les poids et les biais sont des valeurs dérivées manuellement.

Python

and_gate.py

import numpy as np

def AND(x1, x2):
  x = np.array([x1, x2])
  w = np.array([0.5, 0.5]) #poids
  b = -0.7 #biais
  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] #poids
  b = -0.7 #biais
  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

Résultat d'exécution

Comparez les résultats d'exécution de Python et Ruby. Si les entrées ont la même valeur, on peut voir que la sortie a également la même valeur.

$ 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

Porte NAND

La mise en œuvre des portes NAND ne diffère des portes ET que par leur poids et leur biais.

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

Résultat d'exécution

$ 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

OU porte

L'implémentation de la porte OU ne diffère également que par les valeurs de poids et de biais.

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

Résultat d'exécution

$ 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

Porte XOR

L'implémentation de la porte XOR utilise un perceptron multicouche avec des portes NAND, OR et AND empilées.

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

Résultat d'exécution

$ 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

Matériel de référence

--Python vs Ruby "Deep Learning from scratch" Résumé --Qiita http://qiita.com/niwasawa/items/b8191f13d6dafbc2fede