[Mémo d'apprentissage] Apprentissage profond à partir de zéro ~ Mise en œuvre de l'abandon ~

Contexte

Récemment Deep Learning "[Deep Learning from Zero](https://www.amazon.co.jp/ Deep-Learning from Zero - Théorie et mise en œuvre du Deep Learning tirées de Python-Saito-Yasutake / dp / 4873117585)" Je commence à étudier à. L'implémentation de dropout est également répertoriée, mais j'ai creusé un peu plus pour voir comment le contenu fonctionne.

Qu'est-ce que le décrochage?

L'apprentissage automatique a le problème du surapprentissage, qui se spécialise dans les données de formation. En ce qui concerne le surapprentissage, prenons un exemple d'essayer de comprendre le sens d'autres phrases en mémorisant des phrases et leur signification. Même si le mot «hashi» est souvent utilisé pour signifier «pont» dans les phrases mémorisées, même si «hashi» est utilisé comme «fin» dans d'autres phrases, il sera compris comme «pont». Fait référence à une situation. (C'est juste ma compréhension de la situation actuelle, alors veuillez commenter si vous faites une erreur.) Le décrochage est une technique pour éviter cela. Voir ici pour une explication un peu plus détaillée.

Mise en œuvre du décrochage

ici, ・ Python3 ・ Numpy J'utilise. Jetons maintenant un œil à l'implémentation de la couche Dropout.

import numpy as np

class Dropout:
    """
    http://arxiv.org/abs/1207.0580
    """
    def __init__(self, dropout_ratio=0.5):
        self.dropout_ratio = dropout_ratio
        self.mask = None

    def forward(self, x, train_flg=True):
        if train_flg:
            self.mask = np.random.rand(*x.shape) > self.dropout_ratio
            return x * self.mask
        else:
            return x * (1.0 - self.dropout_ratio)

    def backward(self, dout):
        return dout * self.mask

Vérifier le traitement du contenu lors du déplacement

Tout d'abord, la partie d'initialisation.

    def __init__(self, dropout_ratio=0.5):
        self.dropout_ratio = dropout_ratio
        self.mask = None

Ici, remplissez simplement l'argument dropout_ratio dans une variable interne et initialisez le masque de suppression.

Vient ensuite la partie avant.

    def forward(self, x, train_flg=True):
        if train_flg:
            self.mask = np.random.rand(*x.shape) > self.dropout_ratio
            return x * self.mask
        else:
            return x * (1.0 - self.dropout_ratio)

train_flg doit avoir la valeur True pour l'entraînement et False pour l'inférence. Pour plus d'informations sur ce domaine, consultez "[Deep Learning from Zero](https://www.amazon.co.jp/ Deep-Learning from Zero --- Theory and Implementation of Deep Learning Learned from Python-Saito-Yasutake / dp / Veuillez lire 4873117585) ". Décomposons chaque processus et voyons le contenu du processus dans Shell (les valeurs ici sont des exemples).

#Tout d'abord, générez x qui est une entrée appropriée
>>> import numpy as np
>>> x = np.array([0,1,2,3,4])
>>> x
array([0, 1, 2, 3, 4])

#np.random(rand(*x.shape)Sortie de
>>> rand = np.random.rand(*x.shape)
>>> rand
array([0.15816005, 0.03610269, 0.86484777, 0.2235985 , 0.64981875])

#np.random.rand(*x.shape) > self.dropout_ratio (0 ici.Sortie de 5)
>>> dropout_ratio = 0.5
>>> mask = rand > dropout_ratio
>>> mask
array([False, False,  True, False,  True])

#return x * self.sortie du masque
#La partie qui est False dans le masque devient 0 lorsqu'elle est multipliée par x
>>> x * mask
array([0, 0, 2, 0, 4])

#return x * (1.0 - self.dropout_ratio)Sortie de
>>> x * (1.0 - dropout_ratio)
array([0. , 0.5, 1. , 1.5, 2. ])

Vient ensuite la partie en arrière.

    def backward(self, dout):
        return dout * self.mask

Essayez de l'exécuter dans Shell comme vous le feriez pour le transfert. mask utilise celui généré par forward, et dout en génère un approprié. En fait, le masque généré par forward est hérité par backward.

#Générer du dout
>>> dout = [0.0, 0.1, 0.2, 0.3, 0.4]

#return dout * self.sortie du masque
>>> dout * mask
array([0. , 0. , 0.2, 0. , 0.4])

Enfin, voyons comment Dropout est implémenté. Cette fois, seulement en avant. J'avais l'habitude de décrire cette interruption dans un fichier appelé sample.py une fois.

>>> import numpy as np
>>> from sample import Dropout
>>> 
>>> dropout = Dropout()
>>> 
>>> x = np.array([0,1,2,3,4])

#Puisque des nombres aléatoires sont générés, la sortie directe change à chaque fois qu'elle est exécutée.
>>> dropout.forward(x)
array([0, 0, 2, 3, 0])
>>> dropout.forward(x)
array([0, 0, 0, 0, 4])
>>> dropout.forward(x)
array([0, 0, 2, 0, 4])

J'ai pu confirmer la sortie de l'avant. Essayez également de déplacer train_flg = Faux et recule.

Recommended Posts

[Mémo d'apprentissage] Apprentissage profond à partir de zéro ~ Mise en œuvre de l'abandon ~
[Deep Learning from scratch] Implémentation de la méthode Momentum et de la méthode AdaGrad
Apprentissage profond à partir de zéro
[Mémo d'apprentissage] Le Deep Learning fait de zéro [Chapitre 7]
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 / Deep learning made from scratch Chapitre 7 Mémo
Enregistrement d'apprentissage de la lecture "Deep Learning from scratch"
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]
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 10-2) Valeur initiale du poids
Mémo d'auto-apprentissage "Deep Learning from scratch" (glossaire illisible)
"Deep Learning from scratch" Mémo d'auto-apprentissage (n ° 9) Classe MultiLayerNet
Deep Learning from scratch Chapter 2 Perceptron (lecture du mémo)
Mémo d'auto-apprentissage «Deep Learning from scratch» (10) Classe MultiLayerNet
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 11) CNN
Apprentissage profond à partir de zéro 1 à 3 chapitres
Apprentissage par renforcement profond 2 Mise en œuvre de l'apprentissage par renforcement
Python vs Ruby "Deep Learning from scratch" Chapitre 4 Implémentation de la fonction de perte
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 19) Augmentation des données
Application de Deep Learning 2 à partir de zéro Filtre anti-spam
Othello ~ De la troisième ligne de "Implementation Deep Learning" (4) [Fin]
[Deep Learning from scratch] J'ai essayé d'expliquer le décrochage
Python vs Ruby "Deep Learning from scratch" Chapitre 3 Implémentation d'un réseau neuronal à 3 couches
Deep learning / Deep learning made from scratch Chapitre 3 Mémo
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 5 Mémo
Apprentissage profond à partir de zéro (calcul des coûts)
Deep Learning from scratch La théorie et la mise en œuvre de l'apprentissage profond appris avec Python Chapitre 3
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 learning / Deep learning from scratch 2 Chapitre 3 Mémo
Mémo d'apprentissage profond créé à partir de zéro
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 6 Mémo
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 18) One! Miaou! Grad-CAM!
Mémo d'auto-apprentissage "Deep Learning from scratch" (n ° 15) Tutoriel pour débutants TensorFlow
Apprentissage profond à partir de zéro (propagation vers l'avant)
Othello-De la troisième ligne de "Implementation Deep Learning" (3)
Apprentissage profond / Apprentissage profond à partir de zéro 2-Essayez de déplacer GRU
"Deep Learning from scratch" avec Haskell (inachevé)
[Windows 10] Construction de l'environnement "Deep Learning from scratch"
[Deep Learning from scratch] À propos de l'optimisation des hyper paramètres
Othello-De la troisième ligne de "Implementation Deep Learning" (2)
Écrivez vos impressions sur l'édition du framework Deep Learning 3 créée à partir de zéro
Mémo d'auto-apprentissage "Deep Learning from scratch" (n ° 13) Essayez d'utiliser Google Colaboratory
Chapitre 2 Implémentation de Perceptron Ne découpez que les bons points de Deeplearning à partir de zéro
Deep Learning from scratch ① Chapitre 6 "Techniques liées à l'apprentissage"
Deep learning 1 Pratique du deep learning
Résumé Python vs Ruby "Deep Learning from scratch"
Implémentation du modèle Deep Learning pour la reconnaissance d'images
[Deep Learning from scratch] Implémentation de couche de la fonction softmax à l'erreur d'entropie croisée
Apprentissage profond appris par mise en œuvre (segmentation) ~ Mise en œuvre de SegNet ~
[Deep Learning from scratch] Valeur initiale du poids du réseau neuronal utilisant la fonction sigmoïde
[Deep Learning from scratch] J'ai implémenté la couche Affine
Deep running 2 Réglage de l'apprentissage profond
Apprentissage profond / code de travail LSTM
Python vs Ruby "Deep Learning from scratch" Chapitre 3 Graphique de la fonction step, fonction sigmoid, fonction ReLU
"Deep Learning from scratch" Mémo d'auto-apprentissage (n ° 17) J'ai essayé de créer DeepConvNet avec Keras