[PYTHON] Introduction et mise en œuvre de la fonction d'activation

introduction

Cet article est une continuation de Machine Learning ② Fonction d'activation de Perceptron. Cette fois, il s'agit d'un article sur la fonction d'activation, la fonction d'étape et la fonction sigmoïde.

référence

Références: O'REILLY JAPAN Deep Learning from scratch Dernière fois: Machine learning ② Fonction d'activation Perceptron

Fonction d'activation

Qu'est-ce qu'une fonction step?

Une fonction qui commute la sortie à un certain seuil est appelée une fonction d'étape. Il pourrait être exprimé par la formule suivante.

Équation 3-1

aa

y=h(b+w1x1 + w2x2)\\
h(x) = \left\{
\begin{array}{ll}
1 & (x \, > \, 0) \\
0 & (x \, \leqq \, 0)
\end{array}
\right.

Mise en œuvre de la fonction d'étape

Cette fois, je vais implémenter une fonction step en utilisant Python et l'afficher à l'aide d'un graphique. Nous vous serions reconnaissants si vous pouviez vérifier vous-même la méthode d'installation, etc. Tout d'abord, créez une fonction step en Python. Utilisez l'équation 3-1.

3-1step_func.py

def step_function(x):
    #Seuls les nombres réels peuvent être pris en charge comme arguments(N'acceptez pas les tableaux numpy)
    if x > 0:
        return 1
    else:
        return 0

L'implémentation ci-dessus est simple, mais elle présente le problème que seuls des nombres réels peuvent être saisis dans l'argument x. Vous pouvez l'utiliser comme step_function (2.0), mais vous ne pouvez pas prendre le tableau NumPy etc. comme argument. Il est très pratique de pouvoir traiter plusieurs données à la fois s'il peut gérer des tableaux NumPy. Par conséquent, comment remplacer cette fonction créée.

3-1step_func.py

import numpy as np

def step_function(x):
    #Seuls les nombres réels peuvent être pris en charge comme arguments(N'acceptez pas les tableaux numpy)

    #Un type bourian est généré pour chaque élément à l'aide d'opérations d'inégalité sur le tableau NumPy.
    y = x > 0
    
    #astype()Tout type dans la méthode (cette fois np.peut être changé en type int)
    return y.astype(np.int)

input_data = np.array([1.0, 2.0, 3, 0])
output_data = step_function(input_data)
print(output_data)

3-1step_func.résultat d'exécution py

[1 1 1 0]

Je vais omettre l'explication des méthodes et de la syntaxe de base dans le programme, mais j'ai écrit une explication provisoire dans les commentaires. Pour vérifier le résultat de l'exécution, vous pouvez voir que si une valeur supérieure à 0 est entrée, elle renvoie 1.

Graphique de la fonction pas à pas

La fonction step définie cette fois est affichée dans un graphique.

3-1step_func.py

import numpy as np
import matplotlib.pylab as plt

def step_function(x):
    #Seuls les nombres réels peuvent être pris en charge comme arguments(N'acceptez pas les tableaux numpy)

    #Un type bourian est généré pour chaque élément à l'aide d'opérations d'inégalité sur le tableau NumPy.
    y = x > 0
    
    #astype()Tout type dans la méthode (cette fois np.peut être changé en type int)
    return y.astype(np.int)


# -5 ~ 5　0.Générer un tableau en 1 étape
input_data = np.arange(-5.0, 5.0, 0.1)
output_data = step_function(input_data)

#Génération de données graphiques
plt.plot(input_data, output_data)

#Définir la plage de l'axe y
plt.ylim(-0.1, 1.1)
plt.show()

Résultat d'exécution

À partir des résultats ci-dessus, vous pouvez confirmer que le résultat change à 0.

Qu'est-ce qu'une fonction sigmoïde?

L'une des fonctions d'activation souvent utilisées dans les réseaux neuronaux est la fonction sigmoïde exprimée par la formule suivante.

Équation 3-2

aa

h(x) = \frac{1}{1+e^{-x}}\\
e=Nombre de napiers ≒ 2.718

Cela semble compliqué, mais ce n'est qu'une fonction. Comme les autres fonctions, la fonction sigmoïde sort sous la forme convertie en substituant une valeur.

Différence entre Perceptron et Neural Network

La seule différence entre Perceptron et Neural Network est la fonction d'activation. La structure des neurones et la méthode de transmission du signal sont les mêmes pour Perceptron et Neural Network.

Implémentation de la fonction sigmoïde

Tout d'abord, écrivez l'équation 3-2.

3-2sigmoid_func.py

import numpy as np
import matplotlib.pylab as plt

def sigmoid_function(x):

    #np.exp(-x)Est e^-Représente x
    #Le calcul de la valeur scalaire et du tableau NumPy est calculé entre chaque élément du tableau.
    return 1 / (1 + np.exp(-x))

input_data = np.arange(-5.0, 5.0, 0.1)
output_data = sigmoid_function(input_data)
plt.plot(input_data, output_data)
plt.ylim(-0.1, 1.1)
plt.show()

Résultat d'exécution

Le fait est qu'il se situe toujours dans la plage de 0 à 1.

Résumé

En regardant la différence entre les deux fonctions d'activation introduites, cela ressemble à ce qui suit.

sample.py

import numpy as np
import matplotlib.pylab as plt


def step_function(x):
    #Seuls les nombres réels peuvent être pris en charge comme arguments(N'acceptez pas les tableaux numpy)

    #Un type bourian est généré pour chaque élément à l'aide d'opérations d'inégalité sur le tableau NumPy.
    y = x > 0
    
    #astype()Tout type dans la méthode (cette fois np.peut être changé en type int)
    return y.astype(np.int)

def sigmoid_function(x):

    #np.exp(-x)Est e^-Représente x
    #Le calcul de la valeur scalaire et du tableau NumPy est calculé entre chaque élément du tableau.
    return 1 / (1 + np.exp(-x))

input_data1 = np.arange(-5.0, 5.0, 0.1)
output_data1 = step_function(input_data1)

input_data2 = np.arange(-5.0, 5.0, 0.1)
output_data2 = sigmoid_function(input_data2)

#Génération de données graphiques
plt.plot(input_data1, output_data1)
plt.plot(input_data2, output_data2)

#Définir la plage de l'axe y
plt.ylim(-0.1, 1.1)
plt.show()