Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • Alexandre.Meyer/m1if37-animation
  • Alexandre.Meyer/m2-apprentissage-profond-image
  • Alexandre.Meyer/m2-animation
  • Alexandre.Meyer/hugo-web-minimal
  • Alexandre.Meyer/lifami
  • Alexandre.Meyer/lifapcd
  • Alexandre.Meyer/www
  • Alexandre.Meyer/lifstage
8 results
Show changes
Commits on Source (104)
4 additional commits have been omitted to prevent performance issues.
Hide whitespace changes
Inline Side-by-side
Showing
with 981 additions and 162 deletions
.gitlab-ci.yml
View file @ 1715105c
# The Docker image that will be used to build your app # The Docker image that will be used to build your app
image: harbor.pagoda.os.univ-lyon1.fr/ecoquery-hugo/hugo:latest image: harbor.pagoda.os.univ-lyon1.fr/ecoquery-hugo/hugo:latest
pages: pages:
script: script:
- hugo version - hugo version
- cd web - cd web
- ls -la content - ls -la content
- hugo -v - hugo -v
- hugo list drafts - hugo list drafts
- mv public ../public - mv public ../public
- ls -la ../public - ls -la ../public
- ls -la ../public/tags - ls -laR ../public
# - ls -la ../public/page - ls -la ../public/tags
- ls -la ../public/categories # - ls -la ../public/page
- cat ../public/index.html - ls -la ../public/categories
artifacts: #- cat ../public/index.html
paths: artifacts:
- public paths:
only: - public
- main only:
- main
# test:
# script: # test:
# - pwd # script:
# - cd web # - pwd
# - hugo # - cd web
# - mv public ../public # - hugo
# - ls -la .. # - mv public ../public
# - ls -la ../public # - ls -la ..
# - chmod 755 ../public # - ls -la ../public
# - chmod 644 ../public/index.html # - chmod 755 ../public
# except: # - chmod 644 ../public/index.html
# - main # except:
# - main
README.md
View file @ 1715105c
# Site web et ressources de l'UE UE M1if37 Animation en synthèse d'image # Site web et ressources de l'UE Apprentissage Profond Et Image
[La page de l'UE est ici](http://alexandre.meyer.pages.univ-lyon1.fr/m1if37-animation/) [La page de l'UE est ici](http://alexandre.meyer.pages.univ-lyon1.fr/m2-apprentissage-profond-image/)
## Explication de la génération ## Explication de la génération
Le site web est désormais fabriqué par ```Hugo``` (thème [congo](https://jpanther.github.io/congo/)). les sources se trouvent dans le répertoire ```web```. Le site web est désormais fabriqué par ```Hugo``` (thème [congo](https://jpanther.github.io/congo/)). les sources se trouvent dans le répertoire ```web```. Le site web est mis à jour par intégration continue (CI/CD) à chaque fois que vous faites un push (rien besoin d'autre, à part attendre quelques secondes). Le script d'intégration continue est ```.gitlab-ci.yml```. Pour voir le résultat du script de génération, [allez ici](https://forge.univ-lyon1.fr/Alexandre.Meyer/m2-apprentissage-profond-image/-/jobs) ou depuis l'interface dans CI/Jobs.
Le site web est mis à jour par intégration continue (CI/CD) à chaque fois que vous faites un push (rien besoin d'autre, à part attendre quelques secondes). Le script d'intégration continue est ```.gitlab-ci.yml```. Pour voir le résultat du script de génération, [allez ici](https://forge.univ-lyon1.fr/Alexandre.Meyer/m1if37-animation/-/jobs) ou depuis l'interface dans CI/Jobs.
Le fichier ```site/config.toml``` permet de configurer la génération du site. Mais noramlement il n'y a pas besoin d'y toucher. Le fichier ```site/config.toml``` permet de configurer la génération du site. Mais noramlement il n'y a pas besoin d'y toucher sauf pour changer les menus et le titre du site.
* Les pages web sont générées à partir du répertoire ```web/content```. * Les pages web sont générées à partir du répertoire ```web/content```.
* La page principale du site est ```web/content/_index.html```. Il faut bien laissé le ```_```, il indique qu'il y a des sous-répertoires * La page principale du site est ```web/content/_index.html```. Il faut bien laissé le ```_```, il indique qu'il y a des sous-répertoires
* ```web/content/controle``` pour la partie "Conrtôle d'animation". ```web/content/controle/index.md``` produit la page de cette partie. * ```web/content/am```: les pages de contenus de la partie AM
* ```web/content/personnage``` pour la partie "Animation de personnage virtuel". * ```web/content/jd```: les pages de contenus de la partie JD
* ```web/static``` : les fichiers autres (pdf, images, sujets, etc.) sont à ranger dedans. Par exemple, il y a * ```web/content/nb```: les pages de contenus de la partie NB
* ```web/static``` : les fichiers autres (pdf, images, etc.) sont à ranger dedans. Par exemple, il y a
* ```web/static/images``` pour les images du site; * ```web/static/images``` pour les images du site;
* ```web/static/doc``` documents généraux de l'UE; * ```web/static/doc``` documents généraux de l'UE;
* ```web/static/doc_controle``` documents de la partie contrôle (NP);
* ```web/static/doc_charanim``` documents de la partie personnage (AM);
ATTENTION : quand vous mettez un fichier ```web/content/am/TP_Installation.md``` le lien est sans majuscule !
La doc du générateur "hugo" : [https://gohugo.io/content-management/organization/](https://gohugo.io/content-management/organization/)
## Tester le site en local ## Tester le site en local
...@@ -32,5 +33,5 @@ Pour tester vos mises à jour en local : ...@@ -32,5 +33,5 @@ Pour tester vos mises à jour en local :
Vous pouvez aussi essayer de contruire le site en static en faisant juste ```hugo``` : le site sera constuit dans le répertoire public. Vous pouvez aussi essayer de contruire le site en static en faisant juste ```hugo``` : le site sera constuit dans le répertoire public.
Toutes les infos sont détaillées ici ! ### D'autres infos
Pour convertir du DOKUWIKI en Markdown, on peut utiliser pandoc??? (todo) ou certains web en ligne. Pour convertir du DOKUWIKI en Markdown, on peut utiliser pandoc??? (todo) ou certains web en ligne.
\ No newline at end of file
web/config.toml
View file @ 1715105c
baseURL = "http://alexandre.meyer.pages.univ-lyon1.fr/m1if37-animation/" baseURL = "http://alexandre.meyer.pages.univ-lyon1.fr/m2-apprentissage-profond-image/"
title = "M1if37 Animation en synthèse d'images" title = "Apprentissage et Image"
#theme = "etch" #theme = "etch"
#theme = "ucax" #theme = "ucax"
#theme = "paige" #theme = "paige"
#theme = "hugo-flex" #theme = "hugo-flex"
theme = "congo" theme = "congo"
languageCode = "fr-FR" languageCode = "fr-FR"
enableInlineShortcodes = true enableInlineShortcodes = true
pygmentsCodeFences = true pygmentsCodeFences = true
pygmentsUseClasses = true pygmentsUseClasses = true
publishDir = "public" publishDir = "public"
#uglyURLs = true
# [author]
# name = "Alexandre Meyer"
# image = "img/author.jpg" # [author]
# headline = "M1if37" # name = "Alexandre Meyer"
# bio = "" # image = "img/author.jpg"
# headline = "MLImage"
# bio = ""
[params]
description = "Animation en synthèse d'images"
copyright = "" [params]
dark = "auto" description = "Apprentissage Profond Et Image"
highlight = true copyright = ""
mainSections = "personnage;controle;posts" dark = "auto"
#color = "gray" # Any color in CSS syntax highlight = true
#width = "52rem" # Any length in CSS syntax mainSections = "personnage;controle;posts"
colorScheme = "fire" #color = "gray" # Any color in CSS syntax
# footer= "" #width = "52rem" # Any length in CSS syntax
# rss = "" #colorScheme = "avocado"
article.showDate = false #colorScheme = "congo"
colorScheme = "fire"
# footer= ""
# [[footer]] # rss = ""
# name = "Privacy" article.showDate = false
# url = "https://external-link" favicon = "favicon.ico"
# - name: Aboutaaa
# url: about/
# weight: 1 # [[footer]]
# name = "Privacy"
[menu] # url = "https://external-link"
[[menu.main]] # - name: Aboutaaa
identifier = "Physique" # url: about/
name = "Physique" # weight: 1
title = "Physique"
url = "https://perso.liris.cnrs.fr/fzara/Web/M1Animation.html" [menu]
weight = 1 [[menu.main]]
identifier = "PartieAM"
[[menu.main]] name = "PartieAM"
identifier = "Personnage" title = "PartieAM"
name = "Personnage" url = "/am/"
title = "Personnage" weight = 1
url = "/personnage/"
weight = 2 [[menu.main]]
identifier = "PartieJD"
[[menu.main]] name = "PartieJD"
identifier = "Controle" title = "PartieJD"
name = "Controle" url = "https://perso.liris.cnrs.fr/julie.digne/cours/cours_ml.html"
title = "Controle" weight = 2
url = "/controle/"
weight = 3 [[menu.main]]
identifier = "PartieNB"
name = "PartieNB"
[permalinks] title = "PartieNB"
posts = "/:title/" url = "/nb/"
weight = 3
[markup.goldmark.renderer]
# Allow HTML in Markdown
unsafe = true [permalinks]
posts = "/:title/"
[markup.tableOfContents]
ordered = true [markup.goldmark.renderer]
# Allow HTML in Markdown
unsafe = true
[markup.tableOfContents]
ordered = true
web/content/_index.md
View file @ 1715105c
# Master 1 Informatique - UE M1if37 Animation en synthèse d'image (3 ECTS) # Master 2 ID3D - Analyse, Traitement d'Image et Vision 3D
# Master 2 IA - Apprentissage Machine Et Image
Responsables de l'enseignement : [Alexandre Meyer]( Responsables de l'enseignement : [Alexandre Meyer](http://liris.cnrs.fr/alexandre.meyer),
http://liris.cnrs.fr/alexandre.meyer), [Nicolas Pronost]( [Julie Digne](http://liris.cnrs.fr/jule.digne)
http://liris.cnrs.fr/nicolas.pronost) et [Florence Zara]( et [Nicolas Bonneel](http://liris.cnrs.fr/nicolas.bonneel) - LIRIS, Université Lyon 1
http://liris.cnrs.fr/florence.zara) - LIRIS, Université Lyon 1
Volume horaire : 10h30 CM, 19h30 TP Volume horaire : 30h (CM/TP)
![im_all.png](images/im_all.png) ![MLImage_all.jpg](images/MLImage_all.jpg)
## Objectif de l'UE ## Objectif de l'UE
<p style="text-align:justify;">M1if37 est une UE optionnelle de la 1ère année du Master d'Informatique de l'Université Lyon 1. Les cours ont lieu au semestre 2 (printemps). L'objectif de l'UE est de donner les bases de l'animation en synthèse d'images. Nous aborderons les deux grandes familles de méthodes. L'animation basée sur des données, par exemple pour l'animation d'humain virtuel (données issues de capture de mouvement). Et l'animation basée sur un modèle physique pour la simulation de phénomènes naturels comme le mouvement de textiles ou de fluide. L'UE laissera une grande part à l'application pratique avec la réalisation de TPs en C++/OpenGL proposant d'animer par exemple des humains virtuels, des vêtements, des cordes, une surface d'eau, etc.</p> <p style="text-align:justify;"> Cette page regroupe des supports pour des cours de 2ère année du Master d'Informatique de l'Université Lyon 1 (ATIV pour ID3D, et "Apprentissage et Image" pour IA). Les cours ont lieu à l'automne. L'objectif de l'UE est de donner les bases en apprentissage machine (notamment apprentissage profond) pour les problèmes d'images. Le cours présente d'abord les problèmes classiques liés à l'image comme la classification, l'extraction de descripteurs, la reconnaissance de formes, le suivi d'objet, la segmentation, etc. Puis le cours présente les méthodes génératives autour de l'image au sens large. Un large panel des différents types de réseaux (CNN, auto-encoder, LSTM, GAN, transformer, réseaux de diffusion, etc.) est donné en se focalisant sur des données de type image, mais également des données de type nuage de points, maillage, animation (squelette), palette de couleur, etc.
</p>
[Les slides de la présentation des options sont ici.](doc/M1if37_PresOption.pdf) [Les slides de la présentation des options en Master IA sont ici.](doc/MLImage_PresOption.pdf)
## Thématiques abordées ## Thématiques abordées
### Animation par modèles physiques (F. Zara) - 4h30 CM, 6h30 TP ### Deep learning et images
* Concepts physiques (forces, lois de Newton) * Les bases de l'apprentissage profond : entrainement, espace latent, régularisation, etc.
* Méthodes d'intégration numérique * ConvolutionNN
* [La page web de cette partie](https://perso.liris.cnrs.fr/fzara/Web/M1Animation.html) * Segmentation (U-Net, etc.)
* Tracking (YOLO)
* Capture du squelette (OpenPose, XNect, etc.)
* Notion de transformer/attention pour la reconnaissance
### Deep learning génératif
* Génération d'images
* auto-encoder
* GAN
* Réseaux de diffusion
* Notions étendues à des données 3D
### Deep learning géometrique
* Apprentissage pour les données géométriques :
* Nuages de points (pointNet, etc.)
* Maillages (MeshConv, etc.)
* Diffusion sur les surfaces
* Représentations neuronales implicites (IGR, SIREN)
* Champs de radiance neuronaux (Nerf)
### Animation de personnage (A. Meyer) - 4h30 CM, 6h30 TP ### Transport optimal
* Animation basée squelette * Introduction au transport optimal
* Déformation de maillage (skinning)
* [La page web de cette partie](https://perso.liris.cnrs.fr/alexandre.meyer/public_html/www/doku.php?id=charanim_m1#master_1_informatique_-_ue_m1if37_animation_en_synthese_d_image)
### Contrôle de mouvement (Nicolas Pronost) - 1h30 CM, 6h30 TP ## Emploi du temps : automne 2024
* Mouvement d'objets rigides articulés
* [La page web de cette partie](controle)
Les cours sont le jeudi après-midi entre octobre et fin janvier.
## Emploi du temps 2023
![documents/M1if37_edt.png](doc/M1if37_edt.png)
* Cours en salle TD10 Nautibus
* TP en salles TP11, TP12 Nautibus
## Modalités de contrôle des connaissances (MCC) ## Modalités de contrôle des connaissances (MCC)
* **1 note de CCF** portant sur les 3 parties du cours - Partie NB : évaluation du TP
* **3 notes de TP** : TP F. Zara, TP A. Meyer, TP N. Pronost (code + rapport + démo ou vidéo) - Partie AM : examen papier et évaluation du TP "génération d'image à partir d'une pose"
- Partie JD : examen papier
* **Dates des évaluations** :
* Examen écrit : mercredi 24 mai 2023 8h-9h30 en C3
* Démo de TP : mercredi 24 mai 2023, de 9h45 à 12h en TP11, TP12
* Date limite de rendu des 3 archives : mercredi 24 mai 2023 12h
* **Modalité de rendu des TPs :** <p style="text-align:justify;">
* Une archive sera à déposer sur TOMUSS (dans les 3 colonnes correspondantes). Cette archive contiendra le code du TP + un rapport.
* Nous vous demandons également de mettre dans les 3 autres colonnes correspondantes de TOMUSS, l'URL pour accéder à une vidéo de votre projet, si vous ne faites pas de démo (car nous ne le compilerons pas forcément, donc il faut montrer tout votre travail).</p>
web/content/am/TP_AEAnimation.md 0 → 100644
View file @ 1715105c
---
title: "Apprentissage et images (partie AM) - TP"
description: "Partie A. Meyer"
---
## Partie (IV) Animation et DL
<!---
Une vidéo courte expliquant quelques principes pour le TP :
<iframe width="560" height="315" src="//www.youtube.com/embed/ZXjhquKAfVs" frameborder="0" allowfullscreen></iframe>
-->
* [Fast Neural Style Transfer for Motion Data](http://www.ipab.inf.ed.ac.uk/cgvu/cga2017.pdf), Holden etal, 2017.
Le papier qui propose une approche équivalente pour transférer le style d'une animation vers une autre. Le contenu est le geste et le style est l'effet donné dans le geste en relation avec l'état émotionnel, la personnalité ou les caractéristiques physiques particulières (ages, force, etc.). Ce Tp se propose de coder une version simplifiée de ce papier. Nous ferons, comme pour les images précédemment, une optimisation. Le papier original propose d'entrainer un réseau à faire ce travail, ce qui serait plus efficace une fois le réseau entrainé mais qui demanderait plusieurs heures de calculs. Pour ce TP l'optimisation ne prendra que quelques minutes, mais ne fournira un transfert qu'entre 2 animations.
### Le code
* [Le code de départ est à télécharger ici.](https://perso.liris.cnrs.fr/alexandre.meyer/teaching/master_charanim/download/StyleTransfer.zip)
* [le code](../doc/tp_style_transfer.zip)
Il faut installer un peu plus de lib que pour pytorch. Panda3D, pyglm, etc. sont nécessaires pour la visualisation des animations. Vous pouvez sûrement pouvoir installer un env avec le fichier .yml fournit
```
conda env create -f environment.yml
```
Ou alors un environnement neuf :
```
conda create --name py-deepan python=3.8
conda activate py-deepan
conda install numpy
conda install pillow
conda install pytorch torchvision torchaudio cudatoolkit=11.3 -c pytorch (mais allez voir la page de pytorch)
conda install multipledispatch
pip install panda3d (==1.10.7)
pip install torchsummary
pip install PyGLM
```
* Vous devez installer le code comme un package pour que les 'import' trouve les fichiers :
```
cd ....StyleTransfer
pip install -e .
```
* En cas de problème pour trouver les données=le chemin vers data (et seulement en cas de problème). Il faut modifier dans ```pydeepan/__init__.py``` la variable tout à la fin après le dernier "else":
```
else:
dir_resources = dir_pydeepan+"/data" # mettez le chemin absolu???
```
* Le programme principal à lancer est
```
**pydeepan/demo/StyleTransferDemo.py**.
```
* 'z' (dés)active l'animation
* 'n' : joue la frame suivante d'une animation
* 'b' : joue la frame précédente d'une animation
* 'p' : passe aux animations suivantes (en restant dans le même dataset)
* 'd' : change de dataset (il y en a deux : StyleTransfer et Emilya)
* 'l' : lance l'optimisation sur les longueurs de membres
* 'e' : passe les animations dans l'auto-encodeur
* 't' : transfert le style d'une animation vers une autre (le code est à compléter)
Une animation est représentée par un tableau de 240 frames x 73 valeurs. Voir le fichier HPAAnimation.py pour une descriptions valeurs de 0 à 65 qui représentent les positions 3D de chaque articulation. Il n'y a pas de notion d'angles dans ce format d'animations. Déplacer une articulation revient souvent à changer la longueur d'un membre. Il y a une optimisation (touche 'l' et class AOSkeletonConstraint.py) qui effectue une descente de gradient (pytorch) pour "remettre" les longueurs de membre aux valeurs initiales.
Remarque : l'autoencoder de ce code est très basique. Il introduit des tremblements pour certaines animations. Il y a surement moyen de faire mieux.
### Tester l'auto-encodeur
Ajouter une action liée à la touche 'r' qui "casse" une animation pour une ou deux articulations (par exemple figer épaule+coude). Puis vous pourrez tester le passage dans l'auto-encoder avec la touche 'e' (e=encodeur). Testez également l'optimisation sur les longueurs de membres. Regardez dans le fichier "HPAAnimation.py" pour une description des articulations.
```
# 42 = coord X de l'épaule gauche. ':' signifie toutes les valeurs. np.mean calcule la moyenne.
self.anims[:,42] = np.mean( self.anims[:,42] )+ 2
```
Vous pouvez également ajouter de l'aléatoire sur certaines articulations. Pas sur toutes en même temps, l'auto-encodeur n'est pas si fort.
### Interpolation dans l'espace caché (espace latent)
* Faites l'interpolation entre l'animation 1 et l'animation 2 dans l'espace 3D, ranger le résultat dans l'animation 3.
* Faites l'interpolation entre l'animation 1 et l'animation 2 dans l'espace latent (l'espace de l'ato-encodeur), ranger le résultat dans l'animation 4.
* Comparez les 2 résultats.
### Transfert de style
Comme pour les images, l'objectif est de produire une nouvelle animation par optimisation de toutes les positions pour toutes les frames. Donc d'optimiser les 240x73 valeurs. Le code à trou réalisant l'optimisation pour transférer le style est dans **pydeepan/chara/AOStyleTransfer.py**. Vous devez compléter les fonctions 'optimize', 'loss' et 'gram'.
* Essayer déjà de partir d'un tableau/animation random est d'optimiser pour produire une animation ayant le même code que l'animation source (sans s'occuper du style). Dans la fonction 'loss', encoder les deux animations et l'erreur sera la différence au carré des deux codes. Il faut jouer sur le 'learning rate'. A la fin, vous obtenez deux animations très différentes mais qui ont le même code. Un passage dans l'auto-encodeur réduit fortement les différences.
* Ajouter maintenant les infos de style de la 2e animation source dans la fonction 'loss'.
web/content/am/TP_Classification.md 0 → 100644
View file @ 1715105c
---
title: "Apprentissage et images (partie AM) - TP"
description: "Partie A. Meyer"
---
## Partie (I.a) Classification de points 2D
Un réseau de neurones est un très bon 'classifier'. Dans un exemple simple, nous voudrions reconnaitre la classe d'un point à partir de ses coordonnées 2D notées (x_1, x_2). Un point peut appartenir à 2 classes : classe 1 par exemple en bleu ou classe 2 par exemple en vert. Le réseau prend en entrée 2 valeurs (x_1, x_2) et sort 2 valeurs (suis-je_bleu?, suis-je_vert?). "suis-je_bleu?" sera représenté par un nombre réel entre 0 et 1 : proche de 0 indiquant que le point n’appartient pas à la classe, proche de 1 indiquant que le point appartient à la classe. Par exemple, une sortie \[0.3, 0.7\] sera tranché en "c'est un point de la classe 2".
L'entrainement du réseau consistera à lui montrer toute une série de coordonnées de points avec les valeurs de classes associées. Le réseau va optimiser ses paramètres (poids) pour que le taux d'erreur devienne le plus petit possible.
### Un neurone
Un neurone artificiel (ou un perceptron) reçoit des valeurs d’entrées, il les multiplie une à une par un poids, puis en fait la somme. Cette somme est passée à une fonction d'activation. Par exemple une fonction d'activation très simple peut-être de comparer la somme à un seuil. Si elle est inférieure, la valeur de sortie sera 0, 1 sinon. L’objectif de l’apprentissage/optimisation est de retrouver les poids qui ferons correspondre au mieux la sortie à partir des entrées sur une base de connaissance disponible.
![Image alt](../images/dl_neuron.png)
### Un réseau
Le principe du réseau de neurones est d’assembler entre-eux des neurones, pour leur faire apprendre des tâches complexes. Les neurones
vont être regroupés en couches, une couche réalisant une tâche donnant un niveau d’abstraction supplémentaire pour la couche suivante. Par
exemple, pour reconnaître une lettre, la couche la plus basse va repérer des morceaux de courbes et la couche supérieure estime que certaines courbes ensembles forme un 'A' et non un 'S'. L’utilisation de plusieurs couches (layer en anglais) est appelée apprentissage profond/Deep Learning.
![Image alt](../images/dl_layer.png)
Voir une explication plus détaillé dans le cours ou éventuellement sur internet, [la page Wikipedia par exemple.](https://fr.wikipedia.org/wiki/R%C3%A9seau_de_neurones_artificiels)
Dans un 1er temps, allez jouer avec ["Playground classifier"](https://playground.tensorflow.org/) pour comprendre le principe de la classification de points avec un réseau de neurones profond.
![Image alt](../images/dl_playground.jpg)
Dans un 2e temps vous allez écrire votre classifier de points avec PyTorch.
#### Les données
Pour notre problème de reconnaitre la couleur d'un point, il faut des données d'apprentissage. [Le code de départ est donné ici](https://github.com/ucacaxm/DeepLearning_Vision_SimpleExamples/blob/master/src/classifier/classifier_pointcloud_empty.py).
Ce code génère des points (les données) procéduralement, donc autant que l'on veut. La classe bleu sont les points dont les coordonnées sont inférieures à cosinus, et la classe verte sont les points au dessus de cosinus. Dans un "vrai" problème, ces données ne peuvent se générer, il faut les trouver quelque part ...
![Image alt](../images/point_cloud.jpg)
#### L'apprentissage
L'apprentissage se passe en différentes phases.
* La définition du réseau.
* La configuration de l'optimisation (optimizer), en général [Stochastic Gradient Descent](https://fr.wikipedia.org/wiki/Algorithme_du_gradient_stochastique) couplé à une fonction d'erreur.
* La phase d'entrainement optimise les poids de chaque neurone à partir des données d'entrée couplées à leur sortie. La fonction d'erreur sert de mesure à faire descendre.
* Une phase d'évaluation **avec des données que le réseau n'a jamais vu** pour mesurer la qualité de l'apprentissage.
Le code ci-dessous donne un réseau minimaliste. Vous devrez l'améliorer pour qu'il soit plus efficace.
```
# voir le code de départ : https://github.com/ucacaxm/DeepLearning_Vision_SimpleExamples/blob/master/src/classifier/classifier_pointcloud_empty.py
########################################################################################"
# Copier/coller juste avant main
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.fc1 = nn.Linear(2, 64)
self.fc2 = nn.Linear(64, 2)
def forward(self, x):
x = F.relu(self.fc1(x))
x = self.fc2(x)
return x
########################################################################################"
############# NETWORK definition/configuration => à copier/coller dans le main
net = Net()
print(net)
############# SGD config: Stochastic Gradient Descent Config
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
############ TRAINNING
for epoch in range(5): # loop over the dataset multiple times
running_loss = 0.0
for i in range(1000): # iterate on mini batches. mani-batch = a subset of the database
inputs, labels = next_batch(128)
inputs = torch.from_numpy(inputs)
labels = torch.from_numpy(labels).long()
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
loss = criterion(outputs, torch.max(labels, 1)[1] )
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
if i % 100 == 99: # print every 2000 mini-batches
print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 100))
running_loss = 0.0
############ EVALUATION
TODO
############ DRAWING POINT CLOUD WITH ERROR
TODO
```
[Regardez la page des tutos de PyTorch](https://pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html#sphx-glr-beginner-blitz-neural-networks-tutorial-py).
#### Le résultat
Le résultat sera le taux de bonne reconnaissance de points, mesuré avec des points jamais observés pendant l'apprentissage. Par exemple après un apprentissage nous obtenons un taux de 96% de bonne classification, les points rouges sur l'image suivante sont les points mal classifiés.
![Image alt](../images/point_cloud_errorclassif.jpg)
Pour rendre le problème un peu plus dur vous pouvez augmenter la plage de génération des points en changeant ceci :
```
x = np.array( [ 2.0*3.141592*np.random.ranf(), 2.0*np.random.ranf()-1 ])
devient
x = np.array( [ 4.0*3.141592*np.random.ranf(), 2.0*np.random.ranf()-1 ])
```
![Image alt](../images/point_cloud_4pi.jpg)
__
## Partie (I.b) Classification d'images
Pour ce 2e problème un peu plus concret, nous disposons d'images et nous voudrions reconnaitre la classe à laquelle elles appartiennent. Par
exemple, pour reconnaitre le nombre à partir de l'image du nombre écrit ou reconnaitre la figure géométrique à partir d'un dessin, ou plus largement reconnaitre une famille d'objets (chat, voiture, avion, fourchette, etc.).
Pour ce type de tâche, le réseau approprié est le ConvNET ou CNN : Convolution Neural Network. Vous pouvez lire des explications sur ce qu'est un CNN dans le cours ou éventuellement sur internet (par exemple une [explication intuitive ici](https://ujjwalkarn.me/2016/08/11/intuitive-explanation-convnets/) ).
Pour du code avec pytorch, [regardez ici](https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html).
![Image alt](../images/convnet.png)
### Les données
Pour ce TP, nous vous invitons à utiliser [une base de données d'images issue d'un projet de L3 qui cherche à reconnaitre 5 formes dessinés](https://github.com/ucacaxm/DeepLearning_Vision_SimpleExamples/blob/master/data/shapes5_preprocessed.zip) : carré, cercle, triangle, sablier, étoile. Il y a que quelques centaines d'images par forme, c'est un bon challenge de voir ce que la reconnaissance donne avec finalement assez peu d'images. Il est également intéressant d'augmenter les données. Dans le cas d'images comme ici, vous pouvez faire de petites rotations aléatoires aux images pour en augmenter le nombre.
Il est également possible d'utiliser différentes base de données plus classiques :
* MNIST : un base de donnée de chiffre manuscrits
* la base de données de caractères [EMNIST](https://www.nist.gov/itl/iad/image-group/emnist-dataset). Elle est disponible également [ici avec les images rangées dans un répertoire dont le nom est le code ascii en hexa](https://s3.amazonaws.com/nist-srd/SD19/by_merge.zip).
* Toutes les bases classiques de reconnaissance de catégorie d'images: [CIFAR-10](https://www.cs.toronto.edu/~kriz/cifar.html) ou CIFAR-100
* Un peu plus de challenge avec [QuickDraw](https://www.kaggle.com/c/quickdraw-doodle-recognition/data|quickdraw-doodle-recognition) : une base de dessins manuels à reconnaitre, 300 classes, 73 Go de données vectoriels et $12000 de récompense ...
Un exemple de code qui charge une base d'images, voir également la doc de [DataLoader](https://pytorch.org/docs/stable/data.html#) :
```
from torchvision import datasets, transforms
from torch.autograd import Variable
import torchvision
from torchvision.datasets import ImageFolder
from torch.utils.data import DataLoader
from torchvision.transforms import ToTensor
from torch.utils.data.sampler import SubsetRandomSampler
class MyTransform(object): # Votre propre fonction de transfo d'images utilisée en preprocessing (si besoin)
def __call__(self, x):
y = preprocess(x)
return y
def imshow(img): # Pour afficher une image
plt.figure(1)
img = img / 2.0 + 0.5 # unnormalize
npimg = img.numpy()
plt.imshow(np.transpose(npimg, (1, 2, 0)))
#plt.imshow(npimg)
plt.show()
transform_img = transforms.Compose([
MyTransform(), # Votre propre fonction de transfo d'images utilisée en preprocessing
transforms.Resize(16),
#transforms.CenterCrop(256),
transforms.ToTensor(),
transforms.Normalize(mean=[0., 0., 0.],
std=[0.5, 0.5, 0.5] )
])
mydata = ImageFolder(root="../data/shapes5_preprocessed", transform=transform_img)
loader = DataLoader(mydata, batch_size=32, shuffle=True, num_workers=1)
```
* [Un très bon tutoriel sur le chargement de données avec PyTorch](https://github.com/ncullen93/torchsample/blob/master/examples/Transforms%20with%20Pytorch%20and%20Torchsample.ipynb)
### Le réseau
Le code d'un réseau ressemble à ceci. Il y a la partie qui extrait les descripteurs (features) et la partie qui classifie.
```
class Classifier(nn.Module):
def __init__(self):
super(Discriminator, self).__init__()
self.features = nn.Sequential(
# 3 input image channel, 6 output channels, 5x5 square convolution
nn.Conv2d(3, 6, 5)
nn.ReLU(),
nn.MaxPool2d(2, 2),
nn.Conv2d(6, 16, 5)
# ... à compléter
# ...
)
self.classifier = nn.Sequential(
nn.Linear(16 * 5 * 5, 120),
nn.ReLU(),
nn.Linear(120, 84),
nn.ReLU(),
nn.Linear(84, 10)
)
print(self.features)
print(self.classifier)
def forward(self, input):
x = self.features(x)
x = x.view(x.size(0), -1)
x = self.classifier(x)
```
## L'entrainement
De manière assez similaire au classifier de nuages de point plus haut, il faut entrainer le réseau en déclarant également le DataLoader, l'optimiseur, la loss, etc. [Regardez le tutorial CIFAR10 de pytorch](https://github.com/pytorch/tutorials/blob/main/beginner_source/blitz/cifar10_tutorial.py)
```
net = Classifier()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
for epoch in range(2): # loop over the dataset multiple times
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
# get the inputs; data is a list of [inputs, labels]
inputs, labels = data
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
if i % 2000 == 1999: # print every 2000 mini-batches
print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 2000:.3f}')
running_loss = 0.0
print('Finished Training')
```
## Conclusion
Il est intéressant de voir que chaque couche de convolutions devient de plus en plus spécifiques à l'objet :
![Image alt](../images/dl_cnn_progression.png)
web/content/am/TP_Dance.md 0 → 100644
View file @ 1715105c
---
title: "Apprentissage et images (partie AM) - TP"
description: "Partie A. Meyer"
---
## TP : Synthèse de l'image d'une personne guidée par une posture
Ce TP vise à implémenter avec PyTorch le transfert de mouvement d'une vidéo source vers une personne cible, en suivant un papier de Chan∗ etal présenté à ICCV 2019 : [Everybody Dance Now](https://openaccess.thecvf.com/content_ICCV_2019/papers/Chan_Everybody_Dance_Now_ICCV_2019_paper.pdf). Cette approche a été choisie pour faire une introduction au GAN, mais le sujet passe par diverses étapes. Pour comprendre le principe, le TP propose une approche qui recherche la donnée la plus proche dans le jeu de données initial (pas de réseau). Puis un réseau simple qui génére une image de la personne à partir du tableau des points d'un squelette de la personne. Et pour finir un réseau prenant en entrée une image "baton" de la personne, qui est "booster" par un discrimineur à la façon des GAN.
Le papier propose différents points pour améliorer la continuité temporelle et les visages, que nous ne regarderons pas.
![Image alt](../images/dance_principe.png)
### Principe général
En entrée, il faut une vidéo de la personne cible effectuant quelques mouvements. Remarque : des approches récentes peuvent se contenter d'une seule image, mais l'idée ici est de pratiquer, pas d'être sur le dernier papier existant.
À partir d'une 2e vidéo d'une personne source, l'objectif est de faire effectuer les mouvements de la personne source à la personne cible. Ceci se fait en produisant une nouvelle vidéo, image par image de la personne cible avec la pose/squelette extrait de la vidéo source. Pour extraire le squelette des vidéos, nous utilisons un réseau pré-entraîné de la bibliothèque [Mediapipe](https://mediapipe-studio.webapps.google.com/studio/demo/pose_landmarker). Le code donné fait déjà ce travail.
Le modèle de machine learning doit apprendre à partir des images de la vidéo comment produire une nouvelle image de cette personne dans une nouvelle posture donnée en paramètre. Si la vidéo de cette personne est suffisamment riche, et contient toutes les postures possibles, on pourrait simplement rechercher l'image dont le squelette est "similaire" (question 1). Ensuite, on va plutôt chercher à avoir un réseau qui va généraliser. Il sera capable de produire une image, même avec une posture qui n'a jamais vraiment été vue. Nous allons essayer un réseau direct, puis un GAN.
### Le code de départ
[Téléchargez l'archive du code initial ici.](../doc/tp_dance_start.zip)
Il faut installer les classiques (numpy, pytorch), mais aussi OpenCV (cv2) et mediapipe.
Les différents fichiers sont les suivants.
* `VideoReader`: des fonctions de bases pour lire une vidéo et récupérer les images (utilise cv2).
* `Vec3` : des points 3D, basé sur un tableau numpy.
* `Skeleton`: une class qui stocke les positions 3D d'un squelette. Il y a 33 articulations (joints) donnés par mediapipe donc 99 floats en tout. Il est possible de passer en mode réduit (`reduced=True` en paramètre de différentes fonctions pour n'avoir que 13 articulations en 2D, donc 26 floats.
* `VideoSkeleton`: une classe qui associe un squelette à chaque image d'une vidéo. Le squelette est stocké en mémoire, mais l'image de la vidéo est représenté par le nom du fichier de l'image (stocker toutes les images d'une vidéo prendrait trop de mémoire si la vidéo est longue). Cette classe découpe une vidéo en images sauvée sur le disque.
* `GenNearest`, `GenVanilla` et `GenGan`: les 3 générateurs d'images à écrire.
* `DanceDemo` : classe pricipale qui exécute une démo de la dance. L'animation/posture de `self.source` est appliquée au personnage défini par `self.target` en utilisant `self.gen`.
Dans les classes `GenXXX` le cœur du problème est la fonction
``` def generator(self, ske): ```
qui renvoie l'image de la personne cible avec comme posture le squelette `ske` recu en paramètre.
Cette génération se fait à partir du dataset comportant un ensemble de paire (image, squelette).
![Image alt](../images/dance_dataset.png)
### Préparer les données
Lancez d'abord le script `VideoSkeleton` qui va produire les images à partir d'une vidéo. Avec les paramètres par défaut, le script produit 1400 images de la vidéo `taichi.mp4` qui comporte 14000 images.
### Plus proche squelette
La solution basique est de chercher dans le dataset qu'elle est l'image dont le squelette associé est le plus proche de celui recherché. Ce point se code dans la fonction `GenNearest::generate`. Cette solution n'est pas efficace : consommation, mémoire, recherche qui peut être longue.
1. Lancez `DemoDance.py`. Il s'agit du progamme principale. L'image cible est blanche pour commencer.
2. Codez `generate` dans la classe `GenNearest.py`
### Réseau direct
L'idée ici est d'entraîner un réseau basique qui produit une image à partir du squelette. Le squelette est représenté par un tableau de nombres. Dans le code `Skeleton`, vous pouvez choisir d'extraire le squelette de taille réduite : 13 articulations en 2D. Le réseau peut donc prendre 26 nombres en entrée et produire une image.
1. Regardez la classe `GenVanillaNN`.
2. Codez `train`
3. Codez `Generate`
![Image alt](../images/dance_genske2im.png)
### Réseau produisant une image du squelette
Le papier propose de travailler avec une image intermédiaire où le squelette est représenté avec des bâtons. Cette image est simple à obtenir. Dans la classe `Skeleton`, la fonction `draw_reduced` prédit une telle image. Changer le réseau précédent pour qu'il prenne en entrée l'image à la place du squelette.
![Image alt](../images/dance_genske2imbaton2im.png)
### GAN
Pour améliorer la qualité du générateur, le papier ajoute un réseau `discrimineur` qui détecte si l'image est une fausse image ou une vraie image. Ce principe est similaire au GAN, même si dans un GAN l'image d'entrée est du bruit.
![Image alt](../images/dance_genGAN.png)
web/content/am/TP_Installation.md 0 → 100644
View file @ 1715105c
---
title: "Apprentissage et images (partie AM) - TP"
description: "Partie A. Meyer"
---
# Installation
## Les outils de dév en local
Nous vous conseillons de faire l'installations de Anaconda. Anaconda est un gestionnaire d'environnements Python. Il vous permet entre autre d'avoir plusieurs installations de Python avec des packages différents sans interférence entre chaque environnement. Si vous avez besoin d'un turorial décrivant l'installation de chaque étape en détails, [regardez ici](https://mrmint.fr/installer-environnement-python-machine-learning-anaconda).
```
conda create --name deepan python=3.8
```
Dans un environnement python, il faut installer *Numpy, MatPlotlib, OpenCV et PyTorch*. Pour installer PyTorch et de nombreuses dépendances, regardez [la ligne de commande que propose PyTorch](https://pytorch.org/get-started/locally/). Puis installer OpenCV et Mediapipe avec
```
pip install mediapipe
```
Mediapipe installe OpenCV. Si vous avez installé OpenCV avant, parfois Mediapipe ne marche pas.
Sous Windows lancez *anaconda prompt*, sous Linux ouvrez un terminal, puis lancez ```conda activate p36```
Votre code va être écrit en Python. Vous pouvez utiliser [VisualCode](https://code.visualstudio.com/docs/languages/python) par exemple ou [l'IDE Spyder](https://www.spyder-ide.org/) qui s'installe avec Anaconda ou [PyCharm](https://www.jetbrains.com/pycharm/) qui est gratuit pour les étudiants. Éventuellement écrire votre code dans un éditeur de code puis lancer votre script comme ceci :
``` python mon_prog.py```
## Colab
![Image alt](../images/colab.jpg)
Ou vous pouvez travailler avec [Colab/Google](https://colab.research.google.com/). Vous trouverez [un tutoriel ici sur medium](https://medium.com/deep-learning-turkey/google-colab-free-gpu-tutorial-e113627b9f5d). Colab permet d'écrire et exécuter du code en ligne, possibilité de le
faire tourner gratuitement sur une Nvidia K80.
web/content/am/TP_Style.md 0 → 100644
View file @ 1715105c
---
title: "Apprentissage et images (partie AM) - TP"
description: "Partie A. Meyer"
---
# Partie (II) Transfert de style entre images
Cette partie est une application pratique des frameworks d'apprentissage profond et des réseaux pré-entrainés. Nous utilisons leur capacité à optimiser (SGD) pour optimiser les pixels d'une image en basant la fonction de perte (loss) sur l'espace latent donné par un réseau pré-entrainé (VGG19).
Ce TP vise à implémenter avec PyTorch le transfert de style d'une image à une autre en suivant un papier de Gatys etal présenté à CVPR 2016 :
[Image Style Transfer Using Convolutional Neural Networks](https://www.cv-foundation.org/openaccess/content_cvpr_2016/html/Gatys_Image_Style_Transfer_CVPR_2016_paper.html). C'est où le deep learning est utilisé comme un outil pour produire des descripteurs pertinents. Ce sujet dispose de nombreux atouts pour un TP en image : utilisation d'un réseau pré-entrainé comme un outil, utilisation du framework de DL/PyTorch pour l'optimisation, code compact, temps de calcul raisonnable (surtout ca) et résultats visuels "rigolo".
[Le code vide peut se trouver ici](https://github.com/ucacaxm/DeepLearning_Vision_SimpleExamples/blob/master/src/style_transfer/StyleTransfer_empty.py).
* [une image de contenu](https://raw.githubusercontent.com/ucacaxm/DeepLearning_Vision_SimpleExamples/master/src/style_transfer/images/montagne_small.jpg)
* [une image de style](https://raw.githubusercontent.com/ucacaxm/DeepLearning_Vision_SimpleExamples/master/src/style_transfer/images/peinture1_small.jpg)
![Image alt](../images/style_contenu.jpg)
![Image alt](../images/style_style.jpg)
Le programme commence par 3 fonctions pour charger et convertir une image :
* *load_image* pour redimensionner et normaliser avec la moyenne/écart type de VGG19;
* *im_convert* de conversion d'un Tensor en une image Numpy ;
* *imshow* pour visualiser une image sortant de *im_convert*.
```
from PIL import Image
import matplotlib.pyplot as plt
import numpy as np
import torch
import torch.optim as optim
from torchvision import transforms, models
def load_image(img_path, max_size=400, shape=None):
''' Load in and transform an image, making sure the image is <= 400 pixels in the x-y dims.'''
image = Image.open(img_path).convert('RGB')
# large images will slow down processing
if max(image.size) > max_size:
size = max_size
else:
size = max(image.size)
if shape is not None:
size = shape
in_transform = transforms.Compose([
transforms.Resize(size),
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406),
(0.229, 0.224, 0.225))])
# discard the transparent, alpha channel (that's the :3) and add the batch dimension
image = in_transform(image)[:3,:,:].unsqueeze(0)
return image
# helper function for un-normalizing an image and converting it from a Tensor image to a NumPy image for display
def im_convert(tensor):
image = tensor.to("cpu").clone().detach()
image = image.numpy().squeeze()
image = image.transpose(1,2,0)
image = image * np.array((0.229, 0.224, 0.225)) + np.array((0.485, 0.456, 0.406))
image = image.clip(0, 1)
return image
def imshow(img): # Pour afficher une image
plt.figure(1)
plt.imshow(img)
plt.show()
if __name__ == '__main__':
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
#device = torch.device("cpu")
print(device)
########################## DISPLAY IMAGE#########################################################""
content = load_image('images/mer.jpg').to(device)
style = load_image('images/peinture1.jpg', shape=content.shape[-2:]).to(device)
imshow(im_convert(content))
imshow(im_convert(style))
```
Nous allons réutiliser un réseau VGG déjà entrainé. [VGG est un réseau qui combine les convolutions afin d'être efficace pour de la reconnaissance d'images](http://www.robots.ox.ac.uk/~vgg/research/very_deep/) (ImageNet Challenge). Quand nous allons optimiser le transfert de style, nous ne voulons plus optimiser les couches du réseau VGG. Ceci se réalise en passant à False le besoin en gradient des paramètres. Vous pouvez donc charger le réseaux avec PyTorch comme ceci, neutraliser les couches et afficher toutes les couches comme ceci :
```
vgg = models.vgg19(pretrained=True).features
# freeze all VGG parameters since we're only optimizing the target image
for param in vgg.parameters():
param.requires_grad_(False)
features = list(vgg)[:23]
for i,layer in enumerate(features):
print(i," ",layer)
```
Pour récupérer les caractéristiques intermédiaires d'une image qui passe dans un réseau VGG vous pouvez le faire comme ceci :
```
### Run an image forward through a model and get the features for a set of layers. 'model' is supposed to be vgg19
def get_features(image, model, layers=None):
if layers is None:
layers = {'0': 'conv0',
'5': 'conv5',
'10': 'conv10',
'19': 'conv19', ## content representation
}
features = {}
x = image
# model._modules is a dictionary holding each module in the model
for name, layer in model._modules.items():
x = layer(x)
if name in layers:
features[layers[name]] = x
return features
```
Nous allons maintenant créer l'image cible qui va être une copie de l'image de contenu et dont les pixels seront à optimiser :
```
target = content.clone().requires_grad_(True).to(device)
```
Vous devez écrire la fonction *gram_matrix* qui calcule la [matrice de Gram](https://en.wikipedia.org/wiki/Gramian_matrix) à partir d'un
tensor. Vous pouvez regarder la documentation de la fonction [torch.mm](https://pytorch.org/docs/stable/torch.html#torch.mm) qui
multiplie deux matrices, et la fonction [torch.transpose](https://pytorch.org/docs/stable/torch.html#torch.transpose).
La fonction [torch.Tensor.view](https://pytorch.org/docs/stable/tensors.html#torch.Tensor.view) permet de changer la "vue" pour par exemple passer d'un tenseur 2D à un tenseur 1D, ou d'un 3D vers un 2D, etc.
```
def gram_matrix(tensor):
# tensor: Nfeatures x H x W ==> M = Nfeatures x Npixels with Npixel=HxW
...
return gram
```
Écrivez le calcul de coût pour le contenu. Vous pouvez utiliser \[\[\|torch.mean\]\] avec les features extraits de la couche 'conv19'
qui d'après l'article correspondent globalement au contenu. Attention, les noms de couches ne correspondent pas à l'article.
Écrivez le calcul du coût pour le style. Il va se calculer de la même manière mais vous allez itérer sur les features des autres couches. A tester un peu par essai/erreur (ou regardez l'article).
Le coût total (celui qui sera optimisé) se calcule en faisant la moyenne pondérée entre le coût de style et le coût de contenu. A tester un peu par essai/erreur (ou regardez l'article).
La partie optimisation va donc ressembler à ceci.
```
optimizer = optim.Adam([target], lr=0.003)
for i in range(50):
# get the features from your target image
# the content loss
# the style loss
# calculate the *total* loss
# update your target image
optimizer.zero_grad()
total_loss.backward()
optimizer.step()
```
## Pour aller plus loin sur le transfert de style entre images
[Un blog qui décrit bien les évolutions de la recherche après l'approche de Gatys](https://dudeperf3ct.github.io/style/transfer/2018/12/23/Magic-of-Style-Transfer/). Donne des explications également autour des approches de normalisation, AdaIN.
web/content/am/TP_nnFromScratch.md 0 → 100644
View file @ 1715105c
---
title: "Apprentissage et images (partie AM) - TP"
description: "Partie A. Meyer"
---
## Tutorial (TP)
The aim of this tutorial is to implement from scratch a simple neural network trained by backpropagation. This will be a formative introduction to more advanced frameworks (such as PyTorch) where learning is automated.
[All steps are described in the start code here.](https://raw.githubusercontent.com/ucacaxm/DeepLearning_Vision_SimpleExamples/refs/heads/master/src/dl_from_scratch/DLNetworkFromScratch_EXO.py)
## Documents to read
In addition to the course slides:
* [A simple NN 2D->2D](https://github.com/ucacaxm/DeepLearning_Vision_SimpleExamples/blob/master/src/dl_from_scratch/DLNetworkUltraSimple2dto2D.py)
* [The equations behind backpropagation with code and explanations](http://neuralnetworksanddeeplearning.com/chap2.html#the_four_fundamental_equations_behind_backpropagation)
* [The backpropagation equations][doc/backpropagation-from-scratch.pdf]
* [Introduction-au-deep-learning(Miximum)](https://www.miximum.fr/blog/introduction-au-deep-learning-2/)
## Solutions
* [Correction](https://raw.githubusercontent.com/ucacaxm/DeepLearning_Vision_SimpleExamples/refs/heads/master/src/dl_from_scratch/DLNetworkFromScratch.py)
Variant
* [From Miximum](https://raw.githubusercontent.com/ucacaxm/DeepLearning_Vision_SimpleExamples/refs/heads/master/src/dl_from_scratch/DLNetworkFromScratch_WEB1.py)
* [From Miximum](https://raw.githubusercontent.com/ucacaxm/DeepLearning_Vision_SimpleExamples/refs/heads/master/src/dl_from_scratch/DLNetworkFromScratch_WEB2.py)
web/content/am/_index.md 0 → 100644
View file @ 1715105c
---
title: "Vision and machine learning (partie AM)"
description: "Partie A. Meyer"
---
## The foundations of Deep Learning for images
* [Alexandre Meyer](https://perso.liris.cnrs.fr/alexandre.meyer)
<!---
* [L'ancienne page de cette partie](https://perso.liris.cnrs.fr/alexandre.meyer/public_html/www/doku.php?id=image_deeplearning)
-->
![Image alt](images/dl_am.jpg)
### Le Cours
* [CM1](doc/DLIM-CM1_NN.pdf): Introduction to neural networks
* [CM2](doc/DLIM-CM2_CNN.pdf): ConvNN
* [CM3](doc/DLIM-CM3_Vision.pdf): the “modern” vision (Segmentation, Tracking (YOLO), AE, GAN)
<!---
- La vidéo du CM de la 1ère partie : TODO
- La vidéo du CM de la 2e partie
<iframe width="560" height="315" src="//www.youtube.com/embed/ge7V2C7eVWk" frameborder="0" allowfullscreen></iframe>
-->
### Tutorials (TP)
0. [Installation](tp_installation)
1. [A neural network from scratch](tp_nnfromscratch)
2. [Classification](tp_classification) with Pytorch
3. [Style transfer between images](tp_style)
4. [Gesture transfer and person image generation](tp_dance)
* [Old TP: autoencoder and animation](tp_aeanimation)
web/content/am/doc/DLIM-CM1_NN.pdf 0 → 100644
View file @ 1715105c
File added
web/static/doc_controle/tp.zip → web/content/am/doc/DLIM-CM3_Vision.pdf
View file @ 1715105c
No preview for this file type
web/content/am/doc/backpropagation-from-scratch.pdf 0 → 100644
View file @ 1715105c
File added
web/content/am/doc/tp_dance_start.zip 0 → 100644
View file @ 1715105c
File added
web/content/am/images/colab.jpg 0 → 100644
View file @ 1715105c
web/content/am/images/colab.jpg

5.29 KiB

web/content/am/images/convnet.png 0 → 100644
View file @ 1715105c
web/content/am/images/convnet.png

82.8 KiB

web/content/am/images/dance_dataset.png 0 → 100644
View file @ 1715105c
web/content/am/images/dance_dataset.png

21.9 KiB

web/content/am/images/dance_genGAN.png 0 → 100644
View file @ 1715105c
web/content/am/images/dance_genGAN.png

35.5 KiB