Deep Learning 2 from scratch 1.3 Traitement du langage naturel 1.3 Résumé

Qu'est-ce que c'est

C'est le matériel utilisé lors de la présentation lors d'une session d'étude interne.


1.3 Apprentissage du réseau neuronal


1.3.1 Fonction de perte

Des paramètres optimaux doivent être définis afin de faire de «bonnes inférences» dans un réseau de neurones

L'apprentissage des réseaux neuronaux nécessite un index pour savoir dans quelle mesure l'apprentissage fonctionne → ** Perte **

** La fonction de perte ** est utilisée pour trouver la perte du réseau neuronal



Dans cette section, la structure de couche suivante est utilisée pour trouver la perte.

1e49abb0-2cb2-dd5d-d881-5ee1cf946b46.png


Assemblez les couches Softmax et Cross Entropy Error

bd2831b7-351e-9951-be8e-115321114a48.png

Softmax avec perte


Qu'est-ce que Softmax? → ** Fonction Softmax **

y_k =  \frac {exp(s_k)}{\displaystyle \sum _{i=1}^{n} exp(s_i)}

Qu'est-ce que l'erreur d'entropie croisée? → ** Erreur d'entropie croisée **

L = - \sum_{k}t_k\space log\space y_k

logx.png


Considérer le traitement par mini-lots

L = - \frac{1}{N} \sum_{n}\sum_{k}t_{nk}\space log\space y_{nk}

utilisation


1.3.2 Différenciation et gradient

Le but de l'apprentissage d'un réseau de neurones est de trouver des paramètres qui minimisent les pertes Ce qui est important ici, c'est la ** différenciation ** et le ** gradient **.


différentiel → Quantité de changement à un moment donné @ohakutsu Introduction aux mathématiques pour l'IA (intelligence artificielle) à partir des mathématiques du premier cycle du secondaire - YouTube

y = f(x)

La différenciation de y par rapport à x est

\frac{dy}{dx}

Peut être exprimé comme


La différenciation peut être obtenue même s'il y a plusieurs variables Avec x comme vecteur

L = f(x)
\frac{\partial L}{\partial x} = \left( \frac{\partial L}{\partial x_1}, \frac{\partial L}{\partial x_2}, ..., \frac{\partial L}{\partial x_n} \right)

La somme des différentiels de chaque élément du vecteur est appelée ** gradient **.

Dans le cas d'une matrice, le gradient peut être considéré de la même manière. Soit W une matrice m × n

L = g(W)
\frac{\partial L}{\partial W} = \left(
  \begin{array}{ccc}
    \frac{\partial L}{\partial w_{11}} & \cdots & \frac{\partial L}{\partial w_{1n}} \\
    \vdots & \ddots & \\
    \frac{\partial L}{\partial w_{m1}} & & \frac{\partial L}{\partial w_{mn}}
  \end{array}
\right)

1.3.3 Règles de chaîne

Réseau neuronal au moment de l'entraînement, perte de sortie lorsque des données d'entraînement sont fournies Une fois le gradient de perte obtenu pour chaque paramètre, il peut être utilisé pour mettre à jour les paramètres.

Comment trouver le gradient du réseau de neurones → ** Méthode de propagation de retour d'erreur **

La clé pour comprendre la méthode de propagation de retour d'erreur est la ** règle de chaîne **


↓ Un tel gars

y = f(x) \\
z = g(y) \\

Récrire

z = g(f(x)) \\

La différenciation de z par rapport à x est

\frac{\partial z}{\partial x} = \frac{\partial z}{\partial y}\frac{\partial y}{\partial x}

Quelle que soit la complexité d'une fonction, sa différenciation peut être déterminée par la différenciation des fonctions individuelles.


1.3.4 Graphique de calcul

Une représentation visuelle du calcul

Exemple)

z = x + y

097c0e7d-5245-f3a6-7445-c9e8b198efd7.png e22cfed3-f846-7607-fb78-0c8299b16700.png

La propagation inverse est une "rétro-propagation"

6981c2fe-1898-d29b-0ba1-aee35c912493.png


Ci-dessous, des nœuds arithmétiques typiques

--Nœud d'ajout 30e860a6-3518-5221-b139-f82bb44febe2.png

--Nœud Multiplier 951e8bee-fef4-df5b-d9a2-d7de611e25bd.png

--Nœud de branche e4686bbe-ad63-968c-c415-7ee499f24a39.png

--Répéter le nœud 03e79e0c-7f3e-bbf4-b838-232a872dc3eb.png

--Nœud de somme 99fe71b2-03f3-1de4-0a7a-5c416584f6ee.png

--Nœud MatMul 744aada9-deea-379a-a8de-eb76267e1066.png


1.3.5 Dérivation de gradient et implémentation de rétropropagation

Mettre en œuvre chaque couche

bd2831b7-351e-9951-be8e-115321114a48.png


Couche sigmoïde

La fonction sigmoïde est

y =  \frac {1}{1 + exp(-x)}

La différenciation de la fonction sigmoïde est

\frac{\partial y}{\partial x} = y(1 - y)

Le graphe de calcul de la couche sigmoïde est

c725a5fc-e5b6-c377-ff33-df7bc4451a17.png


Lorsqu'il est implémenté en Python

class Sigmoid:
  def __init__(self):
    self.params, self.grads = [], []
    self.out = None

  def forward(self, x):
    out = 1 / (1 + np.exp(-x))
    self.out = out
    return out

  def backward(self, dout):
    dx = dout * (1.0 - self.out) * self.out
    return dx

Couche affine

Propagation vers l'avant de la couche affine

y = np.dot(x, W) + b

L'ajout de biais est diffusé

df1bab77-9c16-6624-2670-7e30a02b4abd.png


Lorsqu'il est implémenté en Python

class Affine:
  def __init__(self, W, b):
    self.params = [W, b]
    self.grads = [np.zeros_like(W), np.zeros_like(b)]
    self.x = None

  def forward(self, x):
    W, b = self.params
    out = np.dot(x, W) + b
    self.x = x
    return out

  def backward(self, dout):
    W, b = self.params
    dx = np.dot(dout, W.T)
    dW = np.dot(self.x.T, dout)
    db = np.sum(dout, axis=0)

    self.grads[0][...] = dW
    self.grads[1][...] = db
    return dx

Softmax avec couche de perte

f9240a28-a5d5-0b1f-03aa-e22edfed5c13.png

class SoftmaxWithLoss:
  def __init__(self):
    self.params, self.grads = [], []
    self.y = None  #sortie de softmax
    self.t = None  #Label enseignant

  def forward(self, x, t):
    self.t = t
    self.y = softmax(x)

    #L'étiquette de l'enseignant en est une-Pour le vecteur chaud, convertir en index correct
    if self.t.size == self.y.size:
      self.t = self.t.argmax(axis=1)

    loss = cross_entropy_error(self.y, self.t)
    return loss

  def backward(self, dout=1):
    batch_size = self.t.shape[0]

    dx = self.y.copy()
    dx[np.arange(batch_size), self.t] -= 1
    dx *= dout
    dx = dx / batch_size

    return dx

1.3.6 Mise à jour du poids

Mettre à jour les paramètres du réseau de neurones en utilisant le gradient obtenu par la méthode de propagation de retour d'erreur

Pour connaître le réseau neuronal, suivez la procédure ci-dessous.

  1. Mini lot --S'il y a beaucoup de données, cela prendra du temps, alors utilisez une partie des données comme une approximation de l'ensemble (à partir de Deep Learning 1 à partir de zéro)
  2. Calcul du gradient --Trouvez le gradient de la fonction de perte pour chaque paramètre de poids par la méthode de propagation des erreurs.
  3. Mise à jour des paramètres
  4. Répétez les étapes 1 à 3

3. Mise à jour des paramètres

En utilisant le gradient obtenu dans "2. Calcul du gradient", mettez à jour les paramètres dans la direction opposée du gradient (direction pour réduire la perte). → ** Méthode de descente de gradient **

sample.png


Ici, j'utilise la méthode ** SGD ** la plus simple pour mettre à jour les poids (j'ai écrit dans Deep Learning 1 qui commence à zéro).

W \leftarrow W - \eta \frac{\partial L}{\partial W} \\
\eta :Coefficient d'apprentissage

Lorsqu'il est implémenté en Python

class SGD:
  def __init__(self, lr=0.01):
    self.lr = lr

  def update(self, params, grads):
    for i in range(len(params)):
      params[i] -= self.lr * grads[i]

La mise à jour réelle des paramètres du réseau neuronal est la suivante

model = TwoLayerNet( ... )
optimizer = SGD()

for i in range(10000):
  ...
  x_batch, t_batch = get_mini_batch( ... ) #Obtenez un mini lot
  loss = model.forward(x_batch, t_batch)
  model.backward()
  optimizer.update(model.params, model.grads)
  ...

Entraînez en fait le réseau de neurones en 1.4


La fin


Lien

Recommended Posts

Deep Learning 2 from scratch 1.3 Traitement du langage naturel 1.3 Résumé
[Python] [Traitement du langage naturel] J'ai essayé le Deep Learning ❷ fait de toutes pièces en japonais ①
Python: apprentissage profond du traitement du langage naturel: principes de base
Deep learning / Deep learning from scratch 2 Chapitre 4 Mémo
Deep learning / Deep learning made from scratch Chapitre 3 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 learning / Deep learning from scratch 2 Chapitre 3 Mémo
Mémo d'apprentissage profond créé à partir de zéro
Résumé de l'installation de l'analyseur de traitement du langage naturel
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 6 Mémo
Apprentissage amélioré pour apprendre de zéro à profond
[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
[Mémo d'apprentissage] Deep Learning fait de zéro [~ Chapitre 4]
Résumé Python vs Ruby "Deep Learning from scratch"
Python: traitement du langage naturel
Apprentissage profond à partir de zéro
RNN_LSTM2 Traitement du langage naturel
Python: Apprentissage en profondeur dans le traitement du langage naturel: Implémentation d'un système de sélection de phrases de réponses
Application de Deep Learning 2 à partir de zéro Filtre anti-spam
Apprentissage profond à partir de zéro 1 à 3 chapitres
Traitement du langage naturel 1 Analyse morphologique
Traitement du langage naturel 3 Continuité des mots
Traitement du langage naturel 2 similitude de mots
100 coups de traitement du langage amateur: Résumé
Étudiez le traitement du langage naturel avec Kikagaku
100 traitements du langage naturel frappent le chapitre 4 Commentaire
[Traitement du langage 100 coups 2020] Chapitre 6: Machine learning
Traitement du langage naturel pour les personnes occupées
Version Lua Apprentissage profond à partir de zéro Partie 6 [Traitement d'inférence de réseau neuronal]
[Traitement du langage naturel] Prétraitement avec le japonais
Apprentissage profond à partir de zéro (calcul des coûts)
100 Language Processing Knock 2020 Chapitre 6: Apprentissage automatique
Écrivez vos impressions sur l'édition du framework Deep Learning 3 créée à partir de zéro
100 traitement du langage knock-73 (en utilisant scikit-learn): apprentissage
Se préparer à démarrer le traitement du langage naturel
Résumé du traitement multi-processus du langage de script
Tutoriel d'apprentissage en profondeur de la construction d'environnement
Traitement de la voix par apprentissage profond: identifions qui est l'acteur vocal à partir de la voix
[Traitement du langage naturel] Extraire les mots-clés de la base de données Kakenhi avec MeCab-ipadic-neologd et termextract
Note récapitulative sur le Deep Learning -4.2 Fonction de perte-
Apprentissage profond à partir de zéro (propagation vers l'avant)
Traiter le nom de la carte Yugioh en langage naturel --Yugiou Data Science 2. PNL
100 Knocking Natural Language Processing Chapitre 1 (Mouvement préparatoire)
Apprentissage profond / Apprentissage profond à partir de zéro 2-Essayez de déplacer GRU
3. Traitement du langage naturel par Python 2-1. Réseau de co-occurrence
[WIP] Pré-traitement des notes dans le traitement du langage naturel
3. Traitement du langage naturel par Python 1-1. Word N-gram
Alignement d'image: du SIFT au deep learning
"Deep Learning from scratch" avec Haskell (inachevé)
[Windows 10] Construction de l'environnement "Deep Learning from scratch"
Enregistrement d'apprentissage de la lecture "Deep Learning from scratch"
À propos du traitement d'expansion des données pour l'apprentissage en profondeur
J'ai essayé le traitement du langage naturel avec des transformateurs.