Wenn wir neurale Netzwerke trainieren, verwenden wir normalerweise Gradientenabstieg, der auf einer kontinuierlichen, differenzierbaren reellen Kostenfunktion beruht. Die endgültige Kostenfunktion könnte beispielsweise den mittleren quadratischen Fehler annehmen. Oder anders gesagt, Gradientenabstieg setzt implizit voraus, dass das Endziel Regression ist - um ein reellwertiges Fehlermaß zu minimieren.Kostenfunktion Trainingsziel versus Genauigkeit gewünschtes Ziel
Manchmal wollen wir, dass ein neuronales Netzwerk eine Klassifizierung durchführt - bei einer Eingabe in zwei oder mehr diskrete Kategorien einordnen. In diesem Fall ist das Endziel, das dem Benutzer wichtig ist, die Klassifizierungsgenauigkeit - der Prozentsatz der Fälle, die korrekt klassifiziert wurden.
Aber wenn wir ein neuronales Netz zur Klassifizierung verwenden, obwohl unser Ziel Klassifikationsgenauigkeit ist, das ist nicht das, was das neuronale Netz zu optimieren versucht. Das neurale Netzwerk versucht immer noch, die reellwertige Kostenfunktion zu optimieren. Manchmal zeigen diese in die gleiche Richtung, manchmal aber auch nicht. Insbesondere bin ich auf Fälle gestoßen, in denen ein neuronales Netzwerk trainiert wurde, um die Kostenfunktion korrekt zu minimieren, eine Klassifizierungsgenauigkeit, die schlechter ist als ein einfacher handcodierter Schwellenwertvergleich.
Ich habe dies mit TensorFlow zu einem minimalen Testfall gekocht. Es erstellt ein Perzeptron (neuronales Netzwerk ohne versteckte Schichten), trainiert es auf einem absolut minimalen Datensatz (eine Eingangsvariable, eine binäre Ausgangsvariable), bewertet die Klassifikationsgenauigkeit des Ergebnisses und vergleicht es dann mit der Klassifikationsgenauigkeit einer einfachen Hand -kodierter Schwellenwertvergleich; Die Ergebnisse sind 60% bzw. 80%. Intuitiv ist dies der Fall, weil ein einzelner Ausreißer mit einem großen Eingangswert einen entsprechend großen Ausgangswert erzeugt, so dass der Weg zur Minimierung der Kostenfunktion darin besteht, besonders hart zu versuchen, diesen einen Fall zu berücksichtigen und dabei zwei weitere Fälle falsch zu klassifizieren. Das Perzeptron tut richtig, was es zu tun hatte; Es entspricht nur nicht dem, was wir eigentlich von einem Klassifikator erwarten. Die Klassifikationsgenauigkeit ist jedoch keine kontinuierliche differenzierbare Funktion, so dass wir sie nicht als Ziel für den Gradientenabfall verwenden können.
Wie können wir ein neuronales Netzwerk so trainieren, dass es die Klassifikationsgenauigkeit maximiert?
import numpy as np
import tensorflow as tf
sess = tf.InteractiveSession()
tf.set_random_seed(1)
# Parameters
epochs = 10000
learning_rate = 0.01
# Data
train_X = [
[0],
[0],
[2],
[2],
[9],
]
train_Y = [
0,
0,
1,
1,
0,
]
rows = np.shape(train_X)[0]
cols = np.shape(train_X)[1]
# Inputs and outputs
X = tf.placeholder(tf.float32)
Y = tf.placeholder(tf.float32)
# Weights
W = tf.Variable(tf.random_normal([cols]))
b = tf.Variable(tf.random_normal([]))
# Model
pred = tf.tensordot(X, W, 1) + b
cost = tf.reduce_sum((pred-Y)**2/rows)
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)
tf.global_variables_initializer().run()
# Train
for epoch in range(epochs):
# Print update at successive doublings of time
if epoch&(epoch-1) == 0 or epoch == epochs-1:
print('{} {} {} {}'.format(
epoch,
cost.eval({X: train_X, Y: train_Y}),
W.eval(),
b.eval(),
))
optimizer.run({X: train_X, Y: train_Y})
# Classification accuracy of perceptron
classifications = [pred.eval({X: x}) > 0.5 for x in train_X]
correct = sum([p == y for (p, y) in zip(classifications, train_Y)])
print('{}/{} = perceptron accuracy'.format(correct, rows))
# Classification accuracy of hand-coded threshold comparison
classifications = [x[0] > 1.0 for x in train_X]
correct = sum([p == y for (p, y) in zip(classifications, train_Y)])
print('{}/{} = threshold accuracy'.format(correct, rows))
Je weniger Fehler, desto höher ist die Genauigkeit. Ist das nicht eine gültige Aussage? –
@AlexeyR. Der Punkt ist nicht die Terminologie, der Punkt ist, dass Gradientabstieg versucht, die Fehlerfunktion * real valued * zu minimieren, wohingegen der Benutzer sich Gedanken um Fehler im Sinne von * Prozent falsch klassifizierter Fälle macht * und dies sind zwei verschiedene Dinge. – rwallace
Verwenden Sie einfach die [rechte Proxy-Funktion] (https://datascience.stackexchange.com/questions/13663/neural-networks-loss-and-accuracy-correlation). Quadratischer Fehler versagt hier sicher. – sascha