Seminar Mod09 - Sujet (1) Partie I

Module09
Deep Learning 02
Séminaire
Module09
Deep Learning 02 Séminaire
Séminaire Module 09 - Deep Learning02
Projet for fun - Automatisation d'un jeu vidéo Maplestory (Démo)
Prétraitement des images
Classification des images et augmentation des données
Entraînement avec différents types de modèles et Tests
Style transfer- Générer votre peinture
[Demo]Visualisation des couches de représentation dans CNN
on utilisera un mini projet en python distribué avec le sujet fast-style-transfer-master.zip
Codez vous même
[Complémentaire]Création par l'IA - Une autre approche GAN (Generative adversarial network)
Génération des objets(visage, chien, peinture, etc)
De-noise/ (mosaic, brouillard, image inpainting,etc)
Génération des données pour aider Supervised Learning - Data augmentation
Handwriting Digit Classification with CNN - Classification des chiffres manuscrites avec CNN
Explication des données
Construction d'un CNN avec KERAS (En utilisant l'exemple du cours - Chapitre 2.8)
Importer les packages nécessaires
Layer 1
A la sortie de la couche CONV1, quelle est la forme d'activation de nos données? Combien de
paramètres a-t-on besoin pour cette couche?
A la sortie de la couche POOL1, quelle est la forme d'activation de nos données? Combien de
Layer 2
A la sortie de la couche CONV2, quelle est la forme d'activation de nos données? Combien de
A la sortie de la couche POOL2, quelle est la forme d'activation de nos données? Combien de
Couches Flatten, FC3 & 4, SoftMax
Compiler le modèle
Classification des chiffres manuscrites avec model_CNNsimple
Vectorisation des données
Préparation de train set, test set
One-Hot Encoding
Entraînement du modèle
Visualiser la précision du modèle
Conclusion
Créez votre propre CNN à partir de zéro et essayez d'atteindre la plus grande précision possible sur MNIST.
Autres pistes d'amélioration du modèle?
Le jeu de données CALTECH-101 (sous-ensemble)
Télécharger et désarchiver le jeu de données CALTECH-101
Importer tous les packages nécessaires
StridedNet
Construisez une fonction build qui prend 6 paramètres:
Préparation base de données
Préparation de training
Implémentation ResNet-50
Importer tous les packages nécessaires
Mise en œuvre du bloc d'identité
Mise en œuvre du bloc convolutif
Mise en œuvre de ResNet-50
Ajouter les couhches de sorties, Fully Connected. Compiler et entraîner le modèle
Conclusion
Rétropropagation dans les réseaux de neurones convolutifs
Introduction
Rétropropagation de la couche convolutive
Calcul de dA
Calcul de dW
Calcul de db
Implémentation de la rétropropagation de CONV
Rétropropagation de la couche de Pooling
Max pooling
Implémentez create_mask_from_window().
Average pooling
Implémentez la fonction ci-dessous pour distribuer également une valeur dz à travers une matrice
de forme dimensionnelle.
Pooling backward
Séminaire Module 09
- Deep Learning02
1 Projet for fun - Automatisation d'un jeu vidéo Maplestory

(Démo)
MapleStory, un MMORPG 2D à défilement latéral. L'objective de ce projet
est d'automatiser la phase farming de ce jeu vidéo. Projet d'inspiration https://github.com/tanjeffreyz/auto-

maple/blob/main/README.md
L'un des systèmes anti-bot est le système des "runes". Il s'agit des puzzles de touches fléchées dans le jeu
qui sont activés chaque 15mins lorsque vous êtes en train de "farming". L'objective est donc de détecter
correctement la direction de chaque flèche.
1.1 Prétraitement des images
def cut_image(img, count):

# top: 230
# left: 520
# bottom: 310
# right:590
img_cropped1 = img[225:315, 505: 595]
img_cropped2 = img[225:315, 595: 685]
img_cropped3 = img[225:315, 685: 775]
img_cropped4 = img[225:315, 775: 865]
# self.left:self.right, self.top:self.bottom
# self.top, self.left, self.bottom, self.right
# 520 230 590 310
bgr1 = cv.cvtColor(img_cropped1, cv.COLOR_BGRA2BGR)
hsv1 = cv.cvtColor(bgr1, cv.COLOR_BGR2HSV)
h1, s1, v1 = cv.split(hsv1)



pathToSave = "samples_arrows/test_File/arrows/"
path1 = pathToSave+"arrow_"+str(int(count))+"_0.png"
cv.imwrite(path1, v1)
1.2 Classification des images et augmentation des données
1.3 Entraînement avec différents types de modèles et Tests
model_CNNsimple = Sequential()
#CONV 1
model_CNNsimple.add(Conv2D(32, kernel_size = 3, padding="valid", activation =
"relu", strides=(1,1), input_shape=(90,90,1)))
#MAXPOOLING 1
model_CNNsimple.add(MaxPooling2D(pool_size=(2, 2), padding="valid", strides=
(2,2)))
#CONV 2
model_CNNsimple.add(Conv2D(128, kernel_size = 3, padding="valid", activation =
"relu", strides=(1,1)))
#MAXPOOLING 2
model_CNNsimple.add(MaxPooling2D(pool_size=(2, 2), padding="valid", strides=
(2,2)))
# COUCHE FLA
model_CNNsimple.add(Flatten())
# COUCHE FC3
model_CNNsimple.add(Dense(128))
# COUCHE FC4
model_CNNsimple.add(Dense(64))
# COUCHE SOFTMAX
model_CNNsimple.add(Dense(4, activation = "softmax"))
def cut_image_return_arrows(img):
# top: 230
# left: 520
# bottom: 310
# right:590
img_cropped1 = img[225:315, 505: 595]
img_cropped2 = img[225:315, 595: 685]
img_cropped3 = img[225:315, 685: 775]
img_cropped4 = img[225:315, 775: 865]
# self.left:self.right, self.top:self.bottom
# self.top, self.left, self.bottom, self.right
# 520 230 590 310



return v1, v2, v3, v4
testFullImagePath = os.listdir("samples_arrows/test_File")
dataTotalImgs = []
for testImg in testFullImagePath:
data = []
data1 = []
data2 = []
data3 = []
data4 = []
predicLabels = ["down", "left", "right", "up"]
finalPredictions = []
if testImg.endswith(".png") or testImg.endswith(".jpg"):
# extract the class label from the filename
imagePath = "samples_arrows/test_File/" + testImg
image = cv.imread(imagePath)
# Use cut image to get the 4 arrows

a1, a2, a3, a4 = cut_image_return_arrows(image)
data1.append(a1)
data2.append(a2)
data3.append(a3)
data4.append(a4)
data1 = np.array(data1, dtype="float")[0] / 255.0
data.append(data1)
data.append(data2)
data.append(data3)
data.append(data4)
data = np.array(data)
dataTotalImgs.append(image[225:315, 505:865])
# plt.imshow(image[225:315, 505:865])
# Reshape data calculate its matix

# for_cov_ai = data3
# X_std, X_mean, X_cov = get_normed_mean_cov(for_cov_ai)
# X_OutPut_CNN = X_std - X_mean
# X_OutPut_CNN = X_OutPut_CNN.reshape(1, 90, 90, 1)
# predictions = reconstructed_model.predict(X_OutPut_CNN)
# finalPredictions.append(predicLabels[np.argmax(predictions[0])])
# print(finalPredictions)
# for i in range(4):
# finalPredictions.append(predicLabels[np.argmax(predictions[i])])
# for i in range(4):
# for_cov_ai = data[i]
# X_std, X_mean, X_cov = get_normed_mean_cov(for_cov_ai)
# X_OutPut_CNN = X_std - X_mean
# X_OutPut_CNN = X_OutPut_CNN.reshape(1, 90, 90, 1)
# predictions = model_CNNsimple.predict(X_OutPut_CNN)
# finalPredictions.append(predicLabels[np.argmax(predictions[0])])
for i in range(4):
for_cov_ai = data[i]
X_std, X_mean, X_cov = get_normed_mean_cov(for_cov_ai)
X_OutPut_CNN = X_std - X_mean
X_OutPut_CNN = X_OutPut_CNN.reshape(1, 90, 90, 1)
predictions = reconstructed_model.predict(X_OutPut_CNN)
finalPredictions.append(predicLabels[np.argmax(predictions[0])])
print(finalPredictions)
2 Style transfer- Générer votre peinture
2.1 [Demo]Visualisation des couches de représentation dans CNN

2.2 on utilisera un mini projet en python distribué avec le sujet fast-style-
transfer-master.zip
les démarches à faire pour la mise en place d'un projet :
1. dézipper le fichier(Bien sur!)

2. ouvrez votre anaconda, lancez un terminal du environnement et puis executez le code suivant:
conda create -n tf-gpu tensorflow-gpu=2.1.0
conda activate tf-gpu
conda install jupyter notebook #conda install jupyterlab
pip install moviepy==1.0.2 ou bien conda install moviepy

Afin de créer votre propre peinture, préparez une photo par vous même et un fichier du type *.ckpyt ex:
scream.ckpt qu'on vous donne.
3. Allez dans le fichier du projet, et puis exécutez le code suivant:
python evaluate.py --checkpoint path/to/style/model.ckpt \

--in-path dir/of/test/imgs/ \
--out-path dir/for/results/
Il y a donc trois paramètres à saisir dans la commande précédente.
Si vous n'arrivez pas, il y aura une démo et une explication du projet dans l'après midi.
2.3 Codez vous même
Téléchargez votre deep learning net VGG19:
lien de telechargement: http://www.vlfeat.org/matconvnet/models/beta16/imagenet-vgg-verydeep-19.mat
explication: https://iq.opengenus.org/vgg19-architecture/
Original paper: https://arxiv.org/abs/1508.06576
Créer donc un autre environnement
conda create -n module9_2 tensorflow=1.14.0
conda activate module9_2
conda install jupyterlab

conda install matplotlib
Ouvrir le projet jupyter Module10_StyleTransfer.ipynb dans Neural Style Transfer.zip et

remplir les endroits avec TO COMPLETE. Il y a au total 9 #TO COMPLETE, veuillez les répondre:
1.
2.
3.
...
2.4 [Complémentaire]Création par l'IA - Une autre approche GAN (Generative
adversarial network)
Applications:
2.4.1 Génération des objets(visage, chien, peinture, etc)
Directe:
Conditionnelle (style transfert/“traduction”)

"Deep Fake"
2.4.2 De-noise/ (mosaic, brouillard, image inpainting,etc)
https://github.com/hezhangsprinter/ID-CGAN
2.4.3 Génération des données pour aider Supervised Learning - Data augmentation
3 Handwriting Digit Classification with CNN - Classification des

chiffres manuscrites avec CNN
3.1 Explication des données
Encore une fois, chaque ligne représente une image de taille 28*28 pixels qui est aplati à 1 * 784. Vous
pouvez tracer par exemple l'image correspondante à la 500e image(ligne). Chaque dimension représente
donc un pixel sur une position spécifique contrairement au cas précédent.
Nous allons re-traiter ce sujet qu'on avait vu dans le module 08 et 09(Classification des chiffres
manuscrites), mais cette fois ci avec l'outil de Deep learning soit CNN. Et vers la fin de cette partie, vous
allez pouvoir comparer la performance entre les différents modèles: Régression logistique pure, Régression
logistique avec PCA, K-MEANS, SVM. CNN.
3.2 Construction d'un CNN avec KERAS (En utilisant l'exemple du cours -
Chapitre 2.8)
Disons que vous entrez une image de 28 x 28 x 1, et que vous essayez de faire une reconnaissance de
chiffres manuscrits.
Activation Forme Activation Taille #Parameters
Input: (28, 28, 1) 784 0
CON1(f=5, s=1) (24, 24, 32) 18432 832
POOL1(f=2, s=2) (12, 12, 32) 4608 0
CON2(f=3, s=1) (10, 10, 128) 12800 36692
POOL2(f=2, s=2) (5, 5, 128) 3200 0
FC3 (128, 1) 128 409728
FC4 (84, 1) 84 10836
Softmax (10, 1) 10 850
3.2.1 Importer les packages nécessaires
from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Conv2D
from tensorflow.keras.layers import MaxPooling2D
from tensorflow.keras.layers import Activation
from tensorflow.keras.layers import Flatten
from tensorflow.keras.layers import Dense
from tensorflow.keras import backend as K
3.2.2 Layer 1
Compléter le code de la couche 1 avec le contexte suivant:
La couche CONV1 utilise 32 filtres de 5 x 5 et une foulée de 1, et aucun padding, la fonction d'activation
sera "ReLU".
La couche POOL1 sera un max-pooling avec une région deux par deux et un stride de deux. Aucun
padding sera nécessaire.
### START CODE HERE ###
### END CODE HERE ###
3.2.2.1 A la sortie de la couche CONV1, quelle est la forme d'activation de nos données? Combien de
3.2.2.2 A la sortie de la couche POOL1, quelle est la forme d'activation de nos données? Combien de
3.2.3 Layer 2
Compléter le code de la couche 1 avec le contexte suivant:
La couche CONV2 utilise 128 filtres de 3 x 3 et une foulée de 1, et aucun padding, la fonction
d'activation sera "ReLU".
La couche POOL2 sera un max-pooling avec une région deux par deux et un stride de deux. Aucun
padding sera nécessaire.
3.2.3.1 A la sortie de la couche CONV2, quelle est la forme d'activation de nos données? Combien de
3.2.3.2 A la sortie de la couche POOL2, quelle est la forme d'activation de nos données? Combien de
3.2.4 Couches Flatten, FC3 & 4, SoftMax

3.2.5 Compiler le modèle
# Compile the model
3.3 Classification des chiffres manuscrites avec model_CNNsimple
Dans la section précédente, nous avons réussi à construire le modèle "model_CNNsimple" en utilisant la
classe Conv2D de l'API Keras et l'a compilé. Nous allons maintenant l'utiliser pour résoudre notre problème
de classification des chiffres manuscrites.
Importons les packages nécessaires et importons également les fichiers train et test, pour rappel, le fichier
"train.csv" contient 42000 images de taille 28 28 ainsi leur étiquettes. et le fichier "test.csv" contient donc
28000 images de taille 28 28 sans étiquette.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from PIL import Image
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
trainData = pd.read_csv("train.csv")
testData = pd.read_csv("test.csv")
3.3.1 Vectorisation des données
D'après ce que vous avez vu pendant le séminaire du module 09, utilisez la méthode to_numpy() ,
reshape() , construisez vous les tenseurs d'entrée pour le modèle: model_CNNsimple.
vecTrain_CNNR: de taille (42000, 28, 28, 1)
Utilisez également StandardScaler pour standardiser votre vecTrain_CNNR

vecTrain_Label: de taille (42000, 1)
3.3.2 Préparation de train set, test set
Utilisez la fonction train_test_split() pour répartir votre train.csv(vecTrain_CNNR, vecTrain_Label)

entre x_train, x_test, y_train, y_test avec un taux de répartition de 75% et 25%.
3.3.3 One-Hot Encoding
Essentiellement, nous allons convertir ces ensembles de données(vecTrain_Label qui contient les 1,...,9) en
un ensemble de 10 nombres à entrer dans le réseau de neurones. Une fois cela fait, nous imprimerons la
nouvelle étiquette de la rame pour la première image.
Exemple: [9] -> [0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
Utilisez la méthode to_categorical() pour faire cette transition de y_train et y_test . Vous devez avoir
à la fin deux outputs:
y_train_one_hot
y_test_one_hot
#One-Hot Encoding
from keras.utils import to_categorical
3.3.4 Entraînement du modèle
Utilisez la méthode fit() pour entraîner votre modèle.
Model.fit(
x=None,
y=None,
batch_size=None,
epochs=1,
verbose="auto",
callbacks=None,
validation_split=0.0,
validation_data=None,
shuffle=True,
class_weight=None,
sample_weight=None,
initial_epoch=0,
steps_per_epoch=None,
validation_steps=None,
validation_batch_size=None,
validation_freq=1,
max_queue_size=10,
workers=1,
use_multiprocessing=False,
)
Les arguments:
x: Input data.
y: Target data.
epochs: Entier. Nombre d'époques pour entraîner le modèle.

validation_data : données sur lesquelles évaluer la perte et toutes les métriques du modèle à la fin de
chaque époque. Le modèle ne sera pas entraîné sur ces données.
Remarque: dans notre modèle, pour simplifier, vous aurez juste besoin de remplir les 4 paramètres clés se
situent au dessus.
3.3.5 Visualiser la précision du modèle
Exécuter le code suivant pour visualiser la précision de notre modèle dans chaque époque et en fin de
conclure.
#Visualize the models accuracy

plt.plot(hist.history['acc'])
plt.plot(hist.history['val_acc'])
plt.title('Model Accuracy')
plt.ylabel('Accuracy')
plt.xlabel('Epoch')
plt.legend(['Train', 'Val'], loc='upper left')
plt.show()
3.4 Conclusion
3.5 Créez votre propre CNN à partir de zéro et essayez d'atteindre la plus
grande précision possible sur MNIST.
“
Hint: Essayons dans un premier temps d'ajouter les couches Dropout

Seminar Mod09 - Sujet (1) Partie I

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Seminar Mod09 - Sujet (1) Partie I

Transféré par

Droits d'auteur :

Formats disponibles

Module09

1 Projet for fun - Automatisation d'un jeu vidéo Maplestory

MapleStory, un MMORPG 2D à défilement latéral. L'objective de ce projet

est d'automatiser la phase farming de ce jeu vidéo. Projet d'inspiration https://github.com/tanjeffreyz/auto-

1.1 Prétraitement des images

def cut_image(img, count):

bgr2 = cv.cvtColor(img_cropped2, cv.COLOR_BGRA2BGR)

bgr3 = cv.cvtColor(img_cropped3, cv.COLOR_BGRA2BGR)

bgr4 = cv.cvtColor(img_cropped4, cv.COLOR_BGRA2BGR)

1.2 Classification des images et augmentation des données

1.3 Entraînement avec différents types de modèles et Tests

bgr2 = cv.cvtColor(img_cropped2, cv.COLOR_BGRA2BGR)

bgr3 = cv.cvtColor(img_cropped3, cv.COLOR_BGRA2BGR)

bgr4 = cv.cvtColor(img_cropped4, cv.COLOR_BGRA2BGR)

return v1, v2, v3, v4

# Use cut image to get the 4 arrows

# Reshape data calculate its matix

2.1 [Demo]Visualisation des couches de représentation dans CNN

les démarches à faire pour la mise en place d'un projet :

1. dézipper le fichier(Bien sur!)

conda create -n tf-gpu tensorflow-gpu=2.1.0

conda activate tf-gpu

conda install jupyter notebook #conda install jupyterlab

pip install moviepy==1.0.2 ou bien conda install moviepy

3. Allez dans le fichier du projet, et puis exécutez le code suivant:

python evaluate.py --checkpoint path/to/style/model.ckpt \

Il y a donc trois paramètres à saisir dans la commande précédente.

2.3 Codez vous même

Téléchargez votre deep learning net VGG19:

lien de telechargement: http://www.vlfeat.org/matconvnet/models/beta16/imagenet-vgg-verydeep-19.mat

Original paper: https://arxiv.org/abs/1508.06576

Créer donc un autre environnement

conda create -n module9_2 tensorflow=1.14.0

conda activate module9_2

conda install jupyterlab

Ouvrir le projet jupyter Module10_StyleTransfer.ipynb dans Neural Style Transfer.zip et

2.4.1 Génération des objets(visage, chien, peinture, etc)

Conditionnelle (style transfert/“traduction”)

3 Handwriting Digit Classification with CNN - Classification des

Activation Forme Activation Taille #Parameters

Input: (28, 28, 1) 784 0

CON1(f=5, s=1) (24, 24, 32) 18432 832

POOL1(f=2, s=2) (12, 12, 32) 4608 0

CON2(f=3, s=1) (10, 10, 128) 12800 36692

POOL2(f=2, s=2) (5, 5, 128) 3200 0

FC3 (128, 1) 128 409728

FC4 (84, 1) 84 10836

Softmax (10, 1) 10 850

3.2.1 Importer les packages nécessaires

from tensorflow.keras.models import Sequential

Compléter le code de la couche 1 avec le contexte suivant:

### START CODE HERE ###

### END CODE HERE ###

Compléter le code de la couche 1 avec le contexte suivant:

d'activation sera "ReLU".

### START CODE HERE ###

### END CODE HERE ###

3.2.4 Couches Flatten, FC3 & 4, SoftMax

### START CODE HERE ###

### END CODE HERE ###

# Compile the model

3.3 Classification des chiffres manuscrites avec model_CNNsimple

3.3.1 Vectorisation des données