[PYTHON] Tiefes Lernen von Grund auf neu (Vorwärtsausbreitung)

Einführung

Es ist ungefähr zwei Wochen her, seit ich angefangen habe, Deep Learning zu lernen. Es ist an der Zeit, dass ich das Geräusch von dem höre, was ich aus meinem Kopf gelernt habe, also möchte ich es auf organisierte Weise ausgeben. Ab diesem Zeitpunkt werden wir DNN mehrmals erstellen. Diesmal ist die Forward Propagation Edition.

Über die zu erstellende DNN

Bauen Sie ein Netzwerk auf, um festzustellen, ob das Bild eine Katze ist (1) oder nicht (0).

Zu verwendende Daten

209 Bilder werden als Trainingsdaten und 50 Bilder als Testdaten verwendet. Die Größe jedes Bildes beträgt 64 * 64.

Number of training examples : 209
Number of testing examples : 50
Each image is of size : 64 * 64

Außerdem ist das Verhältnis von korrekten Antwortdaten und falschen Antwortdaten wie folgt.

Number of cat-images of training data : 72 / 209
Number of cat-images of test data : 33 / 50

DNN zu bauen

Anzahl der Schichten

Erstellen Sie ein vierschichtiges Netzwerk mit 12288 (64 * 64) Eingangsknoten und einem Ausgangsknoten. Ich wollte jeden Knoten mit einer Leitung verbinden, gab aber auf, weil es schwierig war, mit Powerpo zu arbeiten.

Dimention of each layer : [12288, 20, 7, 5, 1]

Aktivierungsfunktion

Dieses Mal verwenden wir die ReLU-Funktion für die Zwischenschicht und die Sigmoid-Funktion für die Ausgangsschicht.

Relu-Funktion

Die Relu-Funktion ist eine Funktion, die 0 ausgibt, wenn der Eingabewert 0 oder weniger ist, und den Eingabewert so ausgibt, wie es sonst ist. Es kann wie folgt geschrieben werden.

y = np.maximum(0, x)

Sigmoidfunktion

Die Sigmoid-Funktion ist eine Funktion, die den Eingabewert von 1 in 0 konvertiert und ausgibt. Es kann wie folgt geschrieben werden. Der Ausdruck ist wie folgt. $ y = \frac{1}{1+e^{-z}} $ In Python geschrieben sieht es so aus:

y = 1 / (1 + np.exp(-x))

Das große Bild des Lernens

Nachdem Sie nun das Gesamtdesign von DNN kennen, wollen wir uns mit DNN befassen. In DNN lernen Sie, indem Sie die folgenden Schritte ausführen. Durch Wiederholen der Schritte 2 bis 5 werden die Parameter schrittweise optimiert.

1. Parameterinitialisierung
2. Vorwärtsausbreitung
3. Berechnen Sie den Fehler
4. Zurück Fehlerausbreitung
5. Aktualisieren Sie die Parameter
6. Kehren Sie zu 2 zurück

Parameterinitialisierung

Dieses Mal wurden alle Ebenen mit den Anfangswerten von Xivier initialisiert. Es scheint, dass Sie die He-Initialisierung verwenden sollten, wenn Sie die Relu-Funktion verwenden, aber ehrlich gesagt ist der Unterschied in diesem Bereich noch nicht gut verstanden.

Xavier-Initialisierung

Die Xivier-Initialisierung extrahiert zufällig die Anfangsparameter aus einer Normalverteilung mit dem Mittelwert $ 0 $ und der Standardabweichung $ \ frac {1} {\ sqrt {n}} $. Im Vergleich zum Extrahieren aus der Standardnormalverteilung verhindert das Extrahieren aus einem engen Bereich, dass die Aktivierung jeder Schicht auf etwa 0 und 1 vorgespannt wird, und macht es weniger wahrscheinlich, dass ein Verschwinden des Gradienten auftritt. Siehe Seite 182 von "Deep Learning von Grund auf neu" für Einzelheiten. Da es 4 Ebenen gibt, müssen die Parameter für 4 Ebenen initialisiert werden. Erstellen Sie eine Funktion, die Parameter mit der Vektorisierung der Anzahl der Ebenen in jeder Ebene als Argument zurückgibt.

def initialize_parameters(layers_dims):
    np.random.seed(1)
    parameters = {}
    L = len(layers_dims)
    
    for l in range(1, L):
        parameters['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l-1]) / np.sqrt(layers_dims[l-1])
        parameters['b' + str(l)] = np.zeros((layers_dims[l], 1))
    return parameters

Vorwärtsausbreitung

Prognostizieren Sie das richtige Antwortetikett anhand der vorbereiteten Parameter. Gehen Sie für alle Ebenen wie folgt vor: Da die in einem anderen Beitrag verwendete Zahl umgeleitet wird, wird die Kostenfunktion $ L (a, y) $ gezeichnet, aber Forwad Propagation muss sich dessen nicht bewusst sein. Ignorieren Sie sie daher.

Die dafür erforderlichen Funktionen sind: Gelegentlich sind Cache und Caches Variablen, die bei der Implementierung der Rückübertragung verwendet werden.

1. Eine Funktion, die das innere Produkt aus Eingabewert X und Parameter W + Bias-Term berechnet
2. Aktivierungsfunktion (sigmoid (), relu ())
3. Eine Funktion, die 1 und 2 kombiniert
4. Eine Funktion, die 3 mehrmals in Ebenen wiederholt

Funktion zur Berechnung des inneren Produkts aus Eingabewert X und Parameter W + Bias-Term

def linear_forward(A, W, b):
    Z = np.dot(W, A) + b
    cache = (A, W, b)
    return Z, cache

Aktivierungsfunktion

def sigmoid(Z):
    A = 1 / (1+np.exp(-Z))
    cache = Z
    return A, cache


def relu(Z):
    A = np.maximum(0, Z)
    cache = Z
    return A, cache

Eine Funktion, die 1 und 2 kombiniert

def linear_activation_forward(A_prev, W, b, activation):
    if activation == 'relu':
        Z, linear_cache = linear_forward(A_prev, W, b)
        A, activation_cache = relu(Z)
    elif activation == 'sigmoid':
        Z, linear_cache = linear_forward(A_prev, W, b)
        A, activation_cache = sigmoid(Z)
    cache = (linear_cache, activation_cache)
    
    return A, cache

Eine Funktion, die 3 für die Anzahl der Ebenen wiederholt

def L_model_forward(X, parameters):
    caches = []
    A = X
    L = len(parameters) // 2
    
    for l in range(1, L):
        A_prev = A
        A, cache = linear_activation_forward(A_prev, parameters['W'+str(l)], parameters['b'+str(l)], activation='relu')
        caches.append(cache)
    AL, cache = linear_activation_forward(A, parameters['W'+str(L)], parameters['b'+str(L)], activation = 'sigmoid')
    caches.append(cache)
    return AL, caches

Die Vorhersage mit Anfangsparametern kann durch Ausführen von L_model_forward durchgeführt werden.

Zusammenfassung

Dieses Mal haben wir bis zur Vorwärtsausbreitung implementiert. Nächstes Mal möchte ich die Kosten berechnen.