Report_Apprentissage approfondi (partie 1)

Couche d'entrée / couche intermédiaire

Vue d'ensemble du réseau neuronal Le flux est la couche d'entrée → couche intermédiaire → couche de sortie. Exemple: réseau de neurones pour déterminer quel animal est à partir de données sur les animaux Couche d'entrée: couche qui donne des données arbitraires. Exemple: longueur du corps, taille des oreilles, etc. Couche intermédiaire: couche qui biaise et pondère les données dans la couche d'entrée Couche de sortie: couche dans laquelle la valeur calculée dans la couche intermédiaire est sortie en sortie. Exemple: D'après les données saisies, cet animal a une probabilité d'être un chien de 0,1, une probabilité d'être un chat de 0,05 et une probabilité d'être une souris de 0,85.

Test de confirmation (1-2) Décrivez en moins de deux lignes ce que le Deep Learning essaie de faire à la fin. De plus, laquelle des valeurs suivantes est le but ultime de l'optimisation? Choisir tous. ① Valeur d'entrée [X] ② Valeur de sortie [Y] ③ Poids [W] ④ Biais [b] ⑤ Entrée totale [u] ⑥ Entrée de couche intermédiaire [z] ⑦ Taux d'apprentissage [ρ]

Estimez le paramètre qui minimise le poids, qui est le paramètre pour estimer la valeur de sortie optimale. Les paramètres sont principalement estimés par le poids (w) et le biais (b).

Mettez le réseau suivant sur papier. Couche d'entrée: 2 nœuds 1 couche, couche intermédiaire: 3 nœuds 2 couches, couche de sortie: 1 nœud 1 couche

Capturer

Test de confirmation (1-4) Mettons un exemple de classification animale dans le diagramme ci-dessous.

Écrivez cette formule en python.

Test de confirmation (1-5) Extrayez la source qui définit la sortie de la couche intermédiaire du fichier 1-1.

Définition de la sortie de la couche intermédiaire z = functions.relu(u) print_vec ("sortie couche intermédiaire", z)

u in z = functions.relu (u) représente l'expression de l'entrée totale.

Test d'exercice Dans l'état initial, le poids et le biais sont définis par eux-mêmes, la valeur d'entrée est multipliée par le poids et le biais est ajouté pour déterminer la valeur d'entrée totale. Ensuite, lorsque le tableau de poids est changé en np.zeros (2), le tableau de poids est changé en [0,0] et la valeur d'entrée totale est également modifiée. Le tableau de poids de np.ones (2) en dessous est changé en [1,1]. np.random.rand (2) est aléatoirement compris entre 0 et 1. Déterminez le nombre.

Fonction d'activation

Dans un réseau neuronal, une fonction non linéaire qui détermine la sortie vers la couche suivante, en fonction de la valeur d'entrée de la couche suivante Déterminez la force.

Il peut être classé en fonctions d'activation pour la couche intermédiaire et la couche de sortie. Pour la couche intermédiaire: fonction ReLu, fonction sigmoïde, fonction étape (non utilisée dans l'apprentissage en profondeur) Pour la couche de sortie: fonction Softmax, mappage constant, fonction sigmoïde

Fonction Step Une fonction qui émet 1 lorsque le seuil est dépassé et 0 lorsque le seuil n'est pas dépassé. La sortie est 0 ou 1 uniquement Il a été utilisé à Perceptron. Comme problème, nous n'avons pas pu faire face au léger changement entre 0 et 1, Il ne peut être utilisé que lorsque la classification linéaire est possible (marche / arrêt).

Fonction Sigmaid Il est maintenant possible de transmettre la force d'un signal en plus de marche / arrêt avec une fonction qui change faiblement entre 0 et 1. Le problème est que le changement de sortie à une valeur élevée est faible, ce qui provoque un problème de disparition du gradient. 　 Fonction ReLu La fonction d'activation la plus utilisée actuellement. Il contribue à résoudre le problème de disparition du gradient et à le rendre clairsemé. Le problème de la disparition du gradient et de la rareté sera décrit plus loin. La plus utilisée, mais selon l'application, la fonction sigmoïde peut produire des résultats précis. L'ingénieur doit déterminer à chaque fois la fonction d'activation la plus appropriée.

Test de confirmation (1-8) Extrayez la partie appropriée du code source distribué. z = functions.sigmoid(u)

Couche de sortie

L'erreur carrée est utilisée comme fonction d'erreur. Erreur au carré: calculée en mettant au carré l'erreur des données de sortie à partir des données de réponse correctes.

Test de confirmation (1-9) Décrivez pourquoi vous mettez au carré plutôt qu'une soustraction. La soustraction est affectée par le signe de ± et ± minimise l'erreur. Au carré pour qu'il ne soit pas affecté par le signe ±.

Décrivez ce que signifie 1/2. En minimisant les paramètres, une différenciation est effectuée pour obtenir le gradient de l'erreur. Multipliez par 1/2 pour simplifier le calcul lors de cette différenciation.

Fonction d'activation pour la couche de sortie Différence par rapport à la couche intermédiaire La couche intermédiaire ajuste la force du signal avant et après le seuil. La couche de sortie convertit le rapport de signal tel quel.

Tâche de régression Utilisez une cartographie uniforme. La fonction d'erreur utilise l'erreur au carré.

Tâche de classification Classification binaire: utilisez la fonction sigmoïde. La fonction d'erreur est l'entropie croisée Classification multi-classes: utilisez la fonction softmax. La fonction d'erreur est l'entropie croisée

Test de confirmation (1-9) Afficher le code source correspondant à (1) à (3) de la fonction softmax et expliquer le traitement ligne par ligne. Code source des fonctions softmax def softmax(x): si x.ndim == 2: Si le nombre de dimensions de x est de 2 dimensions, effectuez le traitement suivant x = x.T Stocke la translocation de l'argument x dans x x = x --np.max (x, axis = 0) Soustraire la valeur maximale de la valeur transposée y = np.exp (x) / np.sum (np.exp (x), axis = 0) La probabilité de la valeur sélectionnée dans l'ensemble est calculée. return y.T Renvoie la valeur transposée de y L'endroit correspondant à ① est def softmax (x): L'emplacement correspondant à ② est np.exp (x) Le lieu correspondant à ③ est np.sum (np.exp (x), axis = 0)

Test de confirmation (1-10) Affichez le code source correspondant à (1) à (3) de la fonction d'entropie croisée et expliquez le traitement ligne par ligne. Code source pour la fonction d'entropie croisée def cross_entropy_error(d, y): if y.ndim == 1: Si le nombre de dimensions de y est égal à un, effectuez le traitement suivant d = d.reshape (1, d.size) Convertit l'argument d en une matrice unidimensionnelle. y = y.reshape (1, y.size) Convertit l'argument y en une matrice unidimensionnelle.

Si les données de l'enseignant sont un vecteur chaud, convertissez-les en index de l'étiquette de réponse correcte

if d.size == y.size: Si les tailles de données de d et y sont identiques, effectuez le traitement suivant. d = d.argmax(axis=1) batch_size = y.shape[0] return -np.sum(np.log(y[np.arange(batch_size), d] + 1e-7)) / batch_size Une petite valeur (1e-7) est ajoutée pour que le nombre de molécules ne devienne pas 0. Ingéniosité dans le montage Le lieu correspondant à ① est def cross_entropy_error (d, y): L'endroit correspondant à ② est return -np.sum (np.log (y [np.arange (batch_size), d] + 1e-7))

Méthode de descente de gradient

Il existe une méthode de descente de gradient, une méthode de descente de gradient stochastique et une méthode de descente de gradient en mini-lot.

Le but de l'apprentissage profond est Estimez le paramètre qui minimise le poids et le biais, qui sont les paramètres pour estimer la valeur de sortie optimale (test de confirmation 1-2). La méthode de descente de gradient est utilisée comme méthode d'estimation.

Test de confirmation (1-11) Trouvons le code source correspondant. network[key] -= learning_rate * grad[key]

Le taux d'apprentissage ε affecte l'efficacité de l'apprentissage. Si le taux d'apprentissage est trop élevé, il n'atteindra pas la valeur minimale et divergera. Si le taux d'apprentissage est trop faible, il faudra un temps considérable pour atteindre la valeur minimale. Le nombre d'apprentissage est compté comme une époque.

Méthode de descente de gradient probabiliste (SGD) La méthode de descente de gradient probabiliste utilise l'erreur d'échantillons échantillonnés au hasard. La méthode de descente de gradient utilise l'erreur moyenne de tous les échantillons. Souvenez-vous de la différence. Les avantages sont la réduction du montant du calcul, la réduction du risque de convergence vers une solution minimale locale et l'apprentissage en ligne.

Test de confirmation (1-11) Résumez ce qu'est l'apprentissage en ligne en deux lignes. Chaque fois que les données d'apprentissage sont entrées, l'apprentissage est effectué en utilisant uniquement les données d'entrée.

Méthode de descente de gradient par mini lot La méthode de descente de gradient par mini-lots utilise l'erreur moyenne d'échantillons appartenant à un ensemble de données divisé de manière aléatoire.

Méthode de propagation de retour d'erreur

Une méthode pour différencier l'erreur calculée et la propager de la couche de sortie à la couche précédente. Cela évite les calculs récursifs inutiles.

Test de confirmation (1-14) La méthode de propagation d'erreur peut éviter un traitement récursif inutile. Contient le résultat du calcul déjà effectué Extrayez le code source. Code source pour la rétropropagation des erreurs

def backward(x, d, z1, y): print ("\ n ##### Erreur de début de propagation de retour #####") grad = {} W1, W2 = network['W1'], network['W2'] b1, b2 = network['b1'], network['b2'] #Delta dans la couche de sortie delta2 = functions.d_sigmoid_with_loss(d, y) Dégradé de # b2 grad['b2'] = np.sum(delta2, axis=0)

W2 dégradé

grad['W2'] = np.dot(z1.T, delta2)

Delta dans la couche intermédiaire

delta1 = np.dot(delta2, W2.T) * functions.d_relu(z1)

Gradient de # b1 grad['b1'] = np.sum(delta1, axis=0)

W1 dégradé

grad['W1'] = np.dot(x.T, delta1)

①delta2 = functions.d_sigmoid_with_loss(d, y)

L'entropie croisée et le résultat de synthèse de la fonction sigmoïde sont conservés. 　　②grad['b2'] = np.sum(delta2, axis=0) La valeur obtenue par conversion vectorielle de la valeur de ① est conservée. 　　③grad['W2'] = np.dot(z1.T, delta2)

Exercice Dans le résultat ci-dessus, la fonction ReLu est utilisée pour effectuer la propagation directe et la propagation arrière d'erreur, et le diagramme de résultat converge également parfaitement. d'accord. Ensuite, le résultat lorsque les fonctions de propagation directe et de propagation arrière d'erreur sont remplacées par la fonction sigmoïde est indiqué dans le diagramme de résultat ci-dessous.

La visualisation montre qu'il existe une variation de convergence en passant à la fonction sigmoïde. En raison de l'implémentation du code, la fonction d'activation de propagation directe et la fonction d'erreur de propagation arrière d'erreur doivent être modifiées comme un ensemble.

Le résultat de la modification de la plage de valeurs x des données d'entraînement est indiqué ci-dessous. Il a été confirmé que même si la plage des valeurs de x était modifiée, la convergence varierait.

Test de confirmation (1-15) Trouvez le code source qui correspond aux deux espaces. Vide ci-dessus delta2 = functions.d_mean_squared_error(d, y) Vide ci-dessous grad['W2'] = np.dot(z1.T, delta2)