[PYTHON] Visualisieren Sie den Grenzwert des mehrschichtigen Perzeptrons
Einführung
Visualisieren Sie den Grenzwert nach dem Training. Es ist wie folgt.
Wenn die Eingabedimension zweidimensional ist, können Sie die Grenzen auf diese Weise visualisieren. Dieses Mal möchte ich das mehrschichtige Perzeptron von TensorFlow als Beispiel visualisieren.
Inhaltsverzeichnis
- Trainingsdaten
- Modell (mehrschichtiges Perzeptron)
- Visualisierungsrichtlinie 4.meshgrid
- Konturdiagramm
- Alle Codes Geschichte
1. Trainingsdaten
Die Daten, die diesmal verwendet werden, sind der sichelförmige Datensatz im Datensatz von scicit-learn. Da es sich um zweidimensionale Daten handelt, können sie in einer Ebene dargestellt werden.
from sklearn import datasets
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
'''
Halbmonddaten generieren
'''
N = 300 #Geben Sie die Anzahl der Daten an
X, y = datasets.make_moons(N, noise=0.2)
Y = y.reshape(N, 1)
#Teilen Sie in Trainingsdaten und Testdaten
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, train_size=0.8)
'''
Datenplot
'''
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()
Lassen Sie uns mit diesen Daten lernen und eine Grenze ziehen.
2. Modell (mehrschichtiges Perzeptron)
Das Lernen erfolgt mit TensorFlow (1.x) mehrschichtigem Perzeptron. Das Modell ist nur ein Beispiel, daher spielt es keine Rolle, mit welchem Modell Sie die Grenzwerte zeichnen. Kombinierte versteckte Ebenen. Der Code für das 3-Schicht-Perceptron ist unten.
class ThreelayerPerceptron(object):
'''
Initialisieren
'''
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': []
}
'''
Gewicht
'''
def weight_variable(self, shape):
initial = tf.truncated_normal(shape, stddev=0.01)
return tf.Variable(initial)
'''
vorspannen
'''
def bias_variable(self, shape):
initial = tf.zeros(shape)
return tf.Variable(initial)
'''
Modelldefinition (3-Schicht-Perzeptron)
'''
def inference(self, x):
#Eingabeebene-Versteckte Ebene
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])
#Versteckte Ebene-Ausgabeschicht
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
'''
Verlustfunktion
'''
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
'''
Optimierungsalgorithmus
'''
def training(self, loss):
optimizer = tf.train.GradientDescentOptimizer(0.05)
train_step = optimizer.minimize(loss)
return train_step
'''
Richtige Antwortrate
'''
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
'''
Prognose
'''
def prediction(self, y):
return tf.cast(tf.greater(y, 0.5),tf.float32)
'''
Lernen
'''
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. Visualisierungsrichtlinie
Die Grenzwertvisualisierung wird durchgeführt, indem die Trainingsergebnisse für jeden Gitterpunkt aufgezeichnet werden. Betrachten Sie die folgenden schwarzen Gitterpunkte als Testdaten und sagen Sie das Ergebnis voraus.
Wenn die blaue Linie der Grenzwert ist, ・ Das Ergebnis ist "0" für die Gitterpunkte über der blauen Linie. ・ Das Ergebnis ist "1" für die Gitterpunkte unterhalb der blauen Linie. Sie erhalten ein solches Ergebnis. Dieses Ergebnis wird durch das später beschriebene "Konturliniendiagramm" farbcodiert.
4.meshgrid
Verwenden Sie numpy.meshgrid für Gitterpunkte. Sie können beispielsweise eine 5x5-Liste erstellen, indem Sie folgende Schritte ausführen:
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]])
Wenn Sie dies auf der x-Achse und der y-Achse angeben, entspricht die Anordnung der Gitterpunkte der in der folgenden Abbildung gezeigten. Ab 0 in den Gittern liegen die Gitterpunkte in der Reihenfolge der Pfeile.
grids = np.array([x.ravel(), y.ravel()]).T
5. Konturdiagramm
Der Grenzwert wird mit der Kontur von matplotlib gezeichnet. Stellen Sie die X-Achse im ersten Argument, die Y-Achse im zweiten Argument und die Höhe im dritten Argument ein. Die Höhe ist entweder "0" oder "1", da dies in diesem Fall das Vorhersageergebnis der binären Klassifizierung ist.
from matplotlib.colors import ListedColormap
cmap = ListedColormap( ( "mistyrose","lightcyan") )
plt.contourf(x, y, pred, cmap=cmap)
Unter der Annahme, dass die Vorhersage der Gitterpunkte vorher ist, kann dieser Code eine Grenzlinie zeichnen, wie in der folgenden Abbildung gezeigt.
6. Alle Codes
Unten finden Sie den vollständigen Code für das Grenzdiagramm, einschließlich des Trainings mit dem Modell.
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):
'''
Initialisieren
'''
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': []
}
'''
Gewicht
'''
def weight_variable(self, shape):
initial = tf.truncated_normal(shape, stddev=0.01)
return tf.Variable(initial)
'''
vorspannen
'''
def bias_variable(self, shape):
initial = tf.zeros(shape)
return tf.Variable(initial)
'''
Modelldefinition (3-Schicht-Perzeptron)
'''
def inference(self, x):
#Eingabeebene-Versteckte Ebene
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])
#Versteckte Ebene-Ausgabeschicht
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
'''
Verlustfunktion
'''
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
'''
Optimierungsalgorithmus
'''
def training(self, loss):
optimizer = tf.train.GradientDescentOptimizer(0.05)
train_step = optimizer.minimize(loss)
return train_step
'''
Richtige Antwortrate
'''
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
'''
Prognose
'''
def prediction(self, y):
return tf.cast(tf.greater(y, 0.5),tf.float32)
'''
Lernen
'''
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
})
'''
Halbmonddaten generieren
'''
N = 300 #Gesamtzahl der Daten
X, y = datasets.make_moons(N, noise=0.2)
Y = y.reshape(N, 1)
#Teilen Sie in Trainingsdaten und Testdaten
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, train_size=0.8)
'''
Datenplot
'''
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()
'''
Modelleinstellungen
'''
model = ThreelayerPerceptron(n_in=len(X[0]),
n_hidden=3,
n_out=len(Y[0]))
'''
Modelllernen
'''
history = model.fit(X_train, Y_train,
nb_epoch=400,
batch_size=20,
verbose=1)
'''
Bewertung der Vorhersagegenauigkeit
'''
accuracy = model.evaluate(X_test, Y_test)
print('accuracy: ', accuracy)
'''
Generieren Sie Rasterdaten, um das Diagramm farblich zu kennzeichnen
'''
meshgrids = np.meshgrid(
np.arange( -1.5, 2.6, 0.01 ),
np.arange( -1, 1.6, 0.01 )
)
xx = meshgrids[0]
yy = meshgrids[1]
#Erstellen Sie eine Liste mit Rasterpunkten
grids = np.array([xx.ravel(), yy.ravel()]).T
'''
Holen Sie sich das Vorhersageergebnis der Rasterdaten
'''
pred = model.predict(grids)
pred = pred.reshape( xx.shape )
'''
Datenplot
'''
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()
Geschichte
2020/03/08 Erste Ausgabe veröffentlicht 2020/03/09 Korrektur der Definition der Verlustfunktion
Recommended Posts