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 $

Changez la fonction $ d $ en $ d = -6x + 3 $ et changez la valeur du bruit

→ 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 $

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

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

Classification 3 couches (mnist)

Redimensionner la couche cachée → Il a été confirmé que plus la taille de la couche cachée est grande, plus la précision de la prédiction est élevée.
Optimiseur de changement

Classification CNN (mnist)

keras

Régression linéaire

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

Changement du nombre d'époques à 100

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.

Changer la taille du lot à 10 avec circuit OU

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

Changement du nombre d'époques à 300

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

Modification de la fonction d'activation de la couche intermédiaire en sigmoïde

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

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

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

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

--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 → 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()

→ 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')

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

Changement du nombre de nœuds de sortie de RNN à 128 Epoch 1/5 10000/10000 [==============================] - 29s 3ms/step - loss: 0.0741 - accuracy: 0.9194 Epoch 2/5 10000/10000 [==============================] - 29s 3ms/step - loss: 0.0020 - accuracy: 1.0000 Epoch 3/5 10000/10000 [==============================] - 29s 3ms/step - loss: 6.9808e-04 - accuracy: 1.0000 Epoch 4/5 10000/10000 [==============================] - 28s 3ms/step - loss: 4.0773e-04 - accuracy: 1.0000 Epoch 5/5 10000/10000 [==============================] - 28s 3ms/step - loss: 2.8269e-04 - accuracy: 1.0000 Test loss: 0.0002439875359702302 Test accuracy: 1.0 → Lorsque le nombre de nœuds de sortie est passé de 16 à 128, la précision de la prédiction s'est améliorée.
Fonction d'activation de la sortie RNN modifiée en sigmoïde Epoch 1/5 10000/10000 [==============================] - 28s 3ms/step - loss: 0.2498 - accuracy: 0.5131 Epoch 2/5 10000/10000 [==============================] - 28s 3ms/step - loss: 0.2487 - accuracy: 0.5302 Epoch 3/5 10000/10000 [==============================] - 28s 3ms/step - loss: 0.2469 - accuracy: 0.5481 Epoch 4/5 10000/10000 [==============================] - 28s 3ms/step - loss: 0.2416 - accuracy: 0.6096 Epoch 5/5 10000/10000 [==============================] - 27s 3ms/step - loss: 0.2166 - accuracy: 0.7125 Test loss: 0.18766544096552618 Test accuracy: 0.7449744939804077 → Lorsque la fonction d'activation de la sortie est passée de ReLU à sigmoïde, la précision de la prédiction a diminué.
Fonction d'activation de sortie RNN modifiée en tanh Epoch 1/5 10000/10000 [==============================] - 28s 3ms/step - loss: 0.1289 - accuracy: 0.8170 Epoch 2/5 10000/10000 [==============================] - 28s 3ms/step - loss: 0.0022 - accuracy: 1.0000 Epoch 3/5 10000/10000 [==============================] - 28s 3ms/step - loss: 7.1403e-04 - accuracy: 1.0000 Epoch 4/5 10000/10000 [==============================] - 27s 3ms/step - loss: 4.1603e-04 - accuracy: 1.0000 Epoch 5/5 10000/10000 [==============================] - 28s 3ms/step - loss: 2.8925e-04 - accuracy: 1.0000 Test loss: 0.00024679134038564263 Test accuracy: 1.0 → La modification de la fonction d'activation de sortie de ReLU à Tanh a amélioré la précision de la prédiction.
Changement de la méthode d'optimisation en Adam Epoch 1/5 10000/10000 [==============================] - 31s 3ms/step - loss: 0.0694 - accuracy: 0.9385 Epoch 2/5 10000/10000 [==============================] - 32s 3ms/step - loss: 0.0012 - accuracy: 1.0000 Epoch 3/5 10000/10000 [==============================] - 31s 3ms/step - loss: 5.4037e-05 - accuracy: 1.0000 Epoch 4/5 10000/10000 [==============================] - 31s 3ms/step - loss: 3.3823e-06 - accuracy: 1.0000 Epoch 5/5 10000/10000 [==============================] - 31s 3ms/step - loss: 2.4213e-07 - accuracy: 1.0000 Test loss: 5.572893907904208e-08 Test accuracy: 1.0 → Lorsque la méthode d'optimisation est passée de sgd à adam, la précision de la prédiction s'est améliorée.

--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.

Méthode d'approximation des fonctions Une méthode d'approximation de fonctions de fonctions de valeur et de fonctions de politique.

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

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)

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

introduction

Liste des sujets

Section 1: Exercice de mise en œuvre

Régression linéaire

Régression non linéaire

Classification 1 couche (mnist)

Classification 3 couches (mnist)

Classification CNN (mnist)

Régression linéaire

Perceptron simple

Simple_perceptron

python:np.random.seed()

Classification (iris)

classifiy_iris

Classification (mnist)

classify_mnist

Classification CNN (mnist)

classify_mnist_with_CNN

classify_cifar10

RNN (Prédiction de l'addition binaire)

RNN (Prédiction de l'addition binaire)

Section 2: Renforcer l'apprentissage

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

Le compromis entre l'exploration et l'utilisation

Image de l'apprentissage par renforcement

Fonction de valeur d'action

Fonction politique

Méthode du gradient de politique

`Simple_perceptron`

`python:np.random.seed()`

`classifiy_iris`

`classify_mnist`

`classify_mnist_with_CNN`

`classify_cifar10`

`RNN (Prédiction de l'addition binaire)`