Visualisez la valeur limite du perceptron multicouche

introduction

Visualisez la valeur limite après l'entraînement. C'est comme suit.

moon_plot.png

Si la cote d'entrée est bidimensionnelle, vous pouvez visualiser les limites de cette manière. Cette fois, je voudrais visualiser le perceptron multicouche de TensorFlow à titre d'exemple.

table des matières

  1. Données de formation
  2. Modèle (perceptron multicouche)
  3. Politique de visualisation 4.meshgrid
  4. Graphique de contour
  5. Tous les codes Histoire

1. Données de formation

Les données utilisées cette fois sont l'ensemble de données en forme de croissant dans l'ensemble de données de scicit-learn. Puisqu'il s'agit de données bidimensionnelles, elles peuvent être illustrées sur un plan.

from sklearn import datasets
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
'''
Générer des données de croissant
'''
N = 300  #Spécifiez le nombre de données
X, y = datasets.make_moons(N, noise=0.2)
Y = y.reshape(N, 1)

#Divisez en données d'entraînement et données de test
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, train_size=0.8)

'''
Graphique de données
'''
plt.figure(figsize=(10, 6))
plt.ylim([-1,1.5])
plt.xlim([-1.5,2.5])
plt.scatter(X[y==1][:,0], X[y==1][:,1], s=10, marker='.')
plt.scatter(X[y==0][:,0], X[y==0][:,1], s=10, marker='^')
plt.show()

moon_plot.png

Apprenons avec ces données et dessinons une frontière.

2. Modèle (perceptron multicouche)

L'apprentissage se fait avec le perceptron multicouche TensorFlow (1.x). Le modèle n'est qu'un exemple, donc peu importe le modèle que vous utilisez pour dessiner les valeurs limites. Couches cachées combinées. Le code du Perceptron 3 couches est ci-dessous.

class ThreelayerPerceptron(object):
    '''
Initialisation
    '''
    def __init__(self, n_in, n_hidden, n_out):
        self.n_in = n_in
        self.n_hidden = n_hidden
        self.n_out = n_out
        self.weights = []
        self.biases = []

        self._x = None
        self._y = None
        self._t = None,
        self._sess = None
        self._history = {
            'accuracy': [],
            'loss': []
        }

    '''
poids
    '''
    def weight_variable(self, shape):
        initial = tf.truncated_normal(shape, stddev=0.01)
        return tf.Variable(initial)

    '''
biais
    '''
    def bias_variable(self, shape):
        initial = tf.zeros(shape)
        return tf.Variable(initial)

    '''
Définition du modèle (perceptron 3 couches)
    '''
    def inference(self, x):
        
        #Couche d'entrée-Couche cachée
        self.weights.append(self.weight_variable([self.n_in, self.n_hidden]))
        self.biases.append(self.bias_variable([self.n_hidden]))
        h = tf.nn.sigmoid(tf.matmul(x, self.weights[-1]) + self.biases[-1])

        #Couche cachée-Couche de sortie
        self.weights.append(self.weight_variable([self.n_hidden, self.n_out]))
        self.biases.append(self.bias_variable([self.n_out]))
        y = tf.nn.sigmoid(tf.matmul(h, self.weights[-1]) + self.biases[-1])

        return y

    '''
Fonction de perte
    '''
    def loss(self, y, t):
        cross_entropy = tf.reduce_mean(-tf.reduce_sum(t * tf.log(y) + (1 - t) * tf.log(1 - y)))
        return cross_entropy

    '''
Algorithme d'optimisation
    '''
    def training(self, loss):
        optimizer = tf.train.GradientDescentOptimizer(0.05)
        train_step = optimizer.minimize(loss)
        return train_step

    '''
Taux de réponse correct
    '''
    def accuracy(self, y, t):
        correct_prediction = tf.equal(tf.cast(tf.greater(y, 0.5),tf.float32), t)
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
        return accuracy
    
    '''
Prévoir
    '''
    def prediction(self, y):
        return tf.cast(tf.greater(y, 0.5),tf.float32)

    '''
Apprentissage
    '''
    def fit(self, X_train, Y_train,
            nb_epoch=100, batch_size=100, p_keep=0.5,
            verbose=1):
        x = tf.placeholder(tf.float32, shape=[None, self.n_in])
        t = tf.placeholder(tf.float32, shape=[None, self.n_out])

        self._x = x
        self._t = t

        y = self.inference(x)
        loss = self.loss(y, t)
        train_step = self.training(loss)
        accuracy = self.accuracy(y, t)

        init = tf.global_variables_initializer()
        sess = tf.Session()
        sess.run(init)

        self._y = y
        self._sess = sess

        N_train = len(X_train)
        n_batches = N_train // batch_size

        for epoch in range(nb_epoch):
            X_, Y_ = shuffle(X_train, Y_train)

            for i in range(n_batches):
                start = i * batch_size
                end = start + batch_size

                sess.run(train_step, feed_dict={
                    x: X_[start:end],
                    t: Y_[start:end]
                })
            loss_ = loss.eval(session=sess, feed_dict={
                x: X_train,
                t: Y_train
            })
            accuracy_ = accuracy.eval(session=sess, feed_dict={
                x: X_train,
                t: Y_train
            })
            self._history['loss'].append(loss_)
            self._history['accuracy'].append(accuracy_)

            if verbose:
                print('epoch:', epoch,
                      ' loss:', loss_,
                      ' accuracy:', accuracy_)

        return self._history

    def evaluate(self, X_test, Y_test):
        accuracy = self.accuracy(self._y, self._t)
        return accuracy.eval(session=self._sess, feed_dict={
            self._x: X_test,
            self._t: Y_test
        })

    def predict(self, X_test):
        prediction = self.prediction(self._y)
        return prediction.eval(session=self._sess, feed_dict={
            self._x: X_test
        })

3. Politique de visualisation

La visualisation de la valeur limite est effectuée en traçant les résultats d'entraînement pour chaque point de grille. Considérez les points de grille noirs suivants comme données de test et prédisez le résultat.

20200308_01.png

Si la ligne bleue est la valeur limite, ・ Le résultat est "0" pour les points de la grille au-dessus de la ligne bleue. ・ Le résultat est "1" pour les points de la grille sous la ligne bleue. Vous obtiendrez un résultat comme celui-ci. Ce résultat est codé en couleur par le "tracé de ligne de contour" décrit plus loin.

4.meshgrid

Utilisez numpy.meshgrid pour les points de grille. Par exemple, vous pouvez obtenir une liste 5x5 en procédant comme suit:

x, y  = np.meshgrid(np.arange( 0, 10, 2),
                    np.arange( 1, 6, 1))
x
y
array([[0, 2, 4, 6, 8],
       [0, 2, 4, 6, 8],
       [0, 2, 4, 6, 8],
       [0, 2, 4, 6, 8],
       [0, 2, 4, 6, 8]])
array([[1, 1, 1, 1, 1],
       [2, 2, 2, 2, 2],
       [3, 3, 3, 3, 3],
       [4, 4, 4, 4, 4],
       [5, 5, 5, 5, 5]])

En spécifiant ceci sur l'axe des x et l'axe des y, le tableau de points de grille sera comme indiqué dans la figure ci-dessous. À partir de 0 dans les grilles, les points de la grille sont dans l'ordre des flèches.

grids = np.array([x.ravel(), y.ravel()]).T

20200308_02.png

5. Graphique de contour

La valeur limite est dessinée avec le contourf de matplotlib. Définissez l'axe X dans le premier argument, l'axe Y dans le deuxième argument et la hauteur dans le troisième argument. La hauteur est «0» ou «1» car c'est le résultat de la prédiction de la classification binaire dans ce cas.

from matplotlib.colors import ListedColormap
cmap = ListedColormap( ( "mistyrose","lightcyan") )
plt.contourf(x, y, pred, cmap=cmap)

En supposant que la prédiction des points de grille est prédite, ce code peut tracer une ligne de démarcation comme indiqué dans la figure ci-dessous.

moon_plot.png

6. Tous les codes

Vous trouverez ci-dessous le code complet du tracé de bordure, y compris la formation avec le modèle.

import numpy as np
import tensorflow as tf
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.utils import shuffle
import matplotlib.pyplot as plt

np.random.seed(0)
tf.set_random_seed(0)

class ThreelayerPerceptron(object):
    '''
Initialisation
    '''
    def __init__(self, n_in, n_hidden, n_out):
        self.n_in = n_in
        self.n_hidden = n_hidden
        self.n_out = n_out
        self.weights = []
        self.biases = []

        self._x = None
        self._y = None
        self._t = None,
        self._sess = None
        self._history = {
            'accuracy': [],
            'loss': []
        }

    '''
poids
    '''
    def weight_variable(self, shape):
        initial = tf.truncated_normal(shape, stddev=0.01)
        return tf.Variable(initial)

    '''
biais
    '''
    def bias_variable(self, shape):
        initial = tf.zeros(shape)
        return tf.Variable(initial)

    '''
Définition du modèle (perceptron 3 couches)
    '''
    def inference(self, x):
        
        #Couche d'entrée-Couche cachée
        self.weights.append(self.weight_variable([self.n_in, self.n_hidden]))
        self.biases.append(self.bias_variable([self.n_hidden]))
        h = tf.nn.sigmoid(tf.matmul(x, self.weights[-1]) + self.biases[-1])

        #Couche cachée-Couche de sortie
        self.weights.append(self.weight_variable([self.n_hidden, self.n_out]))
        self.biases.append(self.bias_variable([self.n_out]))
        y = tf.nn.sigmoid(tf.matmul(h, self.weights[-1]) + self.biases[-1])

        return y

    '''
Fonction de perte
    '''
    def loss(self, y, t):
        cross_entropy = tf.reduce_mean(-tf.reduce_sum(t * tf.log(y) + (1 - t) * tf.log(1 - y)))
        return cross_entropy

    '''
Algorithme d'optimisation
    '''
    def training(self, loss):
        optimizer = tf.train.GradientDescentOptimizer(0.05)
        train_step = optimizer.minimize(loss)
        return train_step

    '''
Taux de réponse correct
    '''
    def accuracy(self, y, t):
        correct_prediction = tf.equal(tf.cast(tf.greater(y, 0.5),tf.float32), t)
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
        return accuracy
    
    '''
Prévoir
    '''
    def prediction(self, y):
        return tf.cast(tf.greater(y, 0.5),tf.float32)

    '''
Apprentissage
    '''
    def fit(self, X_train, Y_train,
            nb_epoch=100, batch_size=100, p_keep=0.5,
            verbose=1):
        x = tf.placeholder(tf.float32, shape=[None, self.n_in])
        t = tf.placeholder(tf.float32, shape=[None, self.n_out])

        self._x = x
        self._t = t

        y = self.inference(x)
        loss = self.loss(y, t)
        train_step = self.training(loss)
        accuracy = self.accuracy(y, t)

        init = tf.global_variables_initializer()
        sess = tf.Session()
        sess.run(init)

        self._y = y
        self._sess = sess

        N_train = len(X_train)
        n_batches = N_train // batch_size

        for epoch in range(nb_epoch):
            X_, Y_ = shuffle(X_train, Y_train)

            for i in range(n_batches):
                start = i * batch_size
                end = start + batch_size

                sess.run(train_step, feed_dict={
                    x: X_[start:end],
                    t: Y_[start:end]
                })
            loss_ = loss.eval(session=sess, feed_dict={
                x: X_train,
                t: Y_train
            })
            accuracy_ = accuracy.eval(session=sess, feed_dict={
                x: X_train,
                t: Y_train
            })
            self._history['loss'].append(loss_)
            self._history['accuracy'].append(accuracy_)

            if verbose:
                print('epoch:', epoch,
                      ' loss:', loss_,
                      ' accuracy:', accuracy_)

        return self._history

    def evaluate(self, X_test, Y_test):
        accuracy = self.accuracy(self._y, self._t)
        return accuracy.eval(session=self._sess, feed_dict={
            self._x: X_test,
            self._t: Y_test
        })

    def predict(self, X_test):
        prediction = self.prediction(self._y)
        return prediction.eval(session=self._sess, feed_dict={
            self._x: X_test
        })


'''
Générer des données de croissant
'''
N = 300  #Nombre total de données
X, y = datasets.make_moons(N, noise=0.2)
Y = y.reshape(N, 1)

#Divisez en données d'entraînement et données de test
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, train_size=0.8)

'''
Graphique de données
'''
plt.figure(figsize=(10, 6))
plt.ylim([-1,1.5])
plt.xlim([-1.5,2.5])
plt.scatter(X[y==1][:,0], X[y==1][:,1], s=10, marker='.')
plt.scatter(X[y==0][:,0], X[y==0][:,1], s=10, marker='^')
plt.show()

'''
Paramètres du modèle
'''
model = ThreelayerPerceptron(n_in=len(X[0]),
                             n_hidden=3,
                             n_out=len(Y[0]))

'''
Apprentissage de modèle
'''
history = model.fit(X_train, Y_train,
                    nb_epoch=400,
                    batch_size=20,
                    verbose=1)

'''
Évaluation de la précision des prévisions
'''
accuracy = model.evaluate(X_test, Y_test)
print('accuracy: ', accuracy)

'''
Générer des données de grille pour coder en couleur le graphique
'''
meshgrids  = np.meshgrid(
               np.arange( -1.5, 2.6, 0.01 ),
               np.arange( -1, 1.6, 0.01 )
             )
xx = meshgrids[0]
yy = meshgrids[1]
#Faire une liste de points de grille
grids = np.array([xx.ravel(), yy.ravel()]).T

'''
Obtenez le résultat de la prédiction des données de la grille
'''
pred = model.predict(grids)
pred = pred.reshape( xx.shape )

'''
Graphique de données
'''
from matplotlib.colors import ListedColormap
w_[1,1] * v_[1])
plt.figure(figsize=(10, 6))
plt.ylim([-1,1.5])
plt.xlim([-1.5,2.5])
cmap = ListedColormap( ( "mistyrose","lightcyan") )
plt.contourf(xx, yy, pred, cmap=cmap)
plt.scatter(X[y==1][:,0], X[y==1][:,1], s=10, marker='.')
plt.scatter(X[y==0][:,0], X[y==0][:,1], s=10, marker='^')
plt.show()

Histoire

2020/03/08 Première édition publiée 2020/03/09 Correction de la définition de la fonction de perte

Recommended Posts

Visualisez la valeur limite du perceptron multicouche
Visualisez la trajectoire de Hayabusa 2
Implémentez le Perceptron multicouche de manière très soignée
Visualisez l'état de la réponse du recensement national 2020
Visualisez les effets de l'apprentissage profond / de la régularisation
Astuces: Comparaison de la taille de trois valeurs
Visualisez les données d'exportation du journal Piyo
Visualisez la couche interne du réseau neuronal
Visualisez le comportement de l'algorithme de tri avec matplotlib
Apprenez en implémentant avec Scipy Les bases de la régression logistique et du perceptron multicouche
Calculer la somme des valeurs uniques par tabulation croisée des pandas
La décision de scikit-learn Comment visualiser un modèle en bois
Visualisez la gamme d'insertions internes et externes avec python
Visualisez le vocabulaire caractéristique d'un document avec D3.js
J'ai essayé de visualiser les informations spacha de VTuber
Visualisez le statut d'appréciation des œuvres d'art avec OpenCV
Visualisez le nombre de plaintes des compagnies d'assurance-vie
Le sens de soi
le zen de Python
L'histoire de sys.path.append ()
La fondation de la fondation Perceptron
La vengeance des types: la vengeance des types
Visualisons le volume des transactions des actions TSE - Exemple Jpxlab
Visualisez les résultats des arbres de décision réalisés avec Python scikit-learn
Visualisez la "couleur régionale" de la ville en appliquant la vectorisation des documents
[Python] J'ai essayé de visualiser la relation de suivi de Twitter
Visualisons le nombre de personnes infectées par le virus corona avec matplotlib
Visualisez le flux des tweets avec Diamond + Graphite + Grafana
Trouvez l'écart moyen / standard des valeurs de luminosité dans l'image
[Flask & Bootstrap] Visualisez le contenu des paroles avec Word Cloud ~ Lyrics Word Cloud ~