TIME_GAN.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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.8.5"
    },
    "toc": {
      "base_numbering": 1,
      "nav_menu": {},
      "number_sections": true,
      "sideBar": true,
      "skip_h1_title": false,
      "title_cell": "Table of Contents",
      "title_sidebar": "Contents",
      "toc_cell": false,
      "toc_position": {},
      "toc_section_display": true,
      "toc_window_display": true
    },
    "toc-autonumbering": true,
    "colab": {
      "name": "TIME_GAN.ipynb",
      "provenance": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "irdFM1UhgLPp"
      },
      "source": [
        "<font size=\"+3\">Time-series Generative Adversarial Network (TimeGAN)</font>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "80jKdWMOgLP-"
      },
      "source": [
        "# Imports & Settings"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:41.928523Z",
          "start_time": "2020-06-22T14:16:41.926684Z"
        },
        "id": "9ib_3LYtgLQB"
      },
      "source": [
        "import warnings\n",
        "warnings.filterwarnings('ignore')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:43.536398Z",
          "start_time": "2020-06-22T14:16:41.930419Z"
        },
        "id": "ZDQaJfcKgLQG"
      },
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "from sklearn.preprocessing import MinMaxScaler\n",
        "import tensorflow as tf\n",
        "from pathlib import Path\n",
        "from tqdm import tqdm\n",
        "\n",
        "from tensorflow.keras.models import Sequential, Model\n",
        "from tensorflow.keras.layers import GRU, Dense, RNN, GRUCell, Input\n",
        "from tensorflow.keras.losses import BinaryCrossentropy, MeanSquaredError\n",
        "from tensorflow.keras.optimizers import Adam\n",
        "from tensorflow.keras.callbacks import TensorBoard\n",
        "from tensorflow.keras.utils import plot_model\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:43.563985Z",
          "start_time": "2020-06-22T14:16:43.537366Z"
        },
        "id": "P_QdMGfJgLQK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1a3e7c3e-d0bd-4875-ec5b-4581bfb0f734"
      },
      "source": [
        "gpu_devices = tf.config.experimental.list_physical_devices('GPU')\n",
        "if gpu_devices:\n",
        "    print('Using GPU')\n",
        "    tf.config.experimental.set_memory_growth(gpu_devices[0], True)\n",
        "else:\n",
        "    print('Using CPU')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Using CPU\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:43.574151Z",
          "start_time": "2020-06-22T14:16:43.565253Z"
        },
        "id": "rA3XS-y5gLQO"
      },
      "source": [
        "sns.set_style('white')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BRyItjqcgLQP"
      },
      "source": [
        "np.random.seed(42)\n",
        "tf.random.set_seed(1234)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Zk6Bsh2kgLQR"
      },
      "source": [
        "## Experiment Path"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:43.583055Z",
          "start_time": "2020-06-22T14:16:43.575523Z"
        },
        "id": "x5QSM91BgLQT"
      },
      "source": [
        "results_path = Path('time_gan')\n",
        "if not results_path.exists():\n",
        "    results_path.mkdir()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:43.596178Z",
          "start_time": "2020-06-22T14:16:43.585768Z"
        },
        "id": "Sv6HY1OcgLQU"
      },
      "source": [
        "experiment = 0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:43.604235Z",
          "start_time": "2020-06-22T14:16:43.598416Z"
        },
        "id": "-leednsxgLQV"
      },
      "source": [
        "log_dir = results_path / f'experiment_{experiment:02}'\n",
        "if not log_dir.exists():\n",
        "    log_dir.mkdir(parents=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:43.624581Z",
          "start_time": "2020-06-22T14:16:43.605204Z"
        },
        "id": "bQ9kEVjNgLQY"
      },
      "source": [
        "hdf_store = results_path / 'TimeSeriesGAN.h5'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DHLGKjUUgLQZ"
      },
      "source": [
        "# TimeGAN Architecture and Training"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mmhRt7YagLQa"
      },
      "source": [
        "## Learning the data generation process across features and time\n",
        "A successful generative model for time-series data needs to capture both the cross-sectional distribution of features at each point in time and the longitudinal relationships among these features over time. Expressed in the image context we just discussed, the model needs to learn not only what a realistic image looks like, but also how one image evolves from the next as in a video."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pwAdAgzAgLQb"
      },
      "source": [
        "## Combining adversarial and supervised training with time-series embedding\n",
        "\n",
        "Prior attempts at generating time-series data like the recurrent (conditional) GAN relied on recurrent neural networks (RNN, see [Chapter 19, RNN for Multivariate Time Series and Sentiment Analysis](https://github.com/stefan-jansen/machine-learning-for-trading/tree/master/19_recurrent_neural_nets)) in the roles of generator and discriminator. TimeGAN explicitly incorporates the autoregressive nature of time series by combining the unsupervised adversarial loss on both real and synthetic sequences familiar from the DCGAN example with a stepwise supervised loss with respect to the original data. The goal is to reward the model for learning the distribution over transitions from one point in time to the next present in the historical data.\n",
        "\n",
        "Furthermore, TimeGAN includes an embedding network that maps the time-series features to a lower-dimensional latent space to reduce the complexity of the adversarial space. The motivation is to capture the drivers of temporal dynamics that often have lower dimensionality (see also the discussions of manifold learning in [Chapter 13](https://github.com/stefan-jansen/machine-learning-for-trading/tree/master/13_unsupervised_learning) and nonlinear dimensionality reduction in [Chapter 20](https://github.com/stefan-jansen/machine-learning-for-trading/tree/master/20_autoencoders_for_conditional_risk_factors)). \n",
        "\n",
        "A **key element** of the TimeGAN architecture is that both the generator and the embedding (or autoencoder) network are responsible for minimizing the supervised loss that measures how well the model learns the dynamic relationship. \n",
        "\n",
        "As a result, the model learns a latent space conditioned on facilitating the generator’s task to faithfully reproduce the temporal relationships observed in the historical data. In addition to time-series data, the model can also process *static* data that do not change or change less frequently over time."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KZD9EuUlgLQe"
      },
      "source": [
        "The design of the TimeGAN components follows the author's sample code."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q2o4xIkVgLQe"
      },
      "source": [
        "## The four components of the TimeGAN architecture\n",
        "The TimeGAN architecture combines an adversarial network with an autoencoder and has thus **four network components** as depicted in the below Figure:\n",
        "- **Autoencoder**: embedding and recovery networks\n",
        "- **Adversarial Network**: sequence generator and sequence discriminator components\n",
        "\n",
        "<img src=\"https://i.imgur.com/2QurkKl.png\" title=\"source: imgur.com\" width=\"600\"/>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8EPg7qhFgLQf"
      },
      "source": [
        "The **embedding and recovery components** of the autoencoder map the feature space into the latent space and vice versa to facilitate the learning of the temporal dynamics by the adversarial network learns in a lower-dimensional space. The authors implement the embedding and recovery network using a stacked RNN and a feedforward network. However, these choices can be flexibly adapted to the task at hand as long as they are autoregressive and respect the temporal order of the data."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TK8J2ScbgLQg"
      },
      "source": [
        "The **generator and discriminator elements** of the adversarial network differ from the DCGAN not only because they operate on sequential data but also because the synthetic features are generated in the latent space that the model learns simultaneously. The authors choose an RNN as generator and a bidirectional RNN with a feedforward output layer for the discriminator."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_x_GlEz5gLQg"
      },
      "source": [
        "## Joint training of autoencoder and adversarial network\n",
        "The three loss functions displayed in the Figure above drive the joint optimization of the network elements just described while training on real and randomly generated time series. In more detail, they aim to accomplish the following:\n",
        "- The **reconstruction loss** is familiar from our discussion of autoencoders in [Chapter 20](https://github.com/stefan-jansen/machine-learning-for-trading/tree/master/20_autoencoders_for_conditional_risk_factors); it compares how well the reconstruction of the encoded data resembles the original. \n",
        "- The **unsupervised loss** reflects the competitive interaction between the generator and the discriminator described in the [DCGAN](https://github.com/stefan-jansen/machine-learning-for-trading/blob/master/21_gans_for_synthetic_time_series/01_deep_convolutional_generative_adversarial_network.ipynb) example; while the generator aims to minimize the probability that the discriminator classifies its output as fake, the discriminator aims to optimize the correct classification or real and fake inputs.\n",
        "- The **supervised loss** captures how well the generator approximates the actual next time step in latent space when receiving encoded real data for the prior sequence.\n",
        "\n",
        "As a result of the joint training, TimeGAN simultaneously learns to encode features, generate representations, and iterate across time. More specifically, the embedding network creates the latent space, the adversarial network operates within this space, and supervised loss synchronizes the latent dynamics of both real and synthetic data."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9Z5tsESqgLQi"
      },
      "source": [
        "## Training in three phases\n",
        "\n",
        "Training proceeds along the following three phases:\n",
        "1. Train the autoencoder on real time series to optimize reconstruction\n",
        "2. Optimize the supervised loss using real time series to capture the temporal dynamics of the historical data\n",
        "3. Jointly train the four components while minimizing all three loss functions\n",
        "\n",
        "TimeGAN includes several hyperparameters used to weigh the components of composite loss functions; however, the authors find the network to be less sensitive to these settings than one might expect given the notorious difficulties of GAN training. In fact, they do not discover significant challenges during training and suggest that the embedding task serves to regularize adversarial learning because it reduces its dimensionality while the supervised loss constrains the stepwise dynamics of the generator.\n",
        "\n",
        "## TimeGAN with TensorFlow 2\n",
        "\n",
        "We now turn to the TimeGAN implementation using TensorFlow 2; see the paper for an in-depth explanation of the math and methodology of the approach.\n",
        "\n",
        "In the next sections, we'll implement the TimeGAN architecture just described. The authors provide sample code using TensorFlow 1 that we port to TensorFlow 2. Building and training TimeGAN requires several steps:\n",
        "1. Selecting and preparing real and random time series inputs\n",
        "2. Creating the key TimeGAN model components\n",
        "3. Defining the various loss functions and train steps used during the three training phases\n",
        "4. Running the training loops and logging the results\n",
        "5. Generating synthetic time series and evaluating the results\n",
        "\n",
        "We’ll walk through the key items for each of these steps; please refer to the notebook TimeGAN_TF2 for the code examples in this section (unless otherwise noted) as well as additional implementation details."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RcXUjpsugLQj"
      },
      "source": [
        "# Prepare Data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wYfT5cvtgLQj"
      },
      "source": [
        "The authors demonstrate the applicability of TimeGAN to financial data using 15 years of daily Google stock prices downloaded from Yahoo Finance with six features, namely open, high, low, close and adjusted close price, and volume. We’ll use instead close to 20 years of adjusted close prices for six different tickers because it introduces somewhat higher variability. We follow the original paper in targeting synthetic series with 24 time steps. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BjbdcmU2gLQk",
        "outputId": "e43b31f2-6b8c-4a79-cea9-1fe348e5d3fa"
      },
      "source": [
        "df = pd.read_csv('data_HackGen_M2DS.csv')\n",
        "df.info()\n",
        "df = df.drop(df.columns[0], axis=1) # df.columns is zero-based pd.Index "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 1189 entries, 0 to 1188\n",
            "Data columns (total 5 columns):\n",
            " #   Column              Non-Null Count  Dtype  \n",
            "---  ------              --------------  -----  \n",
            " 0   0                   1189 non-null   int64  \n",
            " 1   0.0109571007470021  1189 non-null   float64\n",
            " 2   0.0262889222757607  1189 non-null   float64\n",
            " 3   0.0318672389106398  1189 non-null   float64\n",
            " 4   0.0241059707528865  1189 non-null   float64\n",
            "dtypes: float64(4), int64(1)\n",
            "memory usage: 46.6 KB\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "id": "zg9vx5zoibKz",
        "outputId": "4f4a7596-38e1-4368-fdb9-32c413a4c328"
      },
      "source": [
        "df.head()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>0.0109571007470021</th>\n",
              "      <th>0.0262889222757607</th>\n",
              "      <th>0.0318672389106398</th>\n",
              "      <th>0.0241059707528865</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0.013393</td>\n",
              "      <td>0.019890</td>\n",
              "      <td>0.001832</td>\n",
              "      <td>0.007931</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>0.028426</td>\n",
              "      <td>0.013351</td>\n",
              "      <td>0.008690</td>\n",
              "      <td>0.021609</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>0.015443</td>\n",
              "      <td>0.051812</td>\n",
              "      <td>0.004600</td>\n",
              "      <td>0.035438</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>0.008883</td>\n",
              "      <td>0.008022</td>\n",
              "      <td>0.008646</td>\n",
              "      <td>0.007616</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>0.008150</td>\n",
              "      <td>0.000124</td>\n",
              "      <td>0.010214</td>\n",
              "      <td>0.003199</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   0.0109571007470021  ...  0.0241059707528865\n",
              "0            0.013393  ...            0.007931\n",
              "1            0.028426  ...            0.021609\n",
              "2            0.015443  ...            0.035438\n",
              "3            0.008883  ...            0.007616\n",
              "4            0.008150  ...            0.003199\n",
              "\n",
              "[5 rows x 4 columns]"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0rGWhu2UgLQl"
      },
      "source": [
        "## Parameters"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:43.640257Z",
          "start_time": "2020-06-22T14:16:43.625482Z"
        },
        "id": "XadPSQozgLQl"
      },
      "source": [
        "seq_len = 24\n",
        "n_seq = 5\n",
        "batch_size = 128"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:43.653909Z",
          "start_time": "2020-06-22T14:16:43.641409Z"
        },
        "id": "ANFa04WigLQl"
      },
      "source": [
        "tickers = ['First Variable', 'Second Variable', 'Third Variable', 'Fourth Variable']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "43hgh_jKgLQm"
      },
      "source": [
        "## Plot Series"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:50.655004Z",
          "start_time": "2020-06-22T14:16:48.811967Z"
        },
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 319
        },
        "id": "P84T_omfgLQn",
        "outputId": "ecbb922c-5475-438c-85e7-c759c475fc17"
      },
      "source": [
        "axes = df.div(df.iloc[0]).plot(subplots=True,\n",
        "                               figsize=(14, 6),\n",
        "                               layout=(3, 2),\n",
        "                               title=tickers,\n",
        "                               legend=False,\n",
        "                               rot=0,\n",
        "                               lw=1, \n",
        "                               color='k')\n",
        "for ax in axes.flatten():\n",
        "    ax.set_xlabel('')\n",
        "\n",
        "plt.suptitle('Normalized Price Series')\n",
        "plt.gcf().tight_layout()\n",
        "sns.despine();"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1008x432 with 6 Axes>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "id": "nsEVQmUjGWs_",
        "outputId": "fc81ca34-82b2-411b-ec57-7169d726062b"
      },
      "source": [
        "display(df.describe())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>0.0109571007470021</th>\n",
              "      <th>0.0262889222757607</th>\n",
              "      <th>0.0318672389106398</th>\n",
              "      <th>0.0241059707528865</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>count</th>\n",
              "      <td>1189.000000</td>\n",
              "      <td>1189.000000</td>\n",
              "      <td>1189.000000</td>\n",
              "      <td>1189.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>mean</th>\n",
              "      <td>0.012445</td>\n",
              "      <td>0.010763</td>\n",
              "      <td>0.012996</td>\n",
              "      <td>0.012018</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>std</th>\n",
              "      <td>0.011884</td>\n",
              "      <td>0.011954</td>\n",
              "      <td>0.013113</td>\n",
              "      <td>0.010779</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>min</th>\n",
              "      <td>0.000003</td>\n",
              "      <td>0.000005</td>\n",
              "      <td>0.000031</td>\n",
              "      <td>0.000007</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>25%</th>\n",
              "      <td>0.004549</td>\n",
              "      <td>0.003012</td>\n",
              "      <td>0.004640</td>\n",
              "      <td>0.004910</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>50%</th>\n",
              "      <td>0.008950</td>\n",
              "      <td>0.007523</td>\n",
              "      <td>0.009546</td>\n",
              "      <td>0.009359</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>75%</th>\n",
              "      <td>0.016896</td>\n",
              "      <td>0.014569</td>\n",
              "      <td>0.016660</td>\n",
              "      <td>0.015596</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>max</th>\n",
              "      <td>0.153275</td>\n",
              "      <td>0.138418</td>\n",
              "      <td>0.098320</td>\n",
              "      <td>0.101339</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "       0.0109571007470021  ...  0.0241059707528865\n",
              "count         1189.000000  ...         1189.000000\n",
              "mean             0.012445  ...            0.012018\n",
              "std              0.011884  ...            0.010779\n",
              "min              0.000003  ...            0.000007\n",
              "25%              0.004549  ...            0.004910\n",
              "50%              0.008950  ...            0.009359\n",
              "75%              0.016896  ...            0.015596\n",
              "max              0.153275  ...            0.101339\n",
              "\n",
              "[8 rows x 4 columns]"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IEVxI6D_gLQo"
      },
      "source": [
        "## Correlation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:51.104425Z",
          "start_time": "2020-06-22T14:16:50.656239Z"
        },
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 730
        },
        "id": "pZqr2WHhgLQp",
        "outputId": "bd672eba-1664-45ec-e164-5ceda52919c7"
      },
      "source": [
        "sns.clustermap(df.corr(),annot=True,fmt='.2f',cmap=sns.diverging_palette(h_neg=20,h_pos=220), center=0);"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x720 with 4 Axes>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5E5Lz2NhgLQp"
      },
      "source": [
        "## Normalize Data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ffOZmkXUgLQq"
      },
      "source": [
        "We scale each series to the range [0, 1] using scikit-learn’s `MinMaxScaler` that we later use to rescale the synthetic data."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:51.112479Z",
          "start_time": "2020-06-22T14:16:51.106154Z"
        },
        "id": "UaCD2yVfgLQq"
      },
      "source": [
        "scaler = MinMaxScaler()\n",
        "scaled_data = scaler.fit_transform(df).astype(np.float32)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-77gQBGkgLQr"
      },
      "source": [
        "## Create rolling window sequences"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_-vEDjCIgLQr"
      },
      "source": [
        "In the next step, we create rolling windows containing overlapping sequences of 24 consecutive data points for the four series:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:51.124689Z",
          "start_time": "2020-06-22T14:16:51.114092Z"
        },
        "id": "93n7xXsUgLQs"
      },
      "source": [
        "data = []\n",
        "for i in range(len(df) - seq_len):\n",
        "    data.append(scaled_data[i:i + seq_len])\n",
        "\n",
        "n_windows = len(data)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ryF1-Z4dgLQs"
      },
      "source": [
        "## Create tf.data.Dataset"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:51.460479Z",
          "start_time": "2020-06-22T14:16:51.127466Z"
        },
        "id": "ZEgQuxS8gLQt"
      },
      "source": [
        "real_series = (tf.data.Dataset\n",
        "               .from_tensor_slices(data)\n",
        "               .shuffle(buffer_size=n_windows)\n",
        "               .batch(batch_size))\n",
        "real_series_iter = iter(real_series.repeat())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5ST4X2M3gLQu"
      },
      "source": [
        "## Set up random series generator"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KMskPoX2gLQu"
      },
      "source": [
        "We also need a random time series generator that produces simulated data with 24 observations on the six series as long as the training continues.\n",
        "\n",
        "To this end, we create a generator that draws the requisite data uniform at random and feed the result into a second `tf.data.Dataset`. We set this `Dataset` to produce batches of the desired size and to repeat the process as long as necessary:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:51.465137Z",
          "start_time": "2020-06-22T14:16:51.462655Z"
        },
        "id": "jxZ2npyIgLQv"
      },
      "source": [
        "def make_random_data():\n",
        "    while True:\n",
        "        yield np.random.uniform(low=0, high=1, size=(seq_len, n_seq))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z3TmZx1ngLQw"
      },
      "source": [
        "We use the Python generator to feed a `tf.data.Dataset` that continues to call the random number generator as long as necessary and produces the desired batch size."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:51.501020Z",
          "start_time": "2020-06-22T14:16:51.466315Z"
        },
        "id": "UTLTksZMgLQx"
      },
      "source": [
        "random_series = iter(tf.data.Dataset\n",
        "                     .from_generator(make_random_data, output_types=tf.float32)\n",
        "                     .batch(batch_size)\n",
        "                     .repeat())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4Jhv6kFegLQy"
      },
      "source": [
        "# TimeGAN Setup"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eNYr_ql4gLQy"
      },
      "source": [
        "We’ll now create the two autoencoder components and the two adversarial network elements, as well as the supervisor that encourages the generator to learn the temporal dynamic of the historical price series."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zx6BTkv9gLQz"
      },
      "source": [
        "##  Network Parameters"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1msOPtP_gLQ0"
      },
      "source": [
        "We follow the authors’ sample code in creating RNNs with three hidden layers with 24 GRU units each, except for the supervisor that only uses two hidden layers."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:51.504888Z",
          "start_time": "2020-06-22T14:16:51.502406Z"
        },
        "id": "eIwXM_zEgLQ1"
      },
      "source": [
        "hidden_dim = 24\n",
        "num_layers = 4"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-11T21:00:46.029497Z",
          "start_time": "2020-06-11T21:00:46.027650Z"
        },
        "id": "qHoO9s8_gLQ3"
      },
      "source": [
        "## Set up logger"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:51.514147Z",
          "start_time": "2020-06-22T14:16:51.506392Z"
        },
        "id": "qpWEsgwIgLQ4"
      },
      "source": [
        "writer = tf.summary.create_file_writer(log_dir.as_posix())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-11T21:01:03.536533Z",
          "start_time": "2020-06-11T21:01:03.534324Z"
        },
        "id": "VSS6oRHBgLQ5"
      },
      "source": [
        "## Input place holders"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:51.539209Z",
          "start_time": "2020-06-22T14:16:51.515706Z"
        },
        "id": "MoEhxczygLQ5"
      },
      "source": [
        "X = Input(shape=[seq_len, n_seq], name='RealData')\n",
        "Z = Input(shape=[seq_len, n_seq], name='RandomData')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bdj8mv9OgLQ6"
      },
      "source": [
        "## RNN block generator"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T5lAPuL3gLQ6"
      },
      "source": [
        "We keep it simple and use a very similar architecture for all four components. For a real-world application, they should be tailored to the data."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KJq9RqY_gLQ6"
      },
      "source": [
        "The following `make_rnn` function automates the network creation:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:51.547728Z",
          "start_time": "2020-06-22T14:16:51.542460Z"
        },
        "id": "_tRbLkI7gLQ6"
      },
      "source": [
        "def make_rnn(n_layers, hidden_units, output_units, name):\n",
        "    return Sequential([GRU(units=hidden_units,\n",
        "                           return_sequences=True,\n",
        "                           name=f'GRU_{i + 1}') for i in range(n_layers)] +\n",
        "                      [Dense(units=output_units,\n",
        "                             activation='sigmoid',\n",
        "                             name='OUT')], name=name)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FgZf8RR3gLQ7"
      },
      "source": [
        "## Embedder & Recovery"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WG4F88tggLQ7"
      },
      "source": [
        "The autoencoder consists of the embedder and the recovery networks that we instantiate here:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:51.594039Z",
          "start_time": "2020-06-22T14:16:51.549914Z"
        },
        "id": "Svyo9ca0gLQ7"
      },
      "source": [
        "embedder = make_rnn(n_layers=3, \n",
        "                    hidden_units=hidden_dim, \n",
        "                    output_units=hidden_dim, \n",
        "                    name='Embedder')\n",
        "recovery = make_rnn(n_layers=3, \n",
        "                    hidden_units=hidden_dim, \n",
        "                    output_units=n_seq, \n",
        "                    name='Recovery')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-11T21:02:03.263130Z",
          "start_time": "2020-06-11T21:02:03.260572Z"
        },
        "id": "4ovkIzyegLQ8"
      },
      "source": [
        "## Generator & Discriminator"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-11-18T15:45:29.621203Z",
          "start_time": "2020-11-18T15:45:29.618574Z"
        },
        "id": "OA28OKI-gLQ8"
      },
      "source": [
        "We then create the generator, the discriminator, and the supervisor like so:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:51.646017Z",
          "start_time": "2020-06-22T14:16:51.595598Z"
        },
        "id": "SCWO3h9rgLQ8"
      },
      "source": [
        "generator = make_rnn(n_layers=3, \n",
        "                     hidden_units=hidden_dim, \n",
        "                     output_units=hidden_dim, \n",
        "                     name='Generator')\n",
        "discriminator = make_rnn(n_layers=3, \n",
        "                         hidden_units=hidden_dim, \n",
        "                         output_units=1, \n",
        "                         name='Discriminator')\n",
        "supervisor = make_rnn(n_layers=2, \n",
        "                      hidden_units=hidden_dim, \n",
        "                      output_units=hidden_dim, \n",
        "                      name='Supervisor')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Zko20JWHgLQ9"
      },
      "source": [
        "# TimeGAN Training"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cJFM7HXXgLQ9"
      },
      "source": [
        "## Settings"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:51.654925Z",
          "start_time": "2020-06-22T14:16:51.647411Z"
        },
        "id": "EAeo6vKngLQ9"
      },
      "source": [
        "train_steps = 10000\n",
        "gamma = 1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tFbqGAp_gLQ-"
      },
      "source": [
        "## Generic Loss Functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j06EvYItgLQ_"
      },
      "source": [
        "We also define two generic loss functions, namely `MeanSquaredError` and `BinaryCrossEntropy` that we will use later to create the various specific loss functions during the three phases:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:51.668710Z",
          "start_time": "2020-06-22T14:16:51.656698Z"
        },
        "id": "OG3aD9c7gLRA"
      },
      "source": [
        "mse = MeanSquaredError()\n",
        "bce = BinaryCrossentropy()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L0r26VDagLRB"
      },
      "source": [
        "# Phase 1: Autoencoder Training"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ERp1rSeegLRB"
      },
      "source": [
        "## Architecture"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sKCZFWtlgLRB"
      },
      "source": [
        "The autoencoder integrates the embedder and the recovery functions:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:53.289403Z",
          "start_time": "2020-06-22T14:16:51.670765Z"
        },
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hFK3mGIvgLRC",
        "outputId": "49ec2875-c6a8-4cb5-c230-584e5df65a6f"
      },
      "source": [
        "H = embedder(X)\n",
        "X_tilde = recovery(H)\n",
        "\n",
        "tf.shape(X_tilde)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<KerasTensor: shape=(3,) dtype=int32 inferred_value=[None, 24, 5] (created by layer 'tf.compat.v1.shape_1')>"
            ]
          },
          "metadata": {},
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WTsscQNFmg9R"
      },
      "source": [
        "autoencoder = Model(inputs=X,outputs=X_tilde,name='Autoencoder')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:53.294438Z",
          "start_time": "2020-06-22T14:16:53.290299Z"
        },
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W6pmaMWBgLRC",
        "outputId": "57496e14-5a77-4acc-f04b-b008e466f6b6"
      },
      "source": [
        "autoencoder.summary()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"Autoencoder\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " RealData (InputLayer)       [(None, 24, 5)]           0         \n",
            "                                                                 \n",
            " Embedder (Sequential)       (None, 24, 24)            10032     \n",
            "                                                                 \n",
            " Recovery (Sequential)       (None, 24, 5)             10925     \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 20,957\n",
            "Trainable params: 20,957\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:53.441359Z",
          "start_time": "2020-06-22T14:16:53.296275Z"
        },
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 312
        },
        "id": "HbtWG0lbgLRD",
        "outputId": "6d6cb58f-423a-46ec-8b82-914208ead04d"
      },
      "source": [
        "plot_model(autoencoder,\n",
        "           to_file=(results_path / 'autoencoder.png').as_posix(),\n",
        "           show_shapes=True)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TR3EQT6agLRD"
      },
      "source": [
        "We next instantiate the optimizer for this training phase and define the training step. It follows the pattern introduced with the DCGAN example, using tf.GradientTape to record the operations that generate the reconstruction loss. This allows us to rely on the automatic differentiation engine to obtain the gradients with respect to the trainable embedder and recovery network weights that drive backpropagation:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "feB3pvL7gLRD"
      },
      "source": [
        "## Autoencoder Optimizer"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:53.447696Z",
          "start_time": "2020-06-22T14:16:53.444030Z"
        },
        "id": "UWrHAXiygLRE"
      },
      "source": [
        "autoencoder_optimizer = Adam()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o7LOT84XgLRE"
      },
      "source": [
        "## Autoencoder Training Step"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:16:53.459708Z",
          "start_time": "2020-06-22T14:16:53.450198Z"
        },
        "id": "JOC6tN1egLRE"
      },
      "source": [
        "@tf.function\n",
        "def train_autoencoder_init(x):\n",
        "    with tf.GradientTape() as tape:\n",
        "        x_tilde = autoencoder(x)\n",
        "        embedding_loss_t0 = mse(x, x_tilde)\n",
        "        e_loss_0 = 10 * tf.sqrt(embedding_loss_t0)\n",
        "\n",
        "    var_list = embedder.trainable_variables + recovery.trainable_variables\n",
        "    gradients = tape.gradient(e_loss_0, var_list)\n",
        "    autoencoder_optimizer.apply_gradients(zip(gradients, var_list))\n",
        "    return tf.sqrt(embedding_loss_t0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PotKc3d9gLRF"
      },
      "source": [
        "## Autoencoder Training Loop"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aqaAGchjgLRF"
      },
      "source": [
        "The reconstruction loss simply compares the autoencoder outputs with its inputs. We train for 10,000 steps in a little over one minute using this training loop that records the step loss for monitoring with TensorBoard:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:18:21.132545Z",
          "start_time": "2020-06-22T14:16:53.461372Z"
        },
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 554
        },
        "id": "Ax1CtKeEgLRF",
        "outputId": "0e9d024c-dda2-40d8-83b5-4fe7b63ec46e"
      },
      "source": [
        "for step in tqdm(range(train_steps)):\n",
        "    X_ = next(real_series_iter)\n",
        "    step_e_loss_t0 = train_autoencoder_init(X_)\n",
        "    with writer.as_default():\n",
        "        tf.summary.scalar('Loss Autoencoder Init', step_e_loss_t0, step=step)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "  0%|          | 0/10000 [00:00<?, ?it/s]\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-61-b39c35f4d7fc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mstep\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mtqdm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrain_steps\u001b[0m\u001b[0;34m)\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      2\u001b[0m     \u001b[0mX_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreal_series_iter\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0mstep_e_loss_t0\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrain_autoencoder_init\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_\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      4\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mwriter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_default\u001b[0m\u001b[0;34m(\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      5\u001b[0m         \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msummary\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscalar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Loss Autoencoder Init'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstep_e_loss_t0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstep\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/util/traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    151\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    152\u001b[0m       \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 153\u001b[0;31m       \u001b[0;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwith_traceback\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfiltered_tb\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    154\u001b[0m     \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    155\u001b[0m       \u001b[0;32mdel\u001b[0m \u001b[0mfiltered_tb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/tensorflow/python/framework/func_graph.py\u001b[0m in \u001b[0;36mautograph_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m   1127\u001b[0m           \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# pylint:disable=broad-except\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1128\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"ag_error_metadata\"\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-> 1129\u001b[0;31m               \u001b[0;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mag_error_metadata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_exception\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\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   1130\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1131\u001b[0m               \u001b[0;32mraise\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: in user code:\n\n    File \"<ipython-input-44-4931b3f5d381>\", line 4, in train_autoencoder_init  *\n        x_tilde = autoencoder(x)\n    File \"/usr/local/lib/python3.7/dist-packages/keras/utils/traceback_utils.py\", line 67, in error_handler  **\n        raise e.with_traceback(filtered_tb) from None\n    File \"/usr/local/lib/python3.7/dist-packages/keras/engine/input_spec.py\", line 263, in assert_input_compatibility\n        raise ValueError(f'Input {input_index} of layer \"{layer_name}\" is '\n\n    ValueError: Input 0 of layer \"Autoencoder\" is incompatible with the layer: expected shape=(None, 24, 5), found shape=(128, 24, 4)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rzGaZcpsgLRG"
      },
      "source": [
        "## Persist model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:18:21.135850Z",
          "start_time": "2020-06-22T14:18:21.133941Z"
        },
        "id": "E651s0dzgLRG"
      },
      "source": [
        "# autoencoder.save(log_dir / 'autoencoder')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g5W5YGDigLRG"
      },
      "source": [
        "# Phase 2: Supervised training"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qmWfpH_BgLRG"
      },
      "source": [
        "We already created the supervisor model so we just need to instantiate the optimizer and define the train step as follows:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OZoLAQDkgLRH"
      },
      "source": [
        "## Define Optimizer"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:18:21.150618Z",
          "start_time": "2020-06-22T14:18:21.137038Z"
        },
        "id": "EiOO8ERygLRH"
      },
      "source": [
        "supervisor_optimizer = Adam()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rBd9P6NegLRH"
      },
      "source": [
        "## Train Step"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:18:21.159749Z",
          "start_time": "2020-06-22T14:18:21.152011Z"
        },
        "id": "PFQFZQHPgLRH"
      },
      "source": [
        "@tf.function\n",
        "def train_supervisor(x):\n",
        "    with tf.GradientTape() as tape:\n",
        "        h = embedder(x)\n",
        "        h_hat_supervised = supervisor(h)\n",
        "        g_loss_s = mse(h[:, 1:, :], h_hat_supervised[:, 1:, :])\n",
        "\n",
        "    var_list = supervisor.trainable_variables\n",
        "    gradients = tape.gradient(g_loss_s, var_list)\n",
        "    supervisor_optimizer.apply_gradients(zip(gradients, var_list))\n",
        "    return g_loss_s"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I1M6yJFBgLRI"
      },
      "source": [
        "In this case, the loss compares the output of the supervisor with the next timestep for the embedded sequence so that it learns the temporal dynamics of the historical price sequences; the training loop works similarly to the autoencoder example."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uMJXcWd2gLRI"
      },
      "source": [
        "## Training Loop"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:21:43.864154Z",
          "start_time": "2020-06-22T14:18:21.161919Z"
        },
        "id": "LL_68lTdgLRI"
      },
      "source": [
        "for step in tqdm(range(train_steps)):\n",
        "    X_ = next(real_series_iter)\n",
        "    step_g_loss_s = train_supervisor(X_)\n",
        "    with writer.as_default():\n",
        "        tf.summary.scalar('Loss Generator Supervised Init', step_g_loss_s, step=step)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Th8J4W3egLRJ"
      },
      "source": [
        "## Persist Model"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:21:43.866414Z",
          "start_time": "2020-06-22T14:21:43.865006Z"
        },
        "id": "7YdzUtO1gLRJ"
      },
      "source": [
        "# supervisor.save(log_dir / 'supervisor')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "loBM_rZlgLRK"
      },
      "source": [
        "# Joint Training"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L5ZlYsSRgLRK"
      },
      "source": [
        "The joint training involves all four network components as well as the supervisor. It uses multiple loss functions and combinations of the base components to achieve the simultaneous learning of latent space embeddings, transition dynamics, and synthetic data generation. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M_qGWdX5gLRL"
      },
      "source": [
        "## Generator"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lfX1uIzNgLRL"
      },
      "source": [
        "### Adversarial Architecture - Supervised"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:21:44.759375Z",
          "start_time": "2020-06-22T14:21:43.867138Z"
        },
        "id": "q78r73isgLRL"
      },
      "source": [
        "E_hat = generator(Z)\n",
        "H_hat = supervisor(E_hat)\n",
        "Y_fake = discriminator(H_hat)\n",
        "\n",
        "adversarial_supervised = Model(inputs=Z,\n",
        "                               outputs=Y_fake,\n",
        "                               name='AdversarialNetSupervised')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:21:44.765189Z",
          "start_time": "2020-06-22T14:21:44.760237Z"
        },
        "id": "qztIHy9VgLRM"
      },
      "source": [
        "adversarial_supervised.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:21:44.891013Z",
          "start_time": "2020-06-22T14:21:44.766236Z"
        },
        "id": "GFE_eOvKgLRN"
      },
      "source": [
        "plot_model(adversarial_supervised, show_shapes=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JkZwezt1gLRO"
      },
      "source": [
        "### Adversarial Architecture in Latent Space"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:21:45.207968Z",
          "start_time": "2020-06-22T14:21:44.892152Z"
        },
        "id": "n0E2dPmLgLRO"
      },
      "source": [
        "Y_fake_e = discriminator(E_hat)\n",
        "\n",
        "adversarial_emb = Model(inputs=Z,\n",
        "                    outputs=Y_fake_e,\n",
        "                    name='AdversarialNet')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:21:45.213528Z",
          "start_time": "2020-06-22T14:21:45.208923Z"
        },
        "id": "5ECmtcpYgLRQ"
      },
      "source": [
        "adversarial_emb.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:21:45.339928Z",
          "start_time": "2020-06-22T14:21:45.214560Z"
        },
        "id": "CbI99zpxgLRR"
      },
      "source": [
        "plot_model(adversarial_emb, show_shapes=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "40Itxtm4gLRS"
      },
      "source": [
        "### Mean & Variance Loss"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZQScMekGgLRT"
      },
      "source": [
        "To ensure that the generator faithfully reproduces the time series, TimeGAN includes a moment loss that penalizes when mean and variance of the synthetic data deviate from the real version:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:21:45.675612Z",
          "start_time": "2020-06-22T14:21:45.341343Z"
        },
        "id": "SWCxkLIUgLRT"
      },
      "source": [
        "X_hat = recovery(H_hat)\n",
        "synthetic_data = Model(inputs=Z,\n",
        "                       outputs=X_hat,\n",
        "                       name='SyntheticData')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K2xtMFJigLRU"
      },
      "source": [
        "The end-to-end model that produces synthetic data involves the generator, supervisor, and recovery component. It is defined as follows and has close to 30,000 trainable paramters:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:21:45.682769Z",
          "start_time": "2020-06-22T14:21:45.676682Z"
        },
        "id": "_Kl_zbiZgLRU"
      },
      "source": [
        "synthetic_data.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:21:45.808849Z",
          "start_time": "2020-06-22T14:21:45.683931Z"
        },
        "id": "Ab1awHsJgLRV"
      },
      "source": [
        "plot_model(synthetic_data, show_shapes=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:21:45.813915Z",
          "start_time": "2020-06-22T14:21:45.810248Z"
        },
        "id": "O4BpofhvgLRV"
      },
      "source": [
        "def get_generator_moment_loss(y_true, y_pred):\n",
        "    y_true_mean, y_true_var = tf.nn.moments(x=y_true, axes=[0])\n",
        "    y_pred_mean, y_pred_var = tf.nn.moments(x=y_pred, axes=[0])\n",
        "    g_loss_mean = tf.reduce_mean(tf.abs(y_true_mean - y_pred_mean))\n",
        "    g_loss_var = tf.reduce_mean(tf.abs(tf.sqrt(y_true_var + 1e-6) - tf.sqrt(y_pred_var + 1e-6)))\n",
        "    return g_loss_mean + g_loss_var"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ojOZK5s5gLRW"
      },
      "source": [
        "## Discriminator"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xQvBB27-gLRW"
      },
      "source": [
        "### Architecture: Real Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:21:46.138938Z",
          "start_time": "2020-06-22T14:21:45.815300Z"
        },
        "id": "Sk6zQQD4gLRW"
      },
      "source": [
        "Y_real = discriminator(H)\n",
        "discriminator_model = Model(inputs=X,\n",
        "                            outputs=Y_real,\n",
        "                            name='DiscriminatorReal')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:21:46.145727Z",
          "start_time": "2020-06-22T14:21:46.141825Z"
        },
        "id": "r0bi9MrGgLRX"
      },
      "source": [
        "discriminator_model.summary()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:21:46.271876Z",
          "start_time": "2020-06-22T14:21:46.146811Z"
        },
        "id": "6hcsVvvzgLRX"
      },
      "source": [
        "plot_model(discriminator_model, show_shapes=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MxNoxGhugLRY"
      },
      "source": [
        "## Optimizers"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FkSqC0rugLRY"
      },
      "source": [
        "The joint training involves three optimizers for the autoencoder, the generator and the discriminator:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:21:46.275281Z",
          "start_time": "2020-06-22T14:21:46.273098Z"
        },
        "id": "sLbalKf0gLRZ"
      },
      "source": [
        "generator_optimizer = Adam()\n",
        "discriminator_optimizer = Adam()\n",
        "embedding_optimizer = Adam()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D1YWB5PCgLRZ"
      },
      "source": [
        "## Generator Train Step"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uzdx40FogLRa"
      },
      "source": [
        "The train step for the generator illustrates the use of four loss functions and corresponding combinations of network components to achieve the desired learning outlined at the beginning of this section:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:21:46.284057Z",
          "start_time": "2020-06-22T14:21:46.276232Z"
        },
        "id": "QkeQc3JVgLRb"
      },
      "source": [
        "@tf.function\n",
        "def train_generator(x, z):\n",
        "    with tf.GradientTape() as tape:\n",
        "        y_fake = adversarial_supervised(z)\n",
        "        generator_loss_unsupervised = bce(y_true=tf.ones_like(y_fake),\n",
        "                                          y_pred=y_fake)\n",
        "\n",
        "        y_fake_e = adversarial_emb(z)\n",
        "        generator_loss_unsupervised_e = bce(y_true=tf.ones_like(y_fake_e),\n",
        "                                            y_pred=y_fake_e)\n",
        "        h = embedder(x)\n",
        "        h_hat_supervised = supervisor(h)\n",
        "        generator_loss_supervised = mse(h[:, 1:, :], h_hat_supervised[:, 1:, :])\n",
        "\n",
        "        x_hat = synthetic_data(z)\n",
        "        generator_moment_loss = get_generator_moment_loss(x, x_hat)\n",
        "\n",
        "        generator_loss = (generator_loss_unsupervised +\n",
        "                          generator_loss_unsupervised_e +\n",
        "                          100 * tf.sqrt(generator_loss_supervised) +\n",
        "                          100 * generator_moment_loss)\n",
        "\n",
        "    var_list = generator.trainable_variables + supervisor.trainable_variables\n",
        "    gradients = tape.gradient(generator_loss, var_list)\n",
        "    generator_optimizer.apply_gradients(zip(gradients, var_list))\n",
        "    return generator_loss_unsupervised, generator_loss_supervised, generator_moment_loss"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4BcLbBkFgLRc"
      },
      "source": [
        "## Embedding Train Step"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:21:46.295232Z",
          "start_time": "2020-06-22T14:21:46.284920Z"
        },
        "id": "4DW4dGSBgLRc"
      },
      "source": [
        "@tf.function\n",
        "def train_embedder(x):\n",
        "    with tf.GradientTape() as tape:\n",
        "        h = embedder(x)\n",
        "        h_hat_supervised = supervisor(h)\n",
        "        generator_loss_supervised = mse(h[:, 1:, :], h_hat_supervised[:, 1:, :])\n",
        "\n",
        "        x_tilde = autoencoder(x)\n",
        "        embedding_loss_t0 = mse(x, x_tilde)\n",
        "        e_loss = 10 * tf.sqrt(embedding_loss_t0) + 0.1 * generator_loss_supervised\n",
        "\n",
        "    var_list = embedder.trainable_variables + recovery.trainable_variables\n",
        "    gradients = tape.gradient(e_loss, var_list)\n",
        "    embedding_optimizer.apply_gradients(zip(gradients, var_list))\n",
        "    return tf.sqrt(embedding_loss_t0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vNDtKaUFgLRd"
      },
      "source": [
        "## Discriminator Train Step"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:21:46.303397Z",
          "start_time": "2020-06-22T14:21:46.296151Z"
        },
        "id": "fKQw7IiZgLRd"
      },
      "source": [
        "@tf.function\n",
        "def get_discriminator_loss(x, z):\n",
        "    y_real = discriminator_model(x)\n",
        "    discriminator_loss_real = bce(y_true=tf.ones_like(y_real),\n",
        "                                  y_pred=y_real)\n",
        "\n",
        "    y_fake = adversarial_supervised(z)\n",
        "    discriminator_loss_fake = bce(y_true=tf.zeros_like(y_fake),\n",
        "                                  y_pred=y_fake)\n",
        "\n",
        "    y_fake_e = adversarial_emb(z)\n",
        "    discriminator_loss_fake_e = bce(y_true=tf.zeros_like(y_fake_e),\n",
        "                                    y_pred=y_fake_e)\n",
        "    return (discriminator_loss_real +\n",
        "            discriminator_loss_fake +\n",
        "            gamma * discriminator_loss_fake_e)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T14:21:46.314283Z",
          "start_time": "2020-06-22T14:21:46.304404Z"
        },
        "id": "z74s6PNIgLRd"
      },
      "source": [
        "@tf.function\n",
        "def train_discriminator(x, z):\n",
        "    with tf.GradientTape() as tape:\n",
        "        discriminator_loss = get_discriminator_loss(x, z)\n",
        "\n",
        "    var_list = discriminator.trainable_variables\n",
        "    gradients = tape.gradient(discriminator_loss, var_list)\n",
        "    discriminator_optimizer.apply_gradients(zip(gradients, var_list))\n",
        "    return discriminator_loss"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pUPTzXxOgLRe"
      },
      "source": [
        "## Training Loop"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "njeAnO-WgLRe"
      },
      "source": [
        "Finally, the joint training loop pulls the various training steps together and builds on the learning from phase 1 and 2 to train the TimeGAN components on both real and random data. We run the loop for 10,000 iterations in under 50 minutes:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T15:11:24.409536Z",
          "start_time": "2020-06-22T14:21:46.315280Z"
        },
        "id": "2XymTgVvgLRf"
      },
      "source": [
        "step_g_loss_u = step_g_loss_s = step_g_loss_v = step_e_loss_t0 = step_d_loss = 0\n",
        "for step in range(train_steps):\n",
        "    # Train generator (twice as often as discriminator)\n",
        "    for kk in range(2):\n",
        "        X_ = next(real_series_iter)\n",
        "        Z_ = next(random_series)\n",
        "\n",
        "        # Train generator\n",
        "        step_g_loss_u, step_g_loss_s, step_g_loss_v = train_generator(X_, Z_)\n",
        "        # Train embedder\n",
        "        step_e_loss_t0 = train_embedder(X_)\n",
        "\n",
        "    X_ = next(real_series_iter)\n",
        "    Z_ = next(random_series)\n",
        "    step_d_loss = get_discriminator_loss(X_, Z_)\n",
        "    if step_d_loss > 0.15:\n",
        "        step_d_loss = train_discriminator(X_, Z_)\n",
        "\n",
        "    if step % 1000 == 0:\n",
        "        print(f'{step:6,.0f} | d_loss: {step_d_loss:6.4f} | g_loss_u: {step_g_loss_u:6.4f} | '\n",
        "              f'g_loss_s: {step_g_loss_s:6.4f} | g_loss_v: {step_g_loss_v:6.4f} | e_loss_t0: {step_e_loss_t0:6.4f}')\n",
        "\n",
        "    with writer.as_default():\n",
        "        tf.summary.scalar('G Loss S', step_g_loss_s, step=step)\n",
        "        tf.summary.scalar('G Loss U', step_g_loss_u, step=step)\n",
        "        tf.summary.scalar('G Loss V', step_g_loss_v, step=step)\n",
        "        tf.summary.scalar('E Loss T0', step_e_loss_t0, step=step)\n",
        "        tf.summary.scalar('D Loss', step_d_loss, step=step)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QPIwZv-egLRf"
      },
      "source": [
        "## Persist Synthetic Data Generator"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T15:11:40.412907Z",
          "start_time": "2020-06-22T15:11:24.410409Z"
        },
        "id": "-Z3R_ShZgLRh"
      },
      "source": [
        "synthetic_data.save(log_dir / 'synthetic_data')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WhCNDmvkgLRi"
      },
      "source": [
        "# Generate Synthetic Data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BzGMvNQDgLRj"
      },
      "source": [
        "To evaluate the TimeGAN results, we generate synthetic by drawing random inputs and feeding them to the `synthetic_data` network just described. \n",
        "\n",
        "More specifically, we’ll create roughly as many artificial series with 24 observations on the six tickers as there are overlapping windows in the real dataset:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T15:11:42.825347Z",
          "start_time": "2020-06-22T15:11:40.433334Z"
        },
        "id": "eALj9CFOgLRj"
      },
      "source": [
        "generated_data = []\n",
        "for i in range(int(n_windows / batch_size)):\n",
        "    Z_ = next(random_series)\n",
        "    d = synthetic_data(Z_)\n",
        "    generated_data.append(d)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T15:11:42.830084Z",
          "start_time": "2020-06-22T15:11:42.826463Z"
        },
        "id": "8YagwN56gLRj"
      },
      "source": [
        "len(generated_data)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "INbXMCURgLRk"
      },
      "source": [
        "The result is 35 batches containing 128 samples with dimensions 24⨉6 each that we stack like so:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T15:11:42.852034Z",
          "start_time": "2020-06-22T15:11:42.831084Z"
        },
        "id": "qW8knfcjgLRk"
      },
      "source": [
        "generated_data = np.array(np.vstack(generated_data))\n",
        "generated_data.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T15:11:42.857797Z",
          "start_time": "2020-06-22T15:11:42.853108Z"
        },
        "id": "9bIKKgJ3gLRk"
      },
      "source": [
        "np.save(log_dir / 'generated_data.npy', generated_data)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-q2Z04kygLRl"
      },
      "source": [
        "## Rescale"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QhX2umAngLRl"
      },
      "source": [
        "We can use the trained MinMaxScaler to revert the synthetic to the scale of the input series:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T15:11:42.872876Z",
          "start_time": "2020-06-22T15:11:42.858811Z"
        },
        "id": "t-cSqiVMgLRl"
      },
      "source": [
        "generated_data = (scaler.inverse_transform(generated_data\n",
        "                                           .reshape(-1, n_seq))\n",
        "                  .reshape(-1, seq_len, n_seq))\n",
        "generated_data.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QBnYxqwYgLRl"
      },
      "source": [
        "## Persist Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T15:11:42.888314Z",
          "start_time": "2020-06-22T15:11:42.873942Z"
        },
        "id": "w4qfNBkJgLRm"
      },
      "source": [
        "with pd.HDFStore(hdf_store) as store:\n",
        "    store.put('data/synthetic', pd.DataFrame(generated_data.reshape(-1, n_seq),\n",
        "                                             columns=tickers))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oUNJ-B3hgLRm"
      },
      "source": [
        "## Plot sample Series"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MVLAAZgxgLRm"
      },
      "source": [
        "The below figure displays samples of the six synthetic series and the corresponding real series. The synthetic data generally reflect a variation of behavior not unlike their real counterparts and, after rescaling, roughly (due to the random input) match their range."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-06-22T15:11:45.421814Z",
          "start_time": "2020-06-22T15:11:42.890793Z"
        },
        "id": "Xstj5e4CgLRn"
      },
      "source": [
        "fig, axes = plt.subplots(nrows=3, ncols=2, figsize=(14, 7))\n",
        "axes = axes.flatten()\n",
        "\n",
        "index = list(range(1, 25))\n",
        "synthetic = generated_data[np.random.randint(n_windows)]\n",
        "\n",
        "idx = np.random.randint(len(df) - seq_len)\n",
        "real = df.iloc[idx: idx + seq_len]\n",
        "\n",
        "for j, ticker in enumerate(tickers):\n",
        "    (pd.DataFrame({'Real': real.iloc[:, j].values,\n",
        "                   'Synthetic': synthetic[:, j]})\n",
        "     .plot(ax=axes[j],\n",
        "           title=ticker,\n",
        "           secondary_y='Synthetic', style=['-', '--'],\n",
        "           lw=1))\n",
        "sns.despine()\n",
        "fig.tight_layout()"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}