Qu'est-ce que le Deep Learning?

Apprentissage profond en anglais
Une des méthodes d'apprentissage automatique
Réseau neuronal multicouche (NN) de la méthode d'apprentissage automatique qui imite les circuits neuronaux
NN lui-même a une histoire de plus de 50 ans, et après plusieurs époques hivernales (traitées comme de mauvais enfants), a remporté le concours de reconnaissance d'image ILSVRC en 2012 avec une précision écrasante et appelé Deep Learning. Ressuscité par son nom
Il existe différents modèles structurels, et le réseau de neurones convolutifs (CNN) est souvent utilisé pour la reconnaissance d'image, le réseau d'adversaire génératif (GAN) pour la génération d'images et la mémoire à long terme (LSTM) pour le traitement du langage naturel.

L'apprentissage profond en tant qu'apprentissage automatique supervisé

J'ai expliqué que l'apprentissage profond est un NN multicouche, mais en réalité, il est maintenant courant de prendre des configurations compliquées telles que la convolution, le calcul récursif et le calcul d'auto-attention au lieu d'un simple multicouche, donc tout d'abord Je voudrais expliquer brièvement l'apprentissage automatique dans le contexte de l'apprentissage supervisé, puis expliquer quels composants sont l'apprentissage profond.

Apprendre avec un enseignant

L'apprentissage automatique supervisé est la sortie $ \ boldsymbol {y d'une entrée $ \ boldsymbol {x} $ via une fonction de mappage $ f $ avec le paramètre $ \ boldsymbol {w} $, comme exprimé par l'équation suivante. Formulez le problème pour estimer le paramètre $ \ boldsymbol {w '} $ qui minimise la valeur de sortie de la fonction d'erreur $ E $ entre} $ et la vraie réponse $ \ boldsymbol {t} $ peut faire.

\boldsymbol{y} = f(\boldsymbol{w},\boldsymbol{x}) \\
E(\boldsymbol{y}, \boldsymbol{t})← Paramètres qui minimisent cela\boldsymbol{w'}Envie de demander

La valeur d'entrée $ \ boldsymbol {x} $ et la valeur de sortie cible $ \ boldsymbol {t} $ doivent être préparées par Ningen en tant que données [^ 1]. Texte manuscrit (0-9) Identification des nombres dans l'image à partir de l'image Dans l'hypothèse d'une tâche d'apprentissage automatique supervisée, $ \ boldsymbol {x} $ est un vecteur des valeurs de luminosité contenues dans chaque pixel de l'image textuelle manuscrite. Je pense que ce serait bien si vous pouviez imaginer que la version convertie, $ \ boldsymbol {t} $, est un vecteur contenant uniquement l'index du nombre +1 dans l'image, 1 et le reste.

*** Exemple) Valeur d'entrée $ \ boldsymbol {x} $, valeur de sortie cible $ \ boldsymbol {t} $ *** lorsque le nombre dans l'image du caractère manuscrit est 5.

\boldsymbol{x} =
\begin{bmatrix}
0.5 \\
0.3 \\
0.2 \\
0.5 \\

... 
\end{bmatrix}← A autant de dimensions que le nombre de pixels, \,
\boldsymbol{t} =
\begin{bmatrix}
0 \\
0 \\
0 \\
0 \\
0 \\
1 \\
0 \\
0 \\
0 \\
0 \\
\end{bmatrix}← Seul le 6ème index vaut 1

Comment trouvez-vous le paramètre $ \ boldsymbol {w '} $? Il existe différentes techniques d'optimisation, mais dans le contexte du deep learning, la méthode de descente de gradient (probabiliste) (ou sa variante) est couramment utilisée. La méthode de descente de gradient différencie la fonction d'erreur $ E $ avec le paramètre $ \ boldsymbol {w} ^ {(t)} $ et ajuste le paramètre $ \ boldsymbol {w} $ dans le sens de la pente obtenue. En répétant les étapes telles que, recherchez le paramètre qui minimise l'erreur.

\boldsymbol{w}^{(t+1)}
=
\boldsymbol{w}^{(t)}
-
\epsilon
\frac{\partial E(\boldsymbol{y}, \boldsymbol{t})}{\partial \boldsymbol{w}^{(t)}},
\,\epsilon:Taux d'apprentissage, \, t:Nombre d'étapes

Si la fonction d'erreur $ E $ est une fonction quadratique ou une fonction cubique afin d'obtenir une image de ce que cela fait, quel est le paramètre final $ w $ (valeur initiale: 1.0)? Je voudrais que vous voyiez si cela converge vers une certaine valeur.

*** Exemple) Dans le cas d'une fonction quadratique ($ y = x ^ 2 $) (axe vertical: $ E (w) $, axe horizontal: $ w $, $ w ^ {(0)} $: 1.0, pas Numéro: 25000) ***

*** Exemple) Dans le cas d'une fonction cubique ($ y = x ^ 3-0.75x + 1 $) (axe vertical: $ E (w) $, axe horizontal: $ w $, $ w ^ {(0)} $: 1,0, nombre de pas: 25000) ***

Dans l'exemple de la fonction quadratique, elle converge vers la valeur minimale de 0, tandis que dans l'exemple de la fonction cubique, si vous allez vers le côté gauche, vous devriez pouvoir aller à la valeur minimale, mais avec une bosse à mi-chemin [^ 2] Il a convergé. Comme nom de la méthode de descente du gradient, la valeur de $ w ^ {(t + 1)} $ est déterminée en fonction du gradient, donc le gradient est 0 dans Kubomi, et $ w ^ {(t + 1)} = Cela est dû au fait que w ^ {(t)} + 0 $.

\frac{\partial E(w^{(t)})}{\partial w^{(t)}}
← C'est 0

Il existe différentes méthodes pour éviter cela, comme la méthode de l'élan et la méthode d'accélération de la vitesse d'apprentissage [^ 3], comme Adam et AdaGrad (mais si vous êtes intéressé par ce domaine, veuillez google). Trouver (apprendre) le paramètre $ \ boldsymbol {w '} $ qui minimise l'erreur signifie que la sortie est proche de la sortie cible $ \ boldsymbol {t} $ $ \ boldsymbol {y} = f (\ boldsymbol {w' }, \ boldsymbol {x}) Synonyme de $.

L'apprentissage en profondeur

Au fait, c'est une histoire d'apprentissage en profondeur, n'est-ce pas? L'apprentissage en profondeur est $ f $ (bien qu'il ne soit pas nécessaire qu'il s'agisse d'un apprentissage en profondeur). En d'autres termes, c'est une fonction qui mappe l'entrée $ \ boldsymbol {x} $ à la sortie $ \ boldsymbol {y} $. Eh bien, les fonctions quadratiques et cubiques sont-elles également un apprentissage en profondeur? À tous les lecteurs enthousiastes qui ont pensé que ce n'est pas le cas. Ce qui est différent, c'est que la structure des fonctions est différente. Le deep learning est une fonction composite [^ 4] avec imbrication superposée à l'imbrication, et un grand nombre de paramètres $ \ boldsymbol {W} ^ {(1)}, sous forme de multiplication de la sortie de chaque fonction imbriquée. Il a ..., \ boldsymbol {W} ^ {(n)} $. De plus, dans la fonction imbriquée $ \ boldsymbol {a} ^ {(1)}, ..., \ boldsymbol {a} ^ {(n)} $, des différenciations telles que Relu, sigmoid et tanh [^ 5] Des fonctions non linéaires possibles sont utilisées. [^ 6]

\boldsymbol{y}
=
f(\boldsymbol{x})
=
\boldsymbol{W}^{(n)} a^{(n)}(\boldsymbol{W}^{(n-1)}a^{(n-1)}(・ ・ ・(\boldsymbol{W}^{(1)} a^{(1)})・ ・ ・))

Vous vous demandez peut-être pourquoi l'apprentissage profond avec une telle structure est plus précis que d'autres méthodes d'apprentissage automatique, mais en fait, cela n'a pas été prouvé mathématiquement [^ 7]. Cependant, il existe un article selon lequel la solution optimale locale est presque la même que la solution optimale globale dans la méthode d'apprentissage en profondeur qui a une profondeur suffisante (imbrication de 3 couches ou plus) et a une fonction non linéaire [^ 8]. Cela signifie que quelle que soit la valeur initiale du paramètre, s'il converge en tournant la boucle d'apprentissage, la valeur de convergence aura presque la même précision que la solution optimale globale! C'est dire. Je suis très heureux. Apprentissage en profondeur, super! !! !!

MNIST avec réseau neuronal à 3 couches

Bonne nouvelle pour tous ceux qui en ont assez d'expliquer en utilisant des formules moins rigoureuses. Ensuite, j'expliquerai le code non strict. Le code collé ci-dessous utilise un réseau de neurones à trois couches pour entraîner et valider un jeu de données de caractères manuscrits appelé MNIST. Voir le code pour une explication détaillée. En guise de point, j'utilise le framework japonais DNN Chainer [^ 9], et c'est un réseau de neurones qui me rend généralement confus lorsque j'essaye d'écrire avec un scratch complet, mais avec Chainer c'est étrange, c'est facile avec moins de 100 lignes Je peux écrire le code. (La même chose peut être obtenue avec TensorFlow et Pytorch). C'est la marchandisation.

environnement

macOS Catalina 10.15.1
Chaner 7.0.0
Python 3.7.0

`train_test_mnist.py`


##-------------------------------------------
##Importer la bibliothèque
##-------------------------------------------
import numpy as np
import chainer
from chainer import Chain, Variable
import chainer.functions as F
import chainer.links as L

##-------------------------------------------
##modèle(3 couches NN)Définition de
##-------------------------------------------
class NN(chainer.Chain):
    def __init__(self, n_units, n_out):
        super(NN, self).__init__()
        with self.init_scope():
            self.l1=L.Linear(None, n_units)
            self.l2=L.Linear(None, n_units)
            self.l3=L.Linear(None, n_out)

    #Calcul à terme
    def __call__(self, x):
        h1 = F.relu(self.l1(x))       #Fonction d'activation: relu
        h2 = F.relu(self.l2(h1))      #Fonction d'activation: relu
        return F.sigmoid(self.l3(h2)) #Fonction d'activation: sigmoid

##-------------------------------------------
##Une fonction qui renvoie le taux de réponse et la valeur d'erreur corrects
##-------------------------------------------
def compute_accuracy_loss(model, xs, ts):
    ys = model(xs)
    loss = F.softmax_cross_entropy(ys, ts) #Fonction d'erreur: cross entropy
    ys = np.argmax(ys.data, axis=1)
    cors = (ys == ts)
    num_cors = sum(cors)
    accuracy = num_cors / ts.shape[0]
    return accuracy, loss

def main():
    ##-------------------------------------------
    ##Hyper paramètres et autres paramètres
    ##-------------------------------------------
    n_units = 100 #Nombre d'unités dans la couche intermédiaire
    n_out = 10    #Nombre de dimensions du vecteur de sortie(0~9 sur 10)
    n_batch = 100 #Taille du lot
    n_epoch = 100 #Nombre d'apprentissage

    ##-------------------------------------------
    ##Paramètres du modèle
    ##-------------------------------------------
    model = NN(n_units, n_out)
    opt = chainer.optimizers.Adam() #Méthode d'optimisation: Adam
    opt.setup(model)

    ##-------------------------------------------
    ##Préparation des données
    ##-------------------------------------------    
    train, test = chainer.datasets.get_mnist()
    xs, ts = train._datasets   #Données d'entraînement
    txs, tts = test._datasets  #données de test

    ##-------------------------------------------
    ##Apprentissage
    ##-------------------------------------------        
    for i in range(n_epoch):

        for j in range(600):
            model.zerograds()
            x = xs[(j * n_batch):((j + 1) * n_batch)]
            t = ts[(j * n_batch):((j + 1) * n_batch)]
            t = Variable(np.array(t, "i"))
            y = model(x)                  
            loss = F.softmax_cross_entropy(y, t) #Calcul d'erreur
            loss.backward()                      #Calcul du gradient
            opt.update()                         #Mise à jour des paramètres
            
        ##-------------------------------------------
        ##tester
        ##-------------------------------------------        
        acc_train, loss_train = compute_accuracy_loss(model, xs, ts)
        acc_test, _           = compute_accuracy_loss(model, txs, tts)

        print("Epoch %d loss(train) = %f, accuracy(train) = %f, accuracy(test) = %f" % (i + 1, loss_train.data, acc_train, acc_test))

if __name__ == '__main__':
    main()

Lorsque j'exécute ce code dans mon environnement local médiocre [^ 10], j'obtiens les résultats d'apprentissage suivants. Lorsque le nombre d'apprentissage atteint 100, il s'approche de 100%.

finalement

Merci d'avoir lu jusqu'ici. Comme je l'ai mentionné un peu plus haut, l'apprentissage en profondeur, qui est chuchoté dans le monde, n'est plus une technologie élémentaire, et il devient de plus en plus banalisé (s'il se flétrit). Désormais, la clé est de savoir comment combiner le deep learning avec d'autres technologies CS / Web pour créer de nouveaux services et entreprises. Personnellement, j'aime aussi le monde du Web, alors j'aimerais créer un service Web qui utilise cet apprentissage profond à l'avenir. Si vous avez des intérêts similaires, faisons-le avec moi, qui est essentiellement moi! Nous recrutons! !!

[^ 1]: Un grand nombre de combinaisons de $ \ boldsymbol {x} $ et $ \ boldsymbol {t} $ sont appelées données d'entraînement. [^ 2]: Dans un espace de grande dimension, la pente devient 0 même au point appelé Saddle point. [^ 3]: converger avec un petit nombre d'étapes [^ 4]: Puisque les paramètres sont calculés par la méthode de descente de gradient, l'exigence minimale est qu'ils puissent être différenciés. [^ 5]: [Fonction d'activation](https://ja.wikipedia.org/wiki/%E6%B4%BB%E6%80%A7%E5%8C%96%E9%96%A2%E6% Appelé 95% B0) [^ 6]: Le problème dans le monde est [Linear separable](https://ja.wikipedia.org/wiki/%E7%B7%9A%E5%BD%A2%E5%88%86%E9%9B% A2% E5% 8F% AF% E8% 83% BD) Ce n'est pas si simple [^ 7]: On peut dire que la précision est ressortie empiriquement dans divers domaines. [^ 8]: Source requise (où était le papier ... celui publié par la personne du MIT) [^ 9]: Merci Chainer. Et au revoir. Blog des développeurs principaux [^ 10]: Pourquoi utiliser ResNet ou une méthode typique d'apprentissage en profondeur pour la reconnaissance d'image? Mon MacBook Pro a peur de prendre feu. Parce qu'il y a.

[PYTHON] Les chats sont déjà fatigués de l'apprentissage profond et moelleux