From 6deb19eeb24df7c97f278d8b9049a83f12e52004 Mon Sep 17 00:00:00 2001 From: Tsz Kin Chan Date: Sat, 1 Dec 2018 02:32:43 -0500 Subject: [PATCH] Add notebook for "Policy Change Index: A Simulated Example" For the publication in Quantitative Notes at the Open Research Group, Inc. --- ...icy_Change_Index_A_Simulated_Example.ipynb | 275 ++++++++++++++++++ 1 file changed, 275 insertions(+) create mode 100644 Notebooks/Policy_Change_Index_A_Simulated_Example.ipynb diff --git a/Notebooks/Policy_Change_Index_A_Simulated_Example.ipynb b/Notebooks/Policy_Change_Index_A_Simulated_Example.ipynb new file mode 100644 index 00000000..e66535ef --- /dev/null +++ b/Notebooks/Policy_Change_Index_A_Simulated_Example.ipynb @@ -0,0 +1,275 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Using TensorFlow backend.\n" + ] + } + ], + "source": [ + "import itertools, pathlib, pickle, copy, random, os, glob , sys\n", + "from time import time\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "\n", + "import sklearn \n", + "from sklearn.metrics import precision_recall_fscore_support\n", + "\n", + "import keras \n", + "from keras import backend as K\n", + "from keras.preprocessing.sequence import pad_sequences\n", + "from keras.layers import Activation, Dense, Dropout, Input, Embedding, CuDNNLSTM, CuDNNGRU, GlobalMaxPooling1D, GlobalAveragePooling1D,Reshape\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def gen_data(n, signal=9, length=10, dim=10 ):\n", + " x = []\n", + " y = []\n", + " for i in range(0,n):\n", + " seq = np.random.randint(0,dim,length)\n", + " loc = np.where(seq==signal) \n", + " x.append(seq)\n", + " try:\n", + " loc_signal = min(loc[0]) \n", + " if min(loc[0]) == length - 1:\n", + " y.append(0)\n", + " else:\n", + " y.append( (seq[min(loc[0]) + 1 ] > (dim-1)/2) + 0 )\n", + " except:\n", + " y.append(0)\n", + " x = pad_sequences(x)\n", + " y = np.asarray(y)\n", + " return x,y " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "def PCI(x_train,y_train, x_val, y_val, x_future, y_future):\n", + " input_x = Input(shape=(10,))\n", + " GRU_x = Embedding(15,3,input_length=10)(input_x)\n", + " GRU_x = CuDNNGRU(15)(GRU_x)\n", + " GRU_x = Activation('tanh')(GRU_x)\n", + " GRU_x = Dropout(0.2)(GRU_x)\n", + "\n", + " GRU_x = Dense(1, activation='sigmoid')(GRU_x)\n", + "\n", + " GRU_model = keras.models.Model(inputs=[input_x], outputs=[GRU_x] )\n", + "\n", + " GRU_model.compile(\n", + " loss='binary_crossentropy', \n", + " optimizer=keras.optimizers.adam(0.01),\n", + " metrics=['accuracy'])\n", + "\n", + " GRU_model.fit(\n", + " x_train, \n", + " y_train, \n", + " batch_size=200, \n", + " epochs = 50,\n", + " validation_data=(x_val, y_val) , \n", + " shuffle=True, \n", + " verbose = 0)\n", + " acc_val = GRU_model.evaluate(x_val,y_val)[1]\n", + " acc_future = GRU_model.evaluate(x_future,y_future)[1]\n", + " PCI = abs(acc_val- acc_future)\n", + " \n", + " return [acc_val, acc_future, PCI]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Period:0\n", + "500/500 [==============================] - 0s 40us/step\n", + "500/500 [==============================] - 0s 40us/step\n", + "[1. 1. 0.998 0.002]\n", + "Period:1\n", + "500/500 [==============================] - 0s 38us/step\n", + "500/500 [==============================] - 0s 42us/step\n", + "[2. 0.998 0.998 0. ]\n", + "Period:2\n", + "500/500 [==============================] - 0s 38us/step\n", + "500/500 [==============================] - 0s 40us/step\n", + "[3. 1. 1. 0.]\n", + "Period:3\n", + "500/500 [==============================] - 0s 40us/step\n", + "500/500 [==============================] - 0s 42us/step\n", + "[4. 0.974 0.97 0.004]\n", + "Period:4\n", + "500/500 [==============================] - 0s 42us/step\n", + "500/500 [==============================] - 0s 44us/step\n", + "[5. 0.97 0.56 0.41]\n", + "Period:5\n", + "500/500 [==============================] - 0s 40us/step\n", + "500/500 [==============================] - 0s 44us/step\n", + "[6.00000000e+00 9.90000000e-01 9.90000000e-01 4.76837125e-10]\n", + "Period:6\n", + "500/500 [==============================] - 0s 44us/step\n", + "500/500 [==============================] - 0s 44us/step\n", + "[7.00000000e+00 9.88000000e-01 9.92000000e-01 4.00000048e-03]\n", + "Period:7\n", + "500/500 [==============================] - 0s 40us/step\n", + "500/500 [==============================] - 0s 46us/step\n", + "[8.00e+00 9.98e-01 9.94e-01 4.00e-03]\n", + "Period:8\n", + "500/500 [==============================] - 0s 46us/step\n", + "500/500 [==============================] - 0s 44us/step\n", + "[9.00e+00 9.96e-01 1.00e+00 4.00e-03]\n" + ] + } + ], + "source": [ + "np.random.seed(1)\n", + "n = 500\n", + "X_train = [] \n", + "Y_train = []\n", + "X_val = [] \n", + "Y_val = []\n", + "for t in range(0,5):\n", + " tmp_x, tmp_y = gen_data(n,signal=9)\n", + " X_train.append(tmp_x)\n", + " Y_train.append(tmp_y)\n", + " \n", + " tmp_x, tmp_y = gen_data(n,signal=9)\n", + " X_val.append(tmp_x)\n", + " Y_val.append(tmp_y)\n", + " \n", + "for t in range(5,10):\n", + " tmp_x, tmp_y = gen_data(n,signal=8)\n", + " X_train.append(tmp_x)\n", + " Y_train.append(tmp_y)\n", + " \n", + " tmp_x, tmp_y = gen_data(n,signal=8)\n", + " X_val.append(tmp_x)\n", + " Y_val.append(tmp_y)\n", + "\n", + "output = np.zeros((9,4))\n", + "\n", + "for i in range(0,9):\n", + " print(\"Period:\" + str(i))\n", + " tmp = PCI(X_train[i], Y_train[i], X_val[i], Y_val[i] ,X_val[i+1], Y_val[i+1]) \n", + " tmp.insert(0,i+1)\n", + " output[i] = tmp\n", + " print(output[i])\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AxesSubplot(0.125,0.125;0.775x0.755)\n", + "AxesSubplot(0.125,0.125;0.775x0.755)\n", + "AxesSubplot(0.125,0.125;0.775x0.755)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "df = pd.DataFrame(output, columns=[\"time\",\"acc_current\",\"acc_next\",\"PCI\"])\n", + "\n", + "fig1 = df.plot(x='time',y='acc_current',legend=False, color = 'orange')\n", + "fig1.set_xlabel(\"Time period\")\n", + "fig1.set_ylabel(\"Accuracy\")\n", + "fig1.set_ylim(0.56,1.02)\n", + "print(fig1)\n", + "fig1.get_figure().savefig(\"fig1.png\")\n", + "\n", + "fig2 = df.plot(x='time',y=['acc_current', 'acc_next'],style=['-','--'] ,color=['orange','purple'])\n", + "fig2.set_xlabel(\"Time period\")\n", + "fig2.set_ylabel(\"Accuracy\")\n", + "fig2.set_ylim(0.56,1.02)\n", + "fig2.legend([\"Testing\",\"One-Period-Ahead\"])\n", + "print(fig2)\n", + "fig2.get_figure().savefig(\"fig2.png\")\n", + "\n", + "fig3 = df.plot(x='time',y='PCI',legend=False)\n", + "fig3.set_xlabel(\"Time period\")\n", + "fig3.set_ylabel(\"PCI\")\n", + "print(fig3)\n", + "fig3.get_figure().savefig(\"fig3.png\")\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}