From 14cee24b59ac5479fb51c49337c845fffc564ba5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Aur=C3=A9lien=20Geron?= Date: Tue, 16 Feb 2021 15:23:29 +1300 Subject: [PATCH] Add solution to exercise 9 --- 17_autoencoders_and_gans.ipynb | 199 ++++++++++++++++++++++++++++++++- 1 file changed, 198 insertions(+), 1 deletion(-) diff --git a/17_autoencoders_and_gans.ipynb b/17_autoencoders_and_gans.ipynb index bd1a64a..ea4fe9f 100644 --- a/17_autoencoders_and_gans.ipynb +++ b/17_autoencoders_and_gans.ipynb @@ -1603,6 +1603,203 @@ " plt.imshow(image, cmap=\"binary\")\n", " plt.axis(\"off\")" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercise Solutions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. to 8.\n", + "\n", + "See Appendix A." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9.\n", + "_Exercise: Try using a denoising autoencoder to pretrain an image classifier. You can use MNIST (the simplest option), or a more complex image dataset such as [CIFAR10](https://homl.info/122) if you want a bigger challenge. Regardless of the dataset you're using, follow these steps:_\n", + "* Split the dataset into a training set and a test set. Train a deep denoising autoencoder on the full training set.\n", + "* Check that the images are fairly well reconstructed. Visualize the images that most activate each neuron in the coding layer.\n", + "* Build a classification DNN, reusing the lower layers of the autoencoder. Train it using only 500 images from the training set. Does it perform better with or without pretraining?" + ] + }, + { + "cell_type": "code", + "execution_count": 144, + "metadata": {}, + "outputs": [], + "source": [ + "[X_train, y_train], [X_test, y_test] = keras.datasets.cifar10.load_data()\n", + "X_train = X_train / 255\n", + "X_test = X_test / 255" + ] + }, + { + "cell_type": "code", + "execution_count": 203, + "metadata": {}, + "outputs": [], + "source": [ + "tf.random.set_seed(42)\n", + "np.random.seed(42)\n", + "\n", + "denoising_encoder = keras.models.Sequential([\n", + " keras.layers.GaussianNoise(0.1, input_shape=[32, 32, 3]),\n", + " keras.layers.Conv2D(32, kernel_size=3, padding=\"same\", activation=\"relu\"),\n", + " keras.layers.MaxPool2D(),\n", + " keras.layers.Flatten(),\n", + " keras.layers.Dense(512, activation=\"relu\"),\n", + "])" + ] + }, + { + "cell_type": "code", + "execution_count": 204, + "metadata": {}, + "outputs": [], + "source": [ + "denoising_encoder.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 205, + "metadata": {}, + "outputs": [], + "source": [ + "denoising_decoder = keras.models.Sequential([\n", + " keras.layers.Dense(16 * 16 * 32, activation=\"relu\", input_shape=[512]),\n", + " keras.layers.Reshape([16, 16, 32]),\n", + " keras.layers.Conv2DTranspose(filters=3, kernel_size=3, strides=2,\n", + " padding=\"same\", activation=\"sigmoid\")\n", + "])" + ] + }, + { + "cell_type": "code", + "execution_count": 206, + "metadata": {}, + "outputs": [], + "source": [ + "denoising_decoder.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 207, + "metadata": {}, + "outputs": [], + "source": [ + "denoising_ae = keras.models.Sequential([denoising_encoder, denoising_decoder])\n", + "denoising_ae.compile(loss=\"binary_crossentropy\", optimizer=keras.optimizers.Nadam(),\n", + " metrics=[\"mse\"])\n", + "history = denoising_ae.fit(X_train, X_train, epochs=10,\n", + " validation_data=(X_test, X_test))" + ] + }, + { + "cell_type": "code", + "execution_count": 208, + "metadata": {}, + "outputs": [], + "source": [ + "n_images = 5\n", + "new_images = X_test[:n_images]\n", + "new_images_noisy = new_images + np.random.randn(n_images, 32, 32, 3) * 0.1\n", + "new_images_denoised = denoising_ae.predict(new_images_noisy)\n", + "\n", + "plt.figure(figsize=(6, n_images * 2))\n", + "for index in range(n_images):\n", + " plt.subplot(n_images, 3, index * 3 + 1)\n", + " plt.imshow(new_images[index])\n", + " plt.axis('off')\n", + " if index == 0:\n", + " plt.title(\"Original\")\n", + " plt.subplot(n_images, 3, index * 3 + 2)\n", + " plt.imshow(np.clip(new_images_noisy[index], 0., 1.))\n", + " plt.axis('off')\n", + " if index == 0:\n", + " plt.title(\"Noisy\")\n", + " plt.subplot(n_images, 3, index * 3 + 3)\n", + " plt.imshow(new_images_denoised[index])\n", + " plt.axis('off')\n", + " if index == 0:\n", + " plt.title(\"Denoised\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 10.\n", + "_Exercise: Train a variational autoencoder on the image dataset of your choice, and use it to generate images. Alternatively, you can try to find an unlabeled dataset that you are interested in and see if you can generate new samples._\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 11.\n", + "_Exercise: Train a DCGAN to tackle the image dataset of your choice, and use it to generate images. Add experience replay and see if this helps. Turn it into a conditional GAN where you can control the generated class._\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -1621,7 +1818,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.7.9" }, "nav_menu": { "height": "381px",