Report_Apprentissage approfondi (partie 2)

TensorFlow En pratique, il est courant de créer à l'aide d'une bibliothèque telle que Tensorflow au lieu de créer à partir de numpy.

Comment utiliser Tensorflow

Notez que Tendorflow est écrit différemment de numpy. -Import est le même que numpy. -Utilisez tr.constant () pour définir la constante. Définissez dans l'ordre de la constante (nombre, type de données, forme du tableau). Dans a, seul le nombre 1 est défini, en b, le nombre 2 est défini comme un tableau de type float 3 × 2, et en c, les nombres sont des numéros de série (0 à 4) et définis comme un tableau de type float 2 × 2. -Tensorflow utilise Tensor, et pour faire fonctionner Tensor, il est nécessaire de définir tr.Session (). Par conséquent, dans print () avant de définir tr et Session (), Tensor ne fonctionne pas et il est affiché comme Tensor. Après avoir défini tr.Session (), vous pouvez voir qu'il fonctionne avec sess.run (a).

Ensuite, vérifiez l'espace réservé. Un espace réservé est une image qui définit quelque chose comme une boîte dans laquelle vous pouvez mettre des valeurs plus tard. Défini dans tf.placeholder (). Cette fois, il est défini comme tf.placeholder ((dtype = tf.float32, shape = [None, 3]). Comme les constantes, Tensor ne fonctionne pas sans une session définie. Définissez un tableau 2x3 aléatoire avec X = np.random.rand (2,3). Exécutez Tensor avec sess.run (). sess.run(x,feed_dect={x:X[0].reshape(1, -1)}) Remplacez X [0] par x par feed_dict, c'est-à-dire le 0e du tableau de X. .reshapr (1, -1) transforme la forme du tableau en 1x3. Dans la définition de l'espace réservé, shape = [None, 3] est défini comme 〇 × 3. C'est reshape (1, -1) et la partie de 〇 est mise à 1, et -1 est un tableau 1 × 3 car cela signifie que le 3 défini est utilisé. Lors de la vérification du résultat, confirmez que le 0ème tableau de X est attribué et qu'il s'agit d'un tableau 1x3. L'espace réservé est utilisé lors du remplacement de chaque lot pendant l'apprentissage.

Ensuite, vérifions les variables. variables est une image de variables. Défini dans tf.variables (). Dans ce qui précède, il est d'abord défini comme 1. La valeur de la variable change lors de sa mise à jour. La formule de mise à jour est calc_op = x * a (variable x constante) Utilisez tf.assign () pour mettre à jour la valeur. tf.assign (x, calc_op) est Le processus de mise à jour de x à la valeur de calc_op. Lors de l'utilisation d'une variable, il faut d'abord initialiser la variable (la réécrire à sa valeur initiale). tf.global_variables_initializer () est une méthode pour initialiser des variables. Dans la première impression (sess.run (x)), la valeur initiale est 1, et dans la seconde impression (sess.run (x)), elle est mise à jour à 10 par update_x. Dans la troisième impression (sess.run (x)), update_x met à jour le deuxième x (10) à 100, qui est la multiplication de la constante 10.

Régression linéaire

Vérifiez la régression linéaire. Concernant l'importation, la même chose que ci-dessus. De plus, matplotlib.pyplot est également implémenté pour afficher le graphique. Iters_num définit le nombre d'apprentissages et plot_interval définit le nombre d'apprentissages sur lesquels l'erreur est affichée. Ensuite, la génération de données. x est créé par le nombre aléatoire np.random.readn (n). Le nombre est n, c'est-à-dire qu'il produit 100 nombres aléatoires. En remplaçant ce nombre dans la formule 3 * x + 2 pour générer d. Puisque ce d n'existe que sur la ligne droite de 3 * x + 2, nous ajoutons intentionnellement du bruit et le déplaçons de haut en bas à partir de la ligne droite. L'apprentissage est effectué avec x comme données d'entrée et d comme données de sortie. Jusqu'à présent, ce n'est pas très différent de la méthode de génération avec numpy.

Un espace réservé est utilisé pour les données d'entrée et les données de sortie. Le poids W et le biais b sont définis comme variables et la formule d'apprentissage est obtenue en apprenant avec y = W * xt + b. L'erreur est calculée par l'erreur quadratique moyenne. Calculez le carré avec tf.square () et la moyenne avec tf.reduce_mean (). Définissez le taux d'apprentissage avec tf.tf.train.GradientDescentOptimizer () et L'erreur minimale est calculée par optimizer.minimize (loss). Maintenant que la préparation à l'apprentissage est terminée, l'initialisation des variables et de la session démarre.

L'apprentissage est effectué à l'aide de phrases. Puisque iter_num = 300, l'apprentissage est effectué 300 fois. Il s'agit d'une instruction for qui appelle train avec sess.run, affecte x_train à xt et d_train à dt, et trace à plot_interval. Si vous vérifiez les résultats, vous pouvez voir que les valeurs sont proches de W = 3,07, d = 1,94 et d = 3 * x + 2, et la prédiction correcte est effectuée.

[try] ① Modifiez la valeur du bruit. Mis en œuvre en changeant la valeur de bruit de l'exercice ci-dessus à 0,6. Ce qui précède est la partie modifiée. En regardant les résultats, plus la valeur du bruit est élevée, plus la variation entre le haut et le bas est grande. En conséquence, il a été confirmé que le résultat de la prédiction était moins précis que lorsque la valeur du bruit était de 0,3. ② Modifiez la valeur de d. (1) Changez W en 6. Ce qui précède est la partie modifiée. résultat (2) Remplacez d par 4 Ce qui précède est la partie modifiée. résultat Il a été confirmé que les résultats de (1) et (2) faisaient des prédictions proches de l'équation de d. Puisque les formes de y et d sont les mêmes et que la valeur du bruit, qui est une erreur, n'est pas modifiée. On pense que le résultat était proche de celui de l'exercice. A partir de (1) et (2), il est nécessaire de connaître la valeur de bruit des données afin de faire une bonne prédiction.

Régression non linéaire

L'importation et la génération de données sont similaires à la régression linéaire. Comme non linéaire, la formule de d est différente de celle au moment de la régression linéaire. Puisque le nombre de paramètres de poids est de 4 cette fois à partir de la formule d, W = tf.Variable(tf.random_normal([4, 1], stddev=0.01)) Définit quatre nombres dans. stddev = 0,01 représente un écart type de 0,01 et définit une valeur initiale aléatoire de l'écart type de 0,01. Puisque xt a quatre valeurs comme x3, 2nd, 1st et 0th, 4 espaces réservés et d ont 1 solution, donc 1 espace réservé est préparé. La formule est y = tf.matmul (xt, W) et y = tf.matmul () est la méthode de multiplication. Le flux d'apprentissage consiste à remplacer x_train et d_train par xt et dt de la même manière que pour la régression linéaire. On peut voir que les résultats sont w1 = -0,4, w2 = 1,59, W3 = -2.80, w4 = 0.99, qui sont proches de l'équation d. [try] ① Modifiez la valeur du bruit. Changez la valeur du bruit à 0,5, soit 10 fois l'exercice Ce qui précède est la partie modifiée. résultat Comme pour la régression linéaire, l'augmentation de la valeur du bruit augmente la variation verticale. ② Changer la valeur de d Remplacez W par une valeur appropriée au moment de la pratique. Ce qui précède est la partie modifiée. résultat À partir des résultats, il a été confirmé que même si la valeur de W était modifiée comme dans le cas de la régression linéaire, il était correctement prédit que la valeur du bruit était faible.

Problème de pratique Bien que le résultat puisse être prédit par le programme créé ci-dessus, seule une partie des points est tracée car x = np.random.rand (n) lorsque les données sont générées et que seuls les points sont pris dans la plage de 0 à 1. C'est un graphique.

mnist À propos de la partie compensation x = tf.placeholder(tf.float32, [None, 784]) 784 parce que l'ensemble de données est 28 × 28 = 784. d = tf.placeholder(tf.float32, [None, 10]) La classification est pour 10 classifications de 0 à 9. W = tf.Variable(tf.random_normal([784, 10], stddev=0.01)) Puisque W donne 10 valeurs à partir de la valeur de 784, il a une forme de 784 x 10. La valeur initiale est un écart type de 0,01 b = tf.Variable(tf.zeros([10])) Pour 10 sorties. y = tf.nn.softmax(tf.matmul(x, W) + b) Remplacez la valeur obtenue en ajoutant b à la multiplication de x et W à la fonction softmax. L'erreur est calculée en utilisant l'entropie croisée pour la classification. Un lot de données de train mnist est affecté par x_batch et d_batch dans l'instruction for. Il peut être confirmé que la précision augmente à environ 87% après 100 apprentissages mnist. Dans ce qui précède, vérifiez les 0èmes données de d_batdh, la taille de x_batdh et l'image.

Mnist implémenté en 3 couches. Le but est d'améliorer la précision par rapport à la première couche.

Puisqu'il a une structure à trois couches, deux couches cachées (hidden_layer_size_1 = 600, hidden_layer_size_2 = 300) sont préparées. Cela crée un réseau neuronal qui produit 10 à partir de 784 entrées via 1 600 couches cachées 2 300. Comme il a une structure à trois couches comprenant une couche cachée, il est nécessaire de préparer trois poids W et trois biais b. Étant donné que le nombre de données change à mesure que le calque progresse, il est nécessaire de changer la forme de W en fonction de la forme. En conséquence, il peut être confirmé que la précision est d'environ 90%, ce qui est supérieur à celui de la première couche.

[try] ① Redimensionner le calque caché Changé en hidden_layer_size_1 = 400, hidden_layer_size_2 = 150. Ce qui précède est la partie modifiée. résultat Étant donné que le nombre de couches cachées a diminué depuis le moment de l'exercice, il a été confirmé que la précision avait diminué. Étant donné que le nombre de couches masquées et le temps de calcul (précision) sont dans une relation de compromis, un ajustement est nécessaire à chaque fois. ② Changer d'optimiseur. La figure ci-dessous résume la précision après le passage aux 4 types d'optimiseurs suivants et l'apprentissage 3000 fois. Avec une précision de 3000 apprentissages, l'optimiseur RMS Prop a donné les meilleurs résultats. Lorsque vous comparez en pratique, apprenez jusqu'à ce que la précision atteigne un plateau, puis comparez.

Classification à l'aide de CNN

Le flux de CNN est conv - relu - pool - conv - relu - pool - Exécutez dans l'ordre affin --relu --dropout --affin --softmax. La définition du nombre d'importation et d'apprentissage est la même que ci-dessus. Attribuez les données MNIST à l'espace réservé comme x. Changez le X en un format d'image de canal 28x28x1 et remplacez-le par x_image. Le poids 5x5x1x32 de W_conb1 5x5 est la taille du filtre CNN. 1x32 a le sens d'étendre 1 canal à 32 canaux. Le calcul se fait par h_conv1 = tf.nn.relu (tf.nn.conv2d (x_image, W_conv1, foulées = [1, 1, 1, 1], padding = 'SAME') + b_conv1). Dans tf.nn.conv2d (), x_image est défini sur une opération de convolution avec W_conv1, la foulée vaut 1 et le remplissage est MÊME (identique). Après cela, le biais b_conv1 est ajouté et affecté à la fonction ReLU. Le résultat, Avec h_pool1 = tf.nn.max_pool (h_conv1, ksize = [1, 2, 2, 1], strides = [1, 2, 2, 1], padding = 'SAME') Avec max_pool, ksize et stride 2x2 size, le rembourrage est calculé de la même manière. Le même calcul est effectué pour les deuxième et troisième couches. Après cela, CNN peut être calculé en exécutant l'opération affin --relu --dropout --affin --softmax. Il a été confirmé que la précision augmentait à mesure que le nombre d'apprentissage augmentait et que la précision était d'environ 90% ou plus. [try] ① Modifiez le taux d'abandon à 0. Ce qui précède est la partie modifiée. résultat D'après le résultat, il était d'environ 95%, ce qui était presque le même que l'exercice.

Exercice Keras

Régression linéaire Le résultat est une régression linéaire comme Tensorflow. Le code est plus simple pour Keras. Caractéristiques de Keras Contrairement à Tensorflow, W (poids) et b (biais) n'ont pas besoin d'utiliser des espaces réservés ou des variables. L'entrée x et l'expression d'apprentissage d sont définies de la même manière que Tensorflow. Ensuite, préparez la norme Sequential (). C'est la base du modèle de régression linéaire. Cela créera un réseau dense (couche entièrement connectée). Cela crée un réseau à une couche. model.summary () est la partie qui affiche le modèle, et le résumé est affiché comme la deuxième capture d'exercice ci-dessus. Si vous confirmez cela, vous pouvez confirmer que le nombre de paramètres output_Shape1 est de 2 dans le réseau entièrement connecté Dence à 1 couche. Les modèles peuvent être appris simplement en les définissant dans model.compile (). Dans Tensorflow, il était nécessaire de définir ioss et optimizer. Cette fois model.compile (loss = 'mse', optimizer = 'sgd') loss utilise l'erreur carrée et l'optimiseur utilise la méthode de descente de gradient cachée.

Perceptron simple La partie où le code d'apprentissage est différent par rapport à la régression linéaire ci-dessus. Dans la régression linéaire, l'instruction for a été utilisée, mais cette fois, l'apprentissage est effectué à l'aide de model.fit (). Dans model.fit (), le nombre d'apprentissage peut être défini par époques. model.fit (X, T, epochs = 30, model.fit (X, T, epochs = 30, batch_size = 1)) a 30 temps d'apprentissage, et comme batch_size = 1, le nombre de données est 4, donc 30 × 4 Former 120 lots. Lorsque vous exécutez le code, un résumé s'affiche et vous pouvez voir que la précision augmente à mesure que le nombre d'apprentissage augmente. [try] ① Remplacez np.random.seed (0) par np.random.seed (1) Ce qui précède est la partie modifiée. résultat Confirmez que le résultat est différent de l'exercice ci-dessus car la valeur initiale change en passant de np.random.seed (0) à 1.

② Changez le nombre d'époques à 100 Ce qui précède est la partie modifiée. résultat Étant donné que le nombre de formations par lots est passé de 120 pour les exercices à 400 pour 100x4, l'erreur était faible et convergeait.

③ Passer au circuit AND et au circuit XOR [1] Circuit ET Ce qui précède est la partie modifiée. résultat On voit que le circuit ET est également bien appris.

[2] Circuit XOR Ce qui précède est la partie modifiée.

résultat Le circuit XOR (somme logique exclusive) ne peut être représenté que linéairement dans un réseau de couches entièrement couplé. Il a été confirmé qu'une erreur se produit parce que le circuit ne peut pas être représenté linéairement (0 et 1 ne peuvent pas être séparés par une ligne droite).

④ Changez la taille du lot à 10 avec un circuit OU Ce qui précède est la partie modifiée. résultat En augmentant la taille du lot à 10, le nombre d'apprentissages diminue, on peut donc voir que le temps de calcul pendant l'exercice est plus rapide que 2ms. En augmentant la taille du lot de cette manière, le nombre d'apprentissages dans une époque peut être réduit. En général, la taille du lot est un multiple de 2. En outre, lorsque le nombre de données est petit, la taille du lot est petite, et lorsque le nombre de données est grand, la taille du lot est augmentée.

⑤ Changeons le nombre d'époques à 300 Ce qui précède est la partie modifiée. résultat C'est la même chose que (2), et comme le nombre de formations par lots augmente, l'erreur est faible et converge.

Classification de l'iris train_test_split classe les données en données d'entraînement et en données de vérification. Étant donné que les données de vérification sont définies à 20% par train_test_split (x, d, test_size = 0,2), les données d'apprentissage et les données de vérification sont séparées dans un rapport de 4: 1. Le modèle est défini comme ci-dessus. Un réseau neuronal à deux couches via la fonction ReLU avec une taille de couche d'entrée de 4 et une taille de couche intermédiaire de 12, et une fonction softmax avec une taille de matrice de 3. la perte est sparse_categorical_crossentropy C'est parce que la cible est divisée en 0,1,2. Sous la forme de one_hot, categorical_entropy est utilisé. Lorsque les résultats sont confirmés, il peut être confirmé que la précision est améliorée en effectuant l'apprentissage, et que la précision du graphique est la même pour les données d'apprentissage et les données de vérification.

[try] ① Changez la fonction d'activation de la couche intermédiaire en sigmoïde Ce qui précède est la partie modifiée. résultat Le résultat est plus précis que la fonction ReLU. C'est parce que les données d'iris cette fois sont simples. Lorsque les données se compliquent, la fonction sigmoïde provoque la disparition du gradient.

② Importez SGD et changez l'optimiseur en SGD (lr = 0,1) Ce qui précède est la partie modifiée. résultat On peut voir que la vitesse d'apprentissage et la précision ont atteint 1,0 à un stade précoce en réglant SGD (taux d'apprentissage supérieur à l'exercice). En utilisant Keras, il est possible d'implémenter et de modifier facilement la fonction d'activation, le taux d'apprentissage et l'optimiseur.

Classification MNIST Importez les données mnist de data.mnist. Il s'agit d'un réseau neuronal à trois couches avec une entrée 784, des couches intermédiaires 512 et 512 et une sortie 10. La fonction Relu est exécutée dans la couche intermédiaire et la fonction softmax est exécutée dans la sortie. On peut voir d'après les résultats d'exécution que l'apprentissage est effectué à l'aide de 60 000 images en un seul apprentissage.

[try] ① Changez one_hot_label de load_mnist en False Ce qui précède est la partie modifiée. résultat Le résultat est un affichage d'erreur. Puisque categorical_crossentropy est utilisé à one_hot, l'erreur de forme du modèle est terrible.

② Changez la fonction d'erreur en sparse_categorical_crossentropy Remplacez la perte ci-dessus par ①. résultat Il a été confirmé que lorsque one_hot = False était remplacé par sparse_categorical_crossentropy, l'opération commençait normalement et la précision augmentait à environ 98% au 20e temps.

③ Changer la valeur de l'argument d'Adam Ce qui précède est la partie modifiée. résultat Plus le taux d'apprentissage est élevé, plus la vitesse de calcul est rapide, mais l'expérience n'était pas si différente. Le taux d'apprentissage de 0,001 semble être plus approprié. Un autre avantage de Keras est que vous pouvez rapidement modifier le taux d'apprentissage et comparer.

Classification CNN du MNIST Je l'ai en fait utilisé avec epoch = 20, mais cela a pris trop de temps, alors je l'ai changé en epoch = 5. Puisqu'il s'agit d'un CNN, remodelez-le en 28x28x1 et définissez input_shape. Avec Keras, vous pouvez convolution simplement en utilisant Conv2D et MaxPooling2D. model.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape = input_shape)) 32 représente le nombre de canaux de sortie et kernel_size = (3, 3) représente la taille du filtre (3 × 3). Le nombre d'époques est de 5, mais la précision des nombres est passée à environ 98%.

Apprendre avec le jeu de données cifar10 cifar10 est un ensemble de données d'image couleur 32x32 pixels de 10 types d'étiquettes "avion, voiture, oiseau, chat, cerf, chien, grenouille, cheval, bateau, camion". Le nombre de données est de 60000, le nombre de données d'entraînement: 50000, le nombre de données de test: 10000 Étant donné que chaque donnée d'image est écrite en RVB de 0 à 255, une normalisation (divisée par 255 et changée en une plage de 0 à 1) est effectuée. Le réseau neuronal est un réseau utilisant Conv2D et MaxPooling2D comme le CNN ci-dessus. Le résultat était un surapprentissage avec une précision d'apprentissage de 99% et une précision de test de 65%. Après tout, il est difficile d'obtenir une bonne précision avec l'époque numéro 3.

RNN SimpleRNN, LSTM, GRU, etc. expliqués dans toutes les conférences sont également disponibles à Keras. Cette fois, RNN est utilisé pour ajouter des nombres binaires. Les nombres sont ajoutés en notation binaire pour le calcul par RNN. Ceci est dû au fait que les 2 nouveaux nombres sont pris comme les chiffres passés sont reportés. Le modèle est model.add () input_shape = [8, 2] correspond à 8 octets × données a et b La série chronologique représente 8 éléments. La précision est de 94% pour la première fois et de 100% pour la seconde fois et les suivantes. [try] (1) Changez le nombre de nœuds de sortie RNN à 128 Ce qui précède est la partie modifiée. résultat La forme de sortie fluctue en raison du changement du nœud de sortie. La précision est de 100%, ce qui est plus petit que lors de l'exercice d'erreur, et la précision est améliorée.

(2) Changer la fonction d'activation de sortie de RNN en sigmoïde Ce qui précède est la partie modifiée. résultat Il a été confirmé que le résultat était moins précis que la fonction Relu.

③ Changez la fonction d'activation de sortie de RNN en tanh Ce qui précède est la partie modifiée. résultat La précision était meilleure que celle de la fonction sigmoïde et le résultat de la précision était presque le même que celui de la fonction ReLU.

④ Changez la méthode d'optimisation en adam Ce qui précède est la partie modifiée. résultat En conséquence, on peut voir que l'erreur est plus petite que celle de SDG et la précision est améliorée.

⑤ La perte d'entrée RNN est réglée sur 0,5 Ce qui précède est la partie modifiée. résultat J'ai pu constater que la vitesse de calcul était améliorée par l'abandon. Cependant, la précision du calcul est assez médiocre.

⑥ Réglez l'abandon récursif de RNN sur 0,3 Ce qui précède est la partie modifiée. résultat Bien que les performances de généralisation soient améliorées, le résultat est presque le même que ⑤.

⑦ Réglez RNN unroll sur True Unroll fait référence au déploiement d'un réseau. Lorsqu'il est étendu, il a tendance à se concentrer sur la mémoire, mais en revanche, la vitesse de calcul s'améliore. Ce qui précède est la partie modifiée. résultat Comme expliqué ci-dessus, il a été confirmé que la vitesse de calcul était améliorée. La précision est légèrement supérieure à ⑤.

Comment mettre en œuvre le réseau GRU Vous pouvez implémenter un réseau GRU simplement en réécrivant SimpleRNN dans model.add en GRU.

Renforcer l'apprentissage

Apprentissage intensifié: un domaine de l'apprentissage automatique qui vise à créer des agents qui choisissent des actions dans l'environnement afin que les récompenses puissent être maximisées à long terme. Un mécanisme pour déterminer et améliorer les actions en fonction des récompenses données à partir des résultats des actions.

Test de confirmation (4-19) Considérez des exemples qui pourraient être appliqués à l'apprentissage par renforcement et répertoriez en détail l'environnement, les agents et les récompenses.

Exemple: conduite automatique d'une voiture Environnement: Sur la route, Agent: Conducteur, Récompense: Fonctionnement de l'accélérateur / Frein / Poignée, Récompense: Conduire en toute sécurité

Le compromis entre l'exploration et l'utilisation Si vous avez les données (connaissances) que vous pouvez gagner si vous faites cela dans cette scène avec Othello ou Go, vous pouvez prédire et décider de l'action, Il n'y a pas de données sur la façon de tourner le volant pour conduire en toute sécurité comme dans le cas de la conduite d'une voiture dans l'exemple spécifique ci-dessus. Par conséquent, dans l'apprentissage par renforcement, les données sont supposées être incomplètes, et les données sont collectées tout en agissant, et l'action optimale est prise à partir de là.

Par conséquent, si vous n'agissez qu'avec les données passées, vous ne pouvez pas effectuer de recherche et si vous ne collectez que les données, vous ne pouvez pas utiliser les données passées, ce qui est une relation de compromis. L'apprentissage par intensification nécessite une bonne coordination de l'exploration et de l'utilisation.

Différence entre un apprentissage amélioré et un apprentissage avec / sans enseignant Dans l'apprentissage supervisé et non supervisé, l'objectif est de trouver et de prédire des modèles de données. En apprentissage intensif, l'objectif est de trouver un meilleur comportement valorisant. Les objectifs sont différents.

Fonction de valeur d'action Il existe deux types, la fonction de valeur d'état et la fonction de valeur d'action. C'est la fonction de valeur d'état qui se concentre sur la valeur d'un certain état et la fonction de valeur d'action qui se concentre sur la valeur qui combine l'état et la valeur.

Fonction politique C'est une fonction qui donne la probabilité du type d'action à entreprendre dans un certain état dans l'apprentissage par renforcement basé sur les politiques.

Méthode du gradient de politique Techniques de modélisation et d'optimisation des stratégies Il y a une récompense moyenne et une somme de récompense de remise comme méthode de définition.