ipynb/kerk_phillips-moment_calculator.ipynb

{
    "cells": [
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "# Quickly and Easily Calculate Business Cycle Moments\n",
                "\n",
                "### by [Kerk L. Phillips](https://sites.google.com/site/kerkphillips/home), July 2018\n",
                "\n",
                "The code in this Jupyter notebook was written using Python 3.6."
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "This notebook shows how to quickly and easily calculate a set of commonly reported moments from a set of data.  This data could be real world data, or data from a simulated model.  The function used, `calcmom`, can be downloaded at the following Github site.  [https://github.com/kerkphil/DSGE-Utilities](https://github.com/kerkphil/DSGE-Utilities).  For the example in this notebook we use data stored in a csv spreadsheet, `DSGEtestdata.csv`.  That data files and this notebook can be found in the public GitHub repository [https://github.com/kerkphil/Jupyter_Notebooks](https://github.com/kerkphil/Jupyter_Notebooks)."
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## Moment Calculator Code"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "The code below can be downloaded from the repository shown above, however we reproduce it here in order to see how the moments are calculated.\n",
                "\n",
                "Note that the data must be organized as follows:\n",
                "\n",
                "data: an nobs-by-nvar matrix of data with with nobs indexing the time-series observations in rows and nvar indexing the variables in columns.  If GDP is included it should be in the first column."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 2,
            "metadata": {},
            "outputs": [],
            "source": [
                "import pandas as pd\n",
                "import numpy as np\n",
                "\n",
                "def calcmom(data, means = False, stds = True, relstds = True, \n",
                "            corrs = True, autos = True, cvars = False):\n",
                "    '''\n",
                "    This function calculates a user controlled set of moments from data\n",
                "    It takes the following as inputs:\n",
                "    1)  data: an nobs-by-nvar matrix of data with with nobs indexing the \n",
                "        time-series observations in rows and nvar indexing the variables in \n",
                "        columns.  If GDP is included it should be in the first column.\n",
                "    \n",
                "    The function caculates and returns the following outputs in a single\n",
                "    matrix with  rows for each type of momemnt and nvar columns .  The moments,\n",
                "    if calculated are reported in the following order.  Each column can be\n",
                "    turned off or on by setting the appropriate flags.\n",
                "    1) means -     means of the variables\n",
                "    2) stdevs -    standard deviations of variables\n",
                "    3) relstds -   standard deviations of variables relative to GDP\n",
                "    4) correls -   correlations of variables with GDP\n",
                "    5) autocoors - autocorrelations of variables\n",
                "    6) coefvars -  coefficients of variation (stdev/mean)\n",
                "        \n",
                "    Notes:\n",
                "   \n",
                "    '''\n",
                "    # find the number of variables and observations\n",
                "    (nobs, nvar) = data.shape\n",
                "    report = np.zeros(nvar)\n",
                "    count = 0\n",
                "    rindex = []\n",
                "    \n",
                "    if means or cvars:\n",
                "        dmeans= np.mean(data,axis=0)\n",
                "        report = np.vstack((report,dmeans))\n",
                "        count = count + 1\n",
                "        rindex.extend(['means'])\n",
                "        \n",
                "    if stds or cvars:\n",
                "        dstds = np.std(data,axis=0)\n",
                "        report = np.vstack((report,dstds))\n",
                "        count = count + 1\n",
                "        rindex.extend(['standard deviations'])\n",
                "        \n",
                "    if relstds:\n",
                "        drelstds = dstds/dstds[0]\n",
                "        report = np.vstack((report,drelstds))\n",
                "        count = count + 1\n",
                "        rindex.extend(['standard deviations relative to GDP'])\n",
                "        \n",
                "    if corrs:\n",
                "        temp = np.corrcoef(np.transpose(data))\n",
                "        dcorrs = temp[0:nvar,0]\n",
                "        report = np.vstack((report,dcorrs))\n",
                "        count = count + 1\n",
                "        rindex.extend(['corrleations with GDP'])\n",
                "        \n",
                "    if autos:\n",
                "        dlead = np.transpose(data[1:nobs,:])\n",
                "        dlag = np.transpose(data[0:nobs-1,:])\n",
                "        temp = np.corrcoef(dlead,dlag)\n",
                "        dautos = np.diag(temp, -nvar)\n",
                "        report = np.vstack((report,dautos))\n",
                "        count = count + 1\n",
                "        rindex.extend(['autocorrelations'])\n",
                "        \n",
                "    if cvars:\n",
                "        dcvars = dstds/dmeans\n",
                "        report = np.vstack((report,dcvars))\n",
                "        count = count + 1\n",
                "        rindex.extend(['coefficients of variation'])\n",
                "        \n",
                "    # appropriately truncate lists\n",
                "    report = report[1:count+1,:]\n",
                "    rindex = rindex[0:count+1]\n",
                "    \n",
                "    return report, rindex"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## An Example"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 14,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/html": [
                            "<table border=\"1\" class=\"dataframe\">\n",
                            "  <thead>\n",
                            "    <tr style=\"text-align: right;\">\n",
                            "      <th></th>\n",
                            "      <th>y</th>\n",
                            "      <th>c</th>\n",
                            "      <th>i</th>\n",
                            "      <th>g</th>\n",
                            "      <th>w</th>\n",
                            "      <th>e</th>\n",
                            "    </tr>\n",
                            "  </thead>\n",
                            "  <tbody>\n",
                            "    <tr>\n",
                            "      <th>standard deviations</th>\n",
                            "      <td>0.016198</td>\n",
                            "      <td>0.012534</td>\n",
                            "      <td>0.074144</td>\n",
                            "      <td>0.033072</td>\n",
                            "      <td>0.018262</td>\n",
                            "      <td>0.014307</td>\n",
                            "    </tr>\n",
                            "    <tr>\n",
                            "      <th>standard deviations relative to GDP</th>\n",
                            "      <td>1.000000</td>\n",
                            "      <td>0.773792</td>\n",
                            "      <td>4.577319</td>\n",
                            "      <td>2.041723</td>\n",
                            "      <td>1.127394</td>\n",
                            "      <td>0.883242</td>\n",
                            "    </tr>\n",
                            "    <tr>\n",
                            "      <th>corrleations with GDP</th>\n",
                            "      <td>1.000000</td>\n",
                            "      <td>0.770889</td>\n",
                            "      <td>0.837286</td>\n",
                            "      <td>0.155206</td>\n",
                            "      <td>0.862408</td>\n",
                            "      <td>0.820931</td>\n",
                            "    </tr>\n",
                            "    <tr>\n",
                            "      <th>autocorrelations</th>\n",
                            "      <td>0.850491</td>\n",
                            "      <td>0.815801</td>\n",
                            "      <td>0.796125</td>\n",
                            "      <td>0.905775</td>\n",
                            "      <td>0.876654</td>\n",
                            "      <td>0.918816</td>\n",
                            "    </tr>\n",
                            "  </tbody>\n",
                            "</table>"
                        ],
                        "text/plain": [
                            "<IPython.core.display.HTML object>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "# read the data from an external csv file\n",
                "macrodata = pd.read_csv('DSGEtestdata.csv')\n",
                "\n",
                "# based on the data in the file calculate the natural logs of:\n",
                "y = np.log(macrodata.RGDP)  # real GDP\n",
                "c = np.log(macrodata.RCON)  # real consumption\n",
                "i = np.log(macrodata.RINV)  # real inbestment\n",
                "g = np.log(macrodata.RGOV)  # real government purchases\n",
                "w = np.log(macrodata.NWAGE/macrodata.DEFL)  # real wage\n",
                "e = np.log(macrodata.EMP)   # employment\n",
                "\n",
                "# stack this data into a single numpy matrix\n",
                "data = np.stack((y,c,i,g,w,e),axis=1)\n",
                "\n",
                "# assign names for the columns\n",
                "varnames = ['y','c','i','g','w','e']\n",
                "\n",
                "# find number of observations and variables\n",
                "(nobs, nvar) = data.shape\n",
                "\n",
                "# choose a filter to remove the trend\n",
                "filtertype = 'HP'\n",
                "\n",
                "import statsmodels.api as sm\n",
                "if filtertype == 'FD':   # first-differences\n",
                "    cyclical = data[1:nobs,:] - data[0:nobs-1,:]\n",
                "elif filtertype == 'HP': # Hodrick-Prescott\n",
                "    cyclical, trend = sm.tsa.filters.hpfilter(data)\n",
                "elif filtertype == 'CF': # Christiano-Fitzgerald\n",
                "    cyclical, trend = sm.tsa.filters.cffilter(data)\n",
                "elif filtertype == 'BK': # Baxter-King\n",
                "    cyclical = sm.tsa.filters.bkfilter(data)\n",
                "\n",
                "# use calcmom to get the default moments\n",
                "moms, momnames = calcmom(cyclical)\n",
                "\n",
                "# put into a pandas data frame\n",
                "table = pd.DataFrame(moms, index = momnames, columns = varnames) \n",
                "\n",
                "# display on screen\n",
                "from IPython.display import display, HTML\n",
                "display(HTML(table.to_html()))\n",
                "\n",
                "# write to an external csv file\n",
                "table.to_csv('DSGEmoments.csv')"
            ]
        }
    ],
    "metadata": {
        "celltoolbar": "Raw Cell Format",
        "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.5"
        }
    },
    "nbformat": 4,
    "nbformat_minor": 2
}