Einführung

In "Deep Learning von Grund auf neu" wird die Haltung vertreten, den Inhalt von Tensorflow mit Numpy zu implementieren. In diesem Artikel werden wir nachziehen und das Problem der Implementierung eines einfachen Klassifizierungsproblems mit Numpy betrachten.

Nachschlagewerk *

Deep Learning von Grund auf neu Wenn Sie Erfahrung mit maschinellem Lernen haben, ist dieses Buch ein Muss. Sie sollten denken, dass Sie nicht verstehen können, ohne dieses Buch zu lesen. Die Anzahl der Seiten hängt von diesem Buch ab.

Problem

Suppose we want to classify some data (4 samples) into 3 distinct classes: 0, 1, and 2. We have set up a network with a pre-activation output z in the last layer. Applying softmax will give the final model output. input X ---> some network --> z --> y_model = softmax(z)

We quantify the agreement between truth (y) and model using categorical cross-entropy. J = - sum_i (y_i * log(y_model(x_i))

In the following you are to implement softmax and categorical cross-entropy and evaluate them values given the values for z.

Wir werden "y_cl = np.array ([0, 0, 2, 1])" als Eingabewert verwenden und die verborgene Ebene diesmal nicht im Detail betrachten. Angenommen, Arrayy_cl wird zu einem anderen Arrayz, wenn dieser Eingabewert nach einiger Berechnung aus der verborgenen Ebene verschwindet. Wenn Sie den Ausgabewert über die Softmax-Funktion mit "z" betrachten, ergibt sich dann das gleiche Array wie "y_cl"? Bitte besprechen Sie auch die Richtigkeit.

Tensorflow wurde bereits wie folgt implementiert. Implementieren Sie daher ein Programm, das sich nur mit Numpy gleich verhält. (Ich denke, dass Abschnitt 3.5 des Nachschlagewerks hilfreich sein wird.) Es gibt Probleme von 1) bis 5).


from __future__ import print_function
import numpy as np
import tensorflow as tf


# Data: 4 samples with the following class labels (input features X irrelevant here)
y_cl = np.array([0, 0, 2, 1])

# output of the last network layer before applying softmax
z = np.array([
    [  4,   5,   1],
    [ -1,  -2,  -3],
    [0.1, 0.2, 0.3],
    [ -1, 100,   1]
    ])



# TensorFlow implementation as reference. Make sure you get the same results!
print('\nTensorFlow ------------------------------ ')
with tf.Session() as sess:
    z_ = tf.constant(z, dtype='float64')
    y_ = tf.placeholder(dtype='float64', shape=(None,3))

    y = np.array([[1., 0., 0.], [1., 0., 0.], [0., 0., 1.], [0., 1., 0.]])
    print('one-hot encoding of data labels')
    print(y)

    y_model = tf.nn.softmax(z)
    crossentropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y_model), reduction_indices=[1]))

    print('softmax(z)')
    print(sess.run(y_model))

    print('cross entropy = %f' % sess.run(crossentropy, feed_dict={y_: y}))


print('\nMy solution ------------------------------ ')
# 1) Write a function that turns any class labels y_cl into one-hot encodings y. (2 points)
#    0 --> (1, 0, 0)
#    1 --> (0, 1, 0)
#    2 --> (0, 0, 1)
#    Make sure that np.shape(y) = (4, 3) for np.shape(y_cl) = (4).

def to_onehot(y_cl, num_classes):
    y = np.zeros((len(y_cl), num_classes))
    return y


# 2) Write a function that returns the softmax of the input z along the last axis. (2 points)
def softmax(z):
    return None


# 3) Compute the categorical cross-entropy between data and model (2 points)


# 4) Which classes are predicted by the model (maximum entry). (1 point)


# 5) How many samples are correctly classified (accuracy)? (1 point)

Antworten

from __future__ import print_function
import numpy as np
import tensorflow as tf


# Data: 4 samples with the following class labels (input features X irrelevant here)
y_cl = np.array([0, 0, 2, 1])

# output of the last network layer before applying softmax
z = np.array([
    [  4,   5,   1],
    [ -1,  -2,  -3],
    [0.1, 0.2, 0.3],
    [ -1, 100,   1]
    ])

#Tensorflow-Teil weggelassen

print('\n☆My solution ------------------------------ ')
# 1) Write a function that turns any class labels y_cl into one-hot encodings y. (2 points)
#    0 --> (1, 0, 0)
#    1 --> (0, 1, 0)
#    2 --> (0, 0, 1)
#    Make sure that np.shape(y) = (4, 3) for np.shape(y_cl) = (4).

def to_onehot(num_classes, y_cl):
    y_one = np.eye(num_classes)[y_cl]
    return y_one

print('one-hot encoding of data labels by Numpy')
y_one = (to_onehot(3,y_cl)).astype(np.float32)
print(y_one)

#2) Write a function that returns the softmax of the input z along the last axis. (2 points)
def softmax(z):
    e = np.exp(z)
    dist = e / np.sum(e, axis=1, keepdims=True)
    return dist

print('softmax(z) by Numpy')
y_my = softmax(z)
print(y_my)

# 3) Compute the categorical cross-entropy between data and model (2 points)
crossentropy_my = np.mean(-np.sum(y_one*np.log(y_my),axis=1))
print('cross entropy by Numpy: %f' % crossentropy_my)

# 4) Which classes are predicted by the model (maximum entry). (1 point)
print('The predicted class by Numpy:')
y_pre_cl= np.argmax(y_my,axis=1)
print(y_pre_cl)

# 5) How many samples are correctly classified (accuracy)? (1 point)
accuracy_my = np.mean(y_pre_cl == y_cl)
print('accuracy by Numpy: %f' % accuracy_my)

Ausgabe

■Input data with 4 samples:[0 0 2 1]

☆TensorFlow ------------------------------ 
one-hot encoding of data labels
[[ 1.  0.  0.]
 [ 1.  0.  0.]
 [ 0.  0.  1.]
 [ 0.  1.  0.]]
softmax(z)
[[  2.65387929e-01   7.21399184e-01   1.32128870e-02]
 [  6.65240956e-01   2.44728471e-01   9.00305732e-02]
 [  3.00609605e-01   3.32224994e-01   3.67165401e-01]
 [  1.36853947e-44   1.00000000e+00   1.01122149e-43]]
cross entropy: 0.684028
The predicted class:
[1 0 2 1]
accuracy: 0.750000

☆My solution ------------------------------ 
one-hot encoding of data labels by Numpy
[[ 1.  0.  0.]
 [ 1.  0.  0.]
 [ 0.  0.  1.]
 [ 0.  1.  0.]]
softmax(z) by Numpy
[[  2.65387929e-01   7.21399184e-01   1.32128870e-02]
 [  6.65240956e-01   2.44728471e-01   9.00305732e-02]
 [  3.00609605e-01   3.32224994e-01   3.67165401e-01]
 [  1.36853947e-44   1.00000000e+00   1.01122149e-43]]
cross entropy by Numpy: 0.684028
The predicted class by Numpy:
[1 0 2 1]
accuracy by Numpy: 0.750000

Kommentar

Antworten und Fragen können von [hier] heruntergeladen werden (https://gist.github.com/hiroyuki827/b8813ad1920fb42f45e2550132879415).

Frage 1.

Write a function that turns any class labels y_cl into one-hot encodings y. (2 points) 0 --> (1, 0, 0) 1 --> (0, 1, 0) 2 --> (0, 0, 1) Make sure that np.shape(y) = (4, 3) for np.shape(y_cl) = (4).

def to_onehot(num_classes, y_cl):
    y_one = np.eye(num_classes)[y_cl]
    return y_one

Durch Lesen des Numpy-Arrays "y_cl" können Sie ein Array mit "1" an der Position des Elements "y_cl" erhalten. num_class muss der Maximalwert von y_cl sein - der Minimalwert + 1. (Diesmal ist es 0,1,2, es gibt also drei.) Dies ist ein One-Hot-Vektor.

Problem 2.

Write a function that returns the softmax of the input z along the last axis. (2 points)

def softmax(z):
    e = np.exp(z)
    dist = e / np.sum(e, axis=1, keepdims=True)
    return dist

Implementieren Sie die Softmax-Funktion wie definiert. Insbesondere bei großen Eingaben ändert sich die Subtraktion mit dem Maximalwert nicht (S.69), daher kann dies verwendet werden. Beachten Sie auch, dass die Option "keepdims" "1" ist, es sei denn, die Option "keepdims" ist "True". (Ersteres ist ein eindimensionales Array, letzteres ist ein 0-dimensionales Array (nur eine Zahl))

Problem 3.

Compute the categorical cross-entropy between data and model (2 points)

crossentropy_my = np.mean(-np.sum(y_one*np.log(y_my),axis=1))
print('cross entropy by Numpy: %f' % crossentropy_my)

Definition der kategorialen Kreuzentropie

E = - \sum_{k}t_{k} \log{y_k}

Es sollte gemäß implementiert werden. Dabei ist $ t_k $ ein One-Hot-Vektor und $ y_k $ eine Ausgabe.

Außerdem sind tf.reduce_mean und np.mean identisch. Informationen zur Achse in Numpy finden Sie unter hier. Dieses Mal werden wir das Klassifizierungsproblem betrachten. Wenn Sie also Array in Array verwenden (z. B. "[[A, B, C], [D, E, F]]", dann "[A, B, C]" und "[D"). Array) entsprechend E, F] `muss separat betrachtet werden. In diesem Fall können Sie innerhalb dieses Bereichs arbeiten, wenn Sie "Achse = 1" angeben.

Wenn Sie die Dinge bis zu diesem Punkt organisieren

y_cl (Eingabewert) auf einen heißen Vektor geändert. -> y_one
Das Arrayz, das durch die Ebenen herauskam, wurde durch die Softmax-Funktion-> y_my geleitet

Diese sind getrennt und entsprechen $ t_k $ bzw. $ y_k $.

Problem 4.

Which classes are predicted by the model (maximum entry). (1 point)

print('The predicted class by Numpy:')
y_pre_cl = np.argmax(y_my,axis=1)
print(y_pre_cl)

Siehe Seite 70 für Einzelheiten. In dem oben behandelten Array (z. B. "[A, B, C]", "[D, E, F]") ist der Grad der Genauigkeit der Klassifizierung in der Klasse als Element enthalten. Um dies abzurufen, nehmen Sie den Index mit dem größten Wert. Dies ist mit np.argmax möglich. Geben Sie in ähnlicher Weise "Achse = 1" an.

Eine kurze Beschreibung des One-Hot-Vektors

Verwenden Sie bei Klassifizierungsproblemen softmax für die endgültige Aktivierung. Dies liegt daran, dass Sie anhand der Indizes in der Liste der Ausgabewerte sehen können, in welche Kategorie die Daten klassifiziert werden können (Verhältnis oder Wahrscheinlichkeit). Zum Beispiel, wenn Sie drei geeignete Kategorieprobleme berücksichtigen

[0.10, 0.05, 0.85]

Angenommen, Sie erhalten eine Liste von (Dies entspricht einem der jetzt in Frage kommenden, entsprechend abgerufenen Arrays von Softmax (z).) Hier ist "np.argmax ([0.10, 0.05, 0.85]) = [2]", also das Ergebnis Wie Sie sehen können, "scheint die Bezeichnung, auf die dieses Array zeigt, eine Wahrscheinlichkeit der Zugehörigkeit zur Kategorie 2 von etwa 0,85 x 100 = 85% zu haben."

Wenn Sie den größten Index wie diesen verwenden, können Sie die Kategorie sehen. Um es anders herum auszudrücken: Wenn Sie dem richtigen Antwortetikett eine beliebige Nummer zuweisen und es zu etwas Besonderem machen, können Sie dieses Etikett finden und der Computer weiß, dass es sich um eine Kategorie handelt. Wenn Sie darüber nachdenken, wenn Sie 1 auf das richtige Antwortetikett und 0 auf das andere fallen lassen, können Sie anhand des Index, in dem sich 1 befindet, feststellen, ob es sich um die richtige Antwort handelt. Dies wird als One-Hot-Vektor bezeichnet.

Als nächstes sollten Sie den Eingabewert "y_cl" in einen One-Hot-Vektor konvertieren. Da es ausreicht, ein Array so zu definieren, dass sich 1 an der Position jedes Elements 0,0,2,1 von "y_cl" befindet, ist der One-Hot-Vektor zu diesem Zeitpunkt

[ [1, 0, 0], # 0
  [1, 0, 0], # 0
  [0, 0, 1], # 2
  [0, 1, 0] ] # 1

Es wird sein. (Kleine Benachrichtigungen ignorieren.)

Problem 5.

How many samples are correctly classified (accuracy)? (1 point)

accuracy_my = np.mean(y_pre_cl == y_cl)
print('accuracy by Numpy: %f' % accuracy_my)

Wie oben kurz zusammengefasst, zeigt die Softmax-Ausgabe, wie genau das Etikett in seine Position (Klasse) klassifiziert ist. Um herauszufinden, wie gut das endgültige Arrayy_pre_cl mit dem Eingabewert y_cl übereinstimmt, mitteln Sie die Anzahl der True-Werte.

abschließend

Das Klassifizierungsproblem ist auch eine wichtige Aufgabe beim maschinellen Lernen, aber ich denke, es ist schwer zu verstehen. (Warum One-Hot-Vektor verwenden?) Ich würde mich sehr freuen, wenn dieser Artikel auch nur eine dieser Fragen beantworten könnte.

[PYTHON] Möchten Sie ein einfaches Klassifizierungsproblem lösen?