[PYTHON] Visualisez la valeur limite du perceptron multicouche
introduction
Visualisez la valeur limite après l'entraînement. C'est comme suit.
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
- Données de formation
- Modèle (perceptron multicouche)
- Politique de visualisation 4.meshgrid
- Graphique de contour
- 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()
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.
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
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.
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