FINM8006assignment2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from __future__ import division\n",
    "from __future__ import print_function\n",
    "import numpy as np\n",
    "from pandas import Series, DataFrame\n",
    "from pandas.tseries.offsets import MonthEnd\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import seaborn as sns\n",
    "import statsmodels.api as sm\n",
    "import statsmodels.formula.api as smf\n",
    "from scipy.stats import ttest_1samp\n",
    "\n",
    "import datetime\n",
    "plt.rc('figure', figsize=(16, 10))\n",
    "from numpy.linalg import inv\n",
    "from numpy import dot\n",
    "import re"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FINM 8006 Assignment 2\n",
    "### Due Monday 23, October, 2017"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instructions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* You have the option of completing your assignment directly in this notebook. You should have Jupyter (conda install jupyter) installed if you want to use this. \n",
    "* You can alternatively write your answers in the editor of your choosing (Words, etc.), and run your code in Python or R in a separate file. \n",
    "* If you want to use R, I suggest you use R studio and [R Markdown](http://rmarkdown.rstudio.com)\n",
    "* Some parts contains hints in code, you don't neccesary need to follow the exact hint. But please follow the naming convention as suggested. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quick Jupyter notebook\n",
    "* You can add or delete cell as you go\n",
    "* Cells can be a [Markdown](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet#html) cell in which you write your texts and maths. Your math can be typed in [latex symbols](https://oeis.org/wiki/List_of_LaTeX_mathematical_symbols) using `$$ math $$` in a markdown cell. \n",
    "* Default cells are code cells in which you run your python code. \n",
    "* When you are ready to run a (markdown or code) cell, press RETURN + SHIFT at the same time to run the cell.  \n",
    "* Jupyter uses Ipython, so that your codes can be run cell by cell. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set up and Questions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Asset Pricing in Chinese Markets\n",
    "\n",
    "Many have commented that the Chinese stock market is very different from the more mature markets. In this assignment, you will explore some aspects of the asset pricing in Chinese markets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loading data\n",
    "\n",
    "You are given three data sets from year 2000: 'csmar_be.csv' has the December book value (BE) of firms (STKCD). 'csmarstk0016.csv' has monthly market value (ME) and return (ret) information of individual stocks. Data is cleaned to exclude micro stoks and penny stocks. 'csmarmktretrf.csv' has market and risk free returns. Market return here is proxied by returns on the SSE. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style>\n",
       "    .dataframe thead tr:only-child th {\n",
       "        text-align: right;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>STKCD</th>\n",
       "      <th>date</th>\n",
       "      <th>BE</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1999-12-31</td>\n",
       "      <td>2.900831e+09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>2000-12-31</td>\n",
       "      <td>4.738884e+09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>2001-12-31</td>\n",
       "      <td>3.627669e+09</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   STKCD       date            BE\n",
       "0      1 1999-12-31  2.900831e+09\n",
       "1      1 2000-12-31  4.738884e+09\n",
       "2      1 2001-12-31  3.627669e+09"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# December Book Equity where BE >0\n",
    "decbe = pd.read_csv('csmar_be.csv')\n",
    "decbe.date = pd.to_datetime(decbe.date.astype('str'), format='%Y-%m-%d') \n",
    "decbe = decbe.sort_values([\"STKCD\", 'date', 'BE'])\n",
    "decbe = decbe.groupby(['STKCD', 'date']).last().reset_index()\n",
    "decbe.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style>\n",
       "    .dataframe thead tr:only-child th {\n",
       "        text-align: right;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>STKCD</th>\n",
       "      <th>MARKETTYPE</th>\n",
       "      <th>TRDMNT</th>\n",
       "      <th>ME</th>\n",
       "      <th>ret</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>2000-01-31</td>\n",
       "      <td>2.875573e+10</td>\n",
       "      <td>0.061891</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>2000-02-29</td>\n",
       "      <td>2.842984e+10</td>\n",
       "      <td>-0.011333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>2000-03-31</td>\n",
       "      <td>2.850743e+10</td>\n",
       "      <td>0.002729</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   STKCD  MARKETTYPE     TRDMNT            ME       ret\n",
       "0      1           4 2000-01-31  2.875573e+10  0.061891\n",
       "1      1           4 2000-02-29  2.842984e+10 -0.011333\n",
       "2      1           4 2000-03-31  2.850743e+10  0.002729"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# markettype 1 Shanghai A, 4, Shengzhen A\n",
    "stkret =pd.read_csv('csmarstk0016.csv')\n",
    "stkret.TRDMNT = pd.to_datetime(stkret.TRDMNT.astype('str'), format='%Y-%m-%d') \n",
    "stkret = stkret.loc[stkret.ret.notnull()]\n",
    "stkret.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style>\n",
       "    .dataframe thead tr:only-child th {\n",
       "        text-align: right;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>mktret</th>\n",
       "      <th>rf</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>TRDMNT</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2000-01-31</th>\n",
       "      <td>0.123413</td>\n",
       "      <td>0.001856</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2000-02-29</th>\n",
       "      <td>0.118776</td>\n",
       "      <td>0.001856</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2000-03-31</th>\n",
       "      <td>0.049308</td>\n",
       "      <td>0.001856</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              mktret        rf\n",
       "TRDMNT                        \n",
       "2000-01-31  0.123413  0.001856\n",
       "2000-02-29  0.118776  0.001856\n",
       "2000-03-31  0.049308  0.001856"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mktret = pd.read_csv('csmarmktretrf.csv')\n",
    "mktret.TRDMNT = pd.to_datetime(mktret.TRDMNT.astype('str'), format='%Y-%m-%d') \n",
    "mktret = mktret[['TRDMNT', 'mktret', 'rf']].set_index('TRDMNT')\n",
    "mktret.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Preliminaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Q(1a) calculate the Chinese mean (annualized) market excess return."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mktexcess_mean = \n",
    "print(mktexcess_mean)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Q(1b) Assume power utility and relative risk aversion is 3, and constent expected market excess return, what is the optimal proportion of wealth to invest in the risky (stock) assets? (you will invest in a market portfolio). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "optimal_w = \n",
    "print(optimal_w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Q(1c) Your answer above may be different from the typical answer in the U.S. market, explain what mainly drives this difference?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Beta sorts and Fama-Macbeth style estimations\n",
    "\n",
    "* Q(2) For each stock, obtain the CAPM beta over the whole sample. Sort stocks into 20 portfolios according to beta estimates, then do a Fama-Macbeth style estimation test. "
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "#codes that maybe useful\n",
    "df1.merge(df2, on= , how= )\n",
    "df.groupby('somevar')['targetvar'].transform(lambda x: x.count())\n",
    "# apply functions to all columns\n",
    "df.groupby('somevar').apply()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# merge stkret data with mktret data, call it stkretx, \n",
    "#require at least 60 observations for each stock\n",
    "# calculate excess returns\n",
    "\n",
    "stkretx = \n",
    "stkretx['rirf'] = \n",
    "stkretx['mktrf'] =\n",
    "stkretx = stkretx.loc[stkretx.ret.notnull()]\n",
    "stkretx['nobs'] = \n",
    "stkretx = stkretx[stkretx.nobs>=60]\n",
    "stkretx.head(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# define a function that outputs beta\n",
    "# and a fuction that outputs all parameter estimates\n",
    "def ols_beta(df, xcols,  ycol):\n",
    "    X = df[xcols]\n",
    "    X = sm.add_constant(X)\n",
    "    fit = sm.OLS(df[ycol], X).fit()\n",
    "    return fit.params[1]\n",
    "\n",
    "def ols_res(df, xcols,  ycol):\n",
    "    X = df[xcols]\n",
    "    X = sm.add_constant(X)\n",
    "    fit = sm.OLS(df[ycol], X).fit()\n",
    "    return fit.params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# run regression by stock\n",
    "# use pd.qcut() function to sort portfolio\n",
    "stkbeta = \n",
    "stkbeta = pd.DataFrame(stkbeta, columns=['beta'])\n",
    "stkbeta['betaport'] = pd.Series(#pd.qcut fucntion)\n",
    "stkbeta.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# merge beta estimates back to stkbeta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# portfolio beta and return\n",
    "stkbetaport = \n",
    "stkbetaport = \n",
    "stkbetaport = stkbetaport.reset_index()\n",
    "stkbetaport.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# your cross sectional estimates are in estbymonth\n",
    "# you may find ttest_1samp() function useful\n",
    "estbymonth = \n",
    "#\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# do your test of intercept"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# do your test of coefficient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Forming Portfolios\n",
    "\n",
    "According to size and MTB."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Starting from '2000-7-31', from July to end of June of each year, categorize each stock to form a 5X5 portfolios of size and book-to-market. Size and book-to-market are defined as in Fama Frech (1993). You may want to create a 'year' variable that designate portfolio formation year."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# codes that may be useful\n",
    "\n",
    "# code to generate year from datetimeindex column of data df\n",
    "df.datetimeindex.dt.year\n",
    "# conditionaly assign value to a pandas column\n",
    "np.where(condition, value if true, value if false)\n",
    "# assign quintiles to data\n",
    "assignsz = lambda x: pd.qcut(x, 5, labels=['sz1', 'sz2', 'sz3', 'sz4', 'sz5'], retbins=False)\n",
    "df['assignsz'] = df.groupby('somevar)['targetvar'].apply(assignsz)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# year is the portfolio formation year\n",
    "stkret['year'] = np.where( )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# year is the portfolio formation year\n",
    "### "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# stkret_btm contains BTM and return info\n",
    "stkret_btm = \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "bmstkret = stkret_btm.copy()\n",
    "##\n",
    "#\n",
    "\n",
    "# create a column \"port\" that has the assigned name of portfolio that a stock belongs to\n",
    "bmstkret['port'] =  bmstkret.assignsz.astype('str') + (\" \") + bmstkret.assignbm.astype('str') \n",
    "\n",
    "bmstkret = bmstkret[['STKCD', 'MARKETTYPE', 'TRDMNT', 'ret', 'port']]\n",
    "bmstkret.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#create data bmsz that contains mean portfolio return for each of 25 portfolios, index by time\n",
    "bmsz = \n",
    "bmsz.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# join and calculate excess return 'retrf'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# below code will give you return series of portfolios in columns\n",
    "portret = bmsz[['port',  'retrf']].reset_index().set_index(['port', 'TRDMNT']).unstack('port')\n",
    "portret.columns = portret.columns.droplevel()\n",
    "portret.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# do your estimation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Q(3a) Show the CAPM alpha and beta of these portfolios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# you may use the below functin to transform your estimated series to a nice 5X5 block\n",
    "def results_matrix(dfvar):\n",
    "    # get index\n",
    "    szindex = np.array([idx.split()[0] for idx in capm_out.index]).reshape(5,5)[:,0].tolist() \n",
    "    bmindex = np.array([idx.split()[1] for idx in capm_out.index]).reshape(5,5)[0].tolist()\n",
    "    results5by5 = pd.DataFrame(dfvar.values.reshape(5,5), index=szindex, columns=bmindex)\n",
    "    return results5by5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print('Portfolio Beta:')\n",
    "betatb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print('CAPM alpha:')\n",
    "alphatb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Q(3b) Calculate mean portfolio return and compare them with the CAPM estimates, explain any patterns in the data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print('Mean Excess Return:')\n",
    "meanrettb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Q(3c) plot the mean excess return against CAPM predicted return. Plot both within size (BM) plots and the within BM (size) plots."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "#### Constructing SMB and HML factors\n",
    "\n",
    "Construct 2x3 portfolios of size and BTM according to the Shanghai Stock Exchange cutoff (MARKETTYPE==1). Calculate the value-weighted returns of the portfolios and then construct SMB and HML factors following Fama French (93) procedure. "
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "# codes that might be useful\n",
    "df.groupby()[].quantile([ cutoff1, cutoff2]).unstack()\n",
    "# finding rows that somevar contains the string 'high'\n",
    "df.loc[df.somevar.str.contains('high')]\n",
    "#function for cumulative product\n",
    "df.somevar.cumprod()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# SSE ME and BTM for cutoff \n",
    "mebe = \n",
    "mebe = mebe.loc[mebe.MARKETTYPE==1]  #only shanghai market for cutoff calculation\n",
    "mebe.head(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mebe[['ME', 'BE', 'BTM']].describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# from stkret_btm create data that contains designation of 2X3 portfolio\n",
    "# name this new data 'stkretcut'\n",
    "# name this designation variable 'bmsz'\n",
    "\n",
    "stkretcut = \n",
    "\n",
    "\n",
    "stkretcut['bmsz'] = \n",
    "stkretcut.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "calculate value weighted return within each 2X3 portfolio, then construct factors using these portfolio returns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "hml = \n",
    "hml.name = 'HML'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "smb = \n",
    "smb.name = 'SMB'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "plot cumulative returns of the HML and SMB factors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Q(4a) Joinning factors with 25 portfolio returns, run FF 3 factor model. Does the coefficients estimates make sense? Get predicted returns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# concatenate estimate of ff3 in beta smb hml into a big block named bsh\n",
    "print('FF 3 factor model factor loadings')\n",
    "bsh = pd.concat([f3beta, f3smb, f3hml], axis=1, keys=['b', 's', 'h'])\n",
    "bsh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "\n",
    "predictmean = "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "* Q(4b) plot the Mean portfolio return against the Fama-French 3 factor predicted return. Again for both Within-BM Size Plot and Within-Size BM Plot. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "* Q(4c) How do the graphs compare to the earlier CAPM plots? In the U.S. data, the most severe violation of CAPM happens along BTM portfolios, What about China? Can you explain why this factor comes up so significant in the Chinese markets?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5.2"
  },
  "latex_envs": {
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 0
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}