diff --git a/notebook.ipynb b/notebook.ipynb index a9309b4..80ad555 100644 --- a/notebook.ipynb +++ b/notebook.ipynb @@ -1 +1 @@ -{"cells":[{"cell_type":"markdown","metadata":{"id":"arqpDh95Zt6W"},"source":["# Wasserstein GAN\n","\n","L'objectif de ce projet était d'étudier les GANs dans le cas de la distance de Wasserstein.\n","\n","Voici les membres de notre groupe classés par ordres alphabétiques pour leur nom de famille :\n","- Paul Corbalan\n","- Nicolas Gonel\n","- Oihan Joyot\n","- Tristan Portugues\n","- Florian Zorzynski\n","\n","Notre projet s'inspire grandement des ressources suivantes qui sont l'article initial de notre projet ainsi que le code correspondant.\n","- Article : [[1701.07875] Wasserstein GAN (arxiv.org)](https://arxiv.org/abs/1701.07875)\n","- Code : [martinarjovsky/WassersteinGAN (github.com)](https://github.com/martinarjovsky/WassersteinGAN)\n","\n","Un répertoire pour ce projet en général est disponible à l'adresse suivante :\n","https://github.com/paul-corbalan/wasserstein-gan\n","\n","---"]},{"cell_type":"markdown","metadata":{"id":"Hke_hyXT3bSP"},"source":["## Introduction\n","\n","Les Réseaux Antagonistes Génératifs (GANs) représentent une avancée majeure dans le domaine de l'apprentissage profond, révolutionnant la manière dont les machines comprennent et génèrent des données, en particulier des images. Cette technologie imite la façon dont les humains apprennent et créent, ouvrant des portes vers des applications innovantes allant de l'art numérique à des solutions médicales avancées. Le projet \"Wasserstein GAN\" s'inscrit dans cette perspective, visant à explorer une variante spécifique des GANs qui utilise la distance de Wasserstein pour améliorer la stabilité et la qualité des résultats.\n","\n","Le choix de la distance de Wasserstein comme métrique clé dans notre projet offre un avantage distinct sur les méthodes traditionnelles. Elle permet de surmonter certains des défis inhérents aux GANs classiques, comme le mode collapse et les problèmes de convergence. En se concentrant sur cette approche, notre projet cherche à démontrer comment une compréhension approfondie de la théorie mathématique peut être appliquée efficacement pour améliorer la performance et la fiabilité des modèles génératifs.\n","\n","Ce notebook est conçu pour servir d'outil d'apprentissage et d'exploration dans le domaine des GANs, avec un accent particulier sur les Wasserstein GANs. Il guide le lecteur à travers les principes fondamentaux, les défis et les solutions uniques associés à cette technologie, offrant un mélange d'explications théoriques et d'applications pratiques. L'objectif est de fournir une base solide pour comprendre et utiliser les Wasserstein GANs."]},{"cell_type":"markdown","metadata":{"id":"P_O5MYE_xMU5"},"source":["## Generative Adversarial Network (GAN)\n","\n","Les GANs sont des modèles d'apprentissage profond définis par deux réseaux neuronaux, le générateur $G$ et le discriminateur $D$.\n","\n"," Le générateur crée des données, tandis que le discriminateur les évalue. L'objectif du générateur est d'approcher un distribution $\\mathbb{P}_g$ inconnue telle que les données générées $G(z)$ soient indiscernables des données réelles $x$, où $z$ un vecteur de notre espace latent. Le discriminateur est entraîné à faire la distinction entre un inputs et $x$.\n","\n"," Les deux modèles sont mis en compétition et $G$ cherche à minimiser la probabilité que $D$ fasse la distinction entre $G(z)$ et $x$, tandis que $D$ cherche à maximiser cette probabilité.\n","\n","Formellement, cela correspond à résoudre le problème min-max pour :\n","$$V(D, G) = \\mathbb{E}_{x \\sim \\mathbb{P}_{r}}[\\log D(x)] + \\mathbb{E}_{z \\sim \\mathbb{P}_z}[\\log(1 - D(G(z)))]$$\n","où le problème est le suivant :\n","$$\n","\\min _G \\max _D V(D, G)\n","$$\n","\n"," Cette minimisation utilise la log-vraissemblance négative et est la solution d'origine pour arriver à un équilibre entre le générateur et le discriminateur. Cependant cette méthode peut présenter plusieurs problèmes:\n"," - des \"modes collapse\" où l'entraînement converge vers une solution oubliant certaines particularités de la distibution cherché.\n"," - des gradients évanescents, lorsque le discriminateur devient trop parfait, il devient impossible de générer un gradient utilisable à partir de la sortie du discriminateur.\n","\n"," On va donc chercher un moyen de résoudre ces problèmes en changeant de fonction de perte et on va essayer d'utiliser la distance de wasserstein."]},{"cell_type":"markdown","metadata":{"id":"yIx0TILzG6-l"},"source":["## Distance de Wasserstein\n","\n","### Définition\n","\n","En mathématiques, la distance de Wasserstein est une fonction définie entre des distributions de probabilité sur un espace métrique donné $(M,d)$. La distance de Wasserstein d'ordre $p \\in \\left[1,+\\infty \\right]$ entre deux mesures de probabilité $\\mu$ et $\\nu$ définies sur $M$ (avec des moments finis de l'ordre $p$) est définie par :\n","\n","\\begin{equation}\n","\\begin{split}\n","{\\displaystyle W_{p}(\\mu ,\\nu )=\\left(\\inf _{\\gamma \\in \\Gamma (\\mu ,\\nu )}\\mathbf {E} _{(x,y)\\sim \\gamma }d(x,y)^{p}\\right)^{1/p}.}\n","\\end{split}\n","\\end{equation}\n","\n","L'infimum est pris sur $\\Gamma (\\mu,\\nu )$, l'ensemble de tous les couplages dont les distributions marginales sont respectivement $\\mu$ et $\\nu$.\n","\n","### Interprétation physique\n","\n","Cette métrique est également connue sous le nom de earth mover distance. De manière intuitive, si l'on imagine chaque distribution comme une unité de terre empilée sur un espace métrique $M$, la métrique représente le coût minimal pour remodeler une pile en une autre. Ce coût est conçu comme la quantité de terre à déplacer, multipliée par la distance moyenne qu'elle doit parcourir.\n","\n","En d'autres termes, la distance de Wasserstein fournit une mesure précise du coût minimal nécessaire pour transformer une distribution de probabilité en une autre, tout en minimisant le coût total de ce déplacement. C'est pourquoi l'avantage de cette distance réside dans son incorporation des concepts de transport optimal et de couplage, tous deux pertinents et pratiques pour l'étude.\n","\n","### Utilisation pour les images numériques\n","\n","Pour résumer, la distance de Wasserstein est une manière naturelle de comparer les distributions de probabilité de deux variables, où une variable est dérivée de l'autre par de petites perturbations non uniformes (aléatoires ou déterministes). C'est pourquoi, en informatique, cette métrique est largement utilisée pour comparer des distributions discrètes, notamment les histogrammes de couleur de deux images numériques.\n","\n","\n","### Calcul numérique\n","\n","Le problème principal de cette distance est son calcul, l'infimum étant très compliqué à calculer. Heureusement, la dualité de Kantorovich-Rubinstein nous donne :\n","\\begin{equation}\n","W(\\mathbb{P}_r, \\mathbb{P}_{\\theta})=\\frac{1}{K}\\sup_{||f|| 0.7:\n"," print(f\"Image {filename} is predicted as a human face and will be moved.\")\n"," shutil.copy(os.path.join(folder_path, filename), 'predicted_humans')\n","\n","\n","predict_and_move(\"..\")"]},{"cell_type":"markdown","metadata":{"id":"Pl2UlIxJMb-s"},"source":["![confusion.svg](data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->

<svg
   version="1.1"
   id="svg1"
   width="614.40002"
   height="460.79999"
   viewBox="0 0 614.40002 460.79999"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:svg="http://www.w3.org/2000/svg">
  <defs
     id="defs1">
    <clipPath
       clipPathUnits="userSpaceOnUse"
       id="clipPath4">
      <path
         d="M 57.6,38.016 H 414.72 V 304.128 H 57.6 Z"
         id="path4" />
    </clipPath>
    <clipPath
       clipPathUnits="userSpaceOnUse"
       id="clipPath6">
      <path
         d="M 57.6,38.016 H 414.72 V 304.128 H 57.6 Z"
         id="path6" />
    </clipPath>
    <clipPath
       clipPathUnits="userSpaceOnUse"
       id="clipPath8">
      <path
         d="M 57.6,38.016 H 414.72 V 304.128 H 57.6 Z"
         id="path8" />
    </clipPath>
    <clipPath
       clipPathUnits="userSpaceOnUse"
       id="clipPath10">
      <path
         d="M 57.6,38.016 H 414.72 V 304.128 H 57.6 Z"
         id="path10" />
    </clipPath>
  </defs>
  <g
     id="g1">
    <path
       id="path1"
       d="M 0,0 H 460.8 V 345.6 H 0 Z"
       style="fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none"
       transform="matrix(1.3333333,0,0,-1.3333333,0,460.8)" />
    <path
       id="path2"
       d="M 57.6,38.016 H 414.72 V 304.128 H 57.6 Z"
       style="fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none"
       transform="matrix(1.3333333,0,0,-1.3333333,0,460.8)" />
    <path
       id="path3"
       d="M 57.6,304.128 H 236.16 V 171.072 H 57.6 v 133.056"
       style="fill:#b2d2e8;fill-opacity:1;fill-rule:nonzero;stroke:none"
       transform="matrix(1.3333333,0,0,-1.3333333,0,460.8)"
       clip-path="url(#clipPath4)" />
    <path
       id="path5"
       d="M 236.16,304.128 H 414.72 V 171.072 H 236.16 v 133.056"
       style="fill:#f2f8fd;fill-opacity:1;fill-rule:nonzero;stroke:none"
       transform="matrix(1.3333333,0,0,-1.3333333,0,460.8)"
       clip-path="url(#clipPath6)" />
    <path
       id="path7"
       d="M 57.6,171.072 H 236.16 V 38.016 H 57.6 v 133.056"
       style="fill:#f7fbff;fill-opacity:1;fill-rule:nonzero;stroke:none"
       transform="matrix(1.3333333,0,0,-1.3333333,0,460.8)"
       clip-path="url(#clipPath8)" />
    <path
       id="path9"
       d="M 236.16,171.072 H 414.72 V 38.016 H 236.16 v 133.056"
       style="fill:#08306b;fill-opacity:1;fill-rule:nonzero;stroke:none"
       transform="matrix(1.3333333,0,0,-1.3333333,0,460.8)"
       clip-path="url(#clipPath10)" />
    <path
       id="path11"
       d="m 146.88,38.016 v -3.5"
       style="fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:#000000;stroke-width:0.8;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none;stroke-opacity:1"
       transform="matrix(1.3333333,0,0,-1.3333333,0,460.8)" />
    <text
       id="text11"
       xml:space="preserve"
       transform="matrix(1.3333333,0,0,1.3333333,156.07958,429.57033)"><tspan
         style="font-variant:normal;font-weight:normal;font-size:10px;font-family:'DejaVu Sans';writing-mode:lr-tb;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none"
         x="0 7.48 13.6 19.940001 23.549999 31.07 37.41 47.150002 53.279999"
         y="0"
         id="tspan11">Non-Human</tspan></text>
    <path
       id="path12"
       d="m 325.44,38.016 v -3.5"
       style="fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:#000000;stroke-width:0.8;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none;stroke-opacity:1"
       transform="matrix(1.3333333,0,0,-1.3333333,0,460.8)" />
    <text
       id="text12"
       xml:space="preserve"
       transform="matrix(1.3333333,0,0,1.3333333,409.86792,429.57033)"><tspan
         style="font-variant:normal;font-weight:normal;font-size:10px;font-family:'DejaVu Sans';writing-mode:lr-tb;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none"
         x="0 7.52 13.86 23.6 29.73"
         y="0"
         id="tspan12">Human</tspan></text>
    <text
       id="text13"
       xml:space="preserve"
       transform="matrix(1.3333333,0,0,1.3333333,283.5675,447.7995)"><tspan
         style="font-variant:normal;font-weight:normal;font-size:10px;font-family:'DejaVu Sans';writing-mode:lr-tb;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none"
         x="0 5.8581252 9.7493753 15.899375 22.249374 25.029375 30.529375 34.449375 40.599377"
         y="0"
         id="tspan13">Predicted</tspan></text>
    <path
       id="path13"
       d="M 57.6,237.6 H 54.1"
       style="fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:#000000;stroke-width:0.8;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none;stroke-opacity:1"
       transform="matrix(1.3333333,0,0,-1.3333333,0,460.8)" />
    <text
       id="text14"
       xml:space="preserve"
       transform="matrix(0,-1.3333333,1.3333333,0,64.695833,183.76042)"><tspan
         style="font-variant:normal;font-weight:normal;font-size:10px;font-family:'DejaVu Sans';writing-mode:lr-tb;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none"
         x="0 7.48 13.6 19.940001 23.549999 31.07 37.41 47.150002 53.279999"
         y="0"
         id="tspan14">Non-Human</tspan></text>
    <path
       id="path14"
       d="M 57.6,104.544 H 54.1"
       style="fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:#000000;stroke-width:0.8;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none;stroke-opacity:1"
       transform="matrix(1.3333333,0,0,-1.3333333,0,460.8)" />
    <text
       id="text15"
       xml:space="preserve"
       transform="matrix(0,-1.3333333,1.3333333,0,64.695833,345.46008)"><tspan
         style="font-variant:normal;font-weight:normal;font-size:10px;font-family:'DejaVu Sans';writing-mode:lr-tb;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none"
         x="0 7.52 13.86 23.6 29.73"
         y="0"
         id="tspan15">Human</tspan></text>
    <text
       id="text16"
       xml:space="preserve"
       transform="matrix(0,-1.3333333,1.3333333,0,46.466667,246.84983)"><tspan
         style="font-variant:normal;font-weight:normal;font-size:10px;font-family:'DejaVu Sans';writing-mode:lr-tb;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none"
         x="0 4.6412501 8.7512503 15.09125"
         y="0"
         id="tspan16">True</tspan></text>
    <text
       id="text17"
       xml:space="preserve"
       transform="matrix(1.3333333,0,0,1.3333333,183.12125,147.67708)"><tspan
         style="font-variant:normal;font-weight:normal;font-size:10px;font-family:'DejaVu Sans';writing-mode:lr-tb;fill:#262626;fill-opacity:1;fill-rule:nonzero;stroke:none"
         x="0 6.3600001 12.72"
         y="0"
         id="tspan17">676</tspan></text>
    <text
       id="text18"
       xml:space="preserve"
       transform="matrix(1.3333333,0,0,1.3333333,421.20125,147.67708)"><tspan
         style="font-variant:normal;font-weight:normal;font-size:10px;font-family:'DejaVu Sans';writing-mode:lr-tb;fill:#262626;fill-opacity:1;fill-rule:nonzero;stroke:none"
         x="0 6.3600001 12.72"
         y="0"
         id="tspan18">180</tspan></text>
    <text
       id="text19"
       xml:space="preserve"
       transform="matrix(1.3333333,0,0,1.3333333,183.12125,325.08508)"><tspan
         style="font-variant:normal;font-weight:normal;font-size:10px;font-family:'DejaVu Sans';writing-mode:lr-tb;fill:#262626;fill-opacity:1;fill-rule:nonzero;stroke:none"
         x="0 6.3600001 12.72"
         y="0"
         id="tspan19">139</tspan></text>
    <text
       id="text20"
       xml:space="preserve"
       transform="matrix(1.3333333,0,0,1.3333333,416.96167,325.08508)"><tspan
         style="font-variant:normal;font-weight:normal;font-size:10px;font-family:'DejaVu Sans';writing-mode:lr-tb;fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none"
         x="0 6.3600001 12.72 19.08"
         y="0"
         id="tspan20">1841</tspan></text>
    <text
       id="text21"
       xml:space="preserve"
       transform="matrix(1.3333333,0,0,1.3333333,247.34875,47.296)"><tspan
         style="font-variant:normal;font-weight:normal;font-size:12px;font-family:'DejaVu Sans';writing-mode:lr-tb;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none"
         x="0 8.3760004 15.72 23.327999 27.552 35.16 41.411999 44.748001 52.091999 59.700001 63.515999 73.872002 81.227997 85.931999 90.863998 94.199997"
         y="0"
         id="tspan21">Confusion Matrix</tspan></text>
  </g>
</svg>
)"]},{"cell_type":"markdown","metadata":{"id":"vEH1G2zSIZ3p"},"source":["L'ensemble de données a ensuite été mis à l'échelle pour appliquer le filtre de convolution à l'aide de la commande :\n","```shell\n","convert *.png resized 400% *upscaled*/*.png\n","```\n","\n","Les données finales peuvent être téléchargées sur :\n","https://github.com/paul-corbalan/wasserstein-gan/blob/develop/data/predicted_humans.zip"]},{"cell_type":"markdown","metadata":{"id":"xA3azaz1US4k"},"source":["## Architecture du modèle GAN\n","\n","Dans cette partie sont décrites les architectures du discriminateur et du générateur de notre modèle."]},{"cell_type":"markdown","metadata":{"id":"dxaMaimlY21r"},"source":["### Discriminateur"]},{"cell_type":"markdown","metadata":{"id":"dFj_wV-i4dIG"},"source":["![netD_architecture.svg](data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
 "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<!-- Generated by graphviz version 8.1.0 (20230707.0739)
 -->
<!-- Pages: 1 -->
<svg width="776pt" height="864pt"
 viewBox="0.00 0.00 776.48 864.00" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
<g id="graph0" class="graph" transform="scale(0.977929 0.977929) rotate(0) translate(4 879.5)">
<polygon fill="white" stroke="none" points="-4,4 -4,-879.5 790,-879.5 790,4 -4,4"/>
<!-- 140244940585680 -->
<g id="node1" class="node">
<title>140244940585680</title>
<polygon fill="#caff70" stroke="black" points="684,-34.25 630,-34.25 630,0 684,0 684,-34.25"/>
<text text-anchor="middle" x="657" y="-8.75" font-family="monospace" font-size="10.00"> (1)</text>
</g>
<!-- 140244943583744 -->
<g id="node2" class="node">
<title>140244943583744</title>
<polygon fill="lightgrey" stroke="black" points="653,-98.5 559,-98.5 559,-76.25 653,-76.25 653,-98.5"/>
<text text-anchor="middle" x="606" y="-85" font-family="monospace" font-size="10.00">ViewBackward0</text>
</g>
<!-- 140244943583744&#45;&gt;140244940585680 -->
<g id="edge27" class="edge">
<title>140244943583744&#45;&gt;140244940585680</title>
<path fill="none" stroke="black" d="M613.75,-76.01C620.21,-67.36 629.7,-54.66 638.14,-43.37"/>
<polygon fill="black" stroke="black" points="641.43,-45.81 644.61,-35.71 635.82,-41.62 641.43,-45.81"/>
</g>
<!-- 140244943583552 -->
<g id="node3" class="node">
<title>140244943583552</title>
<polygon fill="lightgrey" stroke="black" points="704,-162.75 610,-162.75 610,-140.5 704,-140.5 704,-162.75"/>
<text text-anchor="middle" x="657" y="-149.25" font-family="monospace" font-size="10.00">MeanBackward1</text>
</g>
<!-- 140244943583552&#45;&gt;140244943583744 -->
<g id="edge1" class="edge">
<title>140244943583552&#45;&gt;140244943583744</title>
<path fill="none" stroke="black" d="M648.35,-140.07C640.98,-131.07 630.21,-117.92 621.37,-107.14"/>
<polygon fill="black" stroke="black" points="623.57,-105.3 614.52,-99.78 618.15,-109.73 623.57,-105.3"/>
</g>
<!-- 140244940585584 -->
<g id="node29" class="node">
<title>140244940585584</title>
<polygon fill="#a2cd5a" stroke="black" points="747,-104.5 671,-104.5 671,-70.25 747,-70.25 747,-104.5"/>
<text text-anchor="middle" x="709" y="-79" font-family="monospace" font-size="10.00"> (1, 1, 1)</text>
</g>
<!-- 140244943583552&#45;&gt;140244940585584 -->
<g id="edge28" class="edge">
<title>140244943583552&#45;&gt;140244940585584</title>
<path fill="none" stroke="black" d="M665.82,-140.07C672.03,-132.63 680.61,-122.36 688.49,-112.93"/>
<polygon fill="black" stroke="black" points="691.71,-115.53 695.44,-105.61 686.34,-111.04 691.71,-115.53"/>
</g>
<!-- 140244943584032 -->
<g id="node4" class="node">
<title>140244943584032</title>
<polygon fill="lightgrey" stroke="black" points="725,-221 589,-221 589,-198.75 725,-198.75 725,-221"/>
<text text-anchor="middle" x="657" y="-207.5" font-family="monospace" font-size="10.00">ConvolutionBackward0</text>
</g>
<!-- 140244943584032&#45;&gt;140244943583552 -->
<g id="edge2" class="edge">
<title>140244943584032&#45;&gt;140244943583552</title>
<path fill="none" stroke="black" d="M657,-198.29C657,-191.46 657,-182.32 657,-174.02"/>
<polygon fill="black" stroke="black" points="660.5,-174.16 657,-164.16 653.5,-174.16 660.5,-174.16"/>
</g>
<!-- 140244943578080 -->
<g id="node5" class="node">
<title>140244943578080</title>
<polygon fill="lightgrey" stroke="black" points="649,-279.25 525,-279.25 525,-257 649,-257 649,-279.25"/>
<text text-anchor="middle" x="587" y="-265.75" font-family="monospace" font-size="10.00">LeakyReluBackward1</text>
</g>
<!-- 140244943578080&#45;&gt;140244943584032 -->
<g id="edge3" class="edge">
<title>140244943578080&#45;&gt;140244943584032</title>
<path fill="none" stroke="black" d="M600.17,-256.54C610.14,-248.53 624.05,-237.35 635.61,-228.06"/>
<polygon fill="black" stroke="black" points="637.29,-230.4 642.89,-221.41 632.91,-224.94 637.29,-230.4"/>
</g>
<!-- 140244943583984 -->
<g id="node6" class="node">
<title>140244943583984</title>
<polygon fill="lightgrey" stroke="black" points="662,-343.5 502,-343.5 502,-321.25 662,-321.25 662,-343.5"/>
<text text-anchor="middle" x="582" y="-330" font-family="monospace" font-size="10.00">NativeBatchNormBackward0</text>
</g>
<!-- 140244943583984&#45;&gt;140244943578080 -->
<g id="edge4" class="edge">
<title>140244943583984&#45;&gt;140244943578080</title>
<path fill="none" stroke="black" d="M582.85,-320.82C583.52,-312.45 584.48,-300.49 585.31,-290.18"/>
<polygon fill="black" stroke="black" points="588.85,-290.78 586.16,-280.53 581.87,-290.22 588.85,-290.78"/>
</g>
<!-- 140244943582592 -->
<g id="node7" class="node">
<title>140244943582592</title>
<polygon fill="lightgrey" stroke="black" points="514,-407.75 378,-407.75 378,-385.5 514,-385.5 514,-407.75"/>
<text text-anchor="middle" x="446" y="-394.25" font-family="monospace" font-size="10.00">ConvolutionBackward0</text>
</g>
<!-- 140244943582592&#45;&gt;140244943583984 -->
<g id="edge5" class="edge">
<title>140244943582592&#45;&gt;140244943583984</title>
<path fill="none" stroke="black" d="M469.07,-385.07C491.05,-375 524.37,-359.75 549.12,-348.42"/>
<polygon fill="black" stroke="black" points="550.18,-351.33 557.82,-343.99 547.27,-344.97 550.18,-351.33"/>
</g>
<!-- 140244943584848 -->
<g id="node8" class="node">
<title>140244943584848</title>
<polygon fill="lightgrey" stroke="black" points="393,-472 269,-472 269,-449.75 393,-449.75 393,-472"/>
<text text-anchor="middle" x="331" y="-458.5" font-family="monospace" font-size="10.00">LeakyReluBackward1</text>
</g>
<!-- 140244943584848&#45;&gt;140244943582592 -->
<g id="edge6" class="edge">
<title>140244943584848&#45;&gt;140244943582592</title>
<path fill="none" stroke="black" d="M350.51,-449.32C368.68,-439.48 396.02,-424.68 416.79,-413.43"/>
<polygon fill="black" stroke="black" points="418.27,-416.08 425.4,-408.24 414.94,-409.92 418.27,-416.08"/>
</g>
<!-- 140244943582448 -->
<g id="node9" class="node">
<title>140244943582448</title>
<polygon fill="lightgrey" stroke="black" points="399,-542.25 239,-542.25 239,-520 399,-520 399,-542.25"/>
<text text-anchor="middle" x="319" y="-528.75" font-family="monospace" font-size="10.00">NativeBatchNormBackward0</text>
</g>
<!-- 140244943582448&#45;&gt;140244943584848 -->
<g id="edge7" class="edge">
<title>140244943582448&#45;&gt;140244943584848</title>
<path fill="none" stroke="black" d="M320.82,-519.76C322.53,-510.04 325.14,-495.21 327.29,-483"/>
<polygon fill="black" stroke="black" points="330.88,-483.79 329.16,-473.34 323.98,-482.58 330.88,-483.79"/>
</g>
<!-- 140244943583264 -->
<g id="node10" class="node">
<title>140244943583264</title>
<polygon fill="lightgrey" stroke="black" points="251,-606.5 115,-606.5 115,-584.25 251,-584.25 251,-606.5"/>
<text text-anchor="middle" x="183" y="-593" font-family="monospace" font-size="10.00">ConvolutionBackward0</text>
</g>
<!-- 140244943583264&#45;&gt;140244943582448 -->
<g id="edge8" class="edge">
<title>140244943583264&#45;&gt;140244943582448</title>
<path fill="none" stroke="black" d="M206.07,-583.82C228.05,-573.75 261.37,-558.5 286.12,-547.17"/>
<polygon fill="black" stroke="black" points="287.18,-550.08 294.82,-542.74 284.27,-543.72 287.18,-550.08"/>
</g>
<!-- 140244943579616 -->
<g id="node11" class="node">
<title>140244943579616</title>
<polygon fill="lightgrey" stroke="black" points="134,-670.75 10,-670.75 10,-648.5 134,-648.5 134,-670.75"/>
<text text-anchor="middle" x="72" y="-657.25" font-family="monospace" font-size="10.00">LeakyReluBackward1</text>
</g>
<!-- 140244943579616&#45;&gt;140244943583264 -->
<g id="edge9" class="edge">
<title>140244943579616&#45;&gt;140244943583264</title>
<path fill="none" stroke="black" d="M90.83,-648.07C108.29,-638.27 134.52,-623.56 154.54,-612.34"/>
<polygon fill="black" stroke="black" points="156.07,-614.93 163.08,-606.99 152.64,-608.83 156.07,-614.93"/>
</g>
<!-- 140244943578176 -->
<g id="node12" class="node">
<title>140244943578176</title>
<polygon fill="lightgrey" stroke="black" points="136,-741 0,-741 0,-718.75 136,-718.75 136,-741"/>
<text text-anchor="middle" x="68" y="-727.5" font-family="monospace" font-size="10.00">ConvolutionBackward0</text>
</g>
<!-- 140244943578176&#45;&gt;140244943579616 -->
<g id="edge10" class="edge">
<title>140244943578176&#45;&gt;140244943579616</title>
<path fill="none" stroke="black" d="M68.61,-718.51C69.18,-708.79 70.05,-693.96 70.76,-681.75"/>
<polygon fill="black" stroke="black" points="74.3,-682.28 71.39,-672.09 67.31,-681.87 74.3,-682.28"/>
</g>
<!-- 140244943584512 -->
<g id="node13" class="node">
<title>140244943584512</title>
<polygon fill="lightgrey" stroke="black" points="118,-805.25 18,-805.25 18,-783 118,-783 118,-805.25"/>
<text text-anchor="middle" x="68" y="-791.75" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943584512&#45;&gt;140244943578176 -->
<g id="edge11" class="edge">
<title>140244943584512&#45;&gt;140244943578176</title>
<path fill="none" stroke="black" d="M68,-782.57C68,-774.29 68,-762.5 68,-752.27"/>
<polygon fill="black" stroke="black" points="71.5,-752.28 68,-742.28 64.5,-752.28 71.5,-752.28"/>
</g>
<!-- 140244953121040 -->
<g id="node14" class="node">
<title>140244953121040</title>
<polygon fill="lightblue" stroke="black" points="118,-875.5 18,-875.5 18,-841.25 118,-841.25 118,-875.5"/>
<text text-anchor="middle" x="68" y="-850" font-family="monospace" font-size="10.00"> (32, 3, 4, 4)</text>
</g>
<!-- 140244953121040&#45;&gt;140244943584512 -->
<g id="edge12" class="edge">
<title>140244953121040&#45;&gt;140244943584512</title>
<path fill="none" stroke="black" d="M68,-841.02C68,-833.47 68,-824.41 68,-816.34"/>
<polygon fill="black" stroke="black" points="71.5,-816.52 68,-806.52 64.5,-816.52 71.5,-816.52"/>
</g>
<!-- 140244943580480 -->
<g id="node15" class="node">
<title>140244943580480</title>
<polygon fill="lightgrey" stroke="black" points="254,-670.75 154,-670.75 154,-648.5 254,-648.5 254,-670.75"/>
<text text-anchor="middle" x="204" y="-657.25" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943580480&#45;&gt;140244943583264 -->
<g id="edge13" class="edge">
<title>140244943580480&#45;&gt;140244943583264</title>
<path fill="none" stroke="black" d="M200.44,-648.07C197.58,-639.61 193.49,-627.48 189.99,-617.1"/>
<polygon fill="black" stroke="black" points="193.02,-616.14 186.51,-607.78 186.39,-618.37 193.02,-616.14"/>
</g>
<!-- 140244953120944 -->
<g id="node16" class="node">
<title>140244953120944</title>
<polygon fill="lightblue" stroke="black" points="260,-747 154,-747 154,-712.75 260,-712.75 260,-747"/>
<text text-anchor="middle" x="207" y="-721.5" font-family="monospace" font-size="10.00"> (64, 32, 4, 4)</text>
</g>
<!-- 140244953120944&#45;&gt;140244943580480 -->
<g id="edge14" class="edge">
<title>140244953120944&#45;&gt;140244943580480</title>
<path fill="none" stroke="black" d="M206.27,-712.35C205.87,-703.15 205.36,-691.6 204.93,-681.75"/>
<polygon fill="black" stroke="black" points="208.39,-681.69 204.45,-671.85 201.39,-682 208.39,-681.69"/>
</g>
<!-- 140244943583648 -->
<g id="node17" class="node">
<title>140244943583648</title>
<polygon fill="lightgrey" stroke="black" points="369,-606.5 269,-606.5 269,-584.25 369,-584.25 369,-606.5"/>
<text text-anchor="middle" x="319" y="-593" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943583648&#45;&gt;140244943582448 -->
<g id="edge15" class="edge">
<title>140244943583648&#45;&gt;140244943582448</title>
<path fill="none" stroke="black" d="M319,-583.82C319,-575.54 319,-563.75 319,-553.52"/>
<polygon fill="black" stroke="black" points="322.5,-553.53 319,-543.53 315.5,-553.53 322.5,-553.53"/>
</g>
<!-- 140244953121520 -->
<g id="node18" class="node">
<title>140244953121520</title>
<polygon fill="lightblue" stroke="black" points="346,-676.75 292,-676.75 292,-642.5 346,-642.5 346,-676.75"/>
<text text-anchor="middle" x="319" y="-651.25" font-family="monospace" font-size="10.00"> (64)</text>
</g>
<!-- 140244953121520&#45;&gt;140244943583648 -->
<g id="edge16" class="edge">
<title>140244953121520&#45;&gt;140244943583648</title>
<path fill="none" stroke="black" d="M319,-642.27C319,-634.72 319,-625.66 319,-617.59"/>
<polygon fill="black" stroke="black" points="322.5,-617.77 319,-607.77 315.5,-617.77 322.5,-617.77"/>
</g>
<!-- 140244943584800 -->
<g id="node19" class="node">
<title>140244943584800</title>
<polygon fill="lightgrey" stroke="black" points="487,-606.5 387,-606.5 387,-584.25 487,-584.25 487,-606.5"/>
<text text-anchor="middle" x="437" y="-593" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943584800&#45;&gt;140244943582448 -->
<g id="edge17" class="edge">
<title>140244943584800&#45;&gt;140244943582448</title>
<path fill="none" stroke="black" d="M416.98,-583.82C398.25,-573.93 370.03,-559.05 348.68,-547.78"/>
<polygon fill="black" stroke="black" points="350.59,-544.31 340.12,-542.74 347.33,-550.5 350.59,-544.31"/>
</g>
<!-- 140244953121328 -->
<g id="node20" class="node">
<title>140244953121328</title>
<polygon fill="lightblue" stroke="black" points="464,-676.75 410,-676.75 410,-642.5 464,-642.5 464,-676.75"/>
<text text-anchor="middle" x="437" y="-651.25" font-family="monospace" font-size="10.00"> (64)</text>
</g>
<!-- 140244953121328&#45;&gt;140244943584800 -->
<g id="edge18" class="edge">
<title>140244953121328&#45;&gt;140244943584800</title>
<path fill="none" stroke="black" d="M437,-642.27C437,-634.72 437,-625.66 437,-617.59"/>
<polygon fill="black" stroke="black" points="440.5,-617.77 437,-607.77 433.5,-617.77 440.5,-617.77"/>
</g>
<!-- 140244943585184 -->
<g id="node21" class="node">
<title>140244943585184</title>
<polygon fill="lightgrey" stroke="black" points="517,-472 417,-472 417,-449.75 517,-449.75 517,-472"/>
<text text-anchor="middle" x="467" y="-458.5" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943585184&#45;&gt;140244943582592 -->
<g id="edge19" class="edge">
<title>140244943585184&#45;&gt;140244943582592</title>
<path fill="none" stroke="black" d="M463.44,-449.32C460.58,-440.86 456.49,-428.73 452.99,-418.35"/>
<polygon fill="black" stroke="black" points="456.02,-417.39 449.51,-409.03 449.39,-419.62 456.02,-417.39"/>
</g>
<!-- 140244953130064 -->
<g id="node22" class="node">
<title>140244953130064</title>
<polygon fill="lightblue" stroke="black" points="529,-548.25 417,-548.25 417,-514 529,-514 529,-548.25"/>
<text text-anchor="middle" x="473" y="-522.75" font-family="monospace" font-size="10.00"> (128, 64, 4, 4)</text>
</g>
<!-- 140244953130064&#45;&gt;140244943585184 -->
<g id="edge20" class="edge">
<title>140244953130064&#45;&gt;140244943585184</title>
<path fill="none" stroke="black" d="M471.55,-513.6C470.74,-504.4 469.72,-492.85 468.86,-483"/>
<polygon fill="black" stroke="black" points="472.26,-482.76 467.9,-473.1 465.29,-483.37 472.26,-482.76"/>
</g>
<!-- 140244943583696 -->
<g id="node23" class="node">
<title>140244943583696</title>
<polygon fill="lightgrey" stroke="black" points="632,-407.75 532,-407.75 532,-385.5 632,-385.5 632,-407.75"/>
<text text-anchor="middle" x="582" y="-394.25" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943583696&#45;&gt;140244943583984 -->
<g id="edge21" class="edge">
<title>140244943583696&#45;&gt;140244943583984</title>
<path fill="none" stroke="black" d="M582,-385.07C582,-376.79 582,-365 582,-354.77"/>
<polygon fill="black" stroke="black" points="585.5,-354.78 582,-344.78 578.5,-354.78 585.5,-354.78"/>
</g>
<!-- 140244953130160 -->
<g id="node24" class="node">
<title>140244953130160</title>
<polygon fill="lightblue" stroke="black" points="609,-478 555,-478 555,-443.75 609,-443.75 609,-478"/>
<text text-anchor="middle" x="582" y="-452.5" font-family="monospace" font-size="10.00"> (128)</text>
</g>
<!-- 140244953130160&#45;&gt;140244943583696 -->
<g id="edge22" class="edge">
<title>140244953130160&#45;&gt;140244943583696</title>
<path fill="none" stroke="black" d="M582,-443.52C582,-435.97 582,-426.91 582,-418.84"/>
<polygon fill="black" stroke="black" points="585.5,-419.02 582,-409.02 578.5,-419.02 585.5,-419.02"/>
</g>
<!-- 140244943583312 -->
<g id="node25" class="node">
<title>140244943583312</title>
<polygon fill="lightgrey" stroke="black" points="750,-407.75 650,-407.75 650,-385.5 750,-385.5 750,-407.75"/>
<text text-anchor="middle" x="700" y="-394.25" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943583312&#45;&gt;140244943583984 -->
<g id="edge23" class="edge">
<title>140244943583312&#45;&gt;140244943583984</title>
<path fill="none" stroke="black" d="M679.98,-385.07C661.25,-375.18 633.03,-360.3 611.68,-349.03"/>
<polygon fill="black" stroke="black" points="613.59,-345.56 603.12,-343.99 610.33,-351.75 613.59,-345.56"/>
</g>
<!-- 140244953130256 -->
<g id="node26" class="node">
<title>140244953130256</title>
<polygon fill="lightblue" stroke="black" points="727,-478 673,-478 673,-443.75 727,-443.75 727,-478"/>
<text text-anchor="middle" x="700" y="-452.5" font-family="monospace" font-size="10.00"> (128)</text>
</g>
<!-- 140244953130256&#45;&gt;140244943583312 -->
<g id="edge24" class="edge">
<title>140244953130256&#45;&gt;140244943583312</title>
<path fill="none" stroke="black" d="M700,-443.52C700,-435.97 700,-426.91 700,-418.84"/>
<polygon fill="black" stroke="black" points="703.5,-419.02 700,-409.02 696.5,-419.02 703.5,-419.02"/>
</g>
<!-- 140244943578704 -->
<g id="node27" class="node">
<title>140244943578704</title>
<polygon fill="lightgrey" stroke="black" points="777,-279.25 677,-279.25 677,-257 777,-257 777,-279.25"/>
<text text-anchor="middle" x="727" y="-265.75" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943578704&#45;&gt;140244943584032 -->
<g id="edge25" class="edge">
<title>140244943578704&#45;&gt;140244943584032</title>
<path fill="none" stroke="black" d="M713.83,-256.54C703.86,-248.53 689.95,-237.35 678.39,-228.06"/>
<polygon fill="black" stroke="black" points="681.09,-224.94 671.11,-221.41 676.71,-230.4 681.09,-224.94"/>
</g>
<!-- 140244953130640 -->
<g id="node28" class="node">
<title>140244953130640</title>
<polygon fill="lightblue" stroke="black" points="786,-349.5 680,-349.5 680,-315.25 786,-315.25 786,-349.5"/>
<text text-anchor="middle" x="733" y="-324" font-family="monospace" font-size="10.00"> (1, 128, 4, 4)</text>
</g>
<!-- 140244953130640&#45;&gt;140244943578704 -->
<g id="edge26" class="edge">
<title>140244953130640&#45;&gt;140244943578704</title>
<path fill="none" stroke="black" d="M731.42,-315.02C730.7,-307.47 729.82,-298.41 729.04,-290.34"/>
<polygon fill="black" stroke="black" points="732.45,-290.14 728,-280.52 725.48,-290.81 732.45,-290.14"/>
</g>
<!-- 140244940585584&#45;&gt;140244940585680 -->
<g id="edge29" class="edge">
<title>140244940585584&#45;&gt;140244940585680</title>
<path fill="none" stroke="black" stroke-dasharray="1,5" d="M696.41,-69.85C690.28,-61.81 682.78,-51.96 675.97,-43.02"/>
<polygon fill="black" stroke="black" points="678.32,-41.33 669.47,-35.49 672.75,-45.57 678.32,-41.33"/>
</g>
</g>
</svg>
)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"5DgOVOMHSMqA"},"outputs":[],"source":["class DCGAN_D(nn.Module):\n"," def __init__(self, isize, nz, nc, ndf, ngpu, n_extra_layers=0):\n"," super(DCGAN_D, self).__init__()\n"," self.ngpu = ngpu\n"," assert isize % 16 == 0, \"isize has to be a multiple of 16\"\n","\n"," main = nn.Sequential()\n"," # inputs is nc x isize x isize\n"," main.add_module('initial:{0}-{1}:conv'.format(nc, ndf),\n"," nn.Conv2d(nc, ndf, 4, 2, 1, bias=False))\n"," main.add_module('initial:{0}:relu'.format(ndf),\n"," nn.LeakyReLU(0.2, inplace=True))\n"," csize, cndf = isize / 2, ndf\n","\n"," # Extra layers\n"," for t in range(n_extra_layers):\n"," main.add_module('extra-layers-{0}:{1}:conv'.format(t, cndf),\n"," nn.Conv2d(cndf, cndf, 3, 1, 1, bias=False))\n"," main.add_module('extra-layers-{0}:{1}:batchnorm'.format(t, cndf),\n"," nn.BatchNorm2d(cndf))\n"," main.add_module('extra-layers-{0}:{1}:relu'.format(t, cndf),\n"," nn.LeakyReLU(0.2, inplace=True))\n","\n"," while csize > 4:\n"," in_feat = cndf\n"," out_feat = cndf * 2\n"," main.add_module('pyramid:{0}-{1}:conv'.format(in_feat, out_feat),\n"," nn.Conv2d(in_feat, out_feat, 4, 2, 1, bias=False))\n"," main.add_module('pyramid:{0}:batchnorm'.format(out_feat),\n"," nn.BatchNorm2d(out_feat))\n"," main.add_module('pyramid:{0}:relu'.format(out_feat),\n"," nn.LeakyReLU(0.2, inplace=True))\n"," cndf = cndf * 2\n"," csize = csize / 2\n","\n"," # state size. K x 4 x 4\n"," main.add_module('final:{0}-{1}:conv'.format(cndf, 1),\n"," nn.Conv2d(cndf, 1, 4, 1, 0, bias=False))\n"," self.main = main\n","\n","\n"," def forward(self, inputs):\n"," if isinstance(inputs.data, torch.cuda.FloatTensor) and self.ngpu > 1:\n"," output = nn.parallel.data_parallel(self.main, inputs, range(self.ngpu))\n"," else:\n"," output = self.main(inputs)\n","\n"," output = output.mean(0)\n"," return output.view(1)"]},{"cell_type":"markdown","metadata":{"id":"2X34F3vIY-6c"},"source":["### Generateur"]},{"cell_type":"markdown","metadata":{"id":"Kg60CsB74fHR"},"source":["![netG_architecture.svg](data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
 "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<!-- Generated by graphviz version 8.1.0 (20230707.0739)
 -->
<!-- Pages: 1 -->
<svg width="864pt" height="824pt"
 viewBox="0.00 0.00 864.00 824.35" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
<g id="graph0" class="graph" transform="scale(0.933045 0.933045) rotate(0) translate(4 879.5)">
<polygon fill="white" stroke="none" points="-4,4 -4,-879.5 922,-879.5 922,4 -4,4"/>
<!-- 140244940661072 -->
<g id="node1" class="node">
<title>140244940661072</title>
<polygon fill="#caff70" stroke="black" points="846,-34.25 740,-34.25 740,0 846,0 846,-34.25"/>
<text text-anchor="middle" x="793" y="-8.75" font-family="monospace" font-size="10.00"> (1, 3, 32, 32)</text>
</g>
<!-- 140244943580000 -->
<g id="node2" class="node">
<title>140244943580000</title>
<polygon fill="lightgrey" stroke="black" points="840,-92.5 746,-92.5 746,-70.25 840,-70.25 840,-92.5"/>
<text text-anchor="middle" x="793" y="-79" font-family="monospace" font-size="10.00">TanhBackward0</text>
</g>
<!-- 140244943580000&#45;&gt;140244940661072 -->
<g id="edge31" class="edge">
<title>140244943580000&#45;&gt;140244940661072</title>
<path fill="none" stroke="black" d="M793,-69.82C793,-63.06 793,-53.97 793,-45.3"/>
<polygon fill="black" stroke="black" points="796.5,-45.36 793,-35.36 789.5,-45.36 796.5,-45.36"/>
</g>
<!-- 140244943580432 -->
<g id="node3" class="node">
<title>140244943580432</title>
<polygon fill="lightgrey" stroke="black" points="861,-150.75 725,-150.75 725,-128.5 861,-128.5 861,-150.75"/>
<text text-anchor="middle" x="793" y="-137.25" font-family="monospace" font-size="10.00">ConvolutionBackward0</text>
</g>
<!-- 140244943580432&#45;&gt;140244943580000 -->
<g id="edge1" class="edge">
<title>140244943580432&#45;&gt;140244943580000</title>
<path fill="none" stroke="black" d="M793,-128.04C793,-121.21 793,-112.07 793,-103.77"/>
<polygon fill="black" stroke="black" points="796.5,-103.91 793,-93.91 789.5,-103.91 796.5,-103.91"/>
</g>
<!-- 140244943578320 -->
<g id="node4" class="node">
<title>140244943578320</title>
<polygon fill="lightgrey" stroke="black" points="775,-209 681,-209 681,-186.75 775,-186.75 775,-209"/>
<text text-anchor="middle" x="728" y="-195.5" font-family="monospace" font-size="10.00">ReluBackward0</text>
</g>
<!-- 140244943578320&#45;&gt;140244943580432 -->
<g id="edge2" class="edge">
<title>140244943578320&#45;&gt;140244943580432</title>
<path fill="none" stroke="black" d="M740.23,-186.29C749.4,-178.36 762.15,-167.32 772.82,-158.09"/>
<polygon fill="black" stroke="black" points="774.56,-160.35 779.83,-151.16 769.98,-155.05 774.56,-160.35"/>
</g>
<!-- 140244943580192 -->
<g id="node5" class="node">
<title>140244943580192</title>
<polygon fill="lightgrey" stroke="black" points="800,-273.25 640,-273.25 640,-251 800,-251 800,-273.25"/>
<text text-anchor="middle" x="720" y="-259.75" font-family="monospace" font-size="10.00">NativeBatchNormBackward0</text>
</g>
<!-- 140244943580192&#45;&gt;140244943578320 -->
<g id="edge3" class="edge">
<title>140244943580192&#45;&gt;140244943578320</title>
<path fill="none" stroke="black" d="M721.36,-250.57C722.43,-242.2 723.97,-230.24 725.29,-219.93"/>
<polygon fill="black" stroke="black" points="728.86,-220.64 726.66,-210.28 721.92,-219.75 728.86,-220.64"/>
</g>
<!-- 140244943576880 -->
<g id="node6" class="node">
<title>140244943576880</title>
<polygon fill="lightgrey" stroke="black" points="652,-337.5 516,-337.5 516,-315.25 652,-315.25 652,-337.5"/>
<text text-anchor="middle" x="584" y="-324" font-family="monospace" font-size="10.00">ConvolutionBackward0</text>
</g>
<!-- 140244943576880&#45;&gt;140244943580192 -->
<g id="edge4" class="edge">
<title>140244943576880&#45;&gt;140244943580192</title>
<path fill="none" stroke="black" d="M607.07,-314.82C629.05,-304.75 662.37,-289.5 687.12,-278.17"/>
<polygon fill="black" stroke="black" points="688.18,-281.08 695.82,-273.74 685.27,-274.72 688.18,-281.08"/>
</g>
<!-- 140244943582208 -->
<g id="node7" class="node">
<title>140244943582208</title>
<polygon fill="lightgrey" stroke="black" points="528,-401.75 434,-401.75 434,-379.5 528,-379.5 528,-401.75"/>
<text text-anchor="middle" x="481" y="-388.25" font-family="monospace" font-size="10.00">ReluBackward0</text>
</g>
<!-- 140244943582208&#45;&gt;140244943576880 -->
<g id="edge5" class="edge">
<title>140244943582208&#45;&gt;140244943576880</title>
<path fill="none" stroke="black" d="M498.47,-379.07C514.53,-369.36 538.57,-354.83 557.08,-343.65"/>
<polygon fill="black" stroke="black" points="558.69,-346.15 565.44,-337.99 555.07,-340.16 558.69,-346.15"/>
</g>
<!-- 140244943582016 -->
<g id="node8" class="node">
<title>140244943582016</title>
<polygon fill="lightgrey" stroke="black" points="543,-472 383,-472 383,-449.75 543,-449.75 543,-472"/>
<text text-anchor="middle" x="463" y="-458.5" font-family="monospace" font-size="10.00">NativeBatchNormBackward0</text>
</g>
<!-- 140244943582016&#45;&gt;140244943582208 -->
<g id="edge6" class="edge">
<title>140244943582016&#45;&gt;140244943582208</title>
<path fill="none" stroke="black" d="M465.73,-449.51C468.32,-439.69 472.29,-424.65 475.53,-412.37"/>
<polygon fill="black" stroke="black" points="479.07,-413.65 478.24,-403.09 472.31,-411.87 479.07,-413.65"/>
</g>
<!-- 140244943577888 -->
<g id="node9" class="node">
<title>140244943577888</title>
<polygon fill="lightgrey" stroke="black" points="395,-536.25 259,-536.25 259,-514 395,-514 395,-536.25"/>
<text text-anchor="middle" x="327" y="-522.75" font-family="monospace" font-size="10.00">ConvolutionBackward0</text>
</g>
<!-- 140244943577888&#45;&gt;140244943582016 -->
<g id="edge7" class="edge">
<title>140244943577888&#45;&gt;140244943582016</title>
<path fill="none" stroke="black" d="M350.07,-513.57C372.05,-503.5 405.37,-488.25 430.12,-476.92"/>
<polygon fill="black" stroke="black" points="431.18,-479.83 438.82,-472.49 428.27,-473.47 431.18,-479.83"/>
</g>
<!-- 140244943583024 -->
<g id="node10" class="node">
<title>140244943583024</title>
<polygon fill="lightgrey" stroke="black" points="270,-600.5 176,-600.5 176,-578.25 270,-578.25 270,-600.5"/>
<text text-anchor="middle" x="223" y="-587" font-family="monospace" font-size="10.00">ReluBackward0</text>
</g>
<!-- 140244943583024&#45;&gt;140244943577888 -->
<g id="edge8" class="edge">
<title>140244943583024&#45;&gt;140244943577888</title>
<path fill="none" stroke="black" d="M240.64,-577.82C256.93,-568.07 281.35,-553.45 300.07,-542.24"/>
<polygon fill="black" stroke="black" points="301.49,-544.88 308.27,-536.74 297.89,-538.87 301.49,-544.88"/>
</g>
<!-- 140244943577744 -->
<g id="node11" class="node">
<title>140244943577744</title>
<polygon fill="lightgrey" stroke="black" points="284,-670.75 124,-670.75 124,-648.5 284,-648.5 284,-670.75"/>
<text text-anchor="middle" x="204" y="-657.25" font-family="monospace" font-size="10.00">NativeBatchNormBackward0</text>
</g>
<!-- 140244943577744&#45;&gt;140244943583024 -->
<g id="edge9" class="edge">
<title>140244943577744&#45;&gt;140244943583024</title>
<path fill="none" stroke="black" d="M206.89,-648.26C209.62,-638.44 213.81,-623.4 217.23,-611.12"/>
<polygon fill="black" stroke="black" points="220.78,-612.41 220.09,-601.84 214.03,-610.53 220.78,-612.41"/>
</g>
<!-- 140244943577024 -->
<g id="node12" class="node">
<title>140244943577024</title>
<polygon fill="lightgrey" stroke="black" points="136,-735 0,-735 0,-712.75 136,-712.75 136,-735"/>
<text text-anchor="middle" x="68" y="-721.5" font-family="monospace" font-size="10.00">ConvolutionBackward0</text>
</g>
<!-- 140244943577024&#45;&gt;140244943577744 -->
<g id="edge10" class="edge">
<title>140244943577024&#45;&gt;140244943577744</title>
<path fill="none" stroke="black" d="M91.07,-712.32C113.05,-702.25 146.37,-687 171.12,-675.67"/>
<polygon fill="black" stroke="black" points="172.18,-678.58 179.82,-671.24 169.27,-672.22 172.18,-678.58"/>
</g>
<!-- 140244943602976 -->
<g id="node13" class="node">
<title>140244943602976</title>
<polygon fill="lightgrey" stroke="black" points="118,-799.25 18,-799.25 18,-777 118,-777 118,-799.25"/>
<text text-anchor="middle" x="68" y="-785.75" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943602976&#45;&gt;140244943577024 -->
<g id="edge11" class="edge">
<title>140244943602976&#45;&gt;140244943577024</title>
<path fill="none" stroke="black" d="M68,-776.57C68,-768.29 68,-756.5 68,-746.27"/>
<polygon fill="black" stroke="black" points="71.5,-746.28 68,-736.28 64.5,-746.28 71.5,-746.28"/>
</g>
<!-- 140244952839088 -->
<g id="node14" class="node">
<title>140244952839088</title>
<polygon fill="lightblue" stroke="black" points="127,-875.5 9,-875.5 9,-841.25 127,-841.25 127,-875.5"/>
<text text-anchor="middle" x="68" y="-850" font-family="monospace" font-size="10.00"> (100, 128, 4, 4)</text>
</g>
<!-- 140244952839088&#45;&gt;140244943602976 -->
<g id="edge12" class="edge">
<title>140244952839088&#45;&gt;140244943602976</title>
<path fill="none" stroke="black" d="M68,-840.85C68,-831.65 68,-820.1 68,-810.25"/>
<polygon fill="black" stroke="black" points="71.5,-810.35 68,-800.35 64.5,-810.35 71.5,-810.35"/>
</g>
<!-- 140244943584128 -->
<g id="node15" class="node">
<title>140244943584128</title>
<polygon fill="lightgrey" stroke="black" points="254,-735 154,-735 154,-712.75 254,-712.75 254,-735"/>
<text text-anchor="middle" x="204" y="-721.5" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943584128&#45;&gt;140244943577744 -->
<g id="edge13" class="edge">
<title>140244943584128&#45;&gt;140244943577744</title>
<path fill="none" stroke="black" d="M204,-712.32C204,-704.04 204,-692.25 204,-682.02"/>
<polygon fill="black" stroke="black" points="207.5,-682.03 204,-672.03 200.5,-682.03 207.5,-682.03"/>
</g>
<!-- 140244952841968 -->
<g id="node16" class="node">
<title>140244952841968</title>
<polygon fill="lightblue" stroke="black" points="231,-805.25 177,-805.25 177,-771 231,-771 231,-805.25"/>
<text text-anchor="middle" x="204" y="-779.75" font-family="monospace" font-size="10.00"> (128)</text>
</g>
<!-- 140244952841968&#45;&gt;140244943584128 -->
<g id="edge14" class="edge">
<title>140244952841968&#45;&gt;140244943584128</title>
<path fill="none" stroke="black" d="M204,-770.77C204,-763.22 204,-754.16 204,-746.09"/>
<polygon fill="black" stroke="black" points="207.5,-746.27 204,-736.27 200.5,-746.27 207.5,-746.27"/>
</g>
<!-- 140244943601920 -->
<g id="node17" class="node">
<title>140244943601920</title>
<polygon fill="lightgrey" stroke="black" points="372,-735 272,-735 272,-712.75 372,-712.75 372,-735"/>
<text text-anchor="middle" x="322" y="-721.5" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943601920&#45;&gt;140244943577744 -->
<g id="edge15" class="edge">
<title>140244943601920&#45;&gt;140244943577744</title>
<path fill="none" stroke="black" d="M301.98,-712.32C283.25,-702.43 255.03,-687.55 233.68,-676.28"/>
<polygon fill="black" stroke="black" points="235.59,-672.81 225.12,-671.24 232.33,-679 235.59,-672.81"/>
</g>
<!-- 140244952839280 -->
<g id="node18" class="node">
<title>140244952839280</title>
<polygon fill="lightblue" stroke="black" points="349,-805.25 295,-805.25 295,-771 349,-771 349,-805.25"/>
<text text-anchor="middle" x="322" y="-779.75" font-family="monospace" font-size="10.00"> (128)</text>
</g>
<!-- 140244952839280&#45;&gt;140244943601920 -->
<g id="edge16" class="edge">
<title>140244952839280&#45;&gt;140244943601920</title>
<path fill="none" stroke="black" d="M322,-770.77C322,-763.22 322,-754.16 322,-746.09"/>
<polygon fill="black" stroke="black" points="325.5,-746.27 322,-736.27 318.5,-746.27 325.5,-746.27"/>
</g>
<!-- 140244943582496 -->
<g id="node19" class="node">
<title>140244943582496</title>
<polygon fill="lightgrey" stroke="black" points="398,-600.5 298,-600.5 298,-578.25 398,-578.25 398,-600.5"/>
<text text-anchor="middle" x="348" y="-587" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943582496&#45;&gt;140244943577888 -->
<g id="edge17" class="edge">
<title>140244943582496&#45;&gt;140244943577888</title>
<path fill="none" stroke="black" d="M344.44,-577.82C341.58,-569.36 337.49,-557.23 333.99,-546.85"/>
<polygon fill="black" stroke="black" points="337.02,-545.89 330.51,-537.53 330.39,-548.12 337.02,-545.89"/>
</g>
<!-- 140244953123536 -->
<g id="node20" class="node">
<title>140244953123536</title>
<polygon fill="lightblue" stroke="black" points="414,-676.75 302,-676.75 302,-642.5 414,-642.5 414,-676.75"/>
<text text-anchor="middle" x="358" y="-651.25" font-family="monospace" font-size="10.00"> (128, 64, 4, 4)</text>
</g>
<!-- 140244953123536&#45;&gt;140244943582496 -->
<g id="edge18" class="edge">
<title>140244953123536&#45;&gt;140244943582496</title>
<path fill="none" stroke="black" d="M355.58,-642.1C354.22,-632.8 352.5,-621.1 351.05,-611.18"/>
<polygon fill="black" stroke="black" points="354.41,-610.99 349.5,-601.6 347.49,-612 354.41,-610.99"/>
</g>
<!-- 140244943582832 -->
<g id="node21" class="node">
<title>140244943582832</title>
<polygon fill="lightgrey" stroke="black" points="513,-536.25 413,-536.25 413,-514 513,-514 513,-536.25"/>
<text text-anchor="middle" x="463" y="-522.75" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943582832&#45;&gt;140244943582016 -->
<g id="edge19" class="edge">
<title>140244943582832&#45;&gt;140244943582016</title>
<path fill="none" stroke="black" d="M463,-513.57C463,-505.29 463,-493.5 463,-483.27"/>
<polygon fill="black" stroke="black" points="466.5,-483.28 463,-473.28 459.5,-483.28 466.5,-483.28"/>
</g>
<!-- 140244953123440 -->
<g id="node22" class="node">
<title>140244953123440</title>
<polygon fill="lightblue" stroke="black" points="490,-606.5 436,-606.5 436,-572.25 490,-572.25 490,-606.5"/>
<text text-anchor="middle" x="463" y="-581" font-family="monospace" font-size="10.00"> (64)</text>
</g>
<!-- 140244953123440&#45;&gt;140244943582832 -->
<g id="edge20" class="edge">
<title>140244953123440&#45;&gt;140244943582832</title>
<path fill="none" stroke="black" d="M463,-572.02C463,-564.47 463,-555.41 463,-547.34"/>
<polygon fill="black" stroke="black" points="466.5,-547.52 463,-537.52 459.5,-547.52 466.5,-547.52"/>
</g>
<!-- 140244943582928 -->
<g id="node23" class="node">
<title>140244943582928</title>
<polygon fill="lightgrey" stroke="black" points="631,-536.25 531,-536.25 531,-514 631,-514 631,-536.25"/>
<text text-anchor="middle" x="581" y="-522.75" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943582928&#45;&gt;140244943582016 -->
<g id="edge21" class="edge">
<title>140244943582928&#45;&gt;140244943582016</title>
<path fill="none" stroke="black" d="M560.98,-513.57C542.25,-503.68 514.03,-488.8 492.68,-477.53"/>
<polygon fill="black" stroke="black" points="494.59,-474.06 484.12,-472.49 491.33,-480.25 494.59,-474.06"/>
</g>
<!-- 140244953123344 -->
<g id="node24" class="node">
<title>140244953123344</title>
<polygon fill="lightblue" stroke="black" points="608,-606.5 554,-606.5 554,-572.25 608,-572.25 608,-606.5"/>
<text text-anchor="middle" x="581" y="-581" font-family="monospace" font-size="10.00"> (64)</text>
</g>
<!-- 140244953123344&#45;&gt;140244943582928 -->
<g id="edge22" class="edge">
<title>140244953123344&#45;&gt;140244943582928</title>
<path fill="none" stroke="black" d="M581,-572.02C581,-564.47 581,-555.41 581,-547.34"/>
<polygon fill="black" stroke="black" points="584.5,-547.52 581,-537.52 577.5,-547.52 584.5,-547.52"/>
</g>
<!-- 140244943578416 -->
<g id="node25" class="node">
<title>140244943578416</title>
<polygon fill="lightgrey" stroke="black" points="655,-401.75 555,-401.75 555,-379.5 655,-379.5 655,-401.75"/>
<text text-anchor="middle" x="605" y="-388.25" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943578416&#45;&gt;140244943576880 -->
<g id="edge23" class="edge">
<title>140244943578416&#45;&gt;140244943576880</title>
<path fill="none" stroke="black" d="M601.44,-379.07C598.58,-370.61 594.49,-358.48 590.99,-348.1"/>
<polygon fill="black" stroke="black" points="594.02,-347.14 587.51,-338.78 587.39,-349.37 594.02,-347.14"/>
</g>
<!-- 140244953122960 -->
<g id="node26" class="node">
<title>140244953122960</title>
<polygon fill="lightblue" stroke="black" points="667,-478 561,-478 561,-443.75 667,-443.75 667,-478"/>
<text text-anchor="middle" x="614" y="-452.5" font-family="monospace" font-size="10.00"> (64, 32, 4, 4)</text>
</g>
<!-- 140244953122960&#45;&gt;140244943578416 -->
<g id="edge24" class="edge">
<title>140244953122960&#45;&gt;140244943578416</title>
<path fill="none" stroke="black" d="M611.82,-443.35C610.61,-434.15 609.09,-422.6 607.79,-412.75"/>
<polygon fill="black" stroke="black" points="611.13,-412.31 606.35,-402.85 604.19,-413.22 611.13,-412.31"/>
</g>
<!-- 140244943576304 -->
<g id="node27" class="node">
<title>140244943576304</title>
<polygon fill="lightgrey" stroke="black" points="770,-337.5 670,-337.5 670,-315.25 770,-315.25 770,-337.5"/>
<text text-anchor="middle" x="720" y="-324" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943576304&#45;&gt;140244943580192 -->
<g id="edge25" class="edge">
<title>140244943576304&#45;&gt;140244943580192</title>
<path fill="none" stroke="black" d="M720,-314.82C720,-306.54 720,-294.75 720,-284.52"/>
<polygon fill="black" stroke="black" points="723.5,-284.53 720,-274.53 716.5,-284.53 723.5,-284.53"/>
</g>
<!-- 140244953122864 -->
<g id="node28" class="node">
<title>140244953122864</title>
<polygon fill="lightblue" stroke="black" points="747,-407.75 693,-407.75 693,-373.5 747,-373.5 747,-407.75"/>
<text text-anchor="middle" x="720" y="-382.25" font-family="monospace" font-size="10.00"> (32)</text>
</g>
<!-- 140244953122864&#45;&gt;140244943576304 -->
<g id="edge26" class="edge">
<title>140244953122864&#45;&gt;140244943576304</title>
<path fill="none" stroke="black" d="M720,-373.27C720,-365.72 720,-356.66 720,-348.59"/>
<polygon fill="black" stroke="black" points="723.5,-348.77 720,-338.77 716.5,-348.77 723.5,-348.77"/>
</g>
<!-- 140244943575872 -->
<g id="node29" class="node">
<title>140244943575872</title>
<polygon fill="lightgrey" stroke="black" points="888,-337.5 788,-337.5 788,-315.25 888,-315.25 888,-337.5"/>
<text text-anchor="middle" x="838" y="-324" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943575872&#45;&gt;140244943580192 -->
<g id="edge27" class="edge">
<title>140244943575872&#45;&gt;140244943580192</title>
<path fill="none" stroke="black" d="M817.98,-314.82C799.25,-304.93 771.03,-290.05 749.68,-278.78"/>
<polygon fill="black" stroke="black" points="751.59,-275.31 741.12,-273.74 748.33,-281.5 751.59,-275.31"/>
</g>
<!-- 140244953122768 -->
<g id="node30" class="node">
<title>140244953122768</title>
<polygon fill="lightblue" stroke="black" points="865,-407.75 811,-407.75 811,-373.5 865,-373.5 865,-407.75"/>
<text text-anchor="middle" x="838" y="-382.25" font-family="monospace" font-size="10.00"> (32)</text>
</g>
<!-- 140244953122768&#45;&gt;140244943575872 -->
<g id="edge28" class="edge">
<title>140244953122768&#45;&gt;140244943575872</title>
<path fill="none" stroke="black" d="M838,-373.27C838,-365.72 838,-356.66 838,-348.59"/>
<polygon fill="black" stroke="black" points="841.5,-348.77 838,-338.77 834.5,-348.77 841.5,-348.77"/>
</g>
<!-- 140244943584944 -->
<g id="node31" class="node">
<title>140244943584944</title>
<polygon fill="lightgrey" stroke="black" points="909,-209 809,-209 809,-186.75 909,-186.75 909,-209"/>
<text text-anchor="middle" x="859" y="-195.5" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943584944&#45;&gt;140244943580432 -->
<g id="edge29" class="edge">
<title>140244943584944&#45;&gt;140244943580432</title>
<path fill="none" stroke="black" d="M846.59,-186.29C837.28,-178.36 824.32,-167.32 813.49,-158.09"/>
<polygon fill="black" stroke="black" points="816.24,-154.98 806.36,-151.16 811.7,-160.31 816.24,-154.98"/>
</g>
<!-- 140244953121424 -->
<g id="node32" class="node">
<title>140244953121424</title>
<polygon fill="lightblue" stroke="black" points="918,-279.25 818,-279.25 818,-245 918,-245 918,-279.25"/>
<text text-anchor="middle" x="868" y="-253.75" font-family="monospace" font-size="10.00"> (32, 3, 4, 4)</text>
</g>
<!-- 140244953121424&#45;&gt;140244943584944 -->
<g id="edge30" class="edge">
<title>140244953121424&#45;&gt;140244943584944</title>
<path fill="none" stroke="black" d="M865.64,-244.77C864.54,-237.22 863.23,-228.16 862.07,-220.09"/>
<polygon fill="black" stroke="black" points="865.4,-219.66 860.5,-210.27 858.47,-220.67 865.4,-219.66"/>
</g>
</g>
</svg>
)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"CiqFCjoAYtBq"},"outputs":[],"source":["class DCGAN_G(nn.Module):\n"," def __init__(self, isize, nz, nc, ngf, ngpu, n_extra_layers=0):\n"," super(DCGAN_G, self).__init__()\n"," self.ngpu = ngpu\n"," assert isize % 16 == 0, \"isize has to be a multiple of 16\"\n","\n"," cngf, tisize = ngf//2, 4\n"," while tisize != isize:\n"," cngf = cngf * 2\n"," tisize = tisize * 2\n","\n"," main = nn.Sequential()\n"," # inputs is Z, going into a convolution\n"," main.add_module('initial:{0}-{1}:convt'.format(nz, cngf),\n"," nn.ConvTranspose2d(nz, cngf, 4, 1, 0, bias=False))\n"," main.add_module('initial:{0}:batchnorm'.format(cngf),\n"," nn.BatchNorm2d(cngf))\n"," main.add_module('initial:{0}:relu'.format(cngf),\n"," nn.ReLU(True))\n","\n"," csize, cndf = 4, cngf\n"," while csize < isize//2:\n"," main.add_module('pyramid:{0}-{1}:convt'.format(cngf, cngf//2),\n"," nn.ConvTranspose2d(cngf, cngf//2, 4, 2, 1, bias=False))\n"," main.add_module('pyramid:{0}:batchnorm'.format(cngf//2),\n"," nn.BatchNorm2d(cngf//2))\n"," main.add_module('pyramid:{0}:relu'.format(cngf//2),\n"," nn.ReLU(True))\n"," cngf = cngf // 2\n"," csize = csize * 2\n","\n"," # Extra layers\n"," for t in range(n_extra_layers):\n"," main.add_module('extra-layers-{0}:{1}:conv'.format(t, cngf),\n"," nn.Conv2d(cngf, cngf, 3, 1, 1, bias=False))\n"," main.add_module('extra-layers-{0}:{1}:batchnorm'.format(t, cngf),\n"," nn.BatchNorm2d(cngf))\n"," main.add_module('extra-layers-{0}:{1}:relu'.format(t, cngf),\n"," nn.ReLU(True))\n","\n"," main.add_module('final:{0}-{1}:convt'.format(cngf, nc),\n"," nn.ConvTranspose2d(cngf, nc, 4, 2, 1, bias=False))\n"," main.add_module('final:{0}:tanh'.format(nc),\n"," nn.Tanh())\n"," self.main = main\n","\n"," def forward(self, inputs):\n"," if isinstance(inputs.data, torch.cuda.FloatTensor) and self.ngpu > 1:\n"," output = nn.parallel.data_parallel(self.main, inputs, range(self.ngpu))\n"," else:\n"," output = self.main(inputs)\n"," return output"]},{"cell_type":"markdown","metadata":{"id":"zyRrm3ClUMX1"},"source":["## Entrainement\n","\n","Voici un exemple de code qui permettrait l'entraînement de notre modèle et la configuration de celui-ci."]},{"cell_type":"markdown","metadata":{"id":"PhynHzMXXEyP"},"source":["### Options pour l'exécution"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"zkk11X5zSQLK"},"outputs":[],"source":["# Path to dataset\n","opt_dataroot = 'data/faces'\n","# Number of data loading workers\n","opt_workers = 2\n","# inputs batch size\n","opt_batchSize = 64\n","# The height / width of the inputs image to network\n","opt_imageSize = 32\n","# inputs image channels\n","nc = 3\n","# Size of the latent z vector\n","nz = 100\n","# Size of feature maps in generator\n","ngf = 32\n","# Size of feature maps in discriminator\n","ndf = 32\n","# Number of epochs to train for\n","opt_niter = 25\n","# Learning rate for Discriminator\n","opt_lrD = 0.00005\n","# Learning rate for Generator\n","opt_lrG = 0.00005\n","# beta1 for adam.\n","opt_beta1 = 0.5\n","# Lower value clamp for Discriminator weights\n","opt_clamp_lower = -0.01\n","# Upper value clamp for Discriminator weights\n","opt_clamp_upper = 0.01\n","# Number of D iters per each G iter\n","opt_Diters = 5\n","# Where to store samples and models\n","opt_experiment = 'samples'"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"LVYpQv-_tFsK"},"outputs":[],"source":["# Use CUDA if a GPU is available\n","opt_cuda = False\n","\n","opt_cuda_resp = input(\"Use cuda? (y/n)\\n{} by default\\n\".format(opt_cuda))\n","\n","# Use CUDA if a GPU is available\n","opt_cuda = True if opt_cuda_resp == 'y' else opt_cuda\n","# Number of GPUs to use for running the model if CUDA is enabled\n","ngpu = 1"]},{"cell_type":"markdown","metadata":{"id":"Ggb5i2jsX1jp"},"source":["### Configuration du modèle"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"ENkqSYs2Tbj9"},"outputs":[],"source":["os.system('mkdir {0}'.format(opt_experiment))\n","\n","opt_manualSeed = random.randint(1, 10000) # fix seed\n","print(\"Random Seed: \", opt_manualSeed)\n","random.seed(opt_manualSeed)\n","torch.manual_seed(opt_manualSeed)\n","\n","cudnn.benchmark = True\n","\n","# folder dataset\n","dataset = dset.ImageFolder(root=opt_dataroot,\n"," transform=transforms.Compose([\n"," transforms.Resize(opt_imageSize),\n"," transforms.CenterCrop(opt_imageSize),\n"," transforms.ToTensor(),\n"," transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n"," ]))\n","assert dataset\n","dataloader = torch.utils.data.DataLoader(dataset, batch_size=opt_batchSize,\n"," shuffle=True, num_workers=int(opt_workers))\n","\n","# custom weights initialization called on netG and netD\n","def weights_init(m):\n"," classname = m.__class__.__name__\n"," if classname.find('Conv') != -1:\n"," m.weight.data.normal_(0.0, 0.02)\n"," elif classname.find('BatchNorm') != -1:\n"," m.weight.data.normal_(1.0, 0.02)\n"," m.bias.data.fill_(0)\n","\n","netG = DCGAN_G(opt_imageSize, nz, nc, ngf, ngpu)\n","\n","netG.apply(weights_init)\n","print(netG)\n","\n","netD = DCGAN_D(opt_imageSize, nz, nc, ndf, ngpu)\n","netD.apply(weights_init)\n","\n","print(netD)\n","\n","inputs = torch.FloatTensor(opt_batchSize, 3, opt_imageSize, opt_imageSize)\n","noise = torch.FloatTensor(opt_batchSize, nz, 1, 1)\n","fixed_noise = torch.FloatTensor(opt_batchSize, nz, 1, 1).normal_(0, 1)\n","one = torch.FloatTensor([1])\n","mone = one * -1\n","\n","if opt_cuda:\n"," netD.cuda()\n"," netG.cuda()\n"," inputs = inputs.cuda()\n"," one, mone = one.cuda(), mone.cuda()\n"," noise, fixed_noise = noise.cuda(), fixed_noise.cuda()\n","\n","# setup optimizer\n","optimizerD = optim.RMSprop(netD.parameters(), lr = opt_lrD)\n","optimizerG = optim.RMSprop(netG.parameters(), lr = opt_lrG)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"W96oVYCkjzPR"},"outputs":[],"source":["netD_graph = make_dot(netD(Variable(torch.randn(1, 3, 32, 32))))\n","netD_graph.render(\"netD_architecture\", format=\"png\")\n","\n","netG_graph = make_dot(netG(Variable(torch.randn(1, 100, 1, 1))))\n","netG_graph.render(\"netG_architecture\", format=\"png\")"]},{"cell_type":"markdown","metadata":{"id":"YkMM0kSeX6cH"},"source":["### Entrainement du modèle"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"Pf06223hTrpJ"},"outputs":[],"source":["gen_iterations = 0\n","for epoch in range(opt_niter):\n"," data_iter = iter(dataloader)\n"," i = 0\n"," while i < len(dataloader):\n"," ############################\n"," # (1) Update D network\n"," ###########################\n"," for p in netD.parameters(): # reset requires_grad\n"," p.requires_grad = True # they are set to False below in netG update\n","\n"," # train the discriminator Diters times\n"," if gen_iterations < 25 or gen_iterations % 500 == 0:\n"," Diters = 100\n"," else:\n"," Diters = opt_Diters\n"," j = 0\n"," while j < Diters and i < len(dataloader):\n"," j += 1\n","\n"," # clamp parameters to a cube\n"," for p in netD.parameters():\n"," p.data.clamp_(opt_clamp_lower, opt_clamp_upper)\n","\n"," data = next(data_iter)\n"," i += 1\n","\n"," # train with real\n"," real_cpu, _ = data\n"," netD.zero_grad()\n"," batch_size = real_cpu.size(0)\n","\n"," if opt_cuda:\n"," real_cpu = real_cpu.cuda()\n"," inputs.resize_as_(real_cpu).copy_(real_cpu)\n"," inputsv = Variable(inputs)\n","\n"," errD_real = netD(inputsv)\n"," errD_real.backward(one)\n","\n"," # train with fake\n"," noise.resize_(opt_batchSize, nz, 1, 1).normal_(0, 1)\n"," noisev = Variable(noise, volatile = True) # totally freeze netG\n"," fake = Variable(netG(noisev).data)\n"," inputsv = fake\n"," errD_fake = netD(inputsv)\n"," errD_fake.backward(mone)\n"," errD = errD_real - errD_fake\n"," optimizerD.step()\n","\n"," ############################\n"," # (2) Update G network\n"," ###########################\n"," for p in netD.parameters():\n"," p.requires_grad = False # to avoid computation\n"," netG.zero_grad()\n"," # in case our last batch was the tail batch of the dataloader,\n"," # make sure we feed a full batch of noise\n"," noise.resize_(opt_batchSize, nz, 1, 1).normal_(0, 1)\n"," noisev = Variable(noise)\n"," fake = netG(noisev)\n"," errG = netD(fake)\n"," errG.backward(one)\n"," optimizerG.step()\n"," gen_iterations += 1\n","\n"," print('[%d/%d][%d/%d][%d] Loss_D: %f Loss_G: %f Loss_D_real: %f Loss_D_fake %f'\n"," % (epoch, opt_niter, i, len(dataloader), gen_iterations,\n"," errD.data[0], errG.data[0], errD_real.data[0], errD_fake.data[0]))\n"," if gen_iterations % 500 == 0:\n"," real_cpu = real_cpu.mul(0.5).add(0.5)\n"," vutils.save_image(real_cpu, '{0}/real_samples.png'.format(opt_experiment))\n"," fake = netG(Variable(fixed_noise, volatile=True))\n"," fake.data = fake.data.mul(0.5).add(0.5)\n"," vutils.save_image(fake.data, '{0}/fake_samples_{1}.png'.format(opt_experiment, gen_iterations))\n","\n"," # do checkpointing\n"," torch.save(netG.state_dict(), '{0}/netG_epoch_{1}.pth'.format(opt_experiment, epoch))\n"," torch.save(netD.state_dict(), '{0}/netD_epoch_{1}.pth'.format(opt_experiment, epoch))"]},{"cell_type":"markdown","metadata":{"id":"NfPfYpS-T5DN"},"source":["## Generation\n","\n","Voici la section de code correspondant à la génération de nos images, plus tard exploitées."]},{"cell_type":"markdown","metadata":{"id":"-B6fUl2zW_Ak"},"source":["### Options pour l'exécution"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"3r_w9O_zUERu"},"outputs":[],"source":["# Number of images to generate\n","opt_nimages = 100\n","# Path to output directory\n","opt_output_dir = 'data/generated'\n","# Path to generator weights .pth file\n","opt_weights = 'samples/netG_epoch_2384.pth'"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"1smXNRDUw-5k"},"outputs":[],"source":["opt_nimages_resp = input(\"How many images to generate?\\n{} by default\\n\".format(opt_nimages))\n","opt_output_dir_resp = input(\"Where to store generated images?\\n{} by default\\n\".format(opt_output_dir))\n","\n","# Number of images to generate\n","opt_nimages = int(opt_nimages_resp) if opt_nimages_resp != '' else opt_nimages\n","# Path to output directory\n","opt_output_dir = opt_output_dir_resp if opt_output_dir_resp != '' else opt_output_dir"]},{"cell_type":"markdown","metadata":{"id":"XWGZgsuyYDet"},"source":["### Configuration du modèle"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"KLNgMfV_T7Ou"},"outputs":[],"source":["netG = DCGAN_G(opt_imageSize, nz, nc, ngf, ngpu)\n","\n","# load weights\n","if opt_cuda:\n"," netG.load_state_dict(torch.load(opt_weights, map_location=torch.device('cuda')))\n","else:\n"," netG.load_state_dict(torch.load(opt_weights, map_location=torch.device('cpu')))\n","\n","# initialize noise\n","fixed_noise = torch.FloatTensor(opt_nimages, nz, 1, 1).normal_(0, 1)\n","\n","if opt_cuda:\n"," netG.cuda()\n"," fixed_noise = fixed_noise.cuda()\n","\n","fake = netG(fixed_noise)\n","fake.data = fake.data.mul(0.5).add(0.5)\n","\n","if not os.path.exists(opt_output_dir):\n"," os.makedirs(opt_output_dir)"]},{"cell_type":"markdown","metadata":{"id":"rPU04cGsYFVz"},"source":["### Génération des images"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"Jg82PIsjUH55"},"outputs":[],"source":["for i in range(opt_nimages):\n"," vutils.save_image(fake.data[i, ...].reshape((1, nc, opt_imageSize, opt_imageSize)), os.path.join(opt_output_dir, \"generated_%02d.png\"%i))"]},{"cell_type":"markdown","metadata":{"id":"ePeCi4PZJ5Ar"},"source":["## Résultats\n","L'entrainement a été réalisé à partir d'un ordinateur équipé d'un GPU accessible via internet ssh et un VPN configuré.\n","\n","Voici la commande utilisée pour effectuer la formation :\n","```shell\n","python main.py --dataset folder --dataroot data/faces --batchSize 2048 --niter 5000 --ngf 32 --ndf 32 --imageSize 32 --cuda\n","```\n","\n","et la génération :\n","```shell\n","python generate.py --config samples/generator_config.json --weight samples/netG_epoch_2384.pth --output_dir data/generated --nimages 100 --cuda\n","```\n","\n","Les fichiers Python sont ceux de l'article original. Ce sont les fichiers qui sont réutilisés et grandement simplifiés dans ce Jupyter Notebook.\n","\n","Les poids et les fichiers de configuration peuvent être téléchargés sur :\n","https://github.com/paul-corbalan/wasserstein-gan/tree/develop/samples\n","\n","La partie verbale de l'exécution `out` est également accessible."]},{"cell_type":"markdown","metadata":{"id":"xme7UNdR678K"},"source":[""]},{"cell_type":"markdown","metadata":{"id":"3PQ8dgt1OLyT"},"source":["Comme nous avons oublié de stocker les pertes pendant la formation, ce script a été créé pour les récupérer à partir du fichier verbeux."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"uLZ1Egi8OEAo"},"outputs":[],"source":["data = open('out', 'r').read()\n","\n","pattern = re.compile(r\"\\[(\\d+)/(\\d+)\\]\\[(\\d+)/(\\d+)\\]\\[(\\d+)\\] Loss_D: ([-+]?\\d*\\.\\d+|\\d+) Loss_G: ([-+]?\\d*\\.\\d+|\\d+) Loss_D_real: ([-+]?\\d*\\.\\d+|\\d+) Loss_D_fake ([-+]?\\d*\\.\\d+|\\d+)\")\n","\n","matches = pattern.findall(data)\n","\n","df = pd.DataFrame(matches, columns=['epoch', 'niter', 'i', 'dataloader_size', 'gen_iterations', 'Loss_D', 'Loss_G', 'Loss_D_real', 'Loss_D_fake'])\n","\n","df = df.apply(pd.to_numeric)\n","\n","plt.plot(df['gen_iterations'][::100], -df['Loss_D'][::100])\n","plt.xlabel('Generator Iterations')\n","plt.ylabel('Loss_D ~ Wasserstein Distance')\n","plt.title('Loss_D vs. Generator Iterations')\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"en27GDwsO4J_"},"source":["Nous traçons l'évolution de la perte du discriminateur car, contrairement au GAN classique, elles sont interprétables. Il s'agit en fait d'une estimation de la distance de Wasserstein entre la distribution générée et la distribution cible. Les valeurs décroissantes sont la preuve que le modèle continue d'apprendre et n'est pas affecté par l'un des problèmes des GANs classiques."]},{"cell_type":"markdown","metadata":{"id":"fdKb4NcvNzTz"},"source":["![evolution.png](data:image/png;base64,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)"]},{"cell_type":"markdown","metadata":{"id":"qLhnYB0uPpjt"},"source":["## Application\n","### Problème inverse : Récupérer le vecteur latent d'une image\n","\n","Voici le problème d'optimisation que nous voulons résoudre :\n","\n","$$\\underset{z \\in \\mathbb{Z}}{\\text{argmin}}\\lVert g(z)-x_0 \\rVert_2^2$$\n","\n","Voici le code pour résoudre ce problème en utilisant la différenciation automatique de PyTorch :"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"sdc3spKfRDO3"},"outputs":[],"source":["x0 = inputsv[0][None, :,:,:]\n","\n","noise = torch.FloatTensor(1, nz, 1, 1).normal_(0,1)\n","noise.requires_grad = True\n","\n","\n","# Choisissez un optimiseur, par exemple Adam\n","optimizer = optim.Adam([noise], lr=0.001)\n","\n","\n","for p in netD.parameters():\n"," p.requires_grad = False\n","for p in netG.parameters():\n"," p.requires_grad = False\n","\n","# Boucle d'optimisation\n","for iteration in range(100000):\n"," optimizer.zero_grad()\n","\n"," # Générer une donnée à partir de z\n"," generated_data = netG(noise)\n","\n"," # Calculer la perte (norme L2 au carré)\n"," loss = torch.norm(generated_data - x0)**2\n","\n"," # Rétropropagation et optimisation\n"," loss.backward()\n"," optimizer.step()\n","\n"," print(f\"Iteration: {iteration}, Loss: {loss.item()}\")"]},{"cell_type":"markdown","metadata":{"id":"pUw0PYPNR5wo"},"source":["Voici un exemple :\n","\n","- Image cible :"]},{"cell_type":"markdown","metadata":{"id":"Ic24cRnN7aus"},"source":[""]},{"cell_type":"markdown","metadata":{"id":"I-DndMBm7YJa"},"source":["- Image trouvée :"]},{"cell_type":"markdown","metadata":{"id":"HXoaWAoV7hoj"},"source":[""]},{"cell_type":"markdown","metadata":{"id":"_tBHFalDSRcI"},"source":["À partir d'un vecteur latent, nous pouvons explorer l'espace engendré par le générateur.\n","\n","---\n","\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"pS4lMtoBSgnZ"},"outputs":[],"source":["fixed_noise = noise.repeat(25, 1, 1, 1)\n","\n","n = int(fixed_noise.shape[0]**.5)\n","for i in range(n):\n"," for j in range(n):\n"," fixed_noise[i*n+j] = fixed_noise[0] + i*torch.eye(nz)[0][:, None, None] + j*torch.eye(nz)[1][:, None, None]\n","\n"," for n in fixed_noise:\n"," im = netG(n[None, :,: ,:])[0]\n"," plt.imshow(torch.permute(im.detach(), (1,2,0)))\n"," plt.show()"]},{"cell_type":"markdown","metadata":{"id":"nDMasgAOS8aa"},"source":[""]},{"cell_type":"markdown","metadata":{"id":"cgRBSaWRTAtT"},"source":["D'après les propriétés énnoncées, nous savons que la distance de Wasserstein est Lipschitz sur l'espace engendré par le générateur. Par conséquent, nous remarquons que toutes les images sont des barycentres de Wasserstein pour les autres."]},{"cell_type":"markdown","metadata":{"id":"cyp-fhG03bS3"},"source":["## Conclusion\n","\n","Notre exploration des Wasserstein GANs, telle que détaillée dans ce projet, nous a permis de nous familiariser avec des concepts clés tels que le Generative Adversarial Network (GAN), la distance de Wasserstein, et les techniques avancées de traitement de données. Cette compréhension approfondie nous a équipés avec une perspective unique et une connaissance approfondie des mécanismes sous-jacents aux GANs, ainsi que de leur potentiel dans des applications variées.\n","\n","En regardant vers l'avenir, nous identifions plusieurs domaines potentiels d'amélioration et de recherche. Parmi ceux-ci, comparer les Wasserstein GANs avec d'autres formes de GANs utilisant différentes fonctions de coût se présente comme une piste prometteuse. De plus, l'optimisation des paramètres du modèle, en se concentrant sur des aspects tels que le taux d'apprentissage, le clipping, et le nombre d'itérations du discriminant, pourrait conduire à des avancées significatives dans la performance et l'efficacité des GANs."]}],"metadata":{"colab":{"provenance":[],"toc_visible":true},"kernelspec":{"display_name":"Python 3 (ipykernel)","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.11.7"}},"nbformat":4,"nbformat_minor":0} \ No newline at end of file +{"cells":[{"cell_type":"markdown","metadata":{"id":"arqpDh95Zt6W"},"source":["# Wasserstein GAN\n","\n","L'objectif de ce projet était d'étudier les GANs dans le cas de la distance de Wasserstein.\n","\n","Voici les membres de notre groupe classés par ordres alphabétiques pour leur nom de famille :\n","- Paul Corbalan\n","- Nicolas Gonel\n","- Oihan Joyot\n","- Tristan Portugues\n","- Florian Zorzynski\n","\n","Notre projet s'inspire grandement des ressources suivantes qui sont l'article initial de notre projet ainsi que le code correspondant.\n","- Article : [[1701.07875] Wasserstein GAN (arxiv.org)](https://arxiv.org/abs/1701.07875)\n","- Code : [martinarjovsky/WassersteinGAN (github.com)](https://github.com/martinarjovsky/WassersteinGAN)\n","\n","Un répertoire pour ce projet en général est disponible à l'adresse suivante :\n","https://code.paul-corbalan.com/paul-corbalan/wasserstein-gan\n","\n","---"]},{"cell_type":"markdown","metadata":{"id":"Hke_hyXT3bSP"},"source":["## Introduction\n","\n","Les Réseaux Antagonistes Génératifs (GANs) représentent une avancée majeure dans le domaine de l'apprentissage profond, révolutionnant la manière dont les machines comprennent et génèrent des données, en particulier des images. Cette technologie imite la façon dont les humains apprennent et créent, ouvrant des portes vers des applications innovantes allant de l'art numérique à des solutions médicales avancées. Le projet \"Wasserstein GAN\" s'inscrit dans cette perspective, visant à explorer une variante spécifique des GANs qui utilise la distance de Wasserstein pour améliorer la stabilité et la qualité des résultats.\n","\n","Le choix de la distance de Wasserstein comme métrique clé dans notre projet offre un avantage distinct sur les méthodes traditionnelles. Elle permet de surmonter certains des défis inhérents aux GANs classiques, comme le mode collapse et les problèmes de convergence. En se concentrant sur cette approche, notre projet cherche à démontrer comment une compréhension approfondie de la théorie mathématique peut être appliquée efficacement pour améliorer la performance et la fiabilité des modèles génératifs.\n","\n","Ce notebook est conçu pour servir d'outil d'apprentissage et d'exploration dans le domaine des GANs, avec un accent particulier sur les Wasserstein GANs. Il guide le lecteur à travers les principes fondamentaux, les défis et les solutions uniques associés à cette technologie, offrant un mélange d'explications théoriques et d'applications pratiques. L'objectif est de fournir une base solide pour comprendre et utiliser les Wasserstein GANs."]},{"cell_type":"markdown","metadata":{"id":"P_O5MYE_xMU5"},"source":["## Generative Adversarial Network (GAN)\n","\n","Les GANs sont des modèles d'apprentissage profond définis par deux réseaux neuronaux, le générateur $G$ et le discriminateur $D$.\n","\n"," Le générateur crée des données, tandis que le discriminateur les évalue. L'objectif du générateur est d'approcher un distribution $\\mathbb{P}_g$ inconnue telle que les données générées $G(z)$ soient indiscernables des données réelles $x$, où $z$ un vecteur de notre espace latent. Le discriminateur est entraîné à faire la distinction entre un inputs et $x$.\n","\n"," Les deux modèles sont mis en compétition et $G$ cherche à minimiser la probabilité que $D$ fasse la distinction entre $G(z)$ et $x$, tandis que $D$ cherche à maximiser cette probabilité.\n","\n","Formellement, cela correspond à résoudre le problème min-max pour :\n","$$V(D, G) = \\mathbb{E}_{x \\sim \\mathbb{P}_{r}}[\\log D(x)] + \\mathbb{E}_{z \\sim \\mathbb{P}_z}[\\log(1 - D(G(z)))]$$\n","où le problème est le suivant :\n","$$\n","\\min _G \\max _D V(D, G)\n","$$\n","\n"," Cette minimisation utilise la log-vraissemblance négative et est la solution d'origine pour arriver à un équilibre entre le générateur et le discriminateur. Cependant cette méthode peut présenter plusieurs problèmes:\n"," - des \"modes collapse\" où l'entraînement converge vers une solution oubliant certaines particularités de la distibution cherché.\n"," - des gradients évanescents, lorsque le discriminateur devient trop parfait, il devient impossible de générer un gradient utilisable à partir de la sortie du discriminateur.\n","\n"," On va donc chercher un moyen de résoudre ces problèmes en changeant de fonction de perte et on va essayer d'utiliser la distance de wasserstein."]},{"cell_type":"markdown","metadata":{"id":"yIx0TILzG6-l"},"source":["## Distance de Wasserstein\n","\n","### Définition\n","\n","En mathématiques, la distance de Wasserstein est une fonction définie entre des distributions de probabilité sur un espace métrique donné $(M,d)$. La distance de Wasserstein d'ordre $p \\in \\left[1,+\\infty \\right]$ entre deux mesures de probabilité $\\mu$ et $\\nu$ définies sur $M$ (avec des moments finis de l'ordre $p$) est définie par :\n","\n","\\begin{equation}\n","\\begin{split}\n","{\\displaystyle W_{p}(\\mu ,\\nu )=\\left(\\inf _{\\gamma \\in \\Gamma (\\mu ,\\nu )}\\mathbf {E} _{(x,y)\\sim \\gamma }d(x,y)^{p}\\right)^{1/p}.}\n","\\end{split}\n","\\end{equation}\n","\n","L'infimum est pris sur $\\Gamma (\\mu,\\nu )$, l'ensemble de tous les couplages dont les distributions marginales sont respectivement $\\mu$ et $\\nu$.\n","\n","### Interprétation physique\n","\n","Cette métrique est également connue sous le nom de earth mover distance. De manière intuitive, si l'on imagine chaque distribution comme une unité de terre empilée sur un espace métrique $M$, la métrique représente le coût minimal pour remodeler une pile en une autre. Ce coût est conçu comme la quantité de terre à déplacer, multipliée par la distance moyenne qu'elle doit parcourir.\n","\n","En d'autres termes, la distance de Wasserstein fournit une mesure précise du coût minimal nécessaire pour transformer une distribution de probabilité en une autre, tout en minimisant le coût total de ce déplacement. C'est pourquoi l'avantage de cette distance réside dans son incorporation des concepts de transport optimal et de couplage, tous deux pertinents et pratiques pour l'étude.\n","\n","### Utilisation pour les images numériques\n","\n","Pour résumer, la distance de Wasserstein est une manière naturelle de comparer les distributions de probabilité de deux variables, où une variable est dérivée de l'autre par de petites perturbations non uniformes (aléatoires ou déterministes). C'est pourquoi, en informatique, cette métrique est largement utilisée pour comparer des distributions discrètes, notamment les histogrammes de couleur de deux images numériques.\n","\n","\n","### Calcul numérique\n","\n","Le problème principal de cette distance est son calcul, l'infimum étant très compliqué à calculer. Heureusement, la dualité de Kantorovich-Rubinstein nous donne :\n","\\begin{equation}\n","W(\\mathbb{P}_r, \\mathbb{P}_{\\theta})=\\frac{1}{K}\\sup_{||f|| 0.7:\n"," print(f\"Image {filename} is predicted as a human face and will be moved.\")\n"," shutil.copy(os.path.join(folder_path, filename), 'predicted_humans')\n","\n","\n","predict_and_move(\"..\")"]},{"cell_type":"markdown","metadata":{"id":"Pl2UlIxJMb-s"},"source":["![confusion.svg](data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->

<svg
   version="1.1"
   id="svg1"
   width="614.40002"
   height="460.79999"
   viewBox="0 0 614.40002 460.79999"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:svg="http://www.w3.org/2000/svg">
  <defs
     id="defs1">
    <clipPath
       clipPathUnits="userSpaceOnUse"
       id="clipPath4">
      <path
         d="M 57.6,38.016 H 414.72 V 304.128 H 57.6 Z"
         id="path4" />
    </clipPath>
    <clipPath
       clipPathUnits="userSpaceOnUse"
       id="clipPath6">
      <path
         d="M 57.6,38.016 H 414.72 V 304.128 H 57.6 Z"
         id="path6" />
    </clipPath>
    <clipPath
       clipPathUnits="userSpaceOnUse"
       id="clipPath8">
      <path
         d="M 57.6,38.016 H 414.72 V 304.128 H 57.6 Z"
         id="path8" />
    </clipPath>
    <clipPath
       clipPathUnits="userSpaceOnUse"
       id="clipPath10">
      <path
         d="M 57.6,38.016 H 414.72 V 304.128 H 57.6 Z"
         id="path10" />
    </clipPath>
  </defs>
  <g
     id="g1">
    <path
       id="path1"
       d="M 0,0 H 460.8 V 345.6 H 0 Z"
       style="fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none"
       transform="matrix(1.3333333,0,0,-1.3333333,0,460.8)" />
    <path
       id="path2"
       d="M 57.6,38.016 H 414.72 V 304.128 H 57.6 Z"
       style="fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none"
       transform="matrix(1.3333333,0,0,-1.3333333,0,460.8)" />
    <path
       id="path3"
       d="M 57.6,304.128 H 236.16 V 171.072 H 57.6 v 133.056"
       style="fill:#b2d2e8;fill-opacity:1;fill-rule:nonzero;stroke:none"
       transform="matrix(1.3333333,0,0,-1.3333333,0,460.8)"
       clip-path="url(#clipPath4)" />
    <path
       id="path5"
       d="M 236.16,304.128 H 414.72 V 171.072 H 236.16 v 133.056"
       style="fill:#f2f8fd;fill-opacity:1;fill-rule:nonzero;stroke:none"
       transform="matrix(1.3333333,0,0,-1.3333333,0,460.8)"
       clip-path="url(#clipPath6)" />
    <path
       id="path7"
       d="M 57.6,171.072 H 236.16 V 38.016 H 57.6 v 133.056"
       style="fill:#f7fbff;fill-opacity:1;fill-rule:nonzero;stroke:none"
       transform="matrix(1.3333333,0,0,-1.3333333,0,460.8)"
       clip-path="url(#clipPath8)" />
    <path
       id="path9"
       d="M 236.16,171.072 H 414.72 V 38.016 H 236.16 v 133.056"
       style="fill:#08306b;fill-opacity:1;fill-rule:nonzero;stroke:none"
       transform="matrix(1.3333333,0,0,-1.3333333,0,460.8)"
       clip-path="url(#clipPath10)" />
    <path
       id="path11"
       d="m 146.88,38.016 v -3.5"
       style="fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:#000000;stroke-width:0.8;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none;stroke-opacity:1"
       transform="matrix(1.3333333,0,0,-1.3333333,0,460.8)" />
    <text
       id="text11"
       xml:space="preserve"
       transform="matrix(1.3333333,0,0,1.3333333,156.07958,429.57033)"><tspan
         style="font-variant:normal;font-weight:normal;font-size:10px;font-family:'DejaVu Sans';writing-mode:lr-tb;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none"
         x="0 7.48 13.6 19.940001 23.549999 31.07 37.41 47.150002 53.279999"
         y="0"
         id="tspan11">Non-Human</tspan></text>
    <path
       id="path12"
       d="m 325.44,38.016 v -3.5"
       style="fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:#000000;stroke-width:0.8;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none;stroke-opacity:1"
       transform="matrix(1.3333333,0,0,-1.3333333,0,460.8)" />
    <text
       id="text12"
       xml:space="preserve"
       transform="matrix(1.3333333,0,0,1.3333333,409.86792,429.57033)"><tspan
         style="font-variant:normal;font-weight:normal;font-size:10px;font-family:'DejaVu Sans';writing-mode:lr-tb;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none"
         x="0 7.52 13.86 23.6 29.73"
         y="0"
         id="tspan12">Human</tspan></text>
    <text
       id="text13"
       xml:space="preserve"
       transform="matrix(1.3333333,0,0,1.3333333,283.5675,447.7995)"><tspan
         style="font-variant:normal;font-weight:normal;font-size:10px;font-family:'DejaVu Sans';writing-mode:lr-tb;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none"
         x="0 5.8581252 9.7493753 15.899375 22.249374 25.029375 30.529375 34.449375 40.599377"
         y="0"
         id="tspan13">Predicted</tspan></text>
    <path
       id="path13"
       d="M 57.6,237.6 H 54.1"
       style="fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:#000000;stroke-width:0.8;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none;stroke-opacity:1"
       transform="matrix(1.3333333,0,0,-1.3333333,0,460.8)" />
    <text
       id="text14"
       xml:space="preserve"
       transform="matrix(0,-1.3333333,1.3333333,0,64.695833,183.76042)"><tspan
         style="font-variant:normal;font-weight:normal;font-size:10px;font-family:'DejaVu Sans';writing-mode:lr-tb;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none"
         x="0 7.48 13.6 19.940001 23.549999 31.07 37.41 47.150002 53.279999"
         y="0"
         id="tspan14">Non-Human</tspan></text>
    <path
       id="path14"
       d="M 57.6,104.544 H 54.1"
       style="fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:#000000;stroke-width:0.8;stroke-linecap:butt;stroke-linejoin:round;stroke-miterlimit:10;stroke-dasharray:none;stroke-opacity:1"
       transform="matrix(1.3333333,0,0,-1.3333333,0,460.8)" />
    <text
       id="text15"
       xml:space="preserve"
       transform="matrix(0,-1.3333333,1.3333333,0,64.695833,345.46008)"><tspan
         style="font-variant:normal;font-weight:normal;font-size:10px;font-family:'DejaVu Sans';writing-mode:lr-tb;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none"
         x="0 7.52 13.86 23.6 29.73"
         y="0"
         id="tspan15">Human</tspan></text>
    <text
       id="text16"
       xml:space="preserve"
       transform="matrix(0,-1.3333333,1.3333333,0,46.466667,246.84983)"><tspan
         style="font-variant:normal;font-weight:normal;font-size:10px;font-family:'DejaVu Sans';writing-mode:lr-tb;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none"
         x="0 4.6412501 8.7512503 15.09125"
         y="0"
         id="tspan16">True</tspan></text>
    <text
       id="text17"
       xml:space="preserve"
       transform="matrix(1.3333333,0,0,1.3333333,183.12125,147.67708)"><tspan
         style="font-variant:normal;font-weight:normal;font-size:10px;font-family:'DejaVu Sans';writing-mode:lr-tb;fill:#262626;fill-opacity:1;fill-rule:nonzero;stroke:none"
         x="0 6.3600001 12.72"
         y="0"
         id="tspan17">676</tspan></text>
    <text
       id="text18"
       xml:space="preserve"
       transform="matrix(1.3333333,0,0,1.3333333,421.20125,147.67708)"><tspan
         style="font-variant:normal;font-weight:normal;font-size:10px;font-family:'DejaVu Sans';writing-mode:lr-tb;fill:#262626;fill-opacity:1;fill-rule:nonzero;stroke:none"
         x="0 6.3600001 12.72"
         y="0"
         id="tspan18">180</tspan></text>
    <text
       id="text19"
       xml:space="preserve"
       transform="matrix(1.3333333,0,0,1.3333333,183.12125,325.08508)"><tspan
         style="font-variant:normal;font-weight:normal;font-size:10px;font-family:'DejaVu Sans';writing-mode:lr-tb;fill:#262626;fill-opacity:1;fill-rule:nonzero;stroke:none"
         x="0 6.3600001 12.72"
         y="0"
         id="tspan19">139</tspan></text>
    <text
       id="text20"
       xml:space="preserve"
       transform="matrix(1.3333333,0,0,1.3333333,416.96167,325.08508)"><tspan
         style="font-variant:normal;font-weight:normal;font-size:10px;font-family:'DejaVu Sans';writing-mode:lr-tb;fill:#ffffff;fill-opacity:1;fill-rule:nonzero;stroke:none"
         x="0 6.3600001 12.72 19.08"
         y="0"
         id="tspan20">1841</tspan></text>
    <text
       id="text21"
       xml:space="preserve"
       transform="matrix(1.3333333,0,0,1.3333333,247.34875,47.296)"><tspan
         style="font-variant:normal;font-weight:normal;font-size:12px;font-family:'DejaVu Sans';writing-mode:lr-tb;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none"
         x="0 8.3760004 15.72 23.327999 27.552 35.16 41.411999 44.748001 52.091999 59.700001 63.515999 73.872002 81.227997 85.931999 90.863998 94.199997"
         y="0"
         id="tspan21">Confusion Matrix</tspan></text>
  </g>
</svg>
)"]},{"cell_type":"markdown","metadata":{"id":"vEH1G2zSIZ3p"},"source":["L'ensemble de données a ensuite été mis à l'échelle pour appliquer le filtre de convolution à l'aide de la commande :\n","```shell\n","convert *.png resized 400% *upscaled*/*.png\n","```\n","\n","Les données finales peuvent être téléchargées sur :\n","https://code.paul-corbalan.com/paul-corbalan/wasserstein-gan/media/branch/master/data/predicted_humans.zip"]},{"cell_type":"markdown","metadata":{"id":"xA3azaz1US4k"},"source":["## Architecture du modèle GAN\n","\n","Dans cette partie sont décrites les architectures du discriminateur et du générateur de notre modèle."]},{"cell_type":"markdown","metadata":{"id":"dxaMaimlY21r"},"source":["### Discriminateur"]},{"cell_type":"markdown","metadata":{"id":"dFj_wV-i4dIG"},"source":["![netD_architecture.svg](data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
 "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<!-- Generated by graphviz version 8.1.0 (20230707.0739)
 -->
<!-- Pages: 1 -->
<svg width="776pt" height="864pt"
 viewBox="0.00 0.00 776.48 864.00" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
<g id="graph0" class="graph" transform="scale(0.977929 0.977929) rotate(0) translate(4 879.5)">
<polygon fill="white" stroke="none" points="-4,4 -4,-879.5 790,-879.5 790,4 -4,4"/>
<!-- 140244940585680 -->
<g id="node1" class="node">
<title>140244940585680</title>
<polygon fill="#caff70" stroke="black" points="684,-34.25 630,-34.25 630,0 684,0 684,-34.25"/>
<text text-anchor="middle" x="657" y="-8.75" font-family="monospace" font-size="10.00"> (1)</text>
</g>
<!-- 140244943583744 -->
<g id="node2" class="node">
<title>140244943583744</title>
<polygon fill="lightgrey" stroke="black" points="653,-98.5 559,-98.5 559,-76.25 653,-76.25 653,-98.5"/>
<text text-anchor="middle" x="606" y="-85" font-family="monospace" font-size="10.00">ViewBackward0</text>
</g>
<!-- 140244943583744&#45;&gt;140244940585680 -->
<g id="edge27" class="edge">
<title>140244943583744&#45;&gt;140244940585680</title>
<path fill="none" stroke="black" d="M613.75,-76.01C620.21,-67.36 629.7,-54.66 638.14,-43.37"/>
<polygon fill="black" stroke="black" points="641.43,-45.81 644.61,-35.71 635.82,-41.62 641.43,-45.81"/>
</g>
<!-- 140244943583552 -->
<g id="node3" class="node">
<title>140244943583552</title>
<polygon fill="lightgrey" stroke="black" points="704,-162.75 610,-162.75 610,-140.5 704,-140.5 704,-162.75"/>
<text text-anchor="middle" x="657" y="-149.25" font-family="monospace" font-size="10.00">MeanBackward1</text>
</g>
<!-- 140244943583552&#45;&gt;140244943583744 -->
<g id="edge1" class="edge">
<title>140244943583552&#45;&gt;140244943583744</title>
<path fill="none" stroke="black" d="M648.35,-140.07C640.98,-131.07 630.21,-117.92 621.37,-107.14"/>
<polygon fill="black" stroke="black" points="623.57,-105.3 614.52,-99.78 618.15,-109.73 623.57,-105.3"/>
</g>
<!-- 140244940585584 -->
<g id="node29" class="node">
<title>140244940585584</title>
<polygon fill="#a2cd5a" stroke="black" points="747,-104.5 671,-104.5 671,-70.25 747,-70.25 747,-104.5"/>
<text text-anchor="middle" x="709" y="-79" font-family="monospace" font-size="10.00"> (1, 1, 1)</text>
</g>
<!-- 140244943583552&#45;&gt;140244940585584 -->
<g id="edge28" class="edge">
<title>140244943583552&#45;&gt;140244940585584</title>
<path fill="none" stroke="black" d="M665.82,-140.07C672.03,-132.63 680.61,-122.36 688.49,-112.93"/>
<polygon fill="black" stroke="black" points="691.71,-115.53 695.44,-105.61 686.34,-111.04 691.71,-115.53"/>
</g>
<!-- 140244943584032 -->
<g id="node4" class="node">
<title>140244943584032</title>
<polygon fill="lightgrey" stroke="black" points="725,-221 589,-221 589,-198.75 725,-198.75 725,-221"/>
<text text-anchor="middle" x="657" y="-207.5" font-family="monospace" font-size="10.00">ConvolutionBackward0</text>
</g>
<!-- 140244943584032&#45;&gt;140244943583552 -->
<g id="edge2" class="edge">
<title>140244943584032&#45;&gt;140244943583552</title>
<path fill="none" stroke="black" d="M657,-198.29C657,-191.46 657,-182.32 657,-174.02"/>
<polygon fill="black" stroke="black" points="660.5,-174.16 657,-164.16 653.5,-174.16 660.5,-174.16"/>
</g>
<!-- 140244943578080 -->
<g id="node5" class="node">
<title>140244943578080</title>
<polygon fill="lightgrey" stroke="black" points="649,-279.25 525,-279.25 525,-257 649,-257 649,-279.25"/>
<text text-anchor="middle" x="587" y="-265.75" font-family="monospace" font-size="10.00">LeakyReluBackward1</text>
</g>
<!-- 140244943578080&#45;&gt;140244943584032 -->
<g id="edge3" class="edge">
<title>140244943578080&#45;&gt;140244943584032</title>
<path fill="none" stroke="black" d="M600.17,-256.54C610.14,-248.53 624.05,-237.35 635.61,-228.06"/>
<polygon fill="black" stroke="black" points="637.29,-230.4 642.89,-221.41 632.91,-224.94 637.29,-230.4"/>
</g>
<!-- 140244943583984 -->
<g id="node6" class="node">
<title>140244943583984</title>
<polygon fill="lightgrey" stroke="black" points="662,-343.5 502,-343.5 502,-321.25 662,-321.25 662,-343.5"/>
<text text-anchor="middle" x="582" y="-330" font-family="monospace" font-size="10.00">NativeBatchNormBackward0</text>
</g>
<!-- 140244943583984&#45;&gt;140244943578080 -->
<g id="edge4" class="edge">
<title>140244943583984&#45;&gt;140244943578080</title>
<path fill="none" stroke="black" d="M582.85,-320.82C583.52,-312.45 584.48,-300.49 585.31,-290.18"/>
<polygon fill="black" stroke="black" points="588.85,-290.78 586.16,-280.53 581.87,-290.22 588.85,-290.78"/>
</g>
<!-- 140244943582592 -->
<g id="node7" class="node">
<title>140244943582592</title>
<polygon fill="lightgrey" stroke="black" points="514,-407.75 378,-407.75 378,-385.5 514,-385.5 514,-407.75"/>
<text text-anchor="middle" x="446" y="-394.25" font-family="monospace" font-size="10.00">ConvolutionBackward0</text>
</g>
<!-- 140244943582592&#45;&gt;140244943583984 -->
<g id="edge5" class="edge">
<title>140244943582592&#45;&gt;140244943583984</title>
<path fill="none" stroke="black" d="M469.07,-385.07C491.05,-375 524.37,-359.75 549.12,-348.42"/>
<polygon fill="black" stroke="black" points="550.18,-351.33 557.82,-343.99 547.27,-344.97 550.18,-351.33"/>
</g>
<!-- 140244943584848 -->
<g id="node8" class="node">
<title>140244943584848</title>
<polygon fill="lightgrey" stroke="black" points="393,-472 269,-472 269,-449.75 393,-449.75 393,-472"/>
<text text-anchor="middle" x="331" y="-458.5" font-family="monospace" font-size="10.00">LeakyReluBackward1</text>
</g>
<!-- 140244943584848&#45;&gt;140244943582592 -->
<g id="edge6" class="edge">
<title>140244943584848&#45;&gt;140244943582592</title>
<path fill="none" stroke="black" d="M350.51,-449.32C368.68,-439.48 396.02,-424.68 416.79,-413.43"/>
<polygon fill="black" stroke="black" points="418.27,-416.08 425.4,-408.24 414.94,-409.92 418.27,-416.08"/>
</g>
<!-- 140244943582448 -->
<g id="node9" class="node">
<title>140244943582448</title>
<polygon fill="lightgrey" stroke="black" points="399,-542.25 239,-542.25 239,-520 399,-520 399,-542.25"/>
<text text-anchor="middle" x="319" y="-528.75" font-family="monospace" font-size="10.00">NativeBatchNormBackward0</text>
</g>
<!-- 140244943582448&#45;&gt;140244943584848 -->
<g id="edge7" class="edge">
<title>140244943582448&#45;&gt;140244943584848</title>
<path fill="none" stroke="black" d="M320.82,-519.76C322.53,-510.04 325.14,-495.21 327.29,-483"/>
<polygon fill="black" stroke="black" points="330.88,-483.79 329.16,-473.34 323.98,-482.58 330.88,-483.79"/>
</g>
<!-- 140244943583264 -->
<g id="node10" class="node">
<title>140244943583264</title>
<polygon fill="lightgrey" stroke="black" points="251,-606.5 115,-606.5 115,-584.25 251,-584.25 251,-606.5"/>
<text text-anchor="middle" x="183" y="-593" font-family="monospace" font-size="10.00">ConvolutionBackward0</text>
</g>
<!-- 140244943583264&#45;&gt;140244943582448 -->
<g id="edge8" class="edge">
<title>140244943583264&#45;&gt;140244943582448</title>
<path fill="none" stroke="black" d="M206.07,-583.82C228.05,-573.75 261.37,-558.5 286.12,-547.17"/>
<polygon fill="black" stroke="black" points="287.18,-550.08 294.82,-542.74 284.27,-543.72 287.18,-550.08"/>
</g>
<!-- 140244943579616 -->
<g id="node11" class="node">
<title>140244943579616</title>
<polygon fill="lightgrey" stroke="black" points="134,-670.75 10,-670.75 10,-648.5 134,-648.5 134,-670.75"/>
<text text-anchor="middle" x="72" y="-657.25" font-family="monospace" font-size="10.00">LeakyReluBackward1</text>
</g>
<!-- 140244943579616&#45;&gt;140244943583264 -->
<g id="edge9" class="edge">
<title>140244943579616&#45;&gt;140244943583264</title>
<path fill="none" stroke="black" d="M90.83,-648.07C108.29,-638.27 134.52,-623.56 154.54,-612.34"/>
<polygon fill="black" stroke="black" points="156.07,-614.93 163.08,-606.99 152.64,-608.83 156.07,-614.93"/>
</g>
<!-- 140244943578176 -->
<g id="node12" class="node">
<title>140244943578176</title>
<polygon fill="lightgrey" stroke="black" points="136,-741 0,-741 0,-718.75 136,-718.75 136,-741"/>
<text text-anchor="middle" x="68" y="-727.5" font-family="monospace" font-size="10.00">ConvolutionBackward0</text>
</g>
<!-- 140244943578176&#45;&gt;140244943579616 -->
<g id="edge10" class="edge">
<title>140244943578176&#45;&gt;140244943579616</title>
<path fill="none" stroke="black" d="M68.61,-718.51C69.18,-708.79 70.05,-693.96 70.76,-681.75"/>
<polygon fill="black" stroke="black" points="74.3,-682.28 71.39,-672.09 67.31,-681.87 74.3,-682.28"/>
</g>
<!-- 140244943584512 -->
<g id="node13" class="node">
<title>140244943584512</title>
<polygon fill="lightgrey" stroke="black" points="118,-805.25 18,-805.25 18,-783 118,-783 118,-805.25"/>
<text text-anchor="middle" x="68" y="-791.75" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943584512&#45;&gt;140244943578176 -->
<g id="edge11" class="edge">
<title>140244943584512&#45;&gt;140244943578176</title>
<path fill="none" stroke="black" d="M68,-782.57C68,-774.29 68,-762.5 68,-752.27"/>
<polygon fill="black" stroke="black" points="71.5,-752.28 68,-742.28 64.5,-752.28 71.5,-752.28"/>
</g>
<!-- 140244953121040 -->
<g id="node14" class="node">
<title>140244953121040</title>
<polygon fill="lightblue" stroke="black" points="118,-875.5 18,-875.5 18,-841.25 118,-841.25 118,-875.5"/>
<text text-anchor="middle" x="68" y="-850" font-family="monospace" font-size="10.00"> (32, 3, 4, 4)</text>
</g>
<!-- 140244953121040&#45;&gt;140244943584512 -->
<g id="edge12" class="edge">
<title>140244953121040&#45;&gt;140244943584512</title>
<path fill="none" stroke="black" d="M68,-841.02C68,-833.47 68,-824.41 68,-816.34"/>
<polygon fill="black" stroke="black" points="71.5,-816.52 68,-806.52 64.5,-816.52 71.5,-816.52"/>
</g>
<!-- 140244943580480 -->
<g id="node15" class="node">
<title>140244943580480</title>
<polygon fill="lightgrey" stroke="black" points="254,-670.75 154,-670.75 154,-648.5 254,-648.5 254,-670.75"/>
<text text-anchor="middle" x="204" y="-657.25" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943580480&#45;&gt;140244943583264 -->
<g id="edge13" class="edge">
<title>140244943580480&#45;&gt;140244943583264</title>
<path fill="none" stroke="black" d="M200.44,-648.07C197.58,-639.61 193.49,-627.48 189.99,-617.1"/>
<polygon fill="black" stroke="black" points="193.02,-616.14 186.51,-607.78 186.39,-618.37 193.02,-616.14"/>
</g>
<!-- 140244953120944 -->
<g id="node16" class="node">
<title>140244953120944</title>
<polygon fill="lightblue" stroke="black" points="260,-747 154,-747 154,-712.75 260,-712.75 260,-747"/>
<text text-anchor="middle" x="207" y="-721.5" font-family="monospace" font-size="10.00"> (64, 32, 4, 4)</text>
</g>
<!-- 140244953120944&#45;&gt;140244943580480 -->
<g id="edge14" class="edge">
<title>140244953120944&#45;&gt;140244943580480</title>
<path fill="none" stroke="black" d="M206.27,-712.35C205.87,-703.15 205.36,-691.6 204.93,-681.75"/>
<polygon fill="black" stroke="black" points="208.39,-681.69 204.45,-671.85 201.39,-682 208.39,-681.69"/>
</g>
<!-- 140244943583648 -->
<g id="node17" class="node">
<title>140244943583648</title>
<polygon fill="lightgrey" stroke="black" points="369,-606.5 269,-606.5 269,-584.25 369,-584.25 369,-606.5"/>
<text text-anchor="middle" x="319" y="-593" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943583648&#45;&gt;140244943582448 -->
<g id="edge15" class="edge">
<title>140244943583648&#45;&gt;140244943582448</title>
<path fill="none" stroke="black" d="M319,-583.82C319,-575.54 319,-563.75 319,-553.52"/>
<polygon fill="black" stroke="black" points="322.5,-553.53 319,-543.53 315.5,-553.53 322.5,-553.53"/>
</g>
<!-- 140244953121520 -->
<g id="node18" class="node">
<title>140244953121520</title>
<polygon fill="lightblue" stroke="black" points="346,-676.75 292,-676.75 292,-642.5 346,-642.5 346,-676.75"/>
<text text-anchor="middle" x="319" y="-651.25" font-family="monospace" font-size="10.00"> (64)</text>
</g>
<!-- 140244953121520&#45;&gt;140244943583648 -->
<g id="edge16" class="edge">
<title>140244953121520&#45;&gt;140244943583648</title>
<path fill="none" stroke="black" d="M319,-642.27C319,-634.72 319,-625.66 319,-617.59"/>
<polygon fill="black" stroke="black" points="322.5,-617.77 319,-607.77 315.5,-617.77 322.5,-617.77"/>
</g>
<!-- 140244943584800 -->
<g id="node19" class="node">
<title>140244943584800</title>
<polygon fill="lightgrey" stroke="black" points="487,-606.5 387,-606.5 387,-584.25 487,-584.25 487,-606.5"/>
<text text-anchor="middle" x="437" y="-593" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943584800&#45;&gt;140244943582448 -->
<g id="edge17" class="edge">
<title>140244943584800&#45;&gt;140244943582448</title>
<path fill="none" stroke="black" d="M416.98,-583.82C398.25,-573.93 370.03,-559.05 348.68,-547.78"/>
<polygon fill="black" stroke="black" points="350.59,-544.31 340.12,-542.74 347.33,-550.5 350.59,-544.31"/>
</g>
<!-- 140244953121328 -->
<g id="node20" class="node">
<title>140244953121328</title>
<polygon fill="lightblue" stroke="black" points="464,-676.75 410,-676.75 410,-642.5 464,-642.5 464,-676.75"/>
<text text-anchor="middle" x="437" y="-651.25" font-family="monospace" font-size="10.00"> (64)</text>
</g>
<!-- 140244953121328&#45;&gt;140244943584800 -->
<g id="edge18" class="edge">
<title>140244953121328&#45;&gt;140244943584800</title>
<path fill="none" stroke="black" d="M437,-642.27C437,-634.72 437,-625.66 437,-617.59"/>
<polygon fill="black" stroke="black" points="440.5,-617.77 437,-607.77 433.5,-617.77 440.5,-617.77"/>
</g>
<!-- 140244943585184 -->
<g id="node21" class="node">
<title>140244943585184</title>
<polygon fill="lightgrey" stroke="black" points="517,-472 417,-472 417,-449.75 517,-449.75 517,-472"/>
<text text-anchor="middle" x="467" y="-458.5" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943585184&#45;&gt;140244943582592 -->
<g id="edge19" class="edge">
<title>140244943585184&#45;&gt;140244943582592</title>
<path fill="none" stroke="black" d="M463.44,-449.32C460.58,-440.86 456.49,-428.73 452.99,-418.35"/>
<polygon fill="black" stroke="black" points="456.02,-417.39 449.51,-409.03 449.39,-419.62 456.02,-417.39"/>
</g>
<!-- 140244953130064 -->
<g id="node22" class="node">
<title>140244953130064</title>
<polygon fill="lightblue" stroke="black" points="529,-548.25 417,-548.25 417,-514 529,-514 529,-548.25"/>
<text text-anchor="middle" x="473" y="-522.75" font-family="monospace" font-size="10.00"> (128, 64, 4, 4)</text>
</g>
<!-- 140244953130064&#45;&gt;140244943585184 -->
<g id="edge20" class="edge">
<title>140244953130064&#45;&gt;140244943585184</title>
<path fill="none" stroke="black" d="M471.55,-513.6C470.74,-504.4 469.72,-492.85 468.86,-483"/>
<polygon fill="black" stroke="black" points="472.26,-482.76 467.9,-473.1 465.29,-483.37 472.26,-482.76"/>
</g>
<!-- 140244943583696 -->
<g id="node23" class="node">
<title>140244943583696</title>
<polygon fill="lightgrey" stroke="black" points="632,-407.75 532,-407.75 532,-385.5 632,-385.5 632,-407.75"/>
<text text-anchor="middle" x="582" y="-394.25" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943583696&#45;&gt;140244943583984 -->
<g id="edge21" class="edge">
<title>140244943583696&#45;&gt;140244943583984</title>
<path fill="none" stroke="black" d="M582,-385.07C582,-376.79 582,-365 582,-354.77"/>
<polygon fill="black" stroke="black" points="585.5,-354.78 582,-344.78 578.5,-354.78 585.5,-354.78"/>
</g>
<!-- 140244953130160 -->
<g id="node24" class="node">
<title>140244953130160</title>
<polygon fill="lightblue" stroke="black" points="609,-478 555,-478 555,-443.75 609,-443.75 609,-478"/>
<text text-anchor="middle" x="582" y="-452.5" font-family="monospace" font-size="10.00"> (128)</text>
</g>
<!-- 140244953130160&#45;&gt;140244943583696 -->
<g id="edge22" class="edge">
<title>140244953130160&#45;&gt;140244943583696</title>
<path fill="none" stroke="black" d="M582,-443.52C582,-435.97 582,-426.91 582,-418.84"/>
<polygon fill="black" stroke="black" points="585.5,-419.02 582,-409.02 578.5,-419.02 585.5,-419.02"/>
</g>
<!-- 140244943583312 -->
<g id="node25" class="node">
<title>140244943583312</title>
<polygon fill="lightgrey" stroke="black" points="750,-407.75 650,-407.75 650,-385.5 750,-385.5 750,-407.75"/>
<text text-anchor="middle" x="700" y="-394.25" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943583312&#45;&gt;140244943583984 -->
<g id="edge23" class="edge">
<title>140244943583312&#45;&gt;140244943583984</title>
<path fill="none" stroke="black" d="M679.98,-385.07C661.25,-375.18 633.03,-360.3 611.68,-349.03"/>
<polygon fill="black" stroke="black" points="613.59,-345.56 603.12,-343.99 610.33,-351.75 613.59,-345.56"/>
</g>
<!-- 140244953130256 -->
<g id="node26" class="node">
<title>140244953130256</title>
<polygon fill="lightblue" stroke="black" points="727,-478 673,-478 673,-443.75 727,-443.75 727,-478"/>
<text text-anchor="middle" x="700" y="-452.5" font-family="monospace" font-size="10.00"> (128)</text>
</g>
<!-- 140244953130256&#45;&gt;140244943583312 -->
<g id="edge24" class="edge">
<title>140244953130256&#45;&gt;140244943583312</title>
<path fill="none" stroke="black" d="M700,-443.52C700,-435.97 700,-426.91 700,-418.84"/>
<polygon fill="black" stroke="black" points="703.5,-419.02 700,-409.02 696.5,-419.02 703.5,-419.02"/>
</g>
<!-- 140244943578704 -->
<g id="node27" class="node">
<title>140244943578704</title>
<polygon fill="lightgrey" stroke="black" points="777,-279.25 677,-279.25 677,-257 777,-257 777,-279.25"/>
<text text-anchor="middle" x="727" y="-265.75" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943578704&#45;&gt;140244943584032 -->
<g id="edge25" class="edge">
<title>140244943578704&#45;&gt;140244943584032</title>
<path fill="none" stroke="black" d="M713.83,-256.54C703.86,-248.53 689.95,-237.35 678.39,-228.06"/>
<polygon fill="black" stroke="black" points="681.09,-224.94 671.11,-221.41 676.71,-230.4 681.09,-224.94"/>
</g>
<!-- 140244953130640 -->
<g id="node28" class="node">
<title>140244953130640</title>
<polygon fill="lightblue" stroke="black" points="786,-349.5 680,-349.5 680,-315.25 786,-315.25 786,-349.5"/>
<text text-anchor="middle" x="733" y="-324" font-family="monospace" font-size="10.00"> (1, 128, 4, 4)</text>
</g>
<!-- 140244953130640&#45;&gt;140244943578704 -->
<g id="edge26" class="edge">
<title>140244953130640&#45;&gt;140244943578704</title>
<path fill="none" stroke="black" d="M731.42,-315.02C730.7,-307.47 729.82,-298.41 729.04,-290.34"/>
<polygon fill="black" stroke="black" points="732.45,-290.14 728,-280.52 725.48,-290.81 732.45,-290.14"/>
</g>
<!-- 140244940585584&#45;&gt;140244940585680 -->
<g id="edge29" class="edge">
<title>140244940585584&#45;&gt;140244940585680</title>
<path fill="none" stroke="black" stroke-dasharray="1,5" d="M696.41,-69.85C690.28,-61.81 682.78,-51.96 675.97,-43.02"/>
<polygon fill="black" stroke="black" points="678.32,-41.33 669.47,-35.49 672.75,-45.57 678.32,-41.33"/>
</g>
</g>
</svg>
)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"5DgOVOMHSMqA"},"outputs":[],"source":["class DCGAN_D(nn.Module):\n"," def __init__(self, isize, nz, nc, ndf, ngpu, n_extra_layers=0):\n"," super(DCGAN_D, self).__init__()\n"," self.ngpu = ngpu\n"," assert isize % 16 == 0, \"isize has to be a multiple of 16\"\n","\n"," main = nn.Sequential()\n"," # inputs is nc x isize x isize\n"," main.add_module('initial:{0}-{1}:conv'.format(nc, ndf),\n"," nn.Conv2d(nc, ndf, 4, 2, 1, bias=False))\n"," main.add_module('initial:{0}:relu'.format(ndf),\n"," nn.LeakyReLU(0.2, inplace=True))\n"," csize, cndf = isize / 2, ndf\n","\n"," # Extra layers\n"," for t in range(n_extra_layers):\n"," main.add_module('extra-layers-{0}:{1}:conv'.format(t, cndf),\n"," nn.Conv2d(cndf, cndf, 3, 1, 1, bias=False))\n"," main.add_module('extra-layers-{0}:{1}:batchnorm'.format(t, cndf),\n"," nn.BatchNorm2d(cndf))\n"," main.add_module('extra-layers-{0}:{1}:relu'.format(t, cndf),\n"," nn.LeakyReLU(0.2, inplace=True))\n","\n"," while csize > 4:\n"," in_feat = cndf\n"," out_feat = cndf * 2\n"," main.add_module('pyramid:{0}-{1}:conv'.format(in_feat, out_feat),\n"," nn.Conv2d(in_feat, out_feat, 4, 2, 1, bias=False))\n"," main.add_module('pyramid:{0}:batchnorm'.format(out_feat),\n"," nn.BatchNorm2d(out_feat))\n"," main.add_module('pyramid:{0}:relu'.format(out_feat),\n"," nn.LeakyReLU(0.2, inplace=True))\n"," cndf = cndf * 2\n"," csize = csize / 2\n","\n"," # state size. K x 4 x 4\n"," main.add_module('final:{0}-{1}:conv'.format(cndf, 1),\n"," nn.Conv2d(cndf, 1, 4, 1, 0, bias=False))\n"," self.main = main\n","\n","\n"," def forward(self, inputs):\n"," if isinstance(inputs.data, torch.cuda.FloatTensor) and self.ngpu > 1:\n"," output = nn.parallel.data_parallel(self.main, inputs, range(self.ngpu))\n"," else:\n"," output = self.main(inputs)\n","\n"," output = output.mean(0)\n"," return output.view(1)"]},{"cell_type":"markdown","metadata":{"id":"2X34F3vIY-6c"},"source":["### Generateur"]},{"cell_type":"markdown","metadata":{"id":"Kg60CsB74fHR"},"source":["![netG_architecture.svg](data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
 "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<!-- Generated by graphviz version 8.1.0 (20230707.0739)
 -->
<!-- Pages: 1 -->
<svg width="864pt" height="824pt"
 viewBox="0.00 0.00 864.00 824.35" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
<g id="graph0" class="graph" transform="scale(0.933045 0.933045) rotate(0) translate(4 879.5)">
<polygon fill="white" stroke="none" points="-4,4 -4,-879.5 922,-879.5 922,4 -4,4"/>
<!-- 140244940661072 -->
<g id="node1" class="node">
<title>140244940661072</title>
<polygon fill="#caff70" stroke="black" points="846,-34.25 740,-34.25 740,0 846,0 846,-34.25"/>
<text text-anchor="middle" x="793" y="-8.75" font-family="monospace" font-size="10.00"> (1, 3, 32, 32)</text>
</g>
<!-- 140244943580000 -->
<g id="node2" class="node">
<title>140244943580000</title>
<polygon fill="lightgrey" stroke="black" points="840,-92.5 746,-92.5 746,-70.25 840,-70.25 840,-92.5"/>
<text text-anchor="middle" x="793" y="-79" font-family="monospace" font-size="10.00">TanhBackward0</text>
</g>
<!-- 140244943580000&#45;&gt;140244940661072 -->
<g id="edge31" class="edge">
<title>140244943580000&#45;&gt;140244940661072</title>
<path fill="none" stroke="black" d="M793,-69.82C793,-63.06 793,-53.97 793,-45.3"/>
<polygon fill="black" stroke="black" points="796.5,-45.36 793,-35.36 789.5,-45.36 796.5,-45.36"/>
</g>
<!-- 140244943580432 -->
<g id="node3" class="node">
<title>140244943580432</title>
<polygon fill="lightgrey" stroke="black" points="861,-150.75 725,-150.75 725,-128.5 861,-128.5 861,-150.75"/>
<text text-anchor="middle" x="793" y="-137.25" font-family="monospace" font-size="10.00">ConvolutionBackward0</text>
</g>
<!-- 140244943580432&#45;&gt;140244943580000 -->
<g id="edge1" class="edge">
<title>140244943580432&#45;&gt;140244943580000</title>
<path fill="none" stroke="black" d="M793,-128.04C793,-121.21 793,-112.07 793,-103.77"/>
<polygon fill="black" stroke="black" points="796.5,-103.91 793,-93.91 789.5,-103.91 796.5,-103.91"/>
</g>
<!-- 140244943578320 -->
<g id="node4" class="node">
<title>140244943578320</title>
<polygon fill="lightgrey" stroke="black" points="775,-209 681,-209 681,-186.75 775,-186.75 775,-209"/>
<text text-anchor="middle" x="728" y="-195.5" font-family="monospace" font-size="10.00">ReluBackward0</text>
</g>
<!-- 140244943578320&#45;&gt;140244943580432 -->
<g id="edge2" class="edge">
<title>140244943578320&#45;&gt;140244943580432</title>
<path fill="none" stroke="black" d="M740.23,-186.29C749.4,-178.36 762.15,-167.32 772.82,-158.09"/>
<polygon fill="black" stroke="black" points="774.56,-160.35 779.83,-151.16 769.98,-155.05 774.56,-160.35"/>
</g>
<!-- 140244943580192 -->
<g id="node5" class="node">
<title>140244943580192</title>
<polygon fill="lightgrey" stroke="black" points="800,-273.25 640,-273.25 640,-251 800,-251 800,-273.25"/>
<text text-anchor="middle" x="720" y="-259.75" font-family="monospace" font-size="10.00">NativeBatchNormBackward0</text>
</g>
<!-- 140244943580192&#45;&gt;140244943578320 -->
<g id="edge3" class="edge">
<title>140244943580192&#45;&gt;140244943578320</title>
<path fill="none" stroke="black" d="M721.36,-250.57C722.43,-242.2 723.97,-230.24 725.29,-219.93"/>
<polygon fill="black" stroke="black" points="728.86,-220.64 726.66,-210.28 721.92,-219.75 728.86,-220.64"/>
</g>
<!-- 140244943576880 -->
<g id="node6" class="node">
<title>140244943576880</title>
<polygon fill="lightgrey" stroke="black" points="652,-337.5 516,-337.5 516,-315.25 652,-315.25 652,-337.5"/>
<text text-anchor="middle" x="584" y="-324" font-family="monospace" font-size="10.00">ConvolutionBackward0</text>
</g>
<!-- 140244943576880&#45;&gt;140244943580192 -->
<g id="edge4" class="edge">
<title>140244943576880&#45;&gt;140244943580192</title>
<path fill="none" stroke="black" d="M607.07,-314.82C629.05,-304.75 662.37,-289.5 687.12,-278.17"/>
<polygon fill="black" stroke="black" points="688.18,-281.08 695.82,-273.74 685.27,-274.72 688.18,-281.08"/>
</g>
<!-- 140244943582208 -->
<g id="node7" class="node">
<title>140244943582208</title>
<polygon fill="lightgrey" stroke="black" points="528,-401.75 434,-401.75 434,-379.5 528,-379.5 528,-401.75"/>
<text text-anchor="middle" x="481" y="-388.25" font-family="monospace" font-size="10.00">ReluBackward0</text>
</g>
<!-- 140244943582208&#45;&gt;140244943576880 -->
<g id="edge5" class="edge">
<title>140244943582208&#45;&gt;140244943576880</title>
<path fill="none" stroke="black" d="M498.47,-379.07C514.53,-369.36 538.57,-354.83 557.08,-343.65"/>
<polygon fill="black" stroke="black" points="558.69,-346.15 565.44,-337.99 555.07,-340.16 558.69,-346.15"/>
</g>
<!-- 140244943582016 -->
<g id="node8" class="node">
<title>140244943582016</title>
<polygon fill="lightgrey" stroke="black" points="543,-472 383,-472 383,-449.75 543,-449.75 543,-472"/>
<text text-anchor="middle" x="463" y="-458.5" font-family="monospace" font-size="10.00">NativeBatchNormBackward0</text>
</g>
<!-- 140244943582016&#45;&gt;140244943582208 -->
<g id="edge6" class="edge">
<title>140244943582016&#45;&gt;140244943582208</title>
<path fill="none" stroke="black" d="M465.73,-449.51C468.32,-439.69 472.29,-424.65 475.53,-412.37"/>
<polygon fill="black" stroke="black" points="479.07,-413.65 478.24,-403.09 472.31,-411.87 479.07,-413.65"/>
</g>
<!-- 140244943577888 -->
<g id="node9" class="node">
<title>140244943577888</title>
<polygon fill="lightgrey" stroke="black" points="395,-536.25 259,-536.25 259,-514 395,-514 395,-536.25"/>
<text text-anchor="middle" x="327" y="-522.75" font-family="monospace" font-size="10.00">ConvolutionBackward0</text>
</g>
<!-- 140244943577888&#45;&gt;140244943582016 -->
<g id="edge7" class="edge">
<title>140244943577888&#45;&gt;140244943582016</title>
<path fill="none" stroke="black" d="M350.07,-513.57C372.05,-503.5 405.37,-488.25 430.12,-476.92"/>
<polygon fill="black" stroke="black" points="431.18,-479.83 438.82,-472.49 428.27,-473.47 431.18,-479.83"/>
</g>
<!-- 140244943583024 -->
<g id="node10" class="node">
<title>140244943583024</title>
<polygon fill="lightgrey" stroke="black" points="270,-600.5 176,-600.5 176,-578.25 270,-578.25 270,-600.5"/>
<text text-anchor="middle" x="223" y="-587" font-family="monospace" font-size="10.00">ReluBackward0</text>
</g>
<!-- 140244943583024&#45;&gt;140244943577888 -->
<g id="edge8" class="edge">
<title>140244943583024&#45;&gt;140244943577888</title>
<path fill="none" stroke="black" d="M240.64,-577.82C256.93,-568.07 281.35,-553.45 300.07,-542.24"/>
<polygon fill="black" stroke="black" points="301.49,-544.88 308.27,-536.74 297.89,-538.87 301.49,-544.88"/>
</g>
<!-- 140244943577744 -->
<g id="node11" class="node">
<title>140244943577744</title>
<polygon fill="lightgrey" stroke="black" points="284,-670.75 124,-670.75 124,-648.5 284,-648.5 284,-670.75"/>
<text text-anchor="middle" x="204" y="-657.25" font-family="monospace" font-size="10.00">NativeBatchNormBackward0</text>
</g>
<!-- 140244943577744&#45;&gt;140244943583024 -->
<g id="edge9" class="edge">
<title>140244943577744&#45;&gt;140244943583024</title>
<path fill="none" stroke="black" d="M206.89,-648.26C209.62,-638.44 213.81,-623.4 217.23,-611.12"/>
<polygon fill="black" stroke="black" points="220.78,-612.41 220.09,-601.84 214.03,-610.53 220.78,-612.41"/>
</g>
<!-- 140244943577024 -->
<g id="node12" class="node">
<title>140244943577024</title>
<polygon fill="lightgrey" stroke="black" points="136,-735 0,-735 0,-712.75 136,-712.75 136,-735"/>
<text text-anchor="middle" x="68" y="-721.5" font-family="monospace" font-size="10.00">ConvolutionBackward0</text>
</g>
<!-- 140244943577024&#45;&gt;140244943577744 -->
<g id="edge10" class="edge">
<title>140244943577024&#45;&gt;140244943577744</title>
<path fill="none" stroke="black" d="M91.07,-712.32C113.05,-702.25 146.37,-687 171.12,-675.67"/>
<polygon fill="black" stroke="black" points="172.18,-678.58 179.82,-671.24 169.27,-672.22 172.18,-678.58"/>
</g>
<!-- 140244943602976 -->
<g id="node13" class="node">
<title>140244943602976</title>
<polygon fill="lightgrey" stroke="black" points="118,-799.25 18,-799.25 18,-777 118,-777 118,-799.25"/>
<text text-anchor="middle" x="68" y="-785.75" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943602976&#45;&gt;140244943577024 -->
<g id="edge11" class="edge">
<title>140244943602976&#45;&gt;140244943577024</title>
<path fill="none" stroke="black" d="M68,-776.57C68,-768.29 68,-756.5 68,-746.27"/>
<polygon fill="black" stroke="black" points="71.5,-746.28 68,-736.28 64.5,-746.28 71.5,-746.28"/>
</g>
<!-- 140244952839088 -->
<g id="node14" class="node">
<title>140244952839088</title>
<polygon fill="lightblue" stroke="black" points="127,-875.5 9,-875.5 9,-841.25 127,-841.25 127,-875.5"/>
<text text-anchor="middle" x="68" y="-850" font-family="monospace" font-size="10.00"> (100, 128, 4, 4)</text>
</g>
<!-- 140244952839088&#45;&gt;140244943602976 -->
<g id="edge12" class="edge">
<title>140244952839088&#45;&gt;140244943602976</title>
<path fill="none" stroke="black" d="M68,-840.85C68,-831.65 68,-820.1 68,-810.25"/>
<polygon fill="black" stroke="black" points="71.5,-810.35 68,-800.35 64.5,-810.35 71.5,-810.35"/>
</g>
<!-- 140244943584128 -->
<g id="node15" class="node">
<title>140244943584128</title>
<polygon fill="lightgrey" stroke="black" points="254,-735 154,-735 154,-712.75 254,-712.75 254,-735"/>
<text text-anchor="middle" x="204" y="-721.5" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943584128&#45;&gt;140244943577744 -->
<g id="edge13" class="edge">
<title>140244943584128&#45;&gt;140244943577744</title>
<path fill="none" stroke="black" d="M204,-712.32C204,-704.04 204,-692.25 204,-682.02"/>
<polygon fill="black" stroke="black" points="207.5,-682.03 204,-672.03 200.5,-682.03 207.5,-682.03"/>
</g>
<!-- 140244952841968 -->
<g id="node16" class="node">
<title>140244952841968</title>
<polygon fill="lightblue" stroke="black" points="231,-805.25 177,-805.25 177,-771 231,-771 231,-805.25"/>
<text text-anchor="middle" x="204" y="-779.75" font-family="monospace" font-size="10.00"> (128)</text>
</g>
<!-- 140244952841968&#45;&gt;140244943584128 -->
<g id="edge14" class="edge">
<title>140244952841968&#45;&gt;140244943584128</title>
<path fill="none" stroke="black" d="M204,-770.77C204,-763.22 204,-754.16 204,-746.09"/>
<polygon fill="black" stroke="black" points="207.5,-746.27 204,-736.27 200.5,-746.27 207.5,-746.27"/>
</g>
<!-- 140244943601920 -->
<g id="node17" class="node">
<title>140244943601920</title>
<polygon fill="lightgrey" stroke="black" points="372,-735 272,-735 272,-712.75 372,-712.75 372,-735"/>
<text text-anchor="middle" x="322" y="-721.5" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943601920&#45;&gt;140244943577744 -->
<g id="edge15" class="edge">
<title>140244943601920&#45;&gt;140244943577744</title>
<path fill="none" stroke="black" d="M301.98,-712.32C283.25,-702.43 255.03,-687.55 233.68,-676.28"/>
<polygon fill="black" stroke="black" points="235.59,-672.81 225.12,-671.24 232.33,-679 235.59,-672.81"/>
</g>
<!-- 140244952839280 -->
<g id="node18" class="node">
<title>140244952839280</title>
<polygon fill="lightblue" stroke="black" points="349,-805.25 295,-805.25 295,-771 349,-771 349,-805.25"/>
<text text-anchor="middle" x="322" y="-779.75" font-family="monospace" font-size="10.00"> (128)</text>
</g>
<!-- 140244952839280&#45;&gt;140244943601920 -->
<g id="edge16" class="edge">
<title>140244952839280&#45;&gt;140244943601920</title>
<path fill="none" stroke="black" d="M322,-770.77C322,-763.22 322,-754.16 322,-746.09"/>
<polygon fill="black" stroke="black" points="325.5,-746.27 322,-736.27 318.5,-746.27 325.5,-746.27"/>
</g>
<!-- 140244943582496 -->
<g id="node19" class="node">
<title>140244943582496</title>
<polygon fill="lightgrey" stroke="black" points="398,-600.5 298,-600.5 298,-578.25 398,-578.25 398,-600.5"/>
<text text-anchor="middle" x="348" y="-587" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943582496&#45;&gt;140244943577888 -->
<g id="edge17" class="edge">
<title>140244943582496&#45;&gt;140244943577888</title>
<path fill="none" stroke="black" d="M344.44,-577.82C341.58,-569.36 337.49,-557.23 333.99,-546.85"/>
<polygon fill="black" stroke="black" points="337.02,-545.89 330.51,-537.53 330.39,-548.12 337.02,-545.89"/>
</g>
<!-- 140244953123536 -->
<g id="node20" class="node">
<title>140244953123536</title>
<polygon fill="lightblue" stroke="black" points="414,-676.75 302,-676.75 302,-642.5 414,-642.5 414,-676.75"/>
<text text-anchor="middle" x="358" y="-651.25" font-family="monospace" font-size="10.00"> (128, 64, 4, 4)</text>
</g>
<!-- 140244953123536&#45;&gt;140244943582496 -->
<g id="edge18" class="edge">
<title>140244953123536&#45;&gt;140244943582496</title>
<path fill="none" stroke="black" d="M355.58,-642.1C354.22,-632.8 352.5,-621.1 351.05,-611.18"/>
<polygon fill="black" stroke="black" points="354.41,-610.99 349.5,-601.6 347.49,-612 354.41,-610.99"/>
</g>
<!-- 140244943582832 -->
<g id="node21" class="node">
<title>140244943582832</title>
<polygon fill="lightgrey" stroke="black" points="513,-536.25 413,-536.25 413,-514 513,-514 513,-536.25"/>
<text text-anchor="middle" x="463" y="-522.75" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943582832&#45;&gt;140244943582016 -->
<g id="edge19" class="edge">
<title>140244943582832&#45;&gt;140244943582016</title>
<path fill="none" stroke="black" d="M463,-513.57C463,-505.29 463,-493.5 463,-483.27"/>
<polygon fill="black" stroke="black" points="466.5,-483.28 463,-473.28 459.5,-483.28 466.5,-483.28"/>
</g>
<!-- 140244953123440 -->
<g id="node22" class="node">
<title>140244953123440</title>
<polygon fill="lightblue" stroke="black" points="490,-606.5 436,-606.5 436,-572.25 490,-572.25 490,-606.5"/>
<text text-anchor="middle" x="463" y="-581" font-family="monospace" font-size="10.00"> (64)</text>
</g>
<!-- 140244953123440&#45;&gt;140244943582832 -->
<g id="edge20" class="edge">
<title>140244953123440&#45;&gt;140244943582832</title>
<path fill="none" stroke="black" d="M463,-572.02C463,-564.47 463,-555.41 463,-547.34"/>
<polygon fill="black" stroke="black" points="466.5,-547.52 463,-537.52 459.5,-547.52 466.5,-547.52"/>
</g>
<!-- 140244943582928 -->
<g id="node23" class="node">
<title>140244943582928</title>
<polygon fill="lightgrey" stroke="black" points="631,-536.25 531,-536.25 531,-514 631,-514 631,-536.25"/>
<text text-anchor="middle" x="581" y="-522.75" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943582928&#45;&gt;140244943582016 -->
<g id="edge21" class="edge">
<title>140244943582928&#45;&gt;140244943582016</title>
<path fill="none" stroke="black" d="M560.98,-513.57C542.25,-503.68 514.03,-488.8 492.68,-477.53"/>
<polygon fill="black" stroke="black" points="494.59,-474.06 484.12,-472.49 491.33,-480.25 494.59,-474.06"/>
</g>
<!-- 140244953123344 -->
<g id="node24" class="node">
<title>140244953123344</title>
<polygon fill="lightblue" stroke="black" points="608,-606.5 554,-606.5 554,-572.25 608,-572.25 608,-606.5"/>
<text text-anchor="middle" x="581" y="-581" font-family="monospace" font-size="10.00"> (64)</text>
</g>
<!-- 140244953123344&#45;&gt;140244943582928 -->
<g id="edge22" class="edge">
<title>140244953123344&#45;&gt;140244943582928</title>
<path fill="none" stroke="black" d="M581,-572.02C581,-564.47 581,-555.41 581,-547.34"/>
<polygon fill="black" stroke="black" points="584.5,-547.52 581,-537.52 577.5,-547.52 584.5,-547.52"/>
</g>
<!-- 140244943578416 -->
<g id="node25" class="node">
<title>140244943578416</title>
<polygon fill="lightgrey" stroke="black" points="655,-401.75 555,-401.75 555,-379.5 655,-379.5 655,-401.75"/>
<text text-anchor="middle" x="605" y="-388.25" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943578416&#45;&gt;140244943576880 -->
<g id="edge23" class="edge">
<title>140244943578416&#45;&gt;140244943576880</title>
<path fill="none" stroke="black" d="M601.44,-379.07C598.58,-370.61 594.49,-358.48 590.99,-348.1"/>
<polygon fill="black" stroke="black" points="594.02,-347.14 587.51,-338.78 587.39,-349.37 594.02,-347.14"/>
</g>
<!-- 140244953122960 -->
<g id="node26" class="node">
<title>140244953122960</title>
<polygon fill="lightblue" stroke="black" points="667,-478 561,-478 561,-443.75 667,-443.75 667,-478"/>
<text text-anchor="middle" x="614" y="-452.5" font-family="monospace" font-size="10.00"> (64, 32, 4, 4)</text>
</g>
<!-- 140244953122960&#45;&gt;140244943578416 -->
<g id="edge24" class="edge">
<title>140244953122960&#45;&gt;140244943578416</title>
<path fill="none" stroke="black" d="M611.82,-443.35C610.61,-434.15 609.09,-422.6 607.79,-412.75"/>
<polygon fill="black" stroke="black" points="611.13,-412.31 606.35,-402.85 604.19,-413.22 611.13,-412.31"/>
</g>
<!-- 140244943576304 -->
<g id="node27" class="node">
<title>140244943576304</title>
<polygon fill="lightgrey" stroke="black" points="770,-337.5 670,-337.5 670,-315.25 770,-315.25 770,-337.5"/>
<text text-anchor="middle" x="720" y="-324" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943576304&#45;&gt;140244943580192 -->
<g id="edge25" class="edge">
<title>140244943576304&#45;&gt;140244943580192</title>
<path fill="none" stroke="black" d="M720,-314.82C720,-306.54 720,-294.75 720,-284.52"/>
<polygon fill="black" stroke="black" points="723.5,-284.53 720,-274.53 716.5,-284.53 723.5,-284.53"/>
</g>
<!-- 140244953122864 -->
<g id="node28" class="node">
<title>140244953122864</title>
<polygon fill="lightblue" stroke="black" points="747,-407.75 693,-407.75 693,-373.5 747,-373.5 747,-407.75"/>
<text text-anchor="middle" x="720" y="-382.25" font-family="monospace" font-size="10.00"> (32)</text>
</g>
<!-- 140244953122864&#45;&gt;140244943576304 -->
<g id="edge26" class="edge">
<title>140244953122864&#45;&gt;140244943576304</title>
<path fill="none" stroke="black" d="M720,-373.27C720,-365.72 720,-356.66 720,-348.59"/>
<polygon fill="black" stroke="black" points="723.5,-348.77 720,-338.77 716.5,-348.77 723.5,-348.77"/>
</g>
<!-- 140244943575872 -->
<g id="node29" class="node">
<title>140244943575872</title>
<polygon fill="lightgrey" stroke="black" points="888,-337.5 788,-337.5 788,-315.25 888,-315.25 888,-337.5"/>
<text text-anchor="middle" x="838" y="-324" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943575872&#45;&gt;140244943580192 -->
<g id="edge27" class="edge">
<title>140244943575872&#45;&gt;140244943580192</title>
<path fill="none" stroke="black" d="M817.98,-314.82C799.25,-304.93 771.03,-290.05 749.68,-278.78"/>
<polygon fill="black" stroke="black" points="751.59,-275.31 741.12,-273.74 748.33,-281.5 751.59,-275.31"/>
</g>
<!-- 140244953122768 -->
<g id="node30" class="node">
<title>140244953122768</title>
<polygon fill="lightblue" stroke="black" points="865,-407.75 811,-407.75 811,-373.5 865,-373.5 865,-407.75"/>
<text text-anchor="middle" x="838" y="-382.25" font-family="monospace" font-size="10.00"> (32)</text>
</g>
<!-- 140244953122768&#45;&gt;140244943575872 -->
<g id="edge28" class="edge">
<title>140244953122768&#45;&gt;140244943575872</title>
<path fill="none" stroke="black" d="M838,-373.27C838,-365.72 838,-356.66 838,-348.59"/>
<polygon fill="black" stroke="black" points="841.5,-348.77 838,-338.77 834.5,-348.77 841.5,-348.77"/>
</g>
<!-- 140244943584944 -->
<g id="node31" class="node">
<title>140244943584944</title>
<polygon fill="lightgrey" stroke="black" points="909,-209 809,-209 809,-186.75 909,-186.75 909,-209"/>
<text text-anchor="middle" x="859" y="-195.5" font-family="monospace" font-size="10.00">AccumulateGrad</text>
</g>
<!-- 140244943584944&#45;&gt;140244943580432 -->
<g id="edge29" class="edge">
<title>140244943584944&#45;&gt;140244943580432</title>
<path fill="none" stroke="black" d="M846.59,-186.29C837.28,-178.36 824.32,-167.32 813.49,-158.09"/>
<polygon fill="black" stroke="black" points="816.24,-154.98 806.36,-151.16 811.7,-160.31 816.24,-154.98"/>
</g>
<!-- 140244953121424 -->
<g id="node32" class="node">
<title>140244953121424</title>
<polygon fill="lightblue" stroke="black" points="918,-279.25 818,-279.25 818,-245 918,-245 918,-279.25"/>
<text text-anchor="middle" x="868" y="-253.75" font-family="monospace" font-size="10.00"> (32, 3, 4, 4)</text>
</g>
<!-- 140244953121424&#45;&gt;140244943584944 -->
<g id="edge30" class="edge">
<title>140244953121424&#45;&gt;140244943584944</title>
<path fill="none" stroke="black" d="M865.64,-244.77C864.54,-237.22 863.23,-228.16 862.07,-220.09"/>
<polygon fill="black" stroke="black" points="865.4,-219.66 860.5,-210.27 858.47,-220.67 865.4,-219.66"/>
</g>
</g>
</svg>
)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"CiqFCjoAYtBq"},"outputs":[],"source":["class DCGAN_G(nn.Module):\n"," def __init__(self, isize, nz, nc, ngf, ngpu, n_extra_layers=0):\n"," super(DCGAN_G, self).__init__()\n"," self.ngpu = ngpu\n"," assert isize % 16 == 0, \"isize has to be a multiple of 16\"\n","\n"," cngf, tisize = ngf//2, 4\n"," while tisize != isize:\n"," cngf = cngf * 2\n"," tisize = tisize * 2\n","\n"," main = nn.Sequential()\n"," # inputs is Z, going into a convolution\n"," main.add_module('initial:{0}-{1}:convt'.format(nz, cngf),\n"," nn.ConvTranspose2d(nz, cngf, 4, 1, 0, bias=False))\n"," main.add_module('initial:{0}:batchnorm'.format(cngf),\n"," nn.BatchNorm2d(cngf))\n"," main.add_module('initial:{0}:relu'.format(cngf),\n"," nn.ReLU(True))\n","\n"," csize, cndf = 4, cngf\n"," while csize < isize//2:\n"," main.add_module('pyramid:{0}-{1}:convt'.format(cngf, cngf//2),\n"," nn.ConvTranspose2d(cngf, cngf//2, 4, 2, 1, bias=False))\n"," main.add_module('pyramid:{0}:batchnorm'.format(cngf//2),\n"," nn.BatchNorm2d(cngf//2))\n"," main.add_module('pyramid:{0}:relu'.format(cngf//2),\n"," nn.ReLU(True))\n"," cngf = cngf // 2\n"," csize = csize * 2\n","\n"," # Extra layers\n"," for t in range(n_extra_layers):\n"," main.add_module('extra-layers-{0}:{1}:conv'.format(t, cngf),\n"," nn.Conv2d(cngf, cngf, 3, 1, 1, bias=False))\n"," main.add_module('extra-layers-{0}:{1}:batchnorm'.format(t, cngf),\n"," nn.BatchNorm2d(cngf))\n"," main.add_module('extra-layers-{0}:{1}:relu'.format(t, cngf),\n"," nn.ReLU(True))\n","\n"," main.add_module('final:{0}-{1}:convt'.format(cngf, nc),\n"," nn.ConvTranspose2d(cngf, nc, 4, 2, 1, bias=False))\n"," main.add_module('final:{0}:tanh'.format(nc),\n"," nn.Tanh())\n"," self.main = main\n","\n"," def forward(self, inputs):\n"," if isinstance(inputs.data, torch.cuda.FloatTensor) and self.ngpu > 1:\n"," output = nn.parallel.data_parallel(self.main, inputs, range(self.ngpu))\n"," else:\n"," output = self.main(inputs)\n"," return output"]},{"cell_type":"markdown","metadata":{"id":"zyRrm3ClUMX1"},"source":["## Entrainement\n","\n","Voici un exemple de code qui permettrait l'entraînement de notre modèle et la configuration de celui-ci."]},{"cell_type":"markdown","metadata":{"id":"PhynHzMXXEyP"},"source":["### Options pour l'exécution"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"zkk11X5zSQLK"},"outputs":[],"source":["# Path to dataset\n","opt_dataroot = 'data/faces'\n","# Number of data loading workers\n","opt_workers = 2\n","# inputs batch size\n","opt_batchSize = 64\n","# The height / width of the inputs image to network\n","opt_imageSize = 32\n","# inputs image channels\n","nc = 3\n","# Size of the latent z vector\n","nz = 100\n","# Size of feature maps in generator\n","ngf = 32\n","# Size of feature maps in discriminator\n","ndf = 32\n","# Number of epochs to train for\n","opt_niter = 25\n","# Learning rate for Discriminator\n","opt_lrD = 0.00005\n","# Learning rate for Generator\n","opt_lrG = 0.00005\n","# beta1 for adam.\n","opt_beta1 = 0.5\n","# Lower value clamp for Discriminator weights\n","opt_clamp_lower = -0.01\n","# Upper value clamp for Discriminator weights\n","opt_clamp_upper = 0.01\n","# Number of D iters per each G iter\n","opt_Diters = 5\n","# Where to store samples and models\n","opt_experiment = 'samples'"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"LVYpQv-_tFsK"},"outputs":[],"source":["# Use CUDA if a GPU is available\n","opt_cuda = False\n","\n","opt_cuda_resp = input(\"Use cuda? (y/n)\\n{} by default\\n\".format(opt_cuda))\n","\n","# Use CUDA if a GPU is available\n","opt_cuda = True if opt_cuda_resp == 'y' else opt_cuda\n","# Number of GPUs to use for running the model if CUDA is enabled\n","ngpu = 1"]},{"cell_type":"markdown","metadata":{"id":"Ggb5i2jsX1jp"},"source":["### Configuration du modèle"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"ENkqSYs2Tbj9"},"outputs":[],"source":["os.system('mkdir {0}'.format(opt_experiment))\n","\n","opt_manualSeed = random.randint(1, 10000) # fix seed\n","print(\"Random Seed: \", opt_manualSeed)\n","random.seed(opt_manualSeed)\n","torch.manual_seed(opt_manualSeed)\n","\n","cudnn.benchmark = True\n","\n","# folder dataset\n","dataset = dset.ImageFolder(root=opt_dataroot,\n"," transform=transforms.Compose([\n"," transforms.Resize(opt_imageSize),\n"," transforms.CenterCrop(opt_imageSize),\n"," transforms.ToTensor(),\n"," transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n"," ]))\n","assert dataset\n","dataloader = torch.utils.data.DataLoader(dataset, batch_size=opt_batchSize,\n"," shuffle=True, num_workers=int(opt_workers))\n","\n","# custom weights initialization called on netG and netD\n","def weights_init(m):\n"," classname = m.__class__.__name__\n"," if classname.find('Conv') != -1:\n"," m.weight.data.normal_(0.0, 0.02)\n"," elif classname.find('BatchNorm') != -1:\n"," m.weight.data.normal_(1.0, 0.02)\n"," m.bias.data.fill_(0)\n","\n","netG = DCGAN_G(opt_imageSize, nz, nc, ngf, ngpu)\n","\n","netG.apply(weights_init)\n","print(netG)\n","\n","netD = DCGAN_D(opt_imageSize, nz, nc, ndf, ngpu)\n","netD.apply(weights_init)\n","\n","print(netD)\n","\n","inputs = torch.FloatTensor(opt_batchSize, 3, opt_imageSize, opt_imageSize)\n","noise = torch.FloatTensor(opt_batchSize, nz, 1, 1)\n","fixed_noise = torch.FloatTensor(opt_batchSize, nz, 1, 1).normal_(0, 1)\n","one = torch.FloatTensor([1])\n","mone = one * -1\n","\n","if opt_cuda:\n"," netD.cuda()\n"," netG.cuda()\n"," inputs = inputs.cuda()\n"," one, mone = one.cuda(), mone.cuda()\n"," noise, fixed_noise = noise.cuda(), fixed_noise.cuda()\n","\n","# setup optimizer\n","optimizerD = optim.RMSprop(netD.parameters(), lr = opt_lrD)\n","optimizerG = optim.RMSprop(netG.parameters(), lr = opt_lrG)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"W96oVYCkjzPR"},"outputs":[],"source":["netD_graph = make_dot(netD(Variable(torch.randn(1, 3, 32, 32))))\n","netD_graph.render(\"netD_architecture\", format=\"png\")\n","\n","netG_graph = make_dot(netG(Variable(torch.randn(1, 100, 1, 1))))\n","netG_graph.render(\"netG_architecture\", format=\"png\")"]},{"cell_type":"markdown","metadata":{"id":"YkMM0kSeX6cH"},"source":["### Entrainement du modèle"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"Pf06223hTrpJ"},"outputs":[],"source":["gen_iterations = 0\n","for epoch in range(opt_niter):\n"," data_iter = iter(dataloader)\n"," i = 0\n"," while i < len(dataloader):\n"," ############################\n"," # (1) Update D network\n"," ###########################\n"," for p in netD.parameters(): # reset requires_grad\n"," p.requires_grad = True # they are set to False below in netG update\n","\n"," # train the discriminator Diters times\n"," if gen_iterations < 25 or gen_iterations % 500 == 0:\n"," Diters = 100\n"," else:\n"," Diters = opt_Diters\n"," j = 0\n"," while j < Diters and i < len(dataloader):\n"," j += 1\n","\n"," # clamp parameters to a cube\n"," for p in netD.parameters():\n"," p.data.clamp_(opt_clamp_lower, opt_clamp_upper)\n","\n"," data = next(data_iter)\n"," i += 1\n","\n"," # train with real\n"," real_cpu, _ = data\n"," netD.zero_grad()\n"," batch_size = real_cpu.size(0)\n","\n"," if opt_cuda:\n"," real_cpu = real_cpu.cuda()\n"," inputs.resize_as_(real_cpu).copy_(real_cpu)\n"," inputsv = Variable(inputs)\n","\n"," errD_real = netD(inputsv)\n"," errD_real.backward(one)\n","\n"," # train with fake\n"," noise.resize_(opt_batchSize, nz, 1, 1).normal_(0, 1)\n"," noisev = Variable(noise, volatile = True) # totally freeze netG\n"," fake = Variable(netG(noisev).data)\n"," inputsv = fake\n"," errD_fake = netD(inputsv)\n"," errD_fake.backward(mone)\n"," errD = errD_real - errD_fake\n"," optimizerD.step()\n","\n"," ############################\n"," # (2) Update G network\n"," ###########################\n"," for p in netD.parameters():\n"," p.requires_grad = False # to avoid computation\n"," netG.zero_grad()\n"," # in case our last batch was the tail batch of the dataloader,\n"," # make sure we feed a full batch of noise\n"," noise.resize_(opt_batchSize, nz, 1, 1).normal_(0, 1)\n"," noisev = Variable(noise)\n"," fake = netG(noisev)\n"," errG = netD(fake)\n"," errG.backward(one)\n"," optimizerG.step()\n"," gen_iterations += 1\n","\n"," print('[%d/%d][%d/%d][%d] Loss_D: %f Loss_G: %f Loss_D_real: %f Loss_D_fake %f'\n"," % (epoch, opt_niter, i, len(dataloader), gen_iterations,\n"," errD.data[0], errG.data[0], errD_real.data[0], errD_fake.data[0]))\n"," if gen_iterations % 500 == 0:\n"," real_cpu = real_cpu.mul(0.5).add(0.5)\n"," vutils.save_image(real_cpu, '{0}/real_samples.png'.format(opt_experiment))\n"," fake = netG(Variable(fixed_noise, volatile=True))\n"," fake.data = fake.data.mul(0.5).add(0.5)\n"," vutils.save_image(fake.data, '{0}/fake_samples_{1}.png'.format(opt_experiment, gen_iterations))\n","\n"," # do checkpointing\n"," torch.save(netG.state_dict(), '{0}/netG_epoch_{1}.pth'.format(opt_experiment, epoch))\n"," torch.save(netD.state_dict(), '{0}/netD_epoch_{1}.pth'.format(opt_experiment, epoch))"]},{"cell_type":"markdown","metadata":{"id":"NfPfYpS-T5DN"},"source":["## Generation\n","\n","Voici la section de code correspondant à la génération de nos images, plus tard exploitées."]},{"cell_type":"markdown","metadata":{"id":"-B6fUl2zW_Ak"},"source":["### Options pour l'exécution"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"3r_w9O_zUERu"},"outputs":[],"source":["# Number of images to generate\n","opt_nimages = 100\n","# Path to output directory\n","opt_output_dir = 'data/generated'\n","# Path to generator weights .pth file\n","opt_weights = 'samples/netG_epoch_2384.pth'"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"1smXNRDUw-5k"},"outputs":[],"source":["opt_nimages_resp = input(\"How many images to generate?\\n{} by default\\n\".format(opt_nimages))\n","opt_output_dir_resp = input(\"Where to store generated images?\\n{} by default\\n\".format(opt_output_dir))\n","\n","# Number of images to generate\n","opt_nimages = int(opt_nimages_resp) if opt_nimages_resp != '' else opt_nimages\n","# Path to output directory\n","opt_output_dir = opt_output_dir_resp if opt_output_dir_resp != '' else opt_output_dir"]},{"cell_type":"markdown","metadata":{"id":"XWGZgsuyYDet"},"source":["### Configuration du modèle"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"KLNgMfV_T7Ou"},"outputs":[],"source":["netG = DCGAN_G(opt_imageSize, nz, nc, ngf, ngpu)\n","\n","# load weights\n","if opt_cuda:\n"," netG.load_state_dict(torch.load(opt_weights, map_location=torch.device('cuda')))\n","else:\n"," netG.load_state_dict(torch.load(opt_weights, map_location=torch.device('cpu')))\n","\n","# initialize noise\n","fixed_noise = torch.FloatTensor(opt_nimages, nz, 1, 1).normal_(0, 1)\n","\n","if opt_cuda:\n"," netG.cuda()\n"," fixed_noise = fixed_noise.cuda()\n","\n","fake = netG(fixed_noise)\n","fake.data = fake.data.mul(0.5).add(0.5)\n","\n","if not os.path.exists(opt_output_dir):\n"," os.makedirs(opt_output_dir)"]},{"cell_type":"markdown","metadata":{"id":"rPU04cGsYFVz"},"source":["### Génération des images"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"Jg82PIsjUH55"},"outputs":[],"source":["for i in range(opt_nimages):\n"," vutils.save_image(fake.data[i, ...].reshape((1, nc, opt_imageSize, opt_imageSize)), os.path.join(opt_output_dir, \"generated_%02d.png\"%i))"]},{"cell_type":"markdown","metadata":{"id":"ePeCi4PZJ5Ar"},"source":["## Résultats\n","L'entrainement a été réalisé à partir d'un ordinateur équipé d'un GPU accessible via internet ssh et un VPN configuré.\n","\n","Voici la commande utilisée pour effectuer la formation :\n","```shell\n","python main.py --dataset folder --dataroot data/faces --batchSize 2048 --niter 5000 --ngf 32 --ndf 32 --imageSize 32 --cuda\n","```\n","\n","et la génération :\n","```shell\n","python generate.py --config samples/generator_config.json --weight samples/netG_epoch_2384.pth --output_dir data/generated --nimages 100 --cuda\n","```\n","\n","Les fichiers Python sont ceux de l'article original. Ce sont les fichiers qui sont réutilisés et grandement simplifiés dans ce Jupyter Notebook.\n","\n","Les poids et les fichiers de configuration peuvent être téléchargés sur :\n","https://code.paul-corbalan.com/paul-corbalan/wasserstein-gan/src/branch/master/samples\n","\n","La partie verbale de l'exécution `out` est également accessible."]},{"cell_type":"markdown","metadata":{"id":"xme7UNdR678K"},"source":[""]},{"cell_type":"markdown","metadata":{"id":"3PQ8dgt1OLyT"},"source":["Comme nous avons oublié de stocker les pertes pendant la formation, ce script a été créé pour les récupérer à partir du fichier verbeux."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"uLZ1Egi8OEAo"},"outputs":[],"source":["data = open('out', 'r').read()\n","\n","pattern = re.compile(r\"\\[(\\d+)/(\\d+)\\]\\[(\\d+)/(\\d+)\\]\\[(\\d+)\\] Loss_D: ([-+]?\\d*\\.\\d+|\\d+) Loss_G: ([-+]?\\d*\\.\\d+|\\d+) Loss_D_real: ([-+]?\\d*\\.\\d+|\\d+) Loss_D_fake ([-+]?\\d*\\.\\d+|\\d+)\")\n","\n","matches = pattern.findall(data)\n","\n","df = pd.DataFrame(matches, columns=['epoch', 'niter', 'i', 'dataloader_size', 'gen_iterations', 'Loss_D', 'Loss_G', 'Loss_D_real', 'Loss_D_fake'])\n","\n","df = df.apply(pd.to_numeric)\n","\n","plt.plot(df['gen_iterations'][::100], -df['Loss_D'][::100])\n","plt.xlabel('Generator Iterations')\n","plt.ylabel('Loss_D ~ Wasserstein Distance')\n","plt.title('Loss_D vs. Generator Iterations')\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"en27GDwsO4J_"},"source":["Nous traçons l'évolution de la perte du discriminateur car, contrairement au GAN classique, elles sont interprétables. Il s'agit en fait d'une estimation de la distance de Wasserstein entre la distribution générée et la distribution cible. Les valeurs décroissantes sont la preuve que le modèle continue d'apprendre et n'est pas affecté par l'un des problèmes des GANs classiques."]},{"cell_type":"markdown","metadata":{"id":"fdKb4NcvNzTz"},"source":["![evolution.png](data:image/png;base64,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)"]},{"cell_type":"markdown","metadata":{"id":"qLhnYB0uPpjt"},"source":["## Application\n","### Problème inverse : Récupérer le vecteur latent d'une image\n","\n","Voici le problème d'optimisation que nous voulons résoudre :\n","\n","$$\\underset{z \\in \\mathbb{Z}}{\\text{argmin}}\\lVert g(z)-x_0 \\rVert_2^2$$\n","\n","Voici le code pour résoudre ce problème en utilisant la différenciation automatique de PyTorch :"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"sdc3spKfRDO3"},"outputs":[],"source":["x0 = inputsv[0][None, :,:,:]\n","\n","noise = torch.FloatTensor(1, nz, 1, 1).normal_(0,1)\n","noise.requires_grad = True\n","\n","\n","# Choisissez un optimiseur, par exemple Adam\n","optimizer = optim.Adam([noise], lr=0.001)\n","\n","\n","for p in netD.parameters():\n"," p.requires_grad = False\n","for p in netG.parameters():\n"," p.requires_grad = False\n","\n","# Boucle d'optimisation\n","for iteration in range(100000):\n"," optimizer.zero_grad()\n","\n"," # Générer une donnée à partir de z\n"," generated_data = netG(noise)\n","\n"," # Calculer la perte (norme L2 au carré)\n"," loss = torch.norm(generated_data - x0)**2\n","\n"," # Rétropropagation et optimisation\n"," loss.backward()\n"," optimizer.step()\n","\n"," print(f\"Iteration: {iteration}, Loss: {loss.item()}\")"]},{"cell_type":"markdown","metadata":{"id":"pUw0PYPNR5wo"},"source":["Voici un exemple :\n","\n","- Image cible :"]},{"cell_type":"markdown","metadata":{"id":"Ic24cRnN7aus"},"source":[""]},{"cell_type":"markdown","metadata":{"id":"I-DndMBm7YJa"},"source":["- Image trouvée :"]},{"cell_type":"markdown","metadata":{"id":"HXoaWAoV7hoj"},"source":[""]},{"cell_type":"markdown","metadata":{"id":"_tBHFalDSRcI"},"source":["À partir d'un vecteur latent, nous pouvons explorer l'espace engendré par le générateur.\n","\n","---\n","\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"pS4lMtoBSgnZ"},"outputs":[],"source":["fixed_noise = noise.repeat(25, 1, 1, 1)\n","\n","n = int(fixed_noise.shape[0]**.5)\n","for i in range(n):\n"," for j in range(n):\n"," fixed_noise[i*n+j] = fixed_noise[0] + i*torch.eye(nz)[0][:, None, None] + j*torch.eye(nz)[1][:, None, None]\n","\n"," for n in fixed_noise:\n"," im = netG(n[None, :,: ,:])[0]\n"," plt.imshow(torch.permute(im.detach(), (1,2,0)))\n"," plt.show()"]},{"cell_type":"markdown","metadata":{"id":"nDMasgAOS8aa"},"source":[""]},{"cell_type":"markdown","metadata":{"id":"cgRBSaWRTAtT"},"source":["D'après les propriétés énnoncées, nous savons que la distance de Wasserstein est Lipschitz sur l'espace engendré par le générateur. Par conséquent, nous remarquons que toutes les images sont des barycentres de Wasserstein pour les autres."]},{"cell_type":"markdown","metadata":{"id":"cyp-fhG03bS3"},"source":["## Conclusion\n","\n","Notre exploration des Wasserstein GANs, telle que détaillée dans ce projet, nous a permis de nous familiariser avec des concepts clés tels que le Generative Adversarial Network (GAN), la distance de Wasserstein, et les techniques avancées de traitement de données. Cette compréhension approfondie nous a équipés avec une perspective unique et une connaissance approfondie des mécanismes sous-jacents aux GANs, ainsi que de leur potentiel dans des applications variées.\n","\n","En regardant vers l'avenir, nous identifions plusieurs domaines potentiels d'amélioration et de recherche. Parmi ceux-ci, comparer les Wasserstein GANs avec d'autres formes de GANs utilisant différentes fonctions de coût se présente comme une piste prometteuse. De plus, l'optimisation des paramètres du modèle, en se concentrant sur des aspects tels que le taux d'apprentissage, le clipping, et le nombre d'itérations du discriminant, pourrait conduire à des avancées significatives dans la performance et l'efficacité des GANs."]}],"metadata":{"colab":{"provenance":[],"toc_visible":true},"kernelspec":{"display_name":"Python 3 (ipykernel)","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.11.7"}},"nbformat":4,"nbformat_minor":0}