1 line
449 KiB
Plaintext
1 line
449 KiB
Plaintext
{"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||<K}\\mathbb{E}_{x\\sim\\mathbb{P}_r}[f(x)]-\\mathbb{E}_{x\\sim\\mathbb{P}_\\theta}[f(x)]\n","\\end{equation}\n","Où le supremum est calculé sur toutes les fonctions lipschitz de coefficient inférieur à K. Afin de pouvoir calculer ce supremum on suppose qu'il est atteint pour une famille paramétrique $(f_w)_{w \\in W}$ :\n","\\begin{equation}\n","W(\\mathbb{P}_r, \\mathbb{P}_{\\theta})=\\frac{1}{K}\\max_{w \\in W}\\mathbb{E}_{x\\sim\\mathbb{P}_r}[f_w(x)]-\\mathbb{E}_{x\\sim\\mathbb{P}_\\theta}[f_w(x)]\n","\\end{equation}\n","Si l'on rapporte cette vision à notre problème, on a alors :\n","\\begin{equation}\n","W(\\mathbb{P}_r, \\mathbb{P}_{\\theta})=\\frac{1}{K}\\max_{w \\in W}\\mathbb{E}_{x\\sim\\mathbb{P}_r}[f_w(x)]-\\mathbb{E}_{z\\sim p(z)}[f_w(g_\\theta(z))]\n","\\end{equation}\n","où $f_w$ est le réseau de neurone discriminateur (ou critique) dont les poids sont $w$ et $g_\\theta$ le réseau de neurone générateur dont les poids sont $\\theta$.\n","Il ne restera plus alors qu'à faire en sorte que le générateur diminue cette distance et il apprendra peu à peu la distribution. Or on a aussi le résultat suivant :\n","\\begin{equation}\n","\\nabla_\\theta W (P_r , P_\\theta ) = -E_{z \\sim p(z)}[\\nabla_\\theta f (g_\\theta (z))]\n","\\end{equation}\n","Ce qui nous donne une direction de descente.\n","On a ainsi le code suivant :"]},{"cell_type":"markdown","metadata":{"id":"NuiEHyS1IyeC"},"source":[""]},{"cell_type":"markdown","metadata":{"id":"k-pyAL11NnqM"},"source":["En résumé, le discriminant ne se contente plus de distinguer entre vrai et faux, il calcule une approximation de la distance entre les distributions, que le générateur cherche à diminuer. Il est important de noter que ici le caractère lipschitz est assuré par un clipping, ce qui est assez brutal, et il est possible que d'autres contraintes soient meilleurs en terme de résultat et plus adapté au problème."]},{"cell_type":"markdown","metadata":{"id":"6HZ9z7mXS8sT"},"source":["## Propriétés importantes de la distance de Wasserstein\n","\n","### Convergence en distribution\n","\n","Soit $\\mathbb{P}$ une distribution sur un espace compact $\\mathcal{X}$ et $(\\mathbb{P}_n)_{n \\in \\mathbb{N}}$ soit une séquence de distributions sur $\\mathcal{X}$ :\n","$$W(\\mathbb{P}_n, \\mathbb{P}) \\to 0 \\Leftrightarrow \\mathbb{P}_n \\xrightarrow{\\mathcal{L}} \\mathbb{P}$$\n","\n","Cette convergence est importante dans les GANs car elle assure que les échantillons générés par le modèle imitent de plus en plus fidèlement la distribution réelle des données. Contrairement à d'autres mesures de divergence, la distance de Wasserstein tient compte de la structure géométrique de l'espace des données, offrant ainsi une approche plus naturelle pour comparer des distributions.\n","\n","\n","### Continuité et différentiabilité\n","\n","Considérons une fonction $g : \\mathcal{Z} \\times \\mathbb{R}^d \\rightarrow \\mathcal{X}$, notée $g_\\theta(z)$, où $z \\in \\mathcal{Z}$ et $\\theta \\in \\mathbb{R}^d$. Soit $\\mathbb{P}_\\theta$ la distribution de $g_\\theta(Z)$, où $Z$ est une variable aléatoire suivant une certaine distribution sur $\\mathcal{Z}$. Dans ce cadre, la distance de Wasserstein $W(\\mathbb{P}, \\mathbb{P}_\\theta)$ présente des propriétés distinctives :\n","1. **Continuité spécifique à la distance de Wasserstein :** Si $g$ est continue en $\\theta$, alors $W(\\mathbb{P}, \\mathbb{P}_\\theta)$ est également continue.\n","2. **Différentiabilité particulière de la distance de Wasserstein :** Sous l'hypothèse où $g$ est localement Lipschitz avec des constantes locales de Lipschitz $L(\\theta, z)$ telles que $\\mathbb{E}_{z \\sim p}[L(\\theta, z)] < +\\infty$, la distance de Wasserstein $W(\\mathbb{P}, \\mathbb{P}_\\theta)$ est continue partout et différentiable presque partout.\n","3. **Contraste avec d'autres divergences :** Contrairement à la distance de Wasserstein, la divergence Jensen-Shannon $JS(\\mathbb{P}, \\mathbb{P}_\\theta)$ et les divergences KL ne partagent pas les mêmes propriétés de continuité et de différentiabilité décrites ci-dessus. Ceci offre plusieurs avantages : Il devient possible de faire une descente de gradient sur la distance de Wassertein. On récupère des gradients propres, sans gradient évanescent. Il est possible d'entrainer le discriminant jusqu'à optimalité sans avoir de surapprentissage. C'est même le contraire, entrainer le discriminateur jusqu'à optimalité garantit une distance plus fidèle.\n","\n"]},{"cell_type":"markdown","metadata":{"id":"3Y1c2J4xUZKE"},"source":["## Prérequis pour l'exécution du code\n","### Importation des librairies"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"2CasM7sCV3qc"},"outputs":[],"source":["# Future imports\n","from __future__ import absolute_import\n","from __future__ import division\n","from __future__ import print_function\n","from __future__ import unicode_literals\n","\n","# Pytorch dependencies\n","import torch\n","import torch.nn as nn\n","import torch.nn.parallel\n","import torch.backends.cudnn as cudnn\n","import torch.optim as optim\n","import torch.utils.data\n","import torchvision.datasets as dset\n","import torchvision.transforms as transforms\n","import torchvision.utils as vutils\n","from torch.autograd import Variable\n","\n","# System dependencies\n","import argparse\n","import random\n","import os\n","import json\n","import shutil\n","import re\n","\n","# Array processing\n","import numpy as np\n","import pandas as pd\n","\n","# Display\n","import matplotlib.pyplot as plt\n","from torchviz import make_dot\n","\n","# Image processing\n","from sklearn.neural_network import MLPClassifier\n","from sklearn.model_selection import train_test_split\n","from sklearn.metrics import accuracy_score, classification_report, confusion_matrix\n","from skimage import io\n","import seaborn as sns"]},{"cell_type":"markdown","metadata":{"id":"kp5fkZ3eA7fk"},"source":["## Création de l'ensemble de données\n","\n","L'ensemble de données original a été téléchargé à partir de\n","https://www.mediafire.com/file/z6wbmo2aqxkztcm/Skins.tar/file\n","\n","Pour recadrer les images, les redimensionner, supprimer le canal alpha, faire des montages etc... le paquetage GNU [ImageMagick](https://imagemagick.org/) a été grandement utilisé."]},{"cell_type":"markdown","metadata":{"id":"KnkISR_SEnxQ"},"source":["### Prétraitements\n","\n","La première étape a consisté à extraire les faces des skins. Cette opération a été réalisée à l'aide de la commande :\n","```shell\n","convert *.png -crop 8x8+8+8 heads/*.png\n","```\n","\n","La deuxième étape consistait à trier les visages humains par rapport aux visages non-humains.\n","\n","Nous décrivons ici la méthode utilisée, inspirée de l'apprentissage actif :\n","1. Tri manuel de $n=1000$ images\n","2. Entraînement d'un MLP sur cette classification\n","3. Tri de $10\\times n$ images avec le MLP\n","4. Correction manuelle du tri\n","5. Revenir à l'étape $2$ jusqu'à ce qu'un dixième de l'ensemble de données soit trié\n","6. Utiliser le modèle pour déplacer les images dont le score de prédiction est supérieur à 70%.\n","\n","Le script suivant a été créé pour entraîner, évaluer les performances du classificateur MLP et déplacer les fichiers à partir des prédictions."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"deKHeyWmDW7G"},"outputs":[],"source":["def load_images(folder_path):\n"," images = []\n"," for filename in os.listdir(folder_path):\n"," if filename.endswith(('.png')):\n"," img_path = os.path.join(folder_path, filename)\n"," img = io.imread(img_path)\n"," r = np.array(img).ravel()\n"," if r.size == 256 : images.append(r)\n"," return images\n","\n","human_faces_data = np.stack(load_images('humans'))\n","non_human_faces_data = np.stack(load_images('nohumans'))\n","\n","\n","human_labels = np.ones(human_faces_data.shape[0])\n","non_human_labels = np.zeros(non_human_faces_data.shape[0])\n","\n","X = np.concatenate([human_faces_data, non_human_faces_data])\n","y = np.concatenate([human_labels, non_human_labels])\n","\n","\n","X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n","perceptron_model = MLPClassifier(hidden_layer_sizes=(8,8,8,8), solver=\"lbfgs\", activation=\"relu\", max_iter=10000)\n","\n","perceptron_model.fit(X_train, y_train)\n","\n","y_pred = perceptron_model.predict(X_test)\n","\n","accuracy = accuracy_score(y_test, y_pred)\n","classification_rep = classification_report(y_test, y_pred)\n","\n","print(f\"Accuracy: {accuracy:.2f}\")\n","print(\"Classification Report:\")\n","print(classification_rep) # Recall is the important metric\n","\n","\n","conf_matrix = confusion_matrix(y_test, y_pred)\n","\n","sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', cbar=False,\n"," xticklabels=['Non-Human', 'Human'],\n"," yticklabels=['Non-Human', 'Human'])\n","plt.xlabel('Predicted')\n","plt.ylabel('True')\n","plt.title('Confusion Matrix')\n","plt.show()\n","\n","\n","\n","fig, axes = plt.subplots(2, 5, figsize=(10, 5))\n","fig.suptitle('Example Predictions')\n","\n","for i in range(5):\n"," axes[0, i].imshow(X_test[i].reshape((8, 8, 4))[:,:,0])\n"," axes[0, i].set_title(f\"Actual: {y_test[i]}, Predicted: {y_pred[i]}\")\n"," axes[0, i].axis('off')\n","\n"," axes[1, i].imshow(X_test[i + 5].reshape((8, 8, 4))[:,:,0])\n"," axes[1, i].set_title(f\"Actual: {y_test[i + 5]}, Predicted: {y_pred[i + 5]}\")\n"," axes[1, i].axis('off')\n","\n","plt.show()\n","\n","\n","def predict_and_move(folder_path):\n"," for filename in os.listdir(folder_path):\n"," if filename.endswith(('.png')):\n"," img_path = os.path.join(folder_path, filename)\n"," img = io.imread(img_path)\n"," img_flat = img.reshape(1, -1)\n"," if img.size==256:\n"," if perceptron_model.predict_proba(img_flat)[0, 1] > 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":[""]},{"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":[""]},{"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":[""]},{"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":["<img src=\"data:image/png;base64,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\" width=\"400\" height=\"400\">"]},{"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":[""]},{"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":["<img src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAACb0lEQVR4nO2UTU8TURSGn07acbwOl5HCWEptmlImhJBSAUljCEYWxPgDXJj4E/w9/go37tyoGzQuTLQaP7qohATSINVhHIdxHG9cCPRDCFFwY/ruzpn3nOe+uTMDffXVV1/HKvEXM2NgdpQ+NOHHaQEuQWWEjN3uNLd4/ZHXsHuYP/lH20ehMsLKUqpYyB40G+ub+pPv3gbvDxvReuoBOHM0YBImS0yW8oV8zhoa0pKGFyovQjOwIHVsghGopAkiVr/0+gZgHmYnyGdTQhiuH9Tq67V3rVqdpoumo51jQWf7c2+OLoAzQvX6NT+I3t1bbXX7ls9SLZPPpfI5WxhG85Nfq7fuP+MlAGe/MZs5M1+txmGkP3z6quN8bcAAOPOXqzduuX74+M1m6+2Hg0fjsLzEYmVcCMM0DCEMd32rVt/bDuyCZjsLKzdFUnPDqPHg+dffAQZYmUKuNC38UNp5OgDDUMxfKBVyB50wiprdGTUxlC1ODZlGJlcUtAHtS44gVkopTqieHV0ApZTiRASllFLERwH+bYJsAktXycjVY9c2u2YyaQxd7+wYup5Jd3lsEz12k5FrGSrb8SntAcZgcYqiFQu/YQZr0zZz5/ccM1B2sEzRuc4yRdlhZr+cO8+0jRmsGX6jKOMrU4kJSEEKkrdHAYaHcaZGSzIWfkNXqmyjFgZzL3aIKDuUnbSUXQApRdlJo1qFOuhUKoNlGxms6aFWkFE8mbXZ2N4GSDy6c/FXZFNappRSSgXuvlDKMoWUwjKFobff6TCKXT/wvMD1AzTN2pcGvuf5vud7XhiFQGLn7tWjL+wU1Puz6wP+Q8BPqlvf9JmKWR8AAAAASUVORK5CYII=\" width=\"200\" height=\"200\">"]},{"cell_type":"markdown","metadata":{"id":"I-DndMBm7YJa"},"source":["- Image trouvée :"]},{"cell_type":"markdown","metadata":{"id":"HXoaWAoV7hoj"},"source":["<img src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAAEyElEQVR4nO2UW29bRRSF156Zc/E5x3acOLYTN02KmyttmlJVgCqERJHoU6mQ+nd45xfwHyp45wkeQAUhVKEKhKo0pGlCrr4eH9vnMhcegCZpy6USj1kvI82sPd/staUBznSmM53pX0WvWuACBNSAEeBbKGTYBw4A/Td+8aqAOWBqCssrEByKw91FuIOfWvj2fwHkgIVF3F5FvXGl4Mq+9MPyYCteH8RpZ4B1QL1Qwv777TYwPYbFeZxbWK7WZ938bKbdUZwpmmkP7QJw+Z87IGAG8IE9oPuCrwhc41hewlqtMeXO8/ao2e6t//L9wy083cFIYBmBm0U5PJ/VMcAAjbHSws1b++HOg4dfbx+c8l0v4db7ODdVXinXx7zq4eZv6xs/3vsK32V/GqqX327Y8/XxgD/+9JvN/ksAFrD0wUfv3rnTips7xcr2Z58/O7oC3LyB1UuNhcmFHF+yBrTbocc/pM9uB+Dnr126fTfIq737tLX5yfZf+8czcIBzjZmLr83OLCxOX26cfL60UZjE+UqlNFkL3Am2p+2tXOfoVIvphVqwUJ66WquuLCf5l0UUsxpEgQkhldNR4akcBfpWOTN1bZc0I8rFYevgyemst3fCtlTBiFpHoZdYQPY8QJr9iA7SuJ+Ls3Kre7K4FICLHHNZko5MdCR7m4qH/DRgwmOxIxOXP1Hpk/Q4u2MAK04YyQUiknJanxrxLoEFObC8SLtM6zg8ir2t4WnAHrpHLCsPk6J36nc4nkE937OsMBnuuGpvmtFJ19rrKOZzvstJzpre+X7H7cjJC84JRxEry/ak0+XOYUmEC+UT8f6xzABvzs9Nl2yftzOFieLwgxq+2AeAagVTF1At+0hHIt6FSsZrZo4NVxg+3MD9DjSwfB0XCxszZs/L0rcq+5Or5QdfNp8CGhB3chAadR+rc9TI7+VTaZJosea/d9NqbGRdhfk3sLLk1GvGt0MTOdz1rWF5slC4WsmK84c3RtgJsLrGZyqHU/bPOdZRTqs6X774qKmbKFuge3fX7Ji5XBev1MZmi8EEV/BkeHTY/jU0TWX6+SqCsXo1qHiJz+McupmMzLCV8PFoMOrpalO6Oct3Bc0WeZFS4kdtdRTrR1tKBfAOaPPjd1zjI4vsxfOG97TrOMQ4TyUNtZMakQkaMG+aM44oMFlsBqmOFJMlu2hQ8qkQagzAIj1ibBBSep6FIXSJ4q5xpw07EMH4BDc5xgqUEblFpWJmK+EMuO1CAcSJSzNqMemYuKebRZMOOBcY9TDuMK7JskhVkBFTfSgPnS7ZDPaQfJfMyGS2cK2YLHB0UJg11oApl1sgRTSwoCJjEuTB4SEFwozQZrpHOUHSA8om4ZQIkgmUoJQMt4gzUhx2AJNHZsG0BPl5xW2yAoZMZoRcyohM1lNhTNIYZvEBaRMyTYSEhmPEfdPnOubU6kAVjHGJBGQBWUzSAaWQHiSBuuAFeGBaCaZHJm4bnXFR4oqQhuCGewExRUnfZD0kHBpIXOIScR+mx4SBkkgAraAsoyXIg4hghKEUWkAyWOOIHTFULc9xDRW4k8CKiPrEOaWhNhFEbJNBlqPYFlAYhRgGx2DqE/CAUmoIcmIHB8OQefN0FAeBhFcjcGulge/A93TM4Bf5pAkAAAAAElFTkSuQmCC\" width=\"200\" height=\"200\">"]},{"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":["<img src=\"data:image/png;base64,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\" width=\"400\" height=\"400\">"]},{"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} |