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

sutudy-ai


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)

Section 1) Exercice de mise en œuvre de TensorFlow

Régression linéaire (DN65)

[try]

Changeons la valeur du bruit Changeons le nombre de d

スクリーンショット 2020-01-04 12.11.10.png

$ \ Rightarrow $ [Discussion]

Optimizer name Description
GradientDescentOptimizer Optimiseur par méthode de descente de gradient
AdagradOptimizer Optimiseur par la méthode AdaGrad
MomentumOptimizer Optimiseur de méthode Momentum
AdamOptimize Méthode Adam
FtrlOptimizer Suivez l'algorithme de leader régularisé(Je n'ai pas appris ça)
RMSPropOptimizer Un algorithme qui automatise l'ajustement du taux d'apprentissage

(Référence) Optimizer for tensorflow

Régression non linéaire (DN66)

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

スクリーンショット 2020-01-04 12.43.50.png

Exercice (DN67)

[try]

スクリーンショット 2020-01-04 14.36.20.png $ \ Rightarrow $ [Discussion] Le résultat était que l'ajustement de learning_rate était plus efficace que l'ajustement de iters_num (numéro d'itération: nombre d'apprentissage itératif). [Changer de source]

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)

Classification 3 couches (mnist) (DN69)

[try] Redimensionnons le calque caché Changeons l'optimiseur $ \ Rightarrow $ [Discussion] スクリーンショット 2020-01-04 19.33.05.png 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 スクリーンショット 2020-01-04 19.54.24.png

(Après changement) dropout_rate = 0 スクリーンショット 2020-01-04 20.02.13.png Je pensais que cela diminuerait davantage, mais cela n'a pas beaucoup changé.

Exemple d'explication

スクリーンショット 2020-01-04 20.37.06.png

$ \ 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) スクリーンショット 2020-01-04 22.40.41.png (Après modification) Changé en np.random.seed (1) スクリーンショット 2020-01-04 22.49.46.png (Après changement) L'époque a changé de 30 fois à 100 fois スクリーンショット 2020-01-04 22.58.35.png (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 スクリーンショット 2020-01-04 23.22.23.png (Après changement) Changeons le nombre d'époques à 300 スクリーンショット 2020-01-04 23.24.53.png

Classification (iris)

[try]

(Avant changement / ReLU) スクリーンショット 2020-01-04 23.38.52.png (Changement de la fonction d'activation en Sygmoïde) スクリーンショット 2020-01-05 0.40.44.png Après tout, à partir du graphique, on peut dire que ReRU est plus précis. (Optimisation modifiée en optimiseur = SGD (lr = 0,1)) スクリーンショット 2020-01-05 0.53.14.png

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 avant) スクリーンショット 2020-01-05 1.17.45.png (Après modification) changez one_hot_label en False スクリーンショット 2020-01-05 4.51.25.png

(Après modification) Remplacez la fonction d'erreur par sparse_categorical_crossentropy Et changez one_hot_label en False スクリーンショット 2020-01-05 5.04.45.png

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) スクリーンショット 2020-01-05 5.10.06.png

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

[try] (Changer avant) スクリーンショット 2020-01-07 15.54.14.png (Après modification) Changez le nombre de nœuds de sortie à 128 Unités SimpleRNN modifiées = 16 $ \ Rightarrow $ units = 128. スクリーンショット 2020-01-07 16.07.28.png 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 スクリーンショット 2020-01-07 16.21.14.png 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 スクリーンショット 2020-01-07 16.33.54.png 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'])

スクリーンショット 2020-01-07 17.09.49.png Acc est presque un bon résultat.

(Après modification) Arrêt d'entrée réglé sur 0,5 スクリーンショット 2020-01-07 16.41.19.png Résultat: Acc ne monte pas autant que prévu.

(Après modification) Réglez le décrochage récursif sur 0,3 スクリーンショット 2020-01-07 16.53.33.png C'est aussi seulement Acc 98%.

(Après modification) réglez le déroulement sur True スクリーンショット 2020-01-07 17.15.36.png 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

Day4.jpg

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

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?

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))]

Recommended Posts

<Cours> Deep Learning Day4 Renforcement de l'apprentissage / flux de tension
<Cours> Apprentissage en profondeur: Day2 CNN
<Cours> Apprentissage en profondeur: Jour 1 NN
Sujets> Deep Learning: Day3 RNN
Apprentissage par renforcement profond 1 Introduction au renforcement de l'apprentissage
Apprentissage par renforcement profond 2 Mise en œuvre de l'apprentissage par renforcement
Deep Strengthening Learning 3 Édition pratique: Briser des blocs
Étudiez en profondeur le Deep Learning [DW Day 0]
Apprenez en faisant! Apprentissage par renforcement profond_1
L'apprentissage en profondeur
Les débutants en apprentissage automatique suivent le cours d'apprentissage en profondeur de Coursera
[Rabbit Challenge (E qualification)] Apprentissage en profondeur (jour2)
Apprentissage amélioré pour apprendre de zéro à profond
[Rabbit Challenge (E qualification)] Apprentissage en profondeur (jour3)
[Rabbit Challenge (E qualification)] Deep learning (day4)
[Introduction] Renforcer l'apprentissage
Mémorandum d'apprentissage profond
Commencer l'apprentissage en profondeur
Apprentissage Python jour 4
Apprentissage par renforcement futur_2
Apprentissage par renforcement futur_1
Apprentissage en profondeur Python
Apprentissage profond × Python
Investissement en actions par apprentissage approfondi (méthode du gradient de politique) (1)
Cours de Deep Learning pouvant être écrasé sur place
Premier apprentissage profond ~ Lutte ~
Python: pratique du Deep Learning
Fonctions d'apprentissage en profondeur / d'activation
Apprentissage profond à partir de zéro
Fiche d'apprentissage 4 (8e jour)
Fiche d'apprentissage 9 (13e jour)
Fiche d'apprentissage 3 (7e jour)
Deep learning 1 Pratique du deep learning
Renforcer l'apprentissage de la troisième ligne
Apprentissage profond / entropie croisée
Fiche d'apprentissage 5 (9e jour)
Fiche d'apprentissage 6 (10e jour)
Premier apprentissage profond ~ Préparation ~
Enregistrement d'apprentissage de la programmation 2ème jour
Première solution d'apprentissage en profondeur ~
Fiche d'apprentissage 8 (12e jour)
[AI] Apprentissage métrique profond
Fiche d'apprentissage 1 (4e jour)
Fiche d'apprentissage 7 (11e jour)
J'ai essayé le deep learning
Mémo du cours d'apprentissage automatique
[Renforcer l'apprentissage] Tâche de bandit
Python: réglage du Deep Learning
Fiche d'apprentissage 2 (6e jour)
Technologie d'apprentissage en profondeur à grande échelle
Apprentissage amélioré Python + Unity (apprentissage)
Fiche d'apprentissage 16 (20e jour)
Dossier d'apprentissage 22 (26e jour)
Renforcer l'apprentissage 1 édition introductive
Fonction d'apprentissage profond / softmax
[Apprentissage en profondeur] Classification d'images avec un réseau neuronal convolutif [DW jour 4]
Chanson auto-exploitée par apprentissage en profondeur (édition Stacked LSTM) [DW Day 6]