dcgan.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "tf.reset_default_graph()\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "training_data = pickle.load(open(\"data_set1.pickle\", \"rb\"))\n",
    "\n",
    "training_data = training_data/255.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ruido_ph = tf.placeholder(tf.float32,[None, 100])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def gerador(ruido, reuse = None):\n",
    "    with tf.variable_scope('gerador', reuse = reuse):\n",
    "        #100 -> 128 -> 128 -> 784\n",
    "        #camada_oculta1 = tf.nn.relu(tf.layers.dense(inputs = ruido, units=1280))\n",
    "        #camada_oculta2 = tf.nn.relu(tf.layers.dense(inputs=camada_oculta1, units=1280))\n",
    "        #camada_saida = tf.layers.dense(inputs = camada_oculta2, units = 9216, activation = tf.nn.tanh)\n",
    "        \n",
    "        camada_oculta1 = tf.layers.dense(inputs = ruido, units = 24*24*64)\n",
    "        normalizacao_oculta1 = tf.layers.batch_normalization(inputs = camada_oculta1)\n",
    "        saida_oculta1 = tf.nn.leaky_relu(normalizacao_oculta1)\n",
    "        \n",
    "        saida_oculta_2d_1 = tf.reshape(saida_oculta1, [-1, 24, 24, 64])\n",
    "        \n",
    "        deconvolucao1 = tf.layers.conv2d_transpose(inputs = saida_oculta_2d_1, filters = 32, \n",
    "                                                   strides = 1, kernel_size = [5, 5], padding = 'same')\n",
    "        \n",
    "        normalizacao1 = tf.layers.batch_normalization(inputs = deconvolucao1)\n",
    "        \n",
    "        saida_convolucao1 = tf.nn.leaky_relu(normalizacao1)\n",
    "        \n",
    "        deconvolucao2 = tf.layers.conv2d_transpose(inputs = saida_convolucao1, filters = 16, \n",
    "                                                   strides = 2, kernel_size = [5, 5], padding = 'same')\n",
    "        \n",
    "        normalizacao2 = tf.layers.batch_normalization(inputs = deconvolucao2)\n",
    "        \n",
    "        saida_convolucao2 = tf.nn.leaky_relu(normalizacao2)\n",
    "        \n",
    "        camada_saida = tf.layers.conv2d_transpose(inputs = saida_convolucao2, filters = 1,\n",
    "                                                  strides = 2, kernel_size = [5, 5], padding = 'same')\n",
    "        \n",
    "        result = tf.nn.tanh(camada_saida)\n",
    "        \n",
    "        return tf.reshape(result, [-1, 9216])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "imagens_reais_ph = tf.placeholder(tf.float32, [None, 9216])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def discriminador(X, reuse = None):\n",
    "    with tf.variable_scope('discriminador', reuse = reuse):\n",
    "        # 784 -> 128 -> 128 -> 1\n",
    "        #camada_oculta1 = tf.nn.relu(tf.layers.dense(inputs = X, units = 1280))\n",
    "        #camada_oculta2 = tf.nn.relu(tf.layers.dense(inputs = camada_oculta1, units = 1280))\n",
    "        \n",
    "        entrada = tf.reshape(X, [-1,96,96,1])\n",
    "        \n",
    "        convolucao1 = tf.layers.conv2d(inputs = entrada, filters = 32, kernel_size = [5,5], activation = tf.nn.relu,\n",
    "                                       padding = 'same')\n",
    "        \n",
    "        pooling1 = tf.layers.max_pooling2d(inputs = convolucao1, pool_size = [2,2], strides = 2)\n",
    "        \n",
    "        convolucao2 = tf.layers.conv2d(inputs = pooling1, filters = 64, kernel_size=[5,5],activation=tf.nn.relu,\n",
    "                                      padding = 'same')\n",
    "        \n",
    "        pooling2 = tf.layers.max_pooling2d(inputs=convolucao2, pool_size = [2,2], strides = 2)\n",
    "        \n",
    "        flattening = tf.reshape(pooling2, [-1, 24*24*64])\n",
    "        \n",
    "        densa = tf.layers.dense(inputs = flattening, units = 1024, activation = tf.nn.relu)\n",
    "        \n",
    "        dropout = tf.layers.dropout(inputs=densa, rate=0.2, training = True)\n",
    "        \n",
    "        logits = tf.layers.dense(inputs = dropout, units=1)\n",
    "        return logits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "logits_imagens_reais = discriminador(imagens_reais_ph)\n",
    "logits_imagens_ruido = discriminador(gerador(ruido_ph), reuse = True)\n",
    "\n",
    "erro_discriminador_real = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits = logits_imagens_reais,\n",
    "                                                                                labels = tf.ones_like(logits_imagens_reais)*(0.9)))\n",
    "\n",
    "erro_discriminador_ruido = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits = logits_imagens_ruido,\n",
    "                                                                                 labels = tf.zeros_like(logits_imagens_ruido)))\n",
    "\n",
    "erro_discriminador = erro_discriminador_real + erro_discriminador_ruido\n",
    "\n",
    "erro_gerador = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits = logits_imagens_ruido,\n",
    "                                                                     labels = tf.ones_like(logits_imagens_ruido)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "variaveis = tf.trainable_variables()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "variaveis_discriminador = [v for v in variaveis if 'discriminador' in v.name]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "variaveis_gerador = [v for v in variaveis if 'gerador' in v.name]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "treinamento_discriminador = tf.train.AdamOptimizer(learning_rate=0.001).minimize(erro_discriminador,\n",
    "                                                                                var_list = variaveis_discriminador)\n",
    "treinamento_gerador = tf.train.AdamOptimizer(learning_rate=0.001).minimize(erro_gerador, var_list=variaveis_gerador)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "batch_size =  100\n",
    "amostras_teste = []\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    \n",
    "    #ruido_teste = np.random.uniform(-1, 1, size =(1,100))\n",
    "    #amostra = sess.run(gerador(ruido_ph, reuse=True), feed_dict = {ruido_ph: ruido_teste})\n",
    "    \n",
    "#     batch = mnist.train.next_batch(100)\n",
    "#     imagens_batch = batch[0].reshape((100, 784))\n",
    "#     imagens_batch = imagens_batch*2 - 1\n",
    "#     r = sess.run(discriminador(imagens_reais_ph, True), feed_dict = {imagens_reais_ph: imagens_batch})\n",
    "\n",
    "    saver = tf.train.Saver()\n",
    "    \n",
    "    for epoca in range(5000):\n",
    "        numero_batches = len(training_data) // batch_size\n",
    "        for i in range(numero_batches):\n",
    "            batch = training_data[batch_size*i:batch_size*i + batch_size]\n",
    "            imagens_batch = batch.reshape((batch_size,9216))\n",
    "            imagens_batch = imagens_batch * 2 - 1\n",
    "    \n",
    "            batch_ruido = np.random.uniform(-1, 1, size=(batch_size,100))\n",
    "        \n",
    "            _, custod = sess.run([treinamento_discriminador, erro_discriminador],\n",
    "                                  feed_dict  = {imagens_reais_ph: imagens_batch, ruido_ph: batch_ruido})\n",
    "            \n",
    "            _, custog = sess.run([treinamento_gerador, erro_gerador], feed_dict = {ruido_ph: batch_ruido})\n",
    "            \n",
    "        print('época: ' + str(epoca + 1) + ' erro D: ' + str(custod) + ' erro G: ' + str(custog))\n",
    "        \n",
    "        if((epoca+1)%500 == 0):\n",
    "            # A cada 500 epocas, salva uma imagem\n",
    "            ruido_teste = np.random.uniform(-1, 1, size=(1,100))\n",
    "            imagem_gerada = sess.run(gerador(ruido_ph, reuse = True), feed_dict={ruido_ph: ruido_teste})\n",
    "\n",
    "            amostras_teste.append(imagem_gerada)\n",
    "            saver.save(sess, 'conv_model_2gen_tan_' + str(epoca))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.imshow((amostras_teste[0].reshape(96,96)+1.0)/2.0, cmap = 'Greys')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}