Skip to content

Instantly share code, notes, and snippets.

@pcaressa

pcaressa/toy_gan.ipynb

Created November 18, 2021 15:13
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save pcaressa/be67ff30dfd9ca4959de9458944c1f29 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save pcaressa/be67ff30dfd9ca4959de9458944c1f29 to your computer and use it in GitHub Desktop.
Download ZIP
toy_gan.ipynb
Display the source blob
Display the rendered blob
Raw
toy_gan.ipynb
{
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"name": "toy_gan.ipynb",
"provenance": [],
"collapsed_sections": [],
"authorship_tag": "ABX9TyNhkejhEdfQQ2me3lPw6Fcj",
"include_colab_link": true
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3"
},
"language_info": {
"name": "python"
}
},
"cells": [
{
"cell_type": "markdown",
"metadata": {
"id": "view-in-github",
"colab_type": "text"
},
"source": [
"<a href=\"https://colab.research.google.com/gist/pcaressa/be67ff30dfd9ca4959de9458944c1f29/toy_gan.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
]
},
{
"cell_type": "code",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 282
},
"id": "D4Jr5pSoRT9e",
"outputId": "c8bbe874-3be9-4d7e-f153-eb0223af61ce"
},
"source": [
"\"\"\"\n",
" Generatore di curve sinusoidali\n",
"\n",
" (una curva è descritta da un insieme di punti (x,y) del piano)\n",
"\"\"\"\n",
"\n",
"from keras.models import Sequential\n",
"from keras.layers import Dense, Dropout, LeakyReLU\n",
"\n",
"import numpy as np\n",
"from numpy.random import randint, uniform\n",
"\n",
"import matplotlib.pyplot as plt\n",
"\n",
"TRAIN_LEN = 64\n",
"TRAIN_SIZE = 8192\n",
"BATCH = 128\n",
"X_MIN, X_MAX = -5.0, 5.0\n",
"Y_MIN, Y_MAX = -1.0, 1.0\n",
"\n",
"X_COORDS = np.linspace(X_MIN , X_MAX, TRAIN_LEN)\n",
"\n",
"print(\"Genera il training set campionando delle sinusoidi\")\n",
"\n",
"X_TRAIN = np.zeros((TRAIN_SIZE, TRAIN_LEN))\n",
"for i in range(0, TRAIN_SIZE):\n",
" scale = uniform(0.5, 2.0)\n",
" phase = uniform(np.math.pi)\n",
" X_TRAIN[i] = np.array([np.sin(scale*x + phase) for x in X_COORDS])\n",
"\n",
"print(\"Crea il discriminatore\")\n",
"\n",
"DIS_DROPOUT = 0.4\n",
"discriminator = Sequential()\n",
"discriminator.add(Dense(TRAIN_LEN, activation = \"relu\"))\n",
"discriminator.add(Dropout(DIS_DROPOUT))\n",
"discriminator.add(Dense(SAMPLE_LEN, activation = \"relu\"))\n",
"discriminator.add(Dropout(DIS_DROPOUT))\n",
"discriminator.add(Dense(1, activation = \"sigmoid\"))\n",
"discriminator.compile(optimizer = \"adam\",\n",
" loss = \"binary_crossentropy\",\n",
" metrics = [\"accuracy\"])\n",
"\n",
"print(\"Addestra il discriminatore\")\n",
"\n",
"BATCH_SIZE = 128\n",
"EPOCHS = 32\n",
"\n",
"ONES = np.ones((BATCH_SIZE//2)) # vettore di label 1\n",
"ZEROS = np.zeros((BATCH_SIZE//2)) # vettore di label 0\n",
"ONEZEROS = (ONES, ZEROS)\n",
"NOISE = uniform(Y_MIN, Y_MAX, size = (TRAIN_SIZE, TRAIN_LEN))\n",
"\n",
"print(\"-------+-------------\")\n",
"print(\" epoca | accuratezza \")\n",
"print(\"-------+-------------\")\n",
"\n",
"for i in range(EPOCHS):\n",
" # Sceglie BATCH_SIZE//2 indici e li torna in n\n",
" n = randint(0, TRAIN_SIZE, size = BATCH_SIZE//2)\n",
" # Ora prepara un batch di training record, metà\n",
" # training (label 1) metà a caso (label 0)\n",
" x = np.concatenate((X_TRAIN[n], NOISE[n]))\n",
" y = np.concatenate(ONEZEROS)\n",
" dummy, acc = discriminator.train_on_batch(x, y)\n",
" print(f\" {i:3} | {acc}\")\n",
"\n",
"print(\"Crea il generatore\")\n",
"\n",
"generator = Sequential()\n",
"generator.add(Dense(TRAIN_LEN, activation = \"relu\"))\n",
"generator.add(Dense(256, activation = \"relu\"))\n",
"generator.add(Dense(TRAIN_LEN, activation = \"tanh\"))\n",
"generator.compile(optimizer = \"adam\", loss = \"mse\", metrics = [\"accuracy\"])\n",
"\n",
"print(\"Crea la GAN\")\n",
"\n",
"gan = Sequential()\n",
"gan.add(generator)\n",
"discriminator.trainable = False\n",
"gan.add(discriminator)\n",
"gan.compile(optimizer = \"adam\", loss = \"binary_crossentropy\", metrics = [\"accuracy\"])\n",
"\n",
"print(\"Addestra la GAN\")\n",
"\n",
"EPOCHS = 64\n",
"\n",
"print(\"-------+------------------------+------------------------\")\n",
"print(\" epoca | accuratezza discrimin. | accuratezza generatore \")\n",
"print(\"-------+------------------------+------------------------\")\n",
"\n",
"for e in range(EPOCHS):\n",
" for k in range(TRAIN_SIZE//BATCH):\n",
" n = randint(0, TRAIN_SIZE, size = BATCH//2)\n",
"\n",
" x = np.concatenate((X_TRAIN[n], generator.predict(NOISE[n])))\n",
" y = np.concatenate(ONEZEROS)\n",
" discriminator.trainable = True\n",
" d_loss, d_acc = discriminator.train_on_batch(x, y)\n",
" discriminator.trainable = False\n",
"\n",
" g_loss, g_acc = gan.train_on_batch(NOISE[n], ONES)\n",
" \n",
" print(f\" {e:03n} | {d_acc:.5f} | {g_acc:.5f}\")\n",
"\n",
"x = uniform(Y_MIN, Y_MAX, size = (1, TRAIN_LEN))\n",
"y = generator.predict(x)[0]\n",
"\n",
"plt.plot(X_COORDS, y)\n",
"plt.show()\n"
],
"execution_count": 1,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Genera il training set campionando delle sinusoidi\n",
"Crea il discriminatore\n"
]
},
{
"output_type": "error",
"ename": "NameError",
"evalue": "ignored",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-1-95e4b138f36d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m 35\u001b[0m \u001b[0mdiscriminator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mDense\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mTRAIN_LEN\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mactivation\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"relu\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 36\u001b[0m \u001b[0mdiscriminator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mDropout\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mDIS_DROPOUT\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 37\u001b[0;31m \u001b[0mdiscriminator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mDense\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mSAMPLE_LEN\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mactivation\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"relu\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 38\u001b[0m \u001b[0mdiscriminator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mDropout\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mDIS_DROPOUT\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 39\u001b[0m \u001b[0mdiscriminator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mDense\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mactivation\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"sigmoid\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;31mNameError\u001b[0m: name 'SAMPLE_LEN' is not defined"
]
}
]
},
{
"cell_type": "code",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "zaNrR3ceRfiZ",
"outputId": "32c6fdff-8765-4392-8fda-192ec231e28b"
},
"source": [
"print(\" CREAZIONE DEL DISCRIMINATORE\")\n",
"\n",
"# Preveniamo la stampa di warning di tensorflow\n",
"import os\n",
"os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' \n",
"\n",
"from keras.models import Sequential\n",
"from keras.layers import Dense, Dropout, LeakyReLU\n",
"\n",
"DROPOUT = Dropout(0.4) # Empirical hype rparameter\n",
"LEAKY_RELU = LeakyReLU(0.2) # Empirical hyperparameter\n",
"\n",
"DROPOUT = 0.4\n",
"LEAKY_RELU = 0.2\n",
"\n",
"discriminator = Sequential()\n",
"discriminator.add(Dense(SAMPLE_LEN, activation=\"relu\"))\n",
"#discriminator.add(LeakyReLU(LEAKY_RELU))\n",
"discriminator.add(Dropout(DROPOUT))\n",
"discriminator.add(Dense(SAMPLE_LEN, activation=\"relu\"))\n",
"#discriminator.add(LeakyReLU(LEAKY_RELU))\n",
"discriminator.add(Dropout(DROPOUT))\n",
"discriminator.add(Dense(1, activation = \"sigmoid\"))\n",
"discriminator.compile(optimizer = \"adam\", loss = \"binary_crossentropy\", metrics = [\"accuracy\"])"
],
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
" CREAZIONE DEL DISCRIMINATORE\n"
]
}
]
},
{
"cell_type": "code",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "AAThoN9DDAgo",
"outputId": "e8f9bd61-7bb4-4d63-e9ae-fbde0d19bb78"
},
"source": [
"print(\" ADDESTRAMENTO DEL DISCRIMINATORE\")\n",
"\n",
"BATCH_SIZE = 128\n",
"BATCH_SIZE_2 = BATCH_SIZE // 2\n",
"EPOCHS = 16\n",
"\n",
"ONES = np.ones((SAMPLE_SIZE)) # vettore di label 1\n",
"ZEROS = np.zeros((SAMPLE_SIZE)) # vettore di label 0\n",
"NOISE = uniform(Y_MIN, Y_MAX, size = (SAMPLE_SIZE, SAMPLE_LEN))\n",
"\n",
"print(\"-------+-------------\")\n",
"print(\" epoca | accuratezza \")\n",
"print(\"-------+-------------\")\n",
"\n",
"for i in range(EPOCHS):\n",
" # Sceglie BATSH_SIZE_2 indici e li torna nel vettore n\n",
" n = randint(0, SAMPLE_SIZE, size = BATCH_SIZE_2)\n",
" # Ora prepara un batch di training record per il discriminatore:\n",
" # metà sono esempi corretti (con label 1) l'altra metà sono\n",
" # punti a caso (con label 0)\n",
" x = np.concatenate((SAMPLE[n], NOISE[n]))\n",
" y = np.concatenate((ONES[n], ZEROS[n]))\n",
" dummy, acc = discriminator.train_on_batch(x, y)\n",
" print(f\" {i:3} | {acc}\")\n",
"\n"
],
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
" ADDESTRAMENTO DEL DISCRIMINATORE\n",
"-------+-------------\n",
" epoca | accuratezza \n",
"-------+-------------\n",
" 0 | 0.4140625\n",
" 1 | 0.4921875\n",
" 2 | 0.4765625\n",
" 3 | 0.53125\n",
" 4 | 0.484375\n",
" 5 | 0.546875\n",
" 6 | 0.6171875\n",
" 7 | 0.5859375\n",
" 8 | 0.5546875\n",
" 9 | 0.6171875\n",
" 10 | 0.5625\n",
" 11 | 0.6640625\n",
" 12 | 0.671875\n",
" 13 | 0.671875\n",
" 14 | 0.75\n",
" 15 | 0.71875\n"
]
}
]
},
{
"cell_type": "code",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "sGUXW8cJRpOR",
"outputId": "09fce87f-05f3-47df-f068-ae6cd3bc64ca"
},
"source": [
"\n",
"print(\" CREAZIONE DEL GENERATORE\")\n",
"\n",
"# Il generatore prende una sequenza a caso di SAMPLE_LEN interi e la trasforma in una sinusoide\n",
"generator = Sequential()\n",
"generator.add(Dense(SAMPLE_LEN))\n",
"generator.add(LeakyReLU(LEAKY_RELU))\n",
"#generator.add(Dropout(DROPOUT))\n",
"generator.add(Dense(512))\n",
"generator.add(LeakyReLU(LEAKY_RELU))\n",
"#generator.add(Dropout(DROPOUT))\n",
"generator.add(Dense(SAMPLE_LEN, activation = \"tanh\"))\n",
"generator.compile(optimizer = \"adam\", loss = \"mse\", metrics = [\"accuracy\"])"
],
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
" CREAZIONE DEL GENERATORE\n"
]
}
]
},
{
"cell_type": "code",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "HEmLLc_5RsuH",
"outputId": "982ed204-07d5-48e8-844e-e894335ef408"
},
"source": [
"print(\" COLLEGAMENTO DEL GENERATORE E DEL DISCRIMINATORE\")\n",
"\n",
"gan = Sequential()\n",
"gan.add(generator)\n",
"discriminator.trainable = False\n",
"gan.add(discriminator)\n",
"gan.compile(optimizer = \"adam\", loss = \"binary_crossentropy\", metrics = [\"accuracy\"])"
],
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
" COLLEGAMENTO DEL GENERATORE E DEL DISCRIMINATORE\n"
]
}
]
},
{
"cell_type": "code",
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 599
},
"id": "z3GY0ygSRvZO",
"outputId": "e393c58b-2b1a-4ff0-a624-755e3210d1de"
},
"source": [
"print(\" ADDESTRAMENTO DELLA GAN\")\n",
"\n",
"BATCH_SIZE = 128\n",
"EPOCHS = 4 #64\n",
"\n",
"NOISE = uniform(-1.0, 1.0, size = (SAMPLE_SIZE, SAMPLE_LEN))\n",
"#NOISE = uniform(X_MIN, X_MAX, size = (SAMPLE_SIZE, SAMPLE_LEN))\n",
"ONES = np.ones((SAMPLE_SIZE))\n",
"ZEROS = np.zeros((SAMPLE_SIZE))\n",
"\n",
"print(\"-------+------------------------+------------------------\")\n",
"print(\" epoca | accuratezza discrimin. | accuratezza generatore \")\n",
"print(\"-------+------------------------+------------------------\")\n",
"\n",
"\n",
"fig = plt.figure(figsize = (8, 12))\n",
"ax_index = 1\n",
"for e in range(EPOCHS):\n",
" for k in range(SAMPLE_SIZE//BATCH_SIZE):\n",
" # Addestra il discriminatore a riconoscere le sinusoidi vere da quelle prodotte dal generatore\n",
" # Sceglie BATCH_SIZE indici e li torna nel vettore n\n",
" n = randint(0, SAMPLE_SIZE, BATCH_SIZE)\n",
" # Ora prepara un batch di training record per il discriminatore\n",
" p = generator.predict(NOISE[n])\n",
" x = np.concatenate((SAMPLE[n], p))\n",
" y = np.concatenate((ONES[n], ZEROS[n]))\n",
"\n",
" d_loss, d_acc = discriminator.train_on_batch(x, y)\n",
"\n",
" # Ora addestra la gan a riconoscere quelli classificati dal discriminatore\n",
" discriminator.trainable = False\n",
" g_loss, g_acc = gan.train_on_batch(NOISE[n], ONES[n])\n",
" discriminator.trainable = True\n",
" print(f\" {e:03n} | {d_acc:.5f} | {g_acc:.5f}\")\n",
" # At 0, 10, 20, ... plots the last generator prediction\n",
" #if e % 10 == 0:\n",
" ax = fig.add_subplot(8, 1, ax_index)\n",
" plt.plot(X_COORDS, p[-1])\n",
" ax.xaxis.set_visible(False)\n",
" plt.ylabel(f\"Epoch: {e}\")\n",
" ax_index += 1\n",
"\n",
"# Plots a curve generated by the GAN\n",
"y = generator.predict(uniform(-1, 1, size = (1, SAMPLE_LEN)))[0]\n",
"ax = fig.add_subplot(8, 1, ax_index)\n",
"plt.plot(X_COORDS, y)\n",
"\n",
"plt.show()"
],
"execution_count": null,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
" ADDESTRAMENTO DELLA GAN\n",
"-------+------------------------+------------------------\n",
" epoca | accuratezza discrimin. | accuratezza generatore \n",
"-------+------------------------+------------------------\n",
" 000 | 0.84766 | 0.11719\n",
" 001 | 0.82812 | 0.07812\n",
" 002 | 0.81250 | 0.08594\n",
" 003 | 0.82422 | 0.06250\n"
]
},
{
"output_type": "display_data",
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 576x864 with 5 Axes>"
]
},
"metadata": {
"needs_background": "light"
}
}
]
}
]
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment