Brock_Mirman_1972.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "In this notebook, we are going to solve a simple optimal growth model with one agent. The model is a simplified version of Brock and Mirman (1972). The planner aims to maximize his time-separable life time utility in \\eqref{eq:obj} subject to his budget constraint defined in \\eqref{eq:const}:\n",
    "\n",
    "\\begin{align}\n",
    "&\\max_{\\left\\{c_{t}\\right\\}_{t=0}^{\\infty}} \\sum_{t=0}^{\\infty} \\beta^{t} \\ln\\left(c_{t}\\right) \\label{eq:obj}\\\\\n",
    "\\text{s.t.} \\quad & k_{t+1} + c_{t} \\leq Ak_{t}^\\alpha \\label{eq:const}\n",
    "\\end{align}\n",
    "\n",
    "where we assume full depreciation, i.e. $\\delta=1$, to simplify the following discussions. As is well known, this particular problem has an analytical solution:\n",
    "\n",
    "\\begin{align}\n",
    "k_{t+1} = \\beta \\alpha A k_{t}^{\\alpha} \\label{eq:analytic_policy}\n",
    "\\end{align}\n",
    "\n",
    "\n",
    "We can numerically solve the above planner's problem by using any global solution algorithms such as the value function iteration or the time iteration collocation. However in this notebook, we demonstrate how the recursive equilibrium can be directly approximated by the deep neural net, which is proposed in Azinovic et.al (2019)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we need to import necessary python numerical libraries and tensorflow:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/takafumi/.pyenv/versions/anaconda3-5.3.1/envs/tensor1/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:526: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "/home/takafumi/.pyenv/versions/anaconda3-5.3.1/envs/tensor1/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:527: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "/home/takafumi/.pyenv/versions/anaconda3-5.3.1/envs/tensor1/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:528: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "/home/takafumi/.pyenv/versions/anaconda3-5.3.1/envs/tensor1/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:529: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "/home/takafumi/.pyenv/versions/anaconda3-5.3.1/envs/tensor1/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:530: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "/home/takafumi/.pyenv/versions/anaconda3-5.3.1/envs/tensor1/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:535: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Version of tensorflow is 1.13.1\n"
     ]
    }
   ],
   "source": [
    "# Import necessary liblaries\n",
    "import numpy as np\n",
    "import math\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import rc\n",
    "# Use TeX font\n",
    "rc('font', **{'family': 'sans-serif', 'serif': ['Helvetica']})\n",
    "rc('text', usetex=True)\n",
    "plt.rcParams[\"font.size\"] = 15\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "print(\"Version of tensorflow is {}\".format(tf.__version__))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We define the following economic parameters. Note that there is no TFP shock."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = 1  # Technology level\n",
    "alpha = 0.36  # Capital share in the Cobb-Douglas production function\n",
    "beta = 0.99  # Discount factor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As mentioned above, the optimal growth model has a closed form solution. We can compute the stationary point (or steady state) as well as the optimal consumption policy based on the closed form solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stationary point is 0.199482\n"
     ]
    }
   ],
   "source": [
    "def k_compute_infty(alpha, beta, A):\n",
    "    \"\"\" Return the stationary point (or steady state) \"\"\"\n",
    "    return (1 / (beta * alpha * A))**(1/(alpha - 1))\n",
    "\n",
    "\n",
    "k_infty = k_compute_infty(alpha, beta, A)\n",
    "print(\"Stationary point is {:5f}\".format(k_infty))\n",
    "\n",
    "\n",
    "def kplus_compute_analytic(k, alpha, beta, A):\n",
    "    \"\"\" Analytical solution\n",
    "    Return the optimal capital stock in the next period \"\"\"\n",
    "    return alpha * beta * A * k**alpha\n",
    "\n",
    "\n",
    "def c_compute(k, kplus, alpha, beta, A):\n",
    "    \"\"\" Return the optimal consumption policy \"\"\"\n",
    "    return A*k**alpha - kplus"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deep neural net\n",
    "In this section, we define the architecture of the deep neural net.\n",
    "\n",
    "## Hyper parameters\n",
    "\n",
    "Hyper parameter defines the architecture of the deep neural net. Following Azinovic et al. (2019), we adopt the following hyper parameters. Note that the purpose of this notebook is in the demonstration of the deep neural net. Detail analyses of the choice of hyper parameters are omitted. We assume the following structure of layers and activation functions: \n",
    "Layer 1: the input layer, 1 neuron corresponding to the capital stock today  \n",
    "Layer 2: the first hidden layer, 50 neurons and is activated by Relu  \n",
    "Layer 3: the second hidden layer, 50 neurons and is activated by Relu  \n",
    "Layer 4: the output layer, 2 neurons corresponding to the capital stock tomorrow and the Lagrange multiplier, activated by softplus to ensure that all of economic variables are non-negative."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dimensions of each layer are [1, 100, 100, 2]\n"
     ]
    }
   ],
   "source": [
    "# Layer setting\n",
    "num_input = 1\n",
    "num_hidden1 = 100\n",
    "num_hidden2 = 100\n",
    "num_output = 2\n",
    "layers_dim = [num_input, num_hidden1, num_hidden2, num_output]\n",
    "print(\"Dimensions of each layer are {}\".format(layers_dim))\n",
    "\n",
    "learning_rate = 0.001  # Leargning rate\n",
    "t_length = 10000  # Simulation length\n",
    "\n",
    "# Number of episodes, epochs and minibatch size\n",
    "num_episodes = 50\n",
    "num_epochs = 10\n",
    "minibatch_size = 64"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Useful functions in the deep neural net\n",
    "We define some useful functions, which facilitate our subsequent implementations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_placeholders(num_x):\n",
    "    \"\"\" Create the placeholders.\n",
    "    The column dimention is None that represents the length of the simulated\n",
    "    path.\"\"\"\n",
    "    X = tf.placeholder(tf.float32, shape=[num_x, None], name='X')\n",
    "    return X\n",
    "\n",
    "\n",
    "def initialize_parameters(layers_dim):\n",
    "    \"\"\" Initialize parameters to build a neural network\n",
    "    1: [num_input, None] -> [num_hidden1, None]\n",
    "    2: [num_hidden1, None] -> [num_hidden2, None]\n",
    "    3: [num_hidden2, None] -> [num_output, None] \"\"\"\n",
    "\n",
    "    W1 = tf.get_variable('W1', [layers_dim[1], layers_dim[0]], tf.float32,\n",
    "                         tf.contrib.layers.xavier_initializer())\n",
    "    b1 = tf.get_variable('b1', [layers_dim[1], 1], tf.float32,\n",
    "                         tf.zeros_initializer())\n",
    "    W2 = tf.get_variable('W2', [layers_dim[2], layers_dim[1]], tf.float32,\n",
    "                         tf.contrib.layers.xavier_initializer())\n",
    "    b2 = tf.get_variable('b2', [layers_dim[2], 1], tf.float32,\n",
    "                         tf.zeros_initializer())\n",
    "    W3 = tf.get_variable('W3', [layers_dim[3], layers_dim[2]], tf.float32,\n",
    "                         tf.contrib.layers.xavier_initializer())\n",
    "    b3 = tf.get_variable('b3', [layers_dim[3], 1], tf.float32,\n",
    "                         tf.zeros_initializer())\n",
    "\n",
    "    parameters = {'W1': W1, 'b1': b1, 'W2': W2, 'b2': b2, 'W3': W3, 'b3': b3}\n",
    "    return parameters\n",
    "\n",
    "\n",
    "def forward_propagation(X, parameters):\n",
    "    \"\"\" Implement the forward propagation for the model\n",
    "    Linear -> Relu -> Linear -> Relu -> Linear -> Softplus \"\"\"\n",
    "\n",
    "    W1 = parameters['W1']\n",
    "    b1 = parameters['b1']\n",
    "    W2 = parameters['W2']\n",
    "    b2 = parameters['b2']\n",
    "    W3 = parameters['W3']\n",
    "    b3 = parameters['b3']\n",
    "\n",
    "    Z1 = tf.add(tf.matmul(W1, X), b1)  # Linear combination\n",
    "    A1 = tf.nn.relu(Z1)  # Activate with Relu\n",
    "    Z2 = tf.add(tf.matmul(W2, A1), b2)  # Linear combination\n",
    "    A2 = tf.nn.relu(Z2)  # Activate with Relu\n",
    "    Z3 = tf.add(tf.matmul(W3, A2), b3)  # Linear combination\n",
    "    A3 = tf.nn.softplus(Z3)  # Activate with Softplus\n",
    "\n",
    "    return A3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mini-batches\n",
    "We use the mini-batch gradient descent to get a gradient update at a lower computational cost. We randomly divide the training data into some subsets, which are refer to as a mini-batch. In each epoch, all of training data points are allocated to a mini-batch and are visited exactly one time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_mini_batches_X(X, mini_batch_size=64, seed=0):\n",
    "    \"\"\"\n",
    "    Creates a list of random minibatches from (X, Y)\n",
    "\n",
    "    Arguments:\n",
    "    X -- input data, of shape (input size, number of examples)\n",
    "    mini_batch_size - size of the mini-batches, integer\n",
    "    seed -- this is only for the purpose of grading, so that you're\n",
    "    \"random minibatches are the same as ours.\n",
    "\n",
    "    Returns:\n",
    "    mini_batches -- list of synchronous (mini_batch_X, mini_batch_Y)\n",
    "    \"\"\"\n",
    "\n",
    "    m = X.shape[1]  # number of training examples\n",
    "    mini_batches = []\n",
    "    np.random.seed(seed)\n",
    "\n",
    "    # Step 1: Shuffle X\n",
    "    permutation = list(np.random.permutation(m))\n",
    "    shuffled_X = X[:, permutation]\n",
    "\n",
    "    # Step 2: Partition shuffled_X. Minus the end case.\n",
    "    # number of mini batches of size mini_batch_size in your partitionning\n",
    "    num_complete_minibatches = math.floor(m / mini_batch_size)\n",
    "    for k in range(0, num_complete_minibatches):\n",
    "        mini_batch_X = shuffled_X[:, k * mini_batch_size:k * mini_batch_size +\n",
    "                                  mini_batch_size]\n",
    "        mini_batch = (mini_batch_X)\n",
    "        mini_batches.append(mini_batch)\n",
    "\n",
    "    # Handling the end case (last mini-batch < mini_batch_size)\n",
    "    if m % mini_batch_size != 0:\n",
    "        mini_batch_X = shuffled_X[:, num_complete_minibatches *\n",
    "                                  mini_batch_size:m]\n",
    "        mini_batch = (mini_batch_X)\n",
    "        mini_batches.append(mini_batch)\n",
    "\n",
    "    return mini_batches"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cost function\n",
    "\n",
    "Now we aim to solve the Brock and Mirman (1972) by using deep learning following Azinovic et al. (2019). When we solve the above model for the first-order condition, we can derive the following two equilibrium conditions. Cost function is the mean squared sum of the relative Euler error and the approximation error in the KKT condition:\n",
    "\n",
    "\\begin{align}\n",
    "& \\lambda_{t} - \\beta \\lambda_{t+1} A \\alpha k_{t+1}^{\\alpha - 1} = 0 \\label{eq:REE}\\\\\n",
    "& \\left[A k_{t}^{\\alpha} - k_{t+1} - \\frac{1}{\\lambda_{t}}\\right]\\lambda_{t} = 0 \\label{eq:KKT}\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_cost(X, A3, parameters, beta, A, alpha):\n",
    "    \"\"\" Compute the mean squared error\n",
    "    errREE: relative Euler error\n",
    "    errKKT: error in the KKT complementarity equation \"\"\"\n",
    "\n",
    "    # Retlieve the current capital state\n",
    "    k = X\n",
    "\n",
    "    # Retlieve the simulation path\n",
    "    # Need to have a dimension of [num_x, None] to have compativility with the\n",
    "    # placeholder X\n",
    "    k_plus = tf.expand_dims(A3[0, :], axis=0)\n",
    "    lambd = tf.expand_dims(A3[1, :], axis=0)\n",
    "\n",
    "    # Retlieve the optimal actions in the next period\n",
    "    action_plus = forward_propagation(k_plus, parameters)\n",
    "    # Need to have a dimension of [num_x, None] to have compativility with the\n",
    "    # placeholder X\n",
    "    k_plusplus = tf.expand_dims(action_plus[0, :], axis=0)\n",
    "    lambd_plus = tf.expand_dims(action_plus[1, :], axis=0)\n",
    "\n",
    "    # Define the relative Euler error\n",
    "    errREE = (beta * lambd_plus * A * alpha * k_plus**(alpha-1)) / lambd - 1\n",
    "\n",
    "    # Define the KKT error\n",
    "    errKKT = lambd * (A * k**alpha - k_plus - 1/lambd)\n",
    "\n",
    "    # Stack two approximation errors\n",
    "    err = tf.stack([errREE[0], errKKT[0]])\n",
    "\n",
    "    # When the two constraints are exactly binding\n",
    "    err_optimal = tf.zeros_like(err)\n",
    "\n",
    "    # Define the cost function\n",
    "    cost = tf.losses.mean_squared_error(err, err_optimal)\n",
    "\n",
    "    return cost\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define the model with the given training data\n",
    "\n",
    "In this section, we define the model where we train the deep neural net with the give training data points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model(train_X, layers_dim, learning_rate, num_epochs, minibatch_size,\n",
    "          print_span, print_cost=True):\n",
    "    \"\"\" Train DNN with the provided training data \"\"\"\n",
    "\n",
    "    tf.reset_default_graph()  # Reset DNN\n",
    "    (num_input, t_length) = train_X.shape\n",
    "    costs = []  # Keep track of the cost\n",
    "\n",
    "    # Create placeholder\n",
    "    X = create_placeholders(num_input)\n",
    "    # Initialize parameters\n",
    "    parameters = initialize_parameters(layers_dim)\n",
    "    # One step of the forward propagation\n",
    "    A3 = forward_propagation(X, parameters)\n",
    "    # Compute the current cost\n",
    "    cost = compute_cost(X, A3, parameters, beta, A, alpha)\n",
    "    # Set the optimizer in the backward propagation\n",
    "    optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(\n",
    "        cost)\n",
    "    # Initialize all the variables\n",
    "    init = tf.global_variables_initializer()\n",
    "\n",
    "    # ----------------------------------------------------------------------- #\n",
    "    # Start to train DNN with random minibatches\n",
    "    # ----------------------------------------------------------------------- #\n",
    "    with tf.Session() as sess:\n",
    "        sess.run(init)  # Initialization\n",
    "\n",
    "        for epoch in range(1, num_epochs+1):\n",
    "            epoch_cost = 0  # Initialize and track the cost for each epoch\n",
    "            # Number of minibatch size\n",
    "            num_minibatches = int(t_length / minibatch_size)\n",
    "            minibatches = random_mini_batches_X(train_X, minibatch_size)\n",
    "\n",
    "            for minibatch in minibatches:\n",
    "                minibatch_X = minibatch\n",
    "                _, minibatch_cost = sess.run(\n",
    "                    [optimizer, cost], feed_dict={X: minibatch_X})\n",
    "                epoch_cost += minibatch_cost / num_minibatches\n",
    "\n",
    "            # Track the cost\n",
    "            costs.append(epoch_cost)\n",
    "\n",
    "            # Print the cost every epoch\n",
    "            if print_cost is True and epoch % print_span == 0:\n",
    "                print(r'Cost after iteration {} is {:.3e}'.format(\n",
    "                    epoch, epoch_cost))\n",
    "\n",
    "        # Save the parameters in a variable\n",
    "        parameters = sess.run(parameters)\n",
    "        print(\"Parameters have been trained\")\n",
    "\n",
    "        return costs, parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Training data is arbitrary given, but should be big enough to contain the stationary point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_X has a shape of (1, 10000)\n"
     ]
    }
   ],
   "source": [
    "kbeg, kend, ksize = 1e-6, 0.25, 250\n",
    "kinit = (kbeg + kend) / 2\n",
    "kgrid = np.linspace(kbeg, kend, ksize, dtype=np.float32)\n",
    "train_X = np.random.uniform(kbeg, kend, (num_input, t_length))\n",
    "print(\"train_X has a shape of {}\".format(train_X.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
      "For more information, please see:\n",
      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
      "  * https://github.com/tensorflow/addons\n",
      "If you depend on functionality not listed there, please file an issue.\n",
      "\n",
      "WARNING:tensorflow:From /home/takafumi/.pyenv/versions/anaconda3-5.3.1/envs/tensor1/lib/python3.7/site-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "WARNING:tensorflow:From /home/takafumi/.pyenv/versions/anaconda3-5.3.1/envs/tensor1/lib/python3.7/site-packages/tensorflow/python/ops/losses/losses_impl.py:667: to_float (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.cast instead.\n",
      "Cost after iteration 50 is 9.008e-04\n",
      "Cost after iteration 100 is 2.460e-04\n",
      "Cost after iteration 150 is 1.593e-04\n",
      "Cost after iteration 200 is 1.249e-04\n",
      "Cost after iteration 250 is 1.094e-04\n",
      "Cost after iteration 300 is 1.025e-04\n",
      "Cost after iteration 350 is 9.669e-05\n",
      "Cost after iteration 400 is 9.304e-05\n",
      "Cost after iteration 450 is 8.480e-05\n",
      "Cost after iteration 500 is 8.237e-05\n",
      "Cost after iteration 550 is 7.763e-05\n",
      "Cost after iteration 600 is 7.257e-05\n",
      "Cost after iteration 650 is 6.996e-05\n",
      "Cost after iteration 700 is 6.946e-05\n",
      "Cost after iteration 750 is 6.682e-05\n",
      "Cost after iteration 800 is 6.047e-05\n",
      "Cost after iteration 850 is 5.422e-05\n",
      "Cost after iteration 900 is 5.193e-05\n",
      "Cost after iteration 950 is 5.025e-05\n",
      "Cost after iteration 1000 is 5.211e-05\n",
      "Parameters have been trained\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0, 1048.95)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "costs, parameters_star = model(\n",
    "    train_X, layers_dim, learning_rate, num_epochs=1000,\n",
    "    minibatch_size=minibatch_size, print_span=50, print_cost=True)\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    # One step of the forward propagation\n",
    "    policy_star = sess.run(forward_propagation(\n",
    "        kgrid.reshape(1, ksize), parameters_star))\n",
    "\n",
    "# Capital stock in the next period\n",
    "kplus_analytic = kplus_compute_analytic(kgrid, alpha, beta, A)\n",
    "# Consumption policy\n",
    "c_analytic = c_compute(kgrid, kplus_analytic, alpha, beta, A)\n",
    "c_dnn = c_compute(kgrid, policy_star[0, :], alpha, beta, A)\n",
    "\n",
    "# Capital stock tomorrow\n",
    "fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(15, 6))\n",
    "axes[0].plot(kgrid, policy_star[0, :], 'k-', label=\"DNN\")\n",
    "axes[0].plot(kgrid, kplus_analytic, 'k--', label=\"Analytic\")\n",
    "axes[0].plot(kgrid, kgrid, 'k:')\n",
    "axes[0].set_xlabel(r\"$k_{t}$\")\n",
    "axes[0].set_ylabel(r\"$k_{t+1}$\")\n",
    "axes[0].set_xlim([kbeg, kend])\n",
    "axes[0].set_ylim([0, kend])\n",
    "axes[0].legend(loc='best')\n",
    "\n",
    "axes[1].plot(kgrid, c_dnn, 'k-', label=\"DNN\")\n",
    "axes[1].plot(kgrid, c_analytic, 'k--', label=\"Analytic\")\n",
    "axes[1].set_xlabel(r\"$k_{t}$\")\n",
    "axes[1].set_ylabel(r\"$c_{t}$\")\n",
    "axes[1].set_xlim([kbeg, kend])\n",
    "axes[1].set_ylim([0, None])\n",
    "axes[1].legend(loc='best')\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(9, 6))\n",
    "ax.plot(np.log10(costs), 'k-')\n",
    "ax.set_xlabel(\"Number of epochs\")\n",
    "ax.set_ylabel(\"$log_{10}$ of the cost\")\n",
    "ax.set_xlim([0, None])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As seen above, deep neural net successfully approximates the policy functions. The cost function decreases as the training proceeds and converges approximately of the order of $10^{-5}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Deep neural net with sampling the most relevant states\n",
    "\n",
    "In the previous example, we train the model with the fixed training data that, we hope, sufficiently covers the ergodic set and the stationary point. In this example, in every episode, we simulate the training data points with the given initial state and updated parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def model_sampling(\n",
    "        init_state, num_input, t_length, layers_dim, learning_rate,\n",
    "        num_episodes, num_epochs, minibatch_size, print_span, print_cost=True):\n",
    "    \"\"\" Train DNN with sampling the most relevant states \"\"\"\n",
    "\n",
    "    tf.reset_default_graph()  # Reset DNN\n",
    "\n",
    "    costs = []  # Keep track of the cost\n",
    "\n",
    "    episodic_costs = []  # Keep track of the episodic cost\n",
    "\n",
    "    # Create placeholder\n",
    "    X = create_placeholders(num_input)\n",
    "    # Initialize parameters\n",
    "    parameters = initialize_parameters(layers_dim)\n",
    "    # One step of the forward propagation\n",
    "    A3 = forward_propagation(X, parameters)\n",
    "    # Compute the current cost\n",
    "    cost = compute_cost(X, A3, parameters, beta, A, alpha)\n",
    "    # Set the optimizer in the backward propagation\n",
    "    optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(\n",
    "        cost)\n",
    "    # Initialize all the variables\n",
    "    init = tf.global_variables_initializer()\n",
    "\n",
    "    # ----------------------------------------------------------------------- #\n",
    "    # Start to train DNN with sampling and random minibatches\n",
    "    # ----------------------------------------------------------------------- #\n",
    "    with tf.Session() as sess:\n",
    "        sess.run(init)  # Initialization\n",
    "\n",
    "        for episode in range(1, num_episodes+2):\n",
    "            episodic_cost = 0\n",
    "            # --------------------------------------------------------------- #\n",
    "            # Simulate one training path\n",
    "            # --------------------------------------------------------------- #\n",
    "            # Training set, which samples the most relevent states\n",
    "            # Keep compativility with placeholder X that has [num_input. None]\n",
    "            train_X = np.empty((num_input, t_length), dtype=np.float32)\n",
    "            # Retlieve the initial state from the previous episode\n",
    "            train_X[0, 0] = init_state\n",
    "            for t in range(1, t_length):\n",
    "                # Keep the same shape with X ([num_input, None])\n",
    "                x_previous = train_X[0, t-1].reshape((num_input, 1))\n",
    "                train_X[0, t] = sess.run(A3, feed_dict={X: x_previous})[0]\n",
    "\n",
    "            # Keep the current trainint set\n",
    "            train_X_previous = train_X\n",
    "\n",
    "            # --------------------------------------------------------------- #\n",
    "            # Train DNN with the sampled state path\n",
    "            # --------------------------------------------------------------- #\n",
    "            for epoch in range(1, num_epochs+1):\n",
    "                epoch_cost = 0  # Initialize and trach the cost for each epoch\n",
    "                # Number of minibatch size\n",
    "                num_minibatches = int(t_length / minibatch_size)\n",
    "                minibatches = random_mini_batches_X(train_X, minibatch_size)\n",
    "\n",
    "                for minibatch in minibatches:\n",
    "                    minibatch_X = minibatch\n",
    "                    _, minibatch_cost = sess.run(\n",
    "                        [optimizer, cost], feed_dict={X: minibatch_X})\n",
    "                    epoch_cost += minibatch_cost / num_minibatches\n",
    "\n",
    "                # Track the cost\n",
    "                costs.append(epoch_cost)\n",
    "                # Track the episode cost\n",
    "                episodic_cost += epoch_cost / num_epochs\n",
    "            # Track the episodic cost\n",
    "            episodic_costs.append(episodic_cost)\n",
    "\n",
    "            # Track the last state for the next episode\n",
    "            init_state = train_X[0, -1]\n",
    "\n",
    "            # Track the convergence process to the stationary point\n",
    "            if episode % 5 == 0:\n",
    "                print(\"Cost after episode {} is {:3e}\".format(\n",
    "                    episode, episodic_cost))\n",
    "                fig, ax = plt.subplots(figsize=(9, 6))\n",
    "                ax.plot(train_X_previous[0, :], train_X[0, :], 'o', \n",
    "                        markersize=3, label='DNN')\n",
    "                ax.plot(k_infty, k_infty, 'o', c='red', markersize=6, \n",
    "                        label='Stationary')\n",
    "                ax.set_xlim([0.199, 0.200])\n",
    "                ax.set_ylim([0.199, 0.200])\n",
    "                ax.set_xlabel(r\"$k_{t}$\")\n",
    "                ax.set_ylabel(r\"$k_{t+1}$\")\n",
    "                ax.legend(loc='best')\n",
    "                ax.set_title(r\"Episode {}\".format(episode))\n",
    "                plt.show()\n",
    "\n",
    "        # Save the parameters in a variable\n",
    "        parameters = sess.run(parameters)\n",
    "\n",
    "        return costs, episodic_costs, parameters, train_X, train_X_previous"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we train the model with sampling the most relevant state:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after episode 5 is 4.065055e-07\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after episode 10 is 9.477689e-07\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after episode 15 is 8.880990e-07\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after episode 20 is 7.982228e-07\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after episode 25 is 7.966302e-07\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAGACAYAAABBbw0iAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAcGElEQVR4nO3dQWycx2If8P8o8oPrIA0l1ZfCfbaXh+bdWpJuhV5N9dJbQMVIfXWo9tqDlcLnB0cCesyB8ruqgJ6YYy8RjVxVhGRyKPLQINxED74plNgejNf3DE8P+y21opYURe9ySc7vByzIb3ZmdqgPkv6cme/7Sq01AAAtujTrAQAAzIogBAA0SxACAJolCAEAzRKEAIBmCULAxJRSnpdS6pjX3GvaLZRStiY4jrlSyvM3qL9cStnqxvqolNIbeW/rwM/ycFLjBGZPEAImbbHWWg689l7Tpp/k9mkM7qAupD1K8mWttXRjGQ07vSSLSea71x+d+iCBqRGEgEkbG3pKKSullLVSysNu5mh05qWX5M5I3bWuzvNSyucH+tjpyh+OzjSVUla78p0kqyPly4e16Swn2a61rnfHt5MsjLw/V2vdrrX2u9frQh1wjghCwGlazWD25cO8OvOSZBB2MggnHyb5OMmdbqmrl+SrJLe695IuPJVSFrrvP85g9uaTrnyu+4xhm2ddH/u6APTxSNFSN7Z0n7nXhbadQ4IUcI4JQsCk7YzM5gxnaIa2a633aq17tdZbSRaOCBa9Wut2kivdLMxKkp/XWje649tJ/qCreyvJvW7mZvheuvc3hm26z1w++EHDWZ4uhA2DU5LMZRCK7iS50ZXZIwQXyOVZDwC4cG4k2Tzkvf6Y46ujBbXW9VLK1SRfdTMyXya5m+Rakp2Rev2REHU1g5mmoeHnzyVZObBx+pXg1fXzVQZLdB93ASzd18WRen+U5NibsIGzz4wQMGn9bvZl/zXyXu9A3V4Gy1X7uvDz81rrYrplrlLKcpLdDDYrD+vN5cV+pH6Sj0a6Weq+7iVZr7VeGb5G+xjxdTfuxWEI6j5joVt2S/Ji5gi4OAQhYNKO2kOz0G1qniulrGWwVHYwXKwk+XpkI/Vc91pP8gddOBnO4Py8q/MgyerIe8OlsZ8nWe42TA8/c230w7rlsCT5sqszd2C57uthv1379QAXhiAETNrB++7UbkYnSTYyWDp7nsGszc2DjWutdzOY4dlJspXBjM56rbWfwaXrD/Nieep212a7+/7rJH+fLux0Ietmd/w8gxmog5/5UQZXiT0/8Brt92HX79W4fB4ulFJrnfUYgAZ0My+f1FpfCT8As2JGCABo1lSuGut+89tLstBNcx98f3izs/la6+3D2hy3DADgJCY+IzS8wqLWupHBjcgWDry/nMF9Pe4l6XWbGF9pc9yySY8fmI5un49lMeBMmcbS2Cd5+ZLWgzcv642U9bvjcW2OWwYAcCLTWBqby8v3Bbk2+mY3EzS0kMFlr4tj2ozr58i+AQDexMzuLN0taz2qtW6XUibZ72q6By7+9m//9uLv/d7vTaxvAGB2tra2/rHW+u4k+5xGENrLi1vmz2VwN9hxlkc2Ox/W5rhl+7oZp3tJsrS0VDc3D7vTPwBwnpRSnky6z2kEoQd5cXv7XgY3UEspZW7kwYarI1eBLR/W5g3KAADe2MQ3Sw+f09MFnL2R5/Z8PVJ+p5SyM3wQ4rg2xy2b9PgBgHZc6DtLWxoDgIujlLJVa116fc3jm9lmaQC4qH7zm9/km2++ya9+9atZD+Vcevvtt/Pee+/lrbfemvpnCUIAMGHffPNNfud3ficffPBBJnlldAtqrdnd3c0333yTDz/8cOqf51ljADBhv/rVr3Lt2jUh6ARKKbl27dqpzaYJQgAwBULQyZ3mn50gBAA0SxACAJolCAHABbO3t5dSSm7cuJHFxcUsLi5mfX09SbK9vZ1SSvr9/n79u3fv5t69e0e+d1G5agwAzoCtJ8/zuL+b671rWXz/yg/ub2FhIY8ePUoyCEaLi4tZWFhIkvR6vdy6dWv//VFHvXcRmRECgBnbevI8n/7scf7bn//vfPqzx9l68nyi/c/NzeX27dtZW1tLkiwvL6fX642d6TnqvYvIjBAAzNjj/m5+/d33+b4mv/nu+zzu705kVmhUr9fL1tbW/vHa2lrm5+ezvLz8St2j3rtozAgBwIxd713Ljy5fym+V5K3Ll3K9d23in9Hv9zM/P/9S2draWm7dujW2/lHvXSSCEADM2OL7V3L/s+v5L//+X+b+Z9cnPhu0t7eXO3fuZGVl5aXy4TLYcMnsuO9dJJbGAOAMWHz/ykQD0Pb2dhYXF/eP79y5k16vl+3t7Zfqra2t5cqV8Z971HsXhafPA8CE/eIXv8hPfvKTWQ/jXBv3ZziNp89bGgMAmiUIAQDNEoQAgGYJQgBAswQhAKBZghAA0CxBCABoliAEALN2/37ywQfJpUuDr/fv/+Au7969m8XFxf3X8EaKe3t7WV9fP7LtaJ319fXcvXv3B4/nrHJnaQCYpfv3k9XV5NtvB8dPngyOk+TTT0/U5fb2dtbW1rKzs5Nk8JyxmzdvZmtrK8+ePcuDBw9eedzGqNE6R9W7CMwIAcAsffHFixA09O23g/IT6vV6efbsWTY2NvaPv/766ySDR21sbGzsz/jcuHFj/zUsG60zOiN08+bN3LhxI4uLi9nY2MjGxkZu3ryZmzdvZnFx8aWZpoP9bmxs5NatW5mfn88f/uEf7s9Qra+v5/bt2yf+WX+wWuuFfS0uLlYAOG1/8zd/c/zKpdSavPoq5QeNYWtrq66urtaFhYW6vLxct7a2aq217uzs1JWVlf3vHz58uF9/eXn5lToPHz6sd+7cqXfu3Kmff/55rbXW58+f116vVx89elQXFhZeKjus39G6jx49qqurq7XWWpeXl+vOzs4r4x/3Z5hks044K1gaA4BZ+vGPB8th48pPqN/vZ25ubv/J8dvb2/n444/z/Pnzl+pdvXo1jx49yqNHj17b587OTm7evJkkmZub2y9fXl5+peywfod1l5eXc+vWrezt7eXZs2fp9Xon+Cknw9IYAMzST3+avPPOy2XvvDMoP6Ht7e3cunVr/3hhYSFXr159pd6XX36ZxcXFrK2t7Yecw8zPz+8Hm2GAOcxx+l1eXs7NmzdfGucsmBECgFkaboj+4ovkl78czAT99Kcn3iidJCsrK+n3+1lcXNwvu3PnTpLBbM329nbW19fzySef5Pbt23n06FF6vV76/X62t7fT6/X26wx9/vnn+3uEnj17locPHx76+eP6/du//duX6ty6dSuLi4vHmo2apjJYcruYlpaW6ubm5qyHAUBjfvGLX+QnP/nJrIdxpm1sbOThw4f7y3cHjfszLKVs1VqXJjkOM0IAwKlaX1/Pl19+uX8l2yzZIwQAnKqVlZVsbW29tMF6VgQhAJiCi7z1ZNpO889OEAKACXv77bezu7srDJ1ArTW7u7t5++23T+Xz7BECgAl777338s033+Tp06ezHsq59Pbbb+e99947lc8ShABgwt566618+OGHsx4Gx2BpDABoliAEADRLEAIAmiUIAQDNEoQAgGYJQgBAswQhAKBZghAA0CxBCABoliAEADRLEAIAmiUIAQDNEoQAgGYJQgBAswQhAKBZghAA0CxBCABoliAEADRLEAIAmiUIAQDNujyNTkspK0n2kizUWu8eUmeh1ro9cvx5kn6Sq7XWe0eUDfvuDcsAAE5i4jNCpZSFJKm1biTZGx4fqLOc5KsDx6m1rieZL6X0DilbSNLv+u6P6xsA4LimsTT2SQYzNslgNmf5YIUuyDwbKbrR1U2Sna7NuLIkudN97Y3OKAEAvKlpBKG5vBxyrh2jzW6SqyPt58eVdcGnX0rZOfAZAABv7Kxsll7PIPwkg+C0O66slDKXwWzTWpKvSim90x4oAHBxTCMI7eXlmZzd1zWotfaTPBjZ89MfV5ZkNcmX3Qbsm0lWDvZVSlktpWyWUjafPn36A38UAOAim0YQepBkOFPTS7KRJN1szlhd2Fnqlr7maq3r48pG2ww3Yx/sq9Z6r9a6VGtdevfddyfzEwEAF9LEg9BwA3N31dfeyIbmr4d1ukvgl7qvwzbPuuO1I8ruJlktpayUUlZdPg8A/BCl1jrrMUzN0tJS3dzcnPUwAIAJKKVs1VqXJtnnWdksDQBw6gQhAKBZghAA0CxBCABoliAEADRLEAIAmiUIAQDNEoQAgGYJQgBAswQhAKBZghAA0CxBCABoliAEADRLEAIAmiUIAQDNEoQAgGYJQgBAswQhAKBZghAA0CxBCABoliAEADRLEAIAmiUIAQDNEoQAgGYJQgBAswQhAKBZghAA0CxBCABoliAEADRLEAIAmiUIAQDNEoQAgGYJQgBAswQhAKBZghAA0CxBCABoliAEADRLEAIAmiUIAQDNEoQAgGYJQgBAswQhAKBZghAA0CxBCABoliAEADRLEAIAmiUIAQDNEoQAgGYJQgBAswQhAKBZghAA0CxBCABoliAEADRLEAIAmiUIAQDNEoQAgGYJQgBAsy5Po9NSykqSvSQLtda7h9RZqLVujxx/nqSf5Gqt9d4RZQtJeklSa12fxvgBgDZMfEaoCyqptW4k2RseH6iznOSrA8fDYDNfSumNK+uq3+rKeuP6BgA4rmnMCH2S5FH3fT/JcpLt0Qq11o1SyrORohtJ/rL7fqdrM3+wrGuz0/UxdqYJAOC4phGE5pKMhpxrx2izm+TqSPtrh5TNJ/uzTsvCEADwQ5yVzdLr6UJOXoSgcWVJsjvcW9TtRQIAOJFpBKG9vDyTs3tE3SRJrbWf5MHInp/+uLIMlsX6I8cfHeyrlLJaStkspWw+ffr0B/wYAMBFN40g9CDdVV3d140kKaXMHdagCztL3UzPXK11fVxZ19do3395sK9a671a61Ktdendd9+d2A8FAFw8Ew9CI8tWy0n2Ri6R/3pYp1vSWhoubXV1nnXHa0eU9TO4Em3YzuXzAMCJlVrrrMcwNUtLS3Vzc3PWwwAAJqCUslVrXZpkn2dlszQAwKkThACmZOvJ8/zpX/xdtp48n/VQgENM5REbAK3bevI8n/7scX793ff50eVLuf/Z9Sy+f2XWwwIOMCMEMAWP+7v59Xff5/ua/Oa77/O4/9o7iQAzIAgBTMH13rX86PKl/FZJ3rp8Kdd7x7nJPnDaLI0BTMHi+1dy/7PredzfzfXeNcticEYJQgBTsvj+FQEIzjhLYwBAswQhAKBZghAA0CxBCABoliAEADRLEAIYw+MxoA0unwc4wOMxoB2CEECSD/74f+x//x//7Y9feTyGIAQXk6UxoHmjIShJ/vv//GUuXyoejwENMCMENO2wPUA3l/5F/vncP/F4DLjgBCGgaYc9Ff73F94TgKABlsaAph227CUEQRsEIaBpi+9fyZ/953/3Utk//Ml/mNFogNP2xktjpZR/Wmv9v9MYDMC0bD15nsf93bF7fhbfvyL8QKNeG4RKKR8n+d3hYZKlJP91moMCmCT3BQIOc5ylsWdJ/k2S/sgL4Nx43N995b5AAMkxZoRqrX+V5K9Giv7qsLoAZ9H13rX86PKl/Oa7790XCHjJG+0RKqV8UGv9hymNBWAqFt+/kvufXT90jxDQrjfdLL2Q5B+mMA6AqVp8/4oABLziWEGolPJhkrkkvVLKv0qSWutfT3NgAADTdtwZoWfdaymDzdJlaiMCADglxwpCtdb/kySllGfuIQQAXBRvemfp7amMAgBgBo4dhLorxv6+lPLB9IYDAHB6XhuESin/upTyJ0nulFI+S7I8/WEBzbt/P/ngg+TSpcHX+/dnPSLgAjr2DRW7K8eSwdVjANNz/36yupp8++3g+MmTwXGSfPrp7MYFXDhHzgiVUh4ML5dPUpP8bheMAKbniy9ehKChb78dlANM0OtmhO7VWv+6mw1aSXI1ifsHAdP1y1++WTnACb0ShEopf55kJ8mjJNullN/PIAA99HgN4FT8+MeD5bBx5QATNG5p7HaSP87gpon/qXv9QZKVkWUygOn56U+Td955ueyddwblABP0yozQyB6gP+teSQZXjyWZj6UxYNqGG6K/+GKwHPbjHw9CkI3SwISVWuusxzA1S0tLdXNzc9bDAAAmoJSyVWtdmmSfb3pnaQCAC0MQAgCaJQgBAM0ShACAZglCAECzBCEAoFmCEADQLEEIAGiWIAQANEsQAgCaJQgBJ7L15Hn+9C/+LltPns96KAAn9spDVwFeZ+vJ83z6s8f59Xff50eXL+X+Z9ez+P6VWQ8L4I2ZEQLe2OP+bn793ff5via/+e77PO7vznpIACciCAFv7HrvWn50+VJ+qyRvXb6U671rsx4SwIlYGgPe2OL7V3L/s+t53N/N9d41y2LAuSUIASey+P4VAQg49yyNAQDNmkoQKqWslFKWSymfH1Fn4cDx51271aPKRt+b7KgBgNZMPAgNA06tdSPJ3sHA09VZTvLVgePUWteTzJdSeuPKDtT/aNJjBwDaMo0ZoU+S7HXf95MsH6zQhaRnI0U3urpJstO1GVcGADAx0whCc3k55BznutrdJFdH2s8fUpZSykIXpAAAfpCzsll6PV3QySA47R5SlrwIRwAAP8g0gtBeXp7Jee0tZ2ut/SQPRvYT9ceVHWc2qJSyWkrZLKVsPn369IQ/AgDQgmkEoQdJhhube0k2kqSUMndYgy7sLNVat5PM1VrXx5Ul6XVXka1037+yEbvWeq/WulRrXXr33Xcn/KMBABfJxINQF1yGV3btDY+TfD2s0wWZpe7rsM2z7njtiLL1LhBdzWC2CQDgxEqtddZjmJqlpaW6ubk562EAABNQStmqtS5Nss+zslkaAODUCUIAQLMEIQCgWYIQANAsQQgAaJYgBAA0SxACAJolCAEAzRKEAIBmCUIAQLMEIQCgWYIQANAsQQgAaJYgBAA0SxACAJolCAEAzRKEAIBmCUIAQLMEIQCgWYIQANAsQQgAaJYgBAA0SxACAJolCAEAzRKEAIBmCUIAQLMEIQCgWYIQANAsQQgAaJYgBAA0SxACAJolCAEAzRKEAIBmCUIAQLMEIQCgWYIQANAsQQgAaJYgBAA0SxACAJolCAEAzRKEAIBmCUIAQLMEIQCgWYIQANAsQQgAaJYgBAA0SxACAJolCAEAzRKEAIBmCUIAQLMEIQCgWYIQANAsQQgAaJYgBAA0SxACAJolCAEAzbo8jU5LKStJ9pIs1FrvHlJnoda6PXL8eZJ+kqu11ntHlK12TeZrrbenMX4AoA0TnxEqpSwkSa11I8ne8PhAneUkXx04Tq11Pcl8KaV3RNlGF4r26wAAnMQ0lsY+yWA2KBnM5rwSVrqQ9Gyk6EZXN0l2ujbjynoj/fW7YwCAE5nG0thcXg45147RZjfJ1ZH218aVHVgKW0jy4IcNFQBo2VnZLL2eZL77fhiCxpUl2V9+ezS6xwgA4E1NIwjt5eWZnN0j6iZJaq39JA9G9hP1x5WNNFk+YhP2aills5Sy+fTp05P9BABAE6YRhB7kxd6dXpKNJCmlzB3WoAs7S90Mz1ytdX1cWVd3dRiCxm2WrrXeq7Uu1VqX3n333Yn+YADAxTLxIDRcrupCyt7I8tXXwzrd5fVL3ddhm2fd8dphZV2fd0opO6WU55MeOwDQllJrnfUYpmZpaalubm7OehgAwASUUrZqrUuT7POsbJYGADh1ghAA0CxBCABoliAEADRLEAIAmiUIAQDNEoQAgGYJQgBAswQhAKBZghAA0CxBCABoliAEADRLEAIAmiUIAQDNEoQAgGYJQgBAswQhAKBZghAA0CxBCABoliAEADRLEAIAmiUIAQDNEoQAgGYJQgBAswQhAKBZghAA0CxBCABoliAEADRLEAIAmiUIAQDNEoQAgGYJQgBAswQhAKBZghAA0CxBCABoliAEADRLEAIAmiUIAQDNEoQAgGYJQgBAswQhAKBZghAA0CxBCABoliAEADRLEAIAmiUIAQDNEoQAgGYJQgBAswQhAKBZghAA0CxBCABoliAEADRLEAIAmiUIAQDNEoQAgGYJQgBAsy5Po9NSykqSvSQLtda7h9RZqLVujxx/nqSf5Gqt9d4RZa/tGwDgOCY+I1RKWUiSWutGkr3h8YE6y0m+OnCcWut6kvlSSu+Qstf2DQBwXNNYGvskgxmbZDCbs3ywQhdkno0U3ejqJslO12Zc2Wv7BgA4rmksjc3l5ZBz7RhtdpNcHWl/7ZCyk/QNADDWWdksvZ5kvvt+GILGlQEATMw0ZoT28vJMzmsDTK21X0p5MLLnpz+uLINAdGTfpZTVJKvd4f8rpfyvE/4cTMc/S/KPsx4E+5yPs8X5OHuck7PlX066w2kEoQdJlrrve0k2kqSUMldr3RvXoAs7S7XWe6WUW7XW9UPK+uP6HtVdXTa8wmyz1rp0sA6z45ycLc7H2eJ8nD3OydlSStmcdJ8TXxobXhLfXfW1N3KJ/NfDOt0l8Evd12GbZ93x2mvKxvUNAPDGpnIfoeE9fw6ULY58v57BHqAcKDvYZlzZK30DAJzEWdksPS1C09njnJwtzsfZ4nycPc7J2TLx81FqrZPuEwDgXJjK0tg0eGzH2TPlczK88m++1np7ij/GhTHN8zFa39+R45vy35GFDC4aGbuNgFed0v8jPVs4zpdzsTTmsR1nz5TPyXKSje4fk/06HG6a5+NA/Y+m+oNcIKdwTm51ZT3/br3eKfw/0u/67jsfx1NKWSmlLHfBctz7q93rzlFtjlt2mHMRhOKxHWfRNM9Jb6S/fnfM0aZ5PjiZqZ2TbvZhp+vjritoj2Xaf0eG/1n3nI/Xe10wHfcL8bg2xy07aiznJQhN4rEd84eUeWzHyUztnNRa741MLS8kmfh9Iy6gaf4dGS4XvHLfLo40zXPyUZJr3T/6r/2NlyTT/TdrO4OZoJ0Dn8HhXhdMx/1CPK7NccsOdV6C0El4bMfZ80bnpEvxj/x2NTVvcj6uhtPwJudkd+TeaiunOciGHOt8lFLmMviPdy3JV6NLyhzqyGB6yC/E49oct+xQ5yUIneixHUleeWzHwbKT9E2S6Z6ToWUbc49taufDbNCJTfPvyE5e/F3px96t45jm+VhN8mX379XNJILphJzGL8TnJQg9yIt9Ii89tuOwBuXFIzq2k8wdeGzHftlhffNa0zwnKaWsDkOQzdLHMs3z0es2Hq7Extw3Mc1zsnGg77+c0s9wkUz136yh4b6UafwAF8xxg+noL8Tj2hy37FDnIgh5bMfZM81z0vV5p5SyU0p5flo/03k25b8j690/9lcz+EeFY5jyOelnsAl02M7l868x5fNxN8lq9wvDqsvnj+W1wXTML8Tj2hy37FBuqAgAnLoyuF9cPyP3XiqlbNVaF7vg8zCDvT5Xk9ystW4c0uZYZYeOQxACAFp1LpbGAACmQRACAJolCAEAzRKEgHOpu6vyo1mPAzjfBCHgvOrn5RtwArwxQQg4r5aTmBECfhBBCDivPkqy3T2V+uGsBwOcT5dnPQCAE1pIstA99uBZMtg35O7wwJswIwScZ1dLKb2R8PPJTEcDnDuCEHDuDJ9IncEzhFZKKb1SSi+Dh8L2jm4N8IIgBJxHvSQb3cNHr+XFw2AfdWUAx+JZY8CF0M0SLeVFQAJ4LUEIAGiWpTEAoFmCEADQLEEIAGiWIAQANEsQAgCaJQgBAM0ShACAZglCAECz/j/cg7sJJKJhTgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 648x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after episode 30 is 7.996796e-07\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after episode 35 is 7.987127e-07\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after episode 40 is 7.104329e-07\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after episode 45 is 7.896243e-07\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after episode 50 is 6.908074e-07\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(0, 52.5)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "costs_sampling, episodic_costs, parameters_sampling, train_X, \\\n",
    "    train_X_previous = model_sampling(\n",
    "        kinit, num_input, t_length, layers_dim, learning_rate, num_episodes,\n",
    "        num_epochs, minibatch_size, print_span=5, print_cost=True)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(9, 6))\n",
    "ax.plot(np.log10(episodic_costs), 'k-')\n",
    "ax.set_xlabel(\"Number of episodes\")\n",
    "ax.set_ylabel(\"$log_{10}$ of the cost\")\n",
    "ax.set_xlim([0, None])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you might expect, the training set converges to the stationary point and the deep neural net approximate policy functions only around the stationary point."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Summary\n",
    "\n",
    "As you have seen, the deep neural net numerically solve the recursive equilibrium of the simple optimal growth model. If the training dataset is given ex ante, as we often do in the grid based methods, the deep neural net approximates policy functions with a tolerable approximation error. If we update the training dataset by simulating the model, the resulted training dataset converges to the stationary point if it is available. We need some stochastic elements to define a reasonable ergodic set so that the deep neural net performs well."
   ]
  }
 ],
 "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.7.3"
  },
  "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": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}