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.

DNN_aruchitecture.png

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)

relu function.png

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))

sigmoid_function.png

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

DNN_learning_cycle.png

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.

LogisticFunction.png

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.

Recommended Posts

Apprentissage profond à partir de zéro (propagation vers l'avant)
Apprentissage profond à partir de zéro
Apprentissage profond à partir de zéro (calcul des coûts)
Mémo d'apprentissage profond créé à partir de zéro
Introduction au Deep Learning ~ Propagation vers l'avant ~
[Mémo d'apprentissage] Le Deep Learning fait de zéro [Chapitre 7]
Apprentissage profond / Apprentissage profond à partir de zéro 2-Essayez de déplacer GRU
Deep learning / Deep learning made from scratch Chapitre 6 Mémo
[Mémo d'apprentissage] Deep Learning fait de zéro [Chapitre 5]
[Mémo d'apprentissage] Le Deep Learning fait de zéro [Chapitre 6]
"Deep Learning from scratch" avec Haskell (inachevé)
Deep learning / Deep learning made from scratch Chapitre 7 Mémo
[Windows 10] Construction de l'environnement "Deep Learning from scratch"
Enregistrement d'apprentissage de la lecture "Deep Learning from scratch"
[Deep Learning from scratch] À propos de l'optimisation des hyper paramètres
Mémo d'auto-apprentissage "Deep Learning from scratch" (partie 12) Deep learning
[Mémo d'apprentissage] Deep Learning fait de zéro [~ Chapitre 4]
Écrivez vos impressions sur l'édition du framework Deep Learning 3 créée à partir de zéro
"Deep Learning from scratch" Mémo d'auto-apprentissage (n ° 9) Classe MultiLayerNet
Deep Learning from scratch ① Chapitre 6 "Techniques liées à l'apprentissage"
GitHub du bon livre "Deep Learning from scratch"
Deep Learning from scratch Chapter 2 Perceptron (lecture du mémo)
[Mémo d'apprentissage] Apprentissage profond à partir de zéro ~ Mise en œuvre de l'abandon ~
Résumé Python vs Ruby "Deep Learning from scratch"
Mémo d'auto-apprentissage «Deep Learning from scratch» (10) Classe MultiLayerNet
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 11) CNN
[Deep Learning from scratch] J'ai implémenté la couche Affine
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 19) Augmentation des données
Apprentissage profond / code de travail LSTM
[Deep Learning from scratch] Accélération du réseau de neurones J'ai expliqué le traitement de la propagation arrière
Application de Deep Learning 2 à partir de zéro Filtre anti-spam
[Deep Learning from scratch] J'ai essayé d'expliquer le décrochage
[Deep Learning from scratch] Implémentation de la méthode Momentum et de la méthode AdaGrad
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 1
Un amateur a trébuché dans le Deep Learning ❷ fait à partir de zéro Note: Chapitre 5
Un amateur a trébuché dans le Deep Learning ❷ fait à partir de zéro Note: Chapitre 2
Créez un environnement pour "Deep Learning from scratch" avec Docker
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 3
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 7
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 5
Un amateur a trébuché dans le Deep Learning ❷ fait de zéro Note: Chapitre 1
Un amateur a trébuché dans le Deep Learning ❷ fait à partir de zéro Note: Chapitre 4
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 18) One! Miaou! Grad-CAM!
Un amateur a trébuché dans le Deep Learning à partir de zéro.
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 2
J'ai essayé d'implémenter Perceptron Part 1 [Deep Learning from scratch]
Mémo d'auto-apprentissage "Deep Learning from scratch" (n ° 15) Tutoriel pour débutants TensorFlow
Deep learning / Deep learning from scratch 2 Chapitre 4 Mémo
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 5 Mémo
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 7 Mémo
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 8 Mémo
Deep learning / Deep learning made from scratch Chapitre 5 Mémo
Deep learning / Deep learning made from scratch Chapitre 4 Mémo
Deep Strengthening Learning 3 Édition pratique: Briser des blocs
Deep learning / Deep learning from scratch 2 Chapitre 3 Mémo
Introduction au Deep Learning ~ Dropout Edition ~
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 6 Mémo