added ic decay example

notebooks/Quick Start 8 - IC Decay Calculation.ipynb

+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "import os\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from alphamind.api import *\n",
+    "from PyFin.api import *\n",
+    "\n",
+    "from matplotlib import rc\n",
+    "from matplotlib import pyplot as plt\n",
+    "\n",
+    "plt.style.use(\"seaborn-poster\")\n",
+    "rc('font', **{'family': 'Microsoft Yahei', 'size': 10})\n",
+    "rc('mathtext', **{'default': 'regular'})\n",
+    "rc('legend', **{'frameon': False})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "factor_name = 'ETOP'\n",
+    "neutralized_styles = industry_styles\n",
+    "start_date = '2010-01-01'\n",
+    "end_date = '2019-03-01'\n",
+    "engine = SqlEngine(os.environ['DB_URI'])\n",
+    "universe_name = 'ashare_ex'\n",
+    "freq = '21b'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "factors = {'ROE': LAST(factor_name),\n",
+    "           'ROE_l1': SHIFT(LAST(factor_name), 1),\n",
+    "           'ROE_l2': SHIFT(LAST(factor_name), 2),\n",
+    "           'ROE_l3': SHIFT(LAST(factor_name), 3)}\n",
+    "\n",
+    "factors_names = list(factors.keys())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "universe = Universe(universe_name)\n",
+    "dates = makeSchedule(start_date, end_date, freq, calendar='china.sse')\n",
+    "factors = engine.fetch_factor_range(universe, factors, dates=dates)\n",
+    "risk_cov, risk_factors = engine.fetch_risk_model_range(universe, dates=dates)\n",
+    "dx_returns = engine.fetch_dx_return_range(universe, dates=dates, horizon=map_freq(freq))\n",
+    "total_data = pd.merge(factors, risk_factors, on=['trade_date', 'code'])\n",
+    "total_data = pd.merge(total_data, dx_returns, on=['trade_date', 'code'])\n",
+    "total_data.dropna(inplace=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "neutralized_factors = neutralize(total_data[neutralized_styles].values.astype(float),\n",
+    "                                 total_data[factors_names].values,\n",
+    "                                 groups=total_data['trade_date'])\n",
+    "total_data[factors_names] = neutralized_factors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "d:\\ProgramData\\Anaconda3\\lib\\site-packages\\numpy\\lib\\function_base.py:2530: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  c /= stddev[:, None]\n",
+      "d:\\ProgramData\\Anaconda3\\lib\\site-packages\\numpy\\lib\\function_base.py:2531: RuntimeWarning: invalid value encountered in true_divide\n",
+      "  c /= stddev[None, :]\n"
+     ]
+    }
+   ],
+   "source": [
+    "values = {}\n",
+    "for f in factors_names:\n",
+    "    ic_series = total_data.groupby('trade_date').apply(lambda x: np.corrcoef(x[f], x['dx'])[0, 1])\n",
+    "    values[f] = ic_series.mean()\n",
+    "values = pd.Series(values)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.axes._subplots.AxesSubplot at 0x2b949dca240>"
+      ]
+     },
+     "execution_count": 41,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1008x576 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "values.plot(kind='bar', figsize=(14, 8))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "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"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}