[PYTHON] Apprentissage profond à partir de zéro (propagation vers l'avant)

introduction

Cela fait environ deux semaines que j'ai commencé à apprendre le Deep Learning. Il est grand temps que j'entende le son de ce que j'ai appris sortir de ma tête, alors j'aimerais le sortir de manière organisée. À partir de ce moment, nous créerons DNN plusieurs fois. Cette fois, c'est l'édition de propagation vers l'avant.

À propos du DNN à créer

Construisez un réseau pour déterminer si l'image est un chat (1) ou non (0).

Données à utiliser

209 images seront utilisées comme données d'entraînement et 50 images seront utilisées comme données de test. La taille de chaque image est de 64 * 64.

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

De plus, le rapport entre les données de réponse correcte et les données de réponse incorrectes est le suivant.

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

DNN à construire

Nombre de couches

Créez un réseau à quatre niveaux avec 12288 (64 * 64) nœuds d'entrée et un nœud de sortie. J'avais l'intention de connecter chaque nœud avec une ligne, mais j'ai abandonné parce que c'était difficile à faire avec Powerpo.

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

Fonction d'activation

Cette fois, nous utiliserons la fonction ReLU pour la couche intermédiaire et la fonction sigmoïde pour la couche de sortie.

Fonction Relu

La fonction Relu est une fonction qui produit 0 si la valeur d'entrée est égale ou inférieure à 0, et sort la valeur d'entrée telle qu'elle est autrement. Il peut s'écrire comme suit.

y = np.maximum(0, x)

fonction sigmoïde

La fonction sigmoïde est une fonction qui convertit la valeur d'entrée de 1 à 0 et la sort. Il peut s'écrire comme suit. L'expression est la suivante. $ y = \frac{1}{1+e^{-z}} $ Écrit en Python, cela ressemble à ceci:

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

La vue d'ensemble de l'apprentissage

Maintenant que vous connaissez la conception globale de DNN, passons en revue l'apprentissage de DNN. Dans DNN, vous apprendrez en suivant les étapes ci-dessous. En répétant les étapes 2 à 5, les paramètres seront progressivement optimisés.

1. Initialisation des paramètres
2. Propagation vers l'avant
3. Calculez l'erreur
4. Propagation en arrière de l'erreur
5. Mettre à jour les paramètres
6. Revenir à 2

Initialisation des paramètres

Cette fois, toutes les couches ont été initialisées en utilisant les valeurs initiales de Xivier. Il semble que vous devriez utiliser l'initialisation He lorsque vous utilisez la fonction relu, mais honnêtement, la différence dans ce domaine n'est pas encore bien comprise.

Initialisation Xavier

L'initialisation de Xivier extrait aléatoirement les paramètres initiaux d'une distribution normale avec une moyenne $ 0 $ et un écart-type $ \ frac {1} {\ sqrt {n}} $. Par rapport à l'extraction de la distribution normale standard, l'extraction à partir d'une plage étroite empêche l'activation de chaque couche d'être biaisée autour de 0 et 1, et rend moins probable la disparition du gradient. Voir page 182 de "Deep Learning from scratch" pour plus de détails. Puisqu'il y a 4 couches, il est nécessaire d'initialiser les paramètres pour 4 couches. Créez une fonction qui renvoie des paramètres avec la vectorisation du nombre de couches dans chaque couche comme argument.

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

Propagation vers l'avant

Prédisez l'étiquette de réponse correcte en utilisant les paramètres préparés. Procédez comme suit pour tous les calques: Puisque le chiffre utilisé dans un autre article est détourné, la fonction de coût $ L (a, y) $ est dessinée, mais Forwad Propagation n'a pas besoin d'en être conscient, donc ignorez-la.

Les fonctions nécessaires pour ce faire sont: Parfois, le cache et les caches sont des variables utilisées lors de la mise en œuvre de la rétro-propagation.

1. Une fonction qui calcule le produit interne de la valeur d'entrée X et du paramètre W + terme de biais
2. fonction d'activation (sigmoïde (), relu ())
3. Une fonction qui combine 1 et 2
4. Une fonction qui se répète 3 fois plusieurs fois en couches

Fonction pour calculer le produit interne de la valeur d'entrée X et du paramètre W + terme de biais

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

fonction d'activation

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

Une fonction qui combine 1 et 2

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

Une fonction qui répète 3 pour le nombre de couches

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

La prédiction avec les paramètres initiaux peut être effectuée en exécutant L_model_forward.

Résumé

Cette fois, nous avons implémenté la propagation avant. La prochaine fois, j'aimerais calculer le coût.