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

• Fonction de perte
• Erreur carrée (dans Deep Learning 1 à partir de zéro) ―― @ohakutsu Sera-t-il utilisé pour la régression?
• Erreur d'entropie croisée
• Souvent utilisé pour la classification multi-classe

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

Assemblez les couches Softmax et Cross Entropy Error

Softmax avec perte

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

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

• Fonctionnalité
• Nombre réel avec sortie de 0,0 à 1,0
• Ajoutez toutes les sorties pour obtenir 1.0 --Peut être interprété comme une probabilité

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

• Fonctionnalité --t est une étiquette d'enseignant pour «one_hot expression» (0 ou 1), donc elle renvoie simplement le logarithme naturel lorsque l'étiquette est 1.
• Plus y est proche de 0, plus il devient petit, et plus il est proche de 1, plus il converge vers 0.

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

• Règles de chaîne
• La loi de différenciation des fonctions synthétiques

↓ 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

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

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

--Nœud d'ajout

--Nœud Multiplier

--Nœud de branche

--Répéter le nœud

--Nœud de somme

--Nœud MatMul

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

Mettre en œuvre chaque couche

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

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é

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

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

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

• O'Reilly Japan - Deep Learning from scratch ❷
• [oreilly-japan / deep-learning-from-scratch-2: "Deep Learning from scratch ❷" (O'Reilly Japan, 2018)](https://github.com/oreilly-japan/deep-learning- à partir de zéro-2)