Effectuer des opérations logiques à l'aide de Perceptron

introduction

Le but est de comprendre ce qu'est Perceptron.

Qu'est-ce que Perceptron?

Il prend plusieurs signaux comme entrées et émet un seul signal. Le signal de sortie prend une valeur binaire de 0 ou 1.

2020-01-24 (3).png

x1 et x2 sont des signaux d'entrée, y sont des signaux de sortie, w1 et w2 sont des poids. ○ est appelé un nœud ou un neurone. Chaque signal d'entrée est multiplié par son propre poids et envoyé au neurone. Le neurone produit la somme des signaux envoyés (x1w1 + x2w2). À ce moment-là, un certain seuil (valeur limite) S'il dépasse, 1 est émis et s'il est inférieur au seuil, 0 est émis.

Un modèle simplifié dans lequel l'entrée et la sortie sont directement connectées est appelé un perceptron simple, tandis qu'un modèle avec une couche (couche intermédiaire, couche cachée) entre l'entrée et la sortie est appelé un perceptron multicouche.

Une expression qui exprime le principe de fonctionnement de Perceptron

y = \left\{
\begin{array}{ll}
0 & (x_1 w_1 + x_2 w_2 \leq \phi) \\
1 & (x_1 w_1 + x_2 w_2 \gt \phi)
\end{array}
\right.

x: signal d'entrée, w: poids, $ \ phi $: seuil

Comme le seuil est difficile à gérer, ajoutez une valeur négative et transférez-la sur le côté gauche. La valeur transférée est $ b $ (biais). Le biais détermine la facilité et la difficulté d'allumage. Le biais est grand → il s'enflamme. Facile (la somme totale des signaux d'entrée a tendance à dépasser 0).

y = \left\{
\begin{array}{ll}
0 & (b + x_1 w_1 + x_2 w_2 \leq 0) \\
1 & (b + x_1 w_1 + x_2 w_2 \gt 0)
\end{array}
\right.
2020-01-24 (4).png

Ajustez les paramètres (biais et poids) pour répondre aux conditions de tir.

ET opération

import numpy as np

def AND(x1, x2):
    x1_x2 = np.array([x1, x2])
    b = -0.8
    w1_w2 = np.array([0.5, 0.5])
    tmp = b + np.sum(x1_x2 * w1_w2)
    if tmp <= 0:
        return 0
    elif tmp > 0:
        return 1

Ajustez les paramètres pour répondre aux conditions. Remplacez par une valeur appropriée ($ b $, $ w_1 $, $ w_2 $). Dans le code ci-dessus, c'est (-0,8, 0,5, 0,5), mais vous pouvez le reproduire avec (-0,3, 0,2, 0,2), par exemple.

L'opération NAND inverse le signe du biais et le poids de l'opération AND.

Opération OU

import numpy as np

def OR(x1, x2):
    x1_x2 = np.array([x1, x2])
    b = -0.3 #Changement
    w1_w2 = np.array([0.5, 0.5])
    tmp = b + np.sum(x1_x2 * w1_w2)
    if tmp <= 0:
        return 0
    elif tmp > 0:
        return 1

Le biais $ b $ a changé.

Fonctionnement XOR

import numpy as np

#Fonctionnement NAND
def NAND(x1, x2):
    x1_x2 = np.array([x1, x2])
    b = 0.8
    w1_w2 = np.array([-0.5, -0.5])
    tmp = b + np.sum(x1_x2 * w1_w2)
    if tmp <= 0:
        return 0
    elif tmp > 0:
        return 1

#Opération OU
def OR(x1, x2):
    x1_x2 = np.array([x1, x2])
    b = -0.3
    w1_w2 = np.array([0.5, 0.5])
    tmp = b + np.sum(x1_x2 * w1_w2)
    if tmp <= 0:
        return 0
    elif tmp > 0:
        return 1

#ET opération
def AND(x1, x2):
    x1_x2 = np.array([x1, x2])
    b = -0.8
    w1_w2 = np.array([0.5, 0.5])
    tmp = b + np.sum(x1_x2 * w1_w2)
    if tmp <= 0:
        return 0
    elif tmp > 0:
        return 1

#Fonctionnement XOR
def XOR(x1, x2):
    nand_ = NAND(x1, x2)
    or_ = OR(x1, x2)
    xor_ = AND(nand_, or_)
    return xor_

Comme l'opération XOR ne peut pas être exprimée par un modèle (perceptron simple) qui relie directement l'entrée et la sortie, une couche est mordue à l'intérieur. C'est un perceptron multicouche. Cette fois, le résultat de OR avec NAND est ANDed. Le fait qu'il ne puisse pas être représenté par un simple perceptron signifie qu'il ne peut pas être séparé linéairement. Veuillez dessiner un graphique et le vérifier.

à la fin

Est-ce comme ça ...

Recommended Posts

Effectuer des opérations logiques à l'aide de Perceptron
J'ai essayé d'apprendre le fonctionnement logique avec TF Learn
Script avec les opérations de fichier de paver
Opération de fichier avec open - "../"
Effectuer un fractionnement stratifié avec PyTorch
Effectuez un ajustement carré minimum avec numpy.
Opération de collecte de type Scala en Python
Conférence ROS 113 Effectuer des tâches avec smach
Perceptron multicouche avec chaînette: ajustement fonctionnel
[Chainer] Apprentissage de XOR avec perceptron multicouche
Expérience d'apprentissage Perceptron apprise avec Python
Automatisation des opérations à distance avec Fabric