[Rabbit Challenge (E qualification)] Deep learning (day4)

introduction

C'est un record d'apprentissage lorsque j'ai relevé le Rabbit Challenge dans le but de réussir la qualification JDLA (Japan Deep Learning Association) E, qui se tiendra les 19 et 20 janvier 2021.

Rabbit Challenge est un cours qui utilise le matériel pédagogique édité à partir de la vidéo enregistrée du cours de fréquentation scolaire du «cours d'apprentissage en profondeur qui peut être écrasé sur le terrain». Il n'y a pas de support pour les questions, mais c'est un cours bon marché (le prix le plus bas en juin 2020) pour passer l'examen de qualification E.

Veuillez vérifier les détails à partir du lien ci-dessous.

Liste des sujets

Mathématiques appliquées Apprentissage automatique Apprentissage en profondeur (jour1) Apprentissage en profondeur (jour2) Apprentissage profond (jour3) Apprentissage en profondeur (jour 4)

Section 1: Exercice de mise en œuvre

Tensorflow

Régression linéaire

-Changer la valeur du bruit pour la fonction $ d = 3x + 2 $ image.png

→ Il a été confirmé que plus la valeur du bruit est élevée, plus l'erreur est grande et plus la précision de la prédiction est faible.

Régression non linéaire

-Changé la valeur du bruit pour la fonction de $ d = -0,4x ^ 3 + 1,6x ^ 2-2,8x + 1 $ image.png

--Change la fonction $ d $ en $ d = 2,1x ^ 3-1,2x ^ 2-4,8x + 2 $ et change la valeur du bruit image.png

→ Il a été confirmé que plus la valeur du bruit est élevée, plus l'erreur est grande et plus la précision de la prédiction est faible.

Classification 1 couche (mnist)

image.png

Classification 3 couches (mnist)

Classification CNN (mnist)

image.png

keras

Régression linéaire

image.png

Perceptron simple

Simple_perceptron


#Chargement du module
import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Activation
from keras.optimizers import SGD
 
#Initialiser un nombre aléatoire avec une valeur fixe
np.random.seed(0)

#Créer un perceptron simple pour le sigmoïde
model = Sequential()
model.add(Dense(input_dim=2, units=1))
model.add(Activation('sigmoid'))
model.summary()

model.compile(loss='binary_crossentropy', optimizer=SGD(lr=0.1))
 
#Entrée d'entraînement X et données de réponse correctes T
X = np.array( [[0,0], [0,1], [1,0], [1,1]] )
T = np.array( [[0], [1], [1], [1]] )
 
#entraînement
model.fit(X, T, epochs=30, batch_size=1)
 
#Classification réelle en détournant les données de formation
Y = model.predict_classes(X, batch_size=1)

print("TEST")
print(Y == T)

--Changé np.random.seed (0) en np.random.seed (1)

Étant donné que les nombres aléatoires générés sont fixés à des valeurs différentes comme indiqué ci-dessous, le résultat d'apprentissage change également.

python:np.random.seed()


import numpy as np
 
#Initialiser un nombre aléatoire avec une valeur fixe
np.random.seed(0)
print(np.random.randn()) -> 1.764052345967664
#Initialiser un nombre aléatoire avec une valeur fixe
np.random.seed(1)
print(np.random.randn()) -> 1.6243453636632417

Il a été confirmé que l'augmentation du nombre d'époques réduisait la perte.

-Changé en circuit ET et circuit XOR

Il a été confirmé que le circuit OU et le circuit ET peuvent être séparés linéairement, mais le XOR ne peut pas être appris car il ne peut pas être séparé linéairement.

Il a été confirmé que la perte augmentait avec l'augmentation de la taille du lot.

Il a été confirmé que l'augmentation du nombre d'époques réduisait la perte.

Classification (iris)

classifiy_iris


import matplotlib.pyplot as plt
from sklearn import datasets
iris = datasets.load_iris()
x = iris.data
d = iris.target

from sklearn.model_selection import train_test_split
x_train, x_test, d_train, d_test = train_test_split(x, d, test_size=0.2)

from keras.models import Sequential
from keras.layers import Dense, Activation
# from keras.optimizers import SGD

#Paramètres du modèle
model = Sequential()
model.add(Dense(12, input_dim=4))
model.add(Activation('relu'))
# model.add(Activation('sigmoid'))
model.add(Dense(3, input_dim=12))
model.add(Activation('softmax'))
model.summary()

model.compile(optimizer='sgd', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

history = model.fit(x_train, d_train, batch_size=5, epochs=20, verbose=1, validation_data=(x_test, d_test))
loss = model.evaluate(x_test, d_test, verbose=0)

#Accuracy
plt.plot(history.history['accuracy'])
plt.plot(history.history['val_accuracy'])
plt.ylabel('accuracy', fontsize=14)
plt.xlabel('epoch', fontsize=14)
plt.legend(['train', 'test'], loc='lower right', fontsize=14)
plt.ylim(0, 1.0)
plt.show()

image.png

→ Une diminution de la précision a été confirmée.

image.png

--Importez SGD et changez l'optimiseur en SGD (lr = 0,1)

→ Il semble que la variation de précision pour chaque époque a augmenté.

image.png

Classification (mnist)

classify_mnist


#Importer les bibliothèques requises
import sys, os
sys.path.append(os.pardir)  #Paramètres d'importation des fichiers dans le répertoire parent
import keras
import matplotlib.pyplot as plt
from data.mnist import load_mnist

(x_train, d_train), (x_test, d_test) = load_mnist(normalize=True, one_hot_label=True)

#Utilisez Adam pour importer et optimiser les bibliothèques requises
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.optimizers import Adam

#La modélisation
model = Sequential()
model.add(Dense(512, activation='relu', input_shape=(784,)))
model.add(Dropout(0.2))
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(10, activation='softmax'))
model.summary()

#Taille du lot, nombre d'époques
batch_size = 128
epochs = 20

model.compile(loss='categorical_crossentropy', 
              optimizer=Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False), 
              metrics=['accuracy'])

history = model.fit(x_train, d_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(x_test, d_test))
loss = model.evaluate(x_test, d_test, verbose=0)
print('Test loss:', loss[0])
print('Test accuracy:', loss[1])

# Accuracy
plt.plot(history.history['accuracy'])
plt.plot(history.history['val_accuracy'])
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper left')
# plt.ylim(0, 1.0)
plt.show()

image.png

--Changé one_hot_label de load_mnist sur False, ou changé la fonction d'erreur en sparse_categorical_crossentropy → Lors de l'utilisation de «crossentropie_catégorique» comme fonction d'erreur, le format des données doit être au format one_hot_label, et lors de l'utilisation de «parse_categorical_crossentropy », il doit être dans un format autre que one_hot_label.

--Modifier la valeur de l'argument d'Adam image.png → Lorsque le taux d'apprentissage est passé de 0,0001 à 0,001, la précision de la prédiction était presque la même, mais la vitesse d'apprentissage s'est améliorée. Cependant, lorsque le taux d'apprentissage passait de 0,001 à 0,01, la précision de la prédiction diminuait.

Classification CNN (mnist)

classify_mnist_with_CNN


#Importer les bibliothèques requises
import sys, os
sys.path.append(os.pardir)  #Paramètres d'importation des fichiers dans le répertoire parent
import keras
import matplotlib.pyplot as plt
from data.mnist import load_mnist

(x_train, d_train), (x_test, d_test) = load_mnist(normalize=True, one_hot_label=True)


#Traitement pour l'entrée sous forme de matrice
batch_size = 128
num_classes = 10
epochs = 20

img_rows, img_cols = 28, 28

x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)


#Utilisez Adam pour importer et optimiser les bibliothèques requises
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras.optimizers import Adam

model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3),
                 activation='relu',
                 input_shape=input_shape))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))
model.summary()

#Taille du lot, nombre d'époques
batch_size = 128
epochs = 20

model.compile(loss='categorical_crossentropy', optimizer=Adam(), metrics=['accuracy'])
history = model.fit(x_train, d_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(x_test, d_test))

# Accuracy
plt.plot(history.history['accuracy'])
plt.plot(history.history['val_accuracy'])
plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper left')
# plt.ylim(0, 1.0)
plt.show()

image.png

→ Il a été confirmé par CNN qu'une précision de prédiction très élevée de 99% ou plus peut être obtenue.

CIFAR-10

classify_cifar10


#CIFAR-Importer 10 ensembles de données
from keras.datasets import cifar10
(x_train, d_train), (x_test, d_test) = cifar10.load_data()

#CIFAR-10 normalisation
from keras.utils import to_categorical
  
#Normalisation des fonctionnalités
x_train = x_train/255.
x_test = x_test/255.
 
#Étiquette de classe 1-vectorisation à chaud
d_train = to_categorical(d_train, 10)
d_test = to_categorical(d_test, 10)
 
#Construire un CNN
import keras
from keras.models import Sequential
from keras.layers.convolutional import Conv2D, MaxPooling2D
from keras.layers.core import Dense, Dropout, Activation, Flatten
import numpy as np
 
model = Sequential()
 
model.add(Conv2D(32, (3, 3), padding='same',input_shape=x_train.shape[1:]))
model.add(Activation('relu'))
model.add(Conv2D(32, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
 
model.add(Conv2D(64, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
 
model.add(Flatten())
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(10))
model.add(Activation('softmax'))
 
#compiler
model.compile(loss='categorical_crossentropy',optimizer='adam',metrics=['accuracy'])
 
#Entraînement
history = model.fit(x_train, d_train, epochs=20)
tf.executing_eagerly()

#Évaluation&Sortie des résultats d'évaluation
print(model.evaluate(x_test, d_test))

# Accuracy
plt.plot(history.history['accuracy'])
plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.show()

#Enregistrer le modèle
# model.save('./CIFAR-10.h5')

image.png

RNN (Prédiction de l'addition binaire)

RNN (Prédiction de l'addition binaire)


# import tensorflow as tf
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

#Modifier le niveau de journalisation
tf.logging.set_verbosity(tf.logging.ERROR)

import numpy as np
import matplotlib.pyplot as plt

import keras
from keras.models import Sequential
from keras.layers.core import Dense, Dropout,Activation
from keras.layers.wrappers import TimeDistributed
from keras.optimizers import SGD
from keras.layers.recurrent import SimpleRNN, LSTM, GRU


#Préparez les données
#Nombre de chiffres binaires
binary_dim = 8
#Valeur maximum+ 1
largest_number = pow(2, binary_dim)

# largest_Préparez des nombres binaires jusqu'au nombre
binary = np.unpackbits(np.array([range(largest_number)], dtype=np.uint8).T,axis=1)[:, ::-1]


# A,Initialisation B(a + b = d)
a_int = np.random.randint(largest_number/2, size=20000)
a_bin = binary[a_int] # binary encoding
b_int = np.random.randint(largest_number/2, size=20000)
b_bin = binary[b_int] # binary encoding

x_int = []
x_bin = []
for i in range(10000):
    x_int.append(np.array([a_int[i], b_int[i]]).T)
    x_bin.append(np.array([a_bin[i], b_bin[i]]).T)

x_int_test = []
x_bin_test = []
for i in range(10001, 20000):
    x_int_test.append(np.array([a_int[i], b_int[i]]).T)
    x_bin_test.append(np.array([a_bin[i], b_bin[i]]).T)

x_int = np.array(x_int)
x_bin = np.array(x_bin)
x_int_test = np.array(x_int_test)
x_bin_test = np.array(x_bin_test)


#Corriger les données de réponse
d_int = a_int + b_int
d_bin = binary[d_int][0:10000]
d_bin_test = binary[d_int][10001:20000]

model = Sequential()

model.add(SimpleRNN(units=16,
               return_sequences=True,
               input_shape=[8, 2],
               go_backwards=False,
               activation='relu',
               # dropout=0.5,
               # recurrent_dropout=0.3,
               # unroll = True,
            ))
#Couche de sortie
model.add(Dense(1, activation='sigmoid', input_shape=(-1,2)))
model.summary()
model.compile(loss='mean_squared_error', optimizer=SGD(lr=0.1), metrics=['accuracy'])
# model.compile(loss='mse', optimizer='adam', metrics=['accuracy'])

history = model.fit(x_bin, d_bin.reshape(-1, 8, 1), epochs=5, batch_size=2)

#Sortie des résultats de test
score = model.evaluate(x_bin_test, d_bin_test.reshape(-1,8,1), verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

Epoch 1/5 10000/10000 [==============================] - 28s 3ms/step - loss: 0.0810 - accuracy: 0.9156 Epoch 2/5 10000/10000 [==============================] - 28s 3ms/step - loss: 0.0029 - accuracy: 1.0000 Epoch 3/5 10000/10000 [==============================] - 28s 3ms/step - loss: 9.7898e-04 - accuracy: 1.0000 Epoch 4/5 10000/10000 [==============================] - 28s 3ms/step - loss: 4.8765e-04 - accuracy: 1.0000 Epoch 5/5 10000/10000 [==============================] - 28s 3ms/step - loss: 3.3379e-04 - accuracy: 1.0000 Test loss: 0.0002865186012966387 Test accuracy: 1.0

--Réglez la perte d'entrée RNN à 0,5 Epoch 1/5 10000/10000 [==============================] - 30s 3ms/step - loss: 0.2324 - accuracy: 0.5875 Epoch 2/5 10000/10000 [==============================] - 31s 3ms/step - loss: 0.2106 - accuracy: 0.6230 Epoch 3/5 10000/10000 [==============================] - 31s 3ms/step - loss: 0.2046 - accuracy: 0.6264 Epoch 4/5 10000/10000 [==============================] - 31s 3ms/step - loss: 0.2032 - accuracy: 0.6244 Epoch 5/5 10000/10000 [==============================] - 30s 3ms/step - loss: 0.1995 - accuracy: 0.6350 Test loss: 0.15461890560702712 Test accuracy: 0.8619986772537231 → Lorsque l'entrée Dropout a été réglée sur 0,5, l'apprentissage n'a pas eu lieu.

--Réglez l'abandon récursif de RNN à 0,3 Epoch 1/5 10000/10000 [==============================] - 32s 3ms/step - loss: 0.1459 - accuracy: 0.8306 Epoch 2/5 10000/10000 [==============================] - 32s 3ms/step - loss: 0.0947 - accuracy: 0.9058 Epoch 3/5 10000/10000 [==============================] - 32s 3ms/step - loss: 0.0895 - accuracy: 0.9099 Epoch 4/5 10000/10000 [==============================] - 31s 3ms/step - loss: 0.0881 - accuracy: 0.9112 Epoch 5/5 10000/10000 [==============================] - 31s 3ms/step - loss: 0.0871 - accuracy: 0.9120 Test loss: 0.09418297858566198 Test accuracy: 0.9016276597976685 → Lorsque l'abandon récursif était réglé sur 0,3, la précision de la prédiction diminuait.

--Réglez RNN unroll à True Epoch 1/5 10000/10000 [==============================] - 20s 2ms/step - loss: 0.0938 - accuracy: 0.8871 Epoch 2/5 10000/10000 [==============================] - 20s 2ms/step - loss: 0.0032 - accuracy: 0.9999 Epoch 3/5 10000/10000 [==============================] - 20s 2ms/step - loss: 9.4733e-04 - accuracy: 1.0000 Epoch 4/5 10000/10000 [==============================] - 21s 2ms/step - loss: 5.3410e-04 - accuracy: 1.0000 Epoch 5/5 10000/10000 [==============================] - 20s 2ms/step - loss: 3.6424e-04 - accuracy: 1.0000 Test loss: 0.0003125413816745379 Test accuracy: 1.0 → Lorsque le déroulement est défini sur Vrai (le calcul est effectué sans boucle), la précision de la prédiction est légèrement réduite. Le temps de calcul est plus rapide car la mémoire a été consolidée.

Section 2: Renforcer l'apprentissage

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 à long terme. → Un mécanisme pour améliorer le principe de détermination des actions en fonction des bénéfices (récompenses) attribués à la suite des actions.

Dans l'apprentissage supervisé et non supervisé, les objectifs sont de faire des prédictions à partir des données et de trouver les modèles contenus dans les données. En revanche, dans l'apprentissage par renforcement, l'objectif est de trouver d'excellentes mesures. Il est possible de prédire et de déterminer le comportement optimal si vous avez une connaissance parfaite de l'environnement à l'avance, mais en apprentissage intensif, vous pouvez collecter des données et trouver le comportement optimal en agissant sur la base de connaissances incomplètes. J'irai.

--Q apprentissage L'invention concerne un procédé pour faire progresser l'apprentissage en mettant à jour la fonction de valeur d'action chaque fois qu'une action est entreprise.

Le compromis entre l'exploration et l'utilisation

Si vous n'effectuez toujours que les meilleures actions basées sur les données historiques, vous ne pouvez pas trouver d'autres meilleures actions. (Recherche insuffisante) $ \ Longleftrightarrow $ Si vous ne faites toujours que des actions inconnues, vous ne pourrez pas utiliser votre expérience passée (utilisation insuffisante)

Image de l'apprentissage par renforcement

image.png

Fonction de valeur d'action

Il existe deux types de fonctions qui expriment une valeur: la fonction de valeur d'état (lorsque vous vous concentrez sur un certain état) et la fonction de valeur d'action (lorsque vous vous concentrez sur la valeur qui combine l'état et la valeur).

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.

Méthode du gradient de politique

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

Recommended Posts

[Rabbit Challenge (E qualification)] Apprentissage en profondeur (jour3)
[Rabbit Challenge (E qualification)] Deep learning (day4)
[Rabbit Challenge (E qualification)] Mathématiques appliquées
Défi de lapin d'apprentissage automatique
<Cours> Apprentissage en profondeur: Day2 CNN
<Cours> Apprentissage en profondeur: Jour 1 NN
Sujets> Deep Learning: Day3 RNN
[Deep Learning Association E Qualification] Que faire pour recevoir
Étudiez en profondeur le Deep Learning [DW Day 0]
<Cours> Deep Learning Day4 Renforcement de l'apprentissage / flux de tension
Mémorandum d'apprentissage profond
Commencer l'apprentissage en profondeur
Apprentissage Python jour 4
Apprentissage en profondeur Python
Apprentissage profond × Python
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 3 (7e jour)
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
Fiche d'apprentissage 8 (12e jour)
[AI] Apprentissage métrique profond
Fiche d'apprentissage 1 (4e jour)
Fiche d'apprentissage 7 (11e jour)
Python: réglage du Deep Learning
Fiche d'apprentissage 2 (6e jour)
Fiche d'apprentissage 16 (20e jour)
Dossier d'apprentissage 22 (26e jour)
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]