[PYTHON] [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.