<Cours> Deep Learning Day4 Renforcement de l'apprentissage / flux de tension

Apprentissage en profondeur

table des matières [Apprentissage en profondeur: Day1 NN] (https://qiita.com/matsukura04583/items/6317c57bc21de646da8e) [Apprentissage en profondeur: Day2 CNN] (https://qiita.com/matsukura04583/items/29f0dcc3ddeca4bf69a2) [Apprentissage en profondeur: Day3 RNN] (https://qiita.com/matsukura04583/items/9b77a238da4441e0f973) [Deep learning: Day4 Strengthening learning / Tensor Flow] (https://qiita.com/matsukura04583/items/50806b750c8d77f2305d)

Deep learning: Day4 Strengthening learning / Tensor Flow (résumé de la conférence)

• Tensor Flow fourni par Google. Le plus souvent utilisé comme raybrari. Par conséquent, dans la conférence, nous nous concentrerons sur Tensor Flow.

Section 1) Exercice de mise en œuvre de TensorFlow

Régression linéaire (DN65)

• Nombre de données 300
  d = 3x + 2 (bruit 0,3)
• Fonction d'erreur Erreur quadratique moyenne
• Méthode de descente de gradient optimiseur
• Taux d'apprentissage 0,1

[try]

Changeons la valeur du bruit Changeons le nombre de d

$ \ Rightarrow $ [Discussion]

• Tensor Flow ne fonctionne pas sans session explicite.
• [(Référence) Examiner comment le remodelage se transforme en -1 avec TensorFlow- "-1 signifie" calculer à partir d'autres éléments et en faire un nombre approprié "](https :: //teratail.com/questions/104809)
• (Référence: ce que j'ai étudié) À propos d'Optimizer
  TensorFlow prend actuellement en charge les éléments suivants:

(Référence) Optimizer for tensorflow

Régression non linéaire (DN66)

• Nombre de données 100
  $ d = --0,4 x ^ 3 + 1,6x ^ 2 --2,8x + 1 $ (bruit 0,05)
  À ce stade, notez que W (poids) est -0,4,1,6, -2,8,1 (x à la puissance 0) et que b (biais) n'est pas utilisé.
• Fonction d'erreur Erreur quadratique moyenne
• Méthode de descente de gradient optimiseur
• Taux d'apprentissage 0,01
• 
  

[try] Changeons la valeur du bruit Changeons le nombre de d

• W = tf.Variable(tf.random_normal([4, 1], stddev=0.01)) stddev = 0,01 est défini dans tf.random_normal comme une valeur initiale aléatoire avec un écart type de 0,01.

Exercice (DN67)

[try]

• Effectuons une régression en utilisant l'équation suivante comme modèle
  $ d = 30x ^ 2 + 0,5x + 0,2 $ (bruit 0,05)
• Ajustez iters_num et learning_rate pour que l'erreur converge

python

import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt

#Changez l'itération ici
iters_num = 10000
plot_interval = 100

#Générer des données
n=100
#random.rand(): 0.0 ou plus, 1.Génération aléatoire inférieure à 0
x = np.random.rand(n).astype(np.float32) * 4 - 2
d =  30 * x ** 2 +0.5 * x + 0.2

#Ajoute du bruit
noise = 0.05
d = d + noise * np.random.randn(n) 

#modèle
#Notez que nous n'utilisons pas b.
#Ajouté: Le nombre de W est passé de 4 à 3, alors changez
#xt = tf.placeholder(tf.float32, [None, 4])
xt = tf.placeholder(tf.float32, [None, 3])
dt = tf.placeholder(tf.float32, [None, 1])
#Ajouté: Le nombre de W est passé de 4 à 3, alors changez
#W = tf.Variable(tf.random_normal([4, 1], stddev=0.01))
W = tf.Variable(tf.random_normal([3, 1], stddev=0.01))
y = tf.matmul(xt,W)

#Fonction d'erreur Erreur quadratique moyenne
loss = tf.reduce_mean(tf.square(y - dt))
#Modifiez le taux d'apprentissage ici
optimizer = tf.train.AdamOptimizer(0.001)
train = optimizer.minimize(loss)

#Initialisation
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)

#Préparez les données créées en tant que données d'entraînement
d_train = d.reshape(-1,1)
#x_train = np.zeros([n, 4])
x_train = np.zeros([n, 3])
for i in range(n):
#Ajouté: Le nombre de W est passé de 4 à 3, alors changez
#    for j in range(4):
    for j in range(3):
        x_train[i, j] = x[i]**j

#entraînement
for i in range(iters_num):
    if (i+1) % plot_interval == 0:
        loss_val = sess.run(loss, feed_dict={xt:x_train, dt:d_train}) 
        W_val = sess.run(W)
        print('Generation: ' + str(i+1) + '.Erreur= ' + str(loss_val))
    sess.run(train, feed_dict={xt:x_train,dt:d_train})

print(W_val[::-1])
    
#Fonction de prédiction
def predict(x):
    result = 0.
#Ajouté: Le nombre de W est passé de 4 à 3, alors changez
#   for i in range(0,4):
    for i in range(0,3):
        result += W_val[i,0] * x ** i
    return result

fig = plt.figure()
subplot = fig.add_subplot(1,1,1)
plt.scatter(x ,d)
linex = np.linspace(-2,2,100)
liney = predict(linex)
subplot.plot(linex,liney)
plt.show()

MNIST1(DN68)

• MNIST est un ensemble de données de caractères manuscrits qui contient 11 canaux d'images en noir et blanc 28✖️28✖️. C'est comme prédire quel nombre de +0 à 9.

Classification 3 couches (mnist) (DN69)

[try] Redimensionnons le calque caché Changeons l'optimiseur $ \ Rightarrow $ [Discussion] Lorsque la taille du calque caché a été réduite de moitié, le taux de réponse correct a considérablement diminué. En revanche, lorsque l'optimiseur est passé d'Adam à Momentum, le taux de réponse correcte est passé de 90 à 94%. J'ai fait d'autres choses, mais RMS Drop était le meilleur avec 96%. J'ai essayé de doubler la taille du calque caché, mais l'amélioration du taux de réponse correcte était d'environ 1%, donc si la taille du calque caché était suffisamment profonde, j'ai pensé qu'il serait souhaitable de l'ajuster avec l'optimiseur après cela.

Classification CNN (mnist) (DN70)

conv - relu - pool - conv - relu - pool - affin - relu - dropout - affin - softmax [try]

Modifions le taux d'abandon à 0 $ \ Rightarrow $ [Discussion] (Avant changement) dropout_rate = 0,5

(Après changement) dropout_rate = 0 Je pensais que cela diminuerait davantage, mais cela n'a pas beaucoup changé.

Exemple d'explication

$ \ Rightarrow $ [Discussion] La réponse est (a)

1. googlenet est un réseau composé d'une pile de modules Inception.
2. Module Inceptin Définissez un petit réseau dans un module comme indiqué dans le tableau ci-dessus. Par conséquent, (D) est la bonne réponse. Le module Inceptin est généralement caractérisé en définissant la taille du filtre et en exécutant la partie en Convolution en utilisant plusieurs tailles de filtre. C, qui réduit les dimensions par convolution 1x1, est la bonne réponse. B est également correct, car il améliore l'expressivité tout en réduisant le nombre de paramètres par de multiples convolutions.

La réponse (a) est incorrecte Tout d'abord, en ce qui concerne la perte, la particularité de cette perte est que le classement est effectué dans la partie branchée du réseau au milieu.

L'explication des exemples suivants est omise.

[DN73] Test de confirmation dans l'explication de l'exemple Décrivez brièvement les fonctionnalités de VGG, GoogleNet et ResNet.

Pour VGG, ce sera le plus ancien modèle de 2014. En tant que fonctionnalité, il est simple d'empiler des réseaux simples tels que Convolution, Convolution, max_pool. En revanche, il se caractérise par un grand nombre de paramètres par rapport aux deux autres. La caractéristique de Google Net est qu'il utilise le module de démarrage. Il se caractérise par une réduction dimensionnelle en utilisant une taille de 1✖️1 et une parcimonie en utilisant différentes tailles de filtre. Concernant ResNet, le module <Skip Connection Identity Module est utilisé pour établir une connexion résiduelle, ce qui permet un apprentissage en profondeur.

Keras2 (DN69)

Perceptron simple

Circuit OU [try] Changement de np.random.seed (0) en np.random.seed (1) Changement du nombre d'époques à 100 Changé en circuit ET et circuit XOR Changer la taille du lot à 10 avec le circuit OU Changeons le nombre d'époques à 300 ⇒ [Discussion] (Avant changement) np.random.seed (0) (Après modification) Changé en np.random.seed (1) (Après changement) L'époque a changé de 30 fois à 100 fois (Après changement) Passer au circuit ET OR et AND peuvent être séparés linéairement, mais XOR ne peut pas être appris car il ne peut pas être séparé linéairement. (Après changement) Changez la taille du lot à 10 avec circuit OU (Après changement) Changeons le nombre d'époques à 300

Classification (iris)

[try]

• Changer la fonction d'activation de la couche intermédiaire en sigmoïde
• Importez SGD et changez l'optimiseur en SGD (lr = 0,1)

(Avant changement / ReLU) (Changement de la fonction d'activation en Sygmoïde) Après tout, à partir du graphique, on peut dire que ReRU est plus précis. (Optimisation modifiée en optimiseur = SGD (lr = 0,1))

Avec l'optimiseur = SGD (lr = 0,1), il y a des zones où la précision s'est améliorée de sorte que 1.0 apparaît parfois, mais il semble qu'il y ait plus de variations.

Classification (mnist)

[try]

• Changer one_hot_label de load_mnist en False (erreur)
• Changez la fonction d'erreur en sparse_categorical_crossentropy
• Changer la valeur de l'argument d'Adam

(Changer avant) (Après modification) changez one_hot_label en False

(Après modification) Remplacez la fonction d'erreur par sparse_categorical_crossentropy Et changez one_hot_label en False

categorical_crossentropy → définissez one_hot_label sur True sparse_categorical_crossentropy → Fales one_hot_label Doit être. Sinon, une erreur se produira.

(Après changement) Changeons la valeur de l'argument lr d'Adam (taux d'apprentissage 0,01-> 0,1)

RNN (Prédiction de l'addition binaire) Documentation Keras RNN

• Changement du nombre de nœuds de sortie RNN à 128
• Changement de la fonction d'activation de la sortie RNN en sigmoïde
• Changement de la fonction d'activation de la sortie RNN en tanh
• Méthode d'optimisation modifiée pour Adam
• Retrait d'entrée RNN réglé à 0,5
• Réglez le décrochage récursif RNN sur 0,3
• Réglez le déroulement RNN sur True

[try] (Changer avant) (Après modification) Changez le nombre de nœuds de sortie à 128 Unités SimpleRNN modifiées = 16 $ \ Rightarrow $ units = 128. Il est passé du stade EPOCH1 à Acc 0.9299. (Après changement) Changement de la fonction d'activation de la sortie en ReLU $ \ Rightarrow $ sigmoid Le résultat de Sygmoid est que Acc ne monte pas autant que LeRU. (Après modification) Changez la fonction d'activation de la sortie sur tanh Cela prend jusqu'à Epoch3 même si Acc est à 100%.

(Après modification) Changez la méthode d'optimisation en adam Changement de source

pyton

#model.compile(loss='mean_squared_error', optimizer=SGD(lr=0.1), metrics=['accuracy'])
model.compile(loss='mse', optimizer='adam', metrics=['accuracy'])

(Après modification) Arrêt d'entrée réglé sur 0,5 Résultat: Acc ne monte pas autant que prévu.

(Après modification) Réglez le décrochage récursif sur 0,3 C'est aussi seulement Acc 98%.

(Après modification) réglez le déroulement sur True C'est aussi un bon résultat.

Section 2) Renforcer l'apprentissage

2-1 Qu'est-ce que l'apprentissage par renforcement?

Un domaine de l'apprentissage automatique qui vise à créer des agents qui peuvent choisir des actions dans l'environnement afin que les récompenses puissent être maximisées sur le long terme. $ \ Rightarrow $ C'est un mécanisme pour améliorer le principe de décision d'une action en fonction du profit (récompense) donné à la suite de l'action.

[D81] Renforcement de l'apprentissage 1 Test de confirmation Considérez des exemples qui pourraient être appliqués à l'apprentissage par renforcement et répertoriez les agents environnementaux, les actions et les récompenses.

⇒ [Discussion] Robot d'investissement en actions Environnement ⇒ Bourse Agent ⇒ Investisseur Action ⇒ Sélectionner et investir dans des actions susceptibles d'être rentables Récompense ⇒ Profit / perte de l'achat et de la vente d'actions

2-2 Exemple d'application de l'apprentissage par renforcement

Pour le marketing Environnement: Département de promotion des ventes de l'entreprise Agent: e-mail de campagne basé sur le profil et l'historique des achats C'est un logiciel qui détermine le client à envoyer. Action: Vous devrez choisir entre les actions d'envoi et de non-envoi pour chaque client. Récompense: récompense négative du coût de la campagne et créée par la campagne Recevez une récompense positive des ventes qui devraient être réalisées

2-3 Compromis entre la recherche et l'utilisation

Avec une parfaite connaissance de l'environnement à l'avance, il est possible de prédire et de déterminer un comportement optimal.
⇒Situation où l'on sait à quel type de client l'e-mail de campagne sera envoyé et quel type d'action sera entreprise.
⇒ Dans le cas d'un apprentissage intensif, l'hypothèse ci-dessus ne tient pas. Recueillir des données en agissant sur la base de connaissances incomplètes. Trouvez la meilleure action.

Avec les données historiques, si vous ne prenez toujours que le meilleur comportement, vous ne pouvez pas trouver un autre meilleur comportement. ⇒ Recherche insuffisante (Les relations supérieures et inférieures sont des relations de compromis) Si vous continuez à n'effectuer que des actions inconnues, vous ne pouvez pas utiliser votre expérience passée. Utilisation insuffisante Relation de compromis ⇒ Seule altitude inconnue

2-4 Image de l'apprentissage par renforcement

2-5 Différence dans l'apprentissage par renforcement

Différences entre l'apprentissage amélioré et l'apprentissage régulier enseigné et non supervisé

Conclusion: des objectifs différents

• Sans enseignant, avec apprentissage, l'objectif est de trouver des modèles contenus dans les données et de prédire à partir de ces données
• En renforçant l'apprentissage, l'objectif est de trouver une bonne stratégie

Histoire de l'apprentissage amélioré À propos de l'apprentissage par renforcement ・ Bien qu'il y ait eu une ère d'hiver, il devient possible d'effectuer un apprentissage intensif quand il a un état à grande échelle en raison de la progression de la vitesse de calcul. ・ Apparition d'une méthode combinant la méthode d'approximation de fonction et l'apprentissage Q

Apprentissage Q ・ Comment procéder à l'apprentissage en mettant à jour la fonction de valeur d'action chaque fois que vous effectuez une action Méthode d'approximation des fonctions ・ Une méthode de fonction-approximation des fonctions de valeur et des fonctions de politique

2-6 Fonction valeur d'action

Qu'est-ce qu'une fonction de valeur d'action?

• Il existe deux types de fonctions de valeur: la fonction de valeur d'état et la fonction de valeur d'action.
• Fonction de valeur d'état en se concentrant sur la valeur d'un certain état Fonction de valeur d'action en se concentrant sur la valeur qui combine état et valeur

2-7 fonction politique

Une fonction de politique est une fonction qui donne la probabilité de l'action à entreprendre dans un certain état dans une méthode d'apprentissage par renforcement basée sur des politiques.

2-8 méthode du gradient de politique

Méthode de répétition des politiques Techniques de modélisation et d'optimisation des stratégies ⇒ Méthode du gradient de politique

\theta^{(t+1)}=\theta^{(t)}\epsilon\nabla j(\theta)

Qu'est-ce que j? ⇒ Bonne politique ... Doit être définie

Méthode de définition ・ Récompense moyenne ・ Remise sur la somme des récompenses Correspondant à la définition ci-dessus, la fonction de valeur d'action: Q (s, a) est définie. Le théorème du gradient de politique tient.

\nabla _{\theta} j(\theta)=E_{\pi_\theta} [\nabla_{\theta} log\pi_\theta(a|s)Q^\pi(s,a))]