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.

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.

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

L'entrée x est 0 ou 1
Lancé uniquement lorsque ($ x_1 $, $ x_2 $) = (1, 1) (le résultat du calcul dépasse 0)

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

Lorsqu'une certaine entrée est donnée, le Perceptron émet une valeur déterminée par s'il s'enflamme ou non.
A le poids et le biais comme paramètres
Simple Perceptron est utilisé pour les modèles linéairement séparables
Pour les modèles séparables non linéairement, utilisez un perceptron multicouche avec une couche intermédiaire

Est-ce comme ça ...

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