multi-factors-strategy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'spare': 1000000, 'total': 1000000}"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from jqdatasdk import *\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "auth('id','password') #ID是申请时所填写的手机号；Password为聚宽官网登录密码，新申请用户默认为手机号后6位\n",
    "get_query_count()#当前剩余可用数据条数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "#get_industry_stocks('I64')# 获取计算机/互联网行业的成分股\n",
    "#get_index_stocks('399951.XSHE', date=None)#获取沪深300银行指数成分股"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "#该函数能够获得指定时间，指定股票成分股的截面数据\n",
    "def getdata(stock,datetime,gap):\n",
    "    #调取截面数据、计算月收益率数据\n",
    "    sample = get_index_stocks(stock, date=datetime)#股票除选择沪深300银行指数成分股\n",
    "    q = query(valuation.code, \n",
    "              valuation.market_cap,#市值\n",
    "              valuation.circulating_market_cap,\n",
    "              balance.total_assets - balance.total_liability,#净资产\n",
    "              balance.total_assets / balance.total_liability, \n",
    "              indicator.net_profit_to_total_revenue, #净利润/营业总收入\n",
    "              indicator.inc_revenue_year_on_year,  #营业收入增长率（同比）\n",
    "              balance.development_expenditure, #RD\n",
    "              valuation.pe_ratio, #市盈率（TTM）\n",
    "              valuation.pb_ratio, #市净率（TTM）\n",
    "              indicator.inc_net_profit_year_on_year,#净利润增长率（同比）\n",
    "              balance.dividend_payable,\n",
    "              indicator.roe,\n",
    "              indicator.roa,\n",
    "              income.operating_profit / income.total_profit, #OPTP\n",
    "              indicator.gross_profit_margin, #销售毛利率GPM\n",
    "              balance.fixed_assets / balance.total_assets, #FACR\n",
    "              valuation.pcf_ratio, #CFP\n",
    "              valuation.ps_ratio #PS\n",
    "            ).filter(\n",
    "                valuation.code.in_(sample)\n",
    "            )\n",
    "    df = get_fundamentals(q, date =datetime)\n",
    "    #df.index = df.code.values\n",
    "    del df['code']\n",
    "    df = df.fillna(0)\n",
    "    \n",
    "    #解决数据日期问题 选取未来一个月的日期\n",
    "    year = int(datetime[:4])\n",
    "    month = int(datetime[5:7])\n",
    "    day=int(datetime[8:10])\n",
    "    if month == 12:       \n",
    "        nexttime = str(year+1)+'-'+str(gap)+'-'+str(day)\n",
    "    else:  \n",
    "        nexttime = str(year)+'-'+str(month+gap)+'-'+str(day)\n",
    "        \n",
    "    #构建特征和标签\n",
    "    sample2 = get_index_stocks(stock, date=nexttime)#股票除选择沪深300银行指数成分股\n",
    "    q2 = query(valuation.code, \n",
    "              valuation.market_cap,#市值\n",
    "            ).filter(\n",
    "                valuation.code.in_(sample2)\n",
    "            )\n",
    "    df2=get_fundamentals(q2, date = nexttime)\n",
    "    del df2['code']\n",
    "    monthreturn=pd.DataFrame(df2['market_cap'].values/df['market_cap'].values, columns=['monthreturn'])\n",
    "    df=pd.concat([df,monthreturn],axis=1)\n",
    "    #df即为我们的训练集 用来训练回归模型 筛选变量和权重\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "#构建一个日期表，从这些日期中选取截面数据\n",
    "def return_datelist(start_date,end_date):\n",
    "    datelist=[]\n",
    "    #start_date:str, 初始日期\n",
    "    #end_date:str,终止日期\n",
    "    start_year = int(start_date[:4])\n",
    "    end_year = int(end_date[:4])\n",
    "    start_month = int(start_date[5:7])\n",
    "    end_month = int(end_date[5:7])\n",
    "    start_day=int(start_date[8:10])\n",
    "    end_day=int(end_date[8:10])\n",
    "    for i in range(end_month):\n",
    "        if(end_month-i<10):\n",
    "            date=str(end_year)+'-'+'0'+str(end_month-i)+'-'+str(end_day)\n",
    "            datelist=datelist+[date]\n",
    "        else:\n",
    "            date=str(end_year)+'-'+str(end_month-i)+'-'+str(end_day)\n",
    "            datelist=datelist+[date]\n",
    "    for i in range(13-start_month):\n",
    "        if(start_month+i<10):\n",
    "            date=str(start_year)+'-'+'0'+str(start_month+i)+'-'+str(start_day)\n",
    "            datelist=datelist+[date]\n",
    "        else:\n",
    "            date=str(start_year)+'-'+str(start_month+i)+'-'+str(start_day)\n",
    "            datelist=datelist+[date]          \n",
    "        current_year=start_year+1\n",
    "    while(current_year!=end_year):\n",
    "        for i in range(11):\n",
    "            if(i+1<10):\n",
    "                date=str(current_year)+'-'+'0'+str(i+1)+'-'+str(start_day)\n",
    "                datelist=datelist+[date]\n",
    "            else:\n",
    "                date=str(current_year)+'-'+str(i+1)+'-'+str(start_day)\n",
    "                datelist=datelist+[date]\n",
    "        current_year=current_year+1\n",
    "    return datelist    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(400, 19)"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#获得训练数据集\n",
    "datelist=return_datelist(start_date='2013-10-15',end_date='2015-10-15')\n",
    "df=getdata(stock='399951.XSHE',datetime='2013-10-15',gap=1)\n",
    "for i in datelist:\n",
    "    dfnew=getdata(stock='399951.XSHE',datetime=i,gap=1)\n",
    "    df=pd.concat([df,dfnew],axis=0)\n",
    "df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(400, 19)"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#借助训练集进行回归模型的训练 归一化数据\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn import preprocessing\n",
    "min_max_scaler = preprocessing.MinMaxScaler()\n",
    "df1=min_max_scaler.fit_transform(df)\n",
    "df2 = pd.DataFrame(df1, columns=df.columns)\n",
    "df2.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((400, 18), (400,))"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y=df2['monthreturn']\n",
    "x=df2.drop(columns = ['monthreturn'])\n",
    "x.shape,y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1.84304025e-01 -3.06198850e-02  1.60895871e-01  1.70025869e-01\n",
      " -4.78423493e-02  1.76786229e-01 -8.74300632e-16  1.58766816e-01\n",
      " -3.79950914e-01 -2.63670587e-01  3.39311135e-02  3.43374766e-01\n",
      " -2.79462321e-01  9.18125757e-02  0.00000000e+00  1.13152446e-02\n",
      " -4.61600751e-02 -4.52255485e-02]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1c884ea2c88>]"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#利用线性模型得到权重\n",
    "from sklearn.linear_model import LinearRegression\n",
    "lr=LinearRegression()\n",
    "lr.fit(x, y)\n",
    "print(lr.coef_)\n",
    "plt.plot(lr.coef_,'o', label = 'linear regression')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.         -0.          0.          0.          0.02263684  0.12729578\n",
      "  0.         -0.         -0.00548703  0.          0.          0.\n",
      "  0.          0.10214221  0.          0.01761991  0.42324258 -0.        ]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1c884e97390>]"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#利用线性模型得到权重\n",
    "from sklearn.linear_model import Lasso\n",
    "lasso = Lasso(fit_intercept=False)\n",
    "lasso.set_params(alpha=0.004)\n",
    "lasso.fit(x, y)\n",
    "print(lasso.coef_)\n",
    "plt.plot(lasso.coef_,'o', label = 'linear regression')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.01834382 -0.01282341 -0.          0.00508764 -0.00061548  0.08580345\n",
      "  0.         -0.00359498 -0.12210169 -0.          0.         -0.00643674\n",
      " -0.          0.          0.          0.00116625 -0.         -0.06356195]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1c88835bba8>]"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAEoFJREFUeJzt3X+MHGd9x/H3t7aTXlsa54eB+JLUSQmWQKg4OqW0KQglJBcowi6KiitErZIqQiVSEaqFraiA0j9IarWV2qKilKQNCJqUYIxFoUdIoK1QCTnjECfAYSeA4rObBJwLVD2B7X77x86l63v2zre349vZu/dLWu3sM8/sfnd2vJ+b55k7R2YiSVK7n+t3AZKk5jEcJEkFw0GSVDAcJEkFw0GSVDAcJEkFw0GSVDAcJEkFw0GSVFjd7wIW44ILLsgNGzb0uwxJGij79u37YWauW0jfgQyHDRs2MD4+3u8yJGmgRMQPFtrXYSVJUsFwkCQVDAdJUsFwkCQVDAdJUmEgr1ZSM+3ZP8musQmOTE2zfu0Q20c3smXTcL/LkrQIhoNqsWf/JDt3H2D6+EkAJqem2bn7AIABIQ0gh5VUi11jEy8Ew4zp4yfZNTbRp4ok9cJwUC2OTE131S6p2QwH1WL92qGu2iU1m+GgWmwf3cjQmlWntA2tWcX20Y19qkhSL5yQVi1mJp29WklaHgwH1WbLpmHDQFomHFaSJBUMB0lSwXCQJBUMB0lSwXCQJBUMB0lSwXCQJBUMB0lSwXCQJBUMB0lSwXCQJBUMB0lSwXCQJBUMB0lSwXCQJBUMB0lSwXCQJBUMB0lSwXCQJBUMB0lSwXCQJBUMB0lSwXCQJBUMB0lSwXCQJBUMB0lSoZZwiIjrI2IiIg5FxI4O68+OiHur9Q9FxIaqfUNETEfEI9XtI3XUI0nqzepenyAiVgEfBq4FDgMPR8TezPxWW7cbgecy82URsRW4HXhbte6JzHx1r3VIkupTx5nDlcChzHwyM38G3ANsntVnM3B3tXwfcE1ERA2vLUk6A+oIh2HgqbbHh6u2jn0y8wTwPHB+te7SiNgfEf8WEa+d60Ui4qaIGI+I8WeffbaGsiVJc6kjHDqdAeQC+xwFLsnMTcB7gU9GxC93epHMvCMzRzJzZN26dT0VLEmaXx3hcBi4uO3xRcCRufpExGrgHOBYZv40M38EkJn7gCeAl9dQkySpB3WEw8PA5RFxaUScBWwF9s7qsxfYVi3fADyYmRkR66oJbSLiMuBy4MkaapIk9aDnq5Uy80RE3AyMAauAuzLz8Yi4FRjPzL3AncDHI+IQcIxWgAC8Drg1Ik4AJ4F3ZeaxXmuSJPUmMmdPDzTfyMhIjo+P97sMSRooEbEvM0cW0tffkJYkFQwHSVLBcJAkFQwHSVLBcJAkFQwHSVLBcJAkFQwHSVLBcJAkFQwHSVLBcJAkFQwHSVLBcJAkFQwHSVLBcJAkFQwHSVLBcJAkFQwHSVLBcJAkFQwHSVLBcJAkFQwHSVLBcJAkFQwHSVLBcJAkFQwHSVLBcJAkFQwHSVLBcJAkFQwHSVLBcJAkFQwHSVLBcJAkFQwHSVJhdb8LUG/27J9k19gER6amWb92iO2jG9myabjfZUkacIbDANuzf5Kduw8wffwkAJNT0+zcfQDAgJDUE4eVBtiusYkXgmHG9PGT7Bqb6FNFkpYLw2GAHZma7qpdkhaqlnCIiOsjYiIiDkXEjg7rz46Ie6v1D0XEhrZ1O6v2iYgYraOelWL92qGu2iUtzJ79k1x124NcuuNfuOq2B9mzf7LfJS25nuccImIV8GHgWuAw8HBE7M3Mb7V1uxF4LjNfFhFbgduBt0XEK4CtwCuB9cCXIuLlmXnqWMkyVMdE8vbRjafMOQAMrVnF9tGNfamnLk2qpU51va+m7Z+mva9en6fOubymfVbdqGNC+krgUGY+CRAR9wCbgfZw2Ax8sFq+D/jbiIiq/Z7M/CnwvYg4VD3ff9ZQV2PVdfDN9O314GvSxHaTaqlTXe+rafunae+rjueZby5vkD+rbtUxrDQMPNX2+HDV1rFPZp4AngfOX+C2y06dE8lbNg3z1R1X873bfpuv7rh6UQddkya2m1RLnep6X03bP017X3U8T11zeU37rLpVx5lDdGjLBfZZyLatJ4i4CbgJ4JJLLummvsZp2kRyk+qps5YmndLX9b6a9FnN97r9el91PM/6tUNMdujf7Vxe0z6rbtVx5nAYuLjt8UXAkbn6RMRq4Bzg2AK3BSAz78jMkcwcWbduXQ1l90/TJpKbVE9dtcyc0k9OTZP8/yl9vyYW63pfTfqs5nvdfr2vOp5n++hGhtasOqVtMXN5TfusulVHODwMXB4Rl0bEWbQmmPfO6rMX2FYt3wA8mJlZtW+trma6FLgc+HoNNTVaXQffcqynrlqadkpf1/tq0mdVZz1Nep4tm4b50FtfxfDaIQIYXjvEh976qkVdMNKkz6pbPQ8rZeaJiLgZGANWAXdl5uMRcSswnpl7gTuBj1cTzsdoBQhVv3+mNXl9Anj3SrhSqa6J5OVYT121NO2Uvq73VednVcewW9PeV53P0+vx36R/V4sRrR/gB8vIyEiOj4/3uww12FW3Pdhx3Hh47RBf3XF1HypqltlX0kDrp9rF/ISswRER+zJzZCF9/Q1pLUuDfkp/pjVt2E3N4x/e07I06Kf0Z1rTht3UPIaDlq06xo2Xq7ou19Ty5bCStAI57KbT8cyhS036xSppsRx20+kYDl0Y9L+VIrVz2E3zcVipC17hIWmlMBy64BUeklYKw6ELg/63UiRpoVZMONTxPzt5hYeklWJFTEg37T/XkaSmWxHhUNf/7ARe4SFpZVgRw0pOJEtSd1ZEODiRLEndWRHh4ESyJHVnRcw5OJEsSd1ZEeEATiRLUjdWxLCSJKk7hoMkqWA4SJIKhoMkqWA4SJIKhoMkqWA4SJIKhoMkqWA4SJIKhoMkqWA4SJIKhoMkqWA4SJIKhoMkqWA4SJIKhoMkqWA4SJIKhoMkqWA4SJIKhoMkqWA4SJIKhoMkqdBTOETEeRFxf0QcrO7PnaPftqrPwYjY1tb+lYiYiIhHqtuLe6lHklSPXs8cdgAPZOblwAPV41NExHnAB4BfB64EPjArRN6ema+ubs/0WI8kqQa9hsNm4O5q+W5gS4c+o8D9mXksM58D7geu7/F1JUlnUK/h8JLMPApQ3XcaFhoGnmp7fLhqm/EP1ZDSn0ZEzPVCEXFTRIxHxPizzz7bY9mSpPmsPl2HiPgS8NIOq25Z4Gt0+sLP6v7tmTkZES8CPg28A/hYpyfJzDuAOwBGRkayUx9JUj1OGw6Z+Ya51kXE0xFxYWYejYgLgU5zBoeB17c9vgj4SvXck9X9TyLik7TmJDqGgyRp6fQ6rLQXmLn6aBvw2Q59xoDrIuLcaiL6OmAsIlZHxAUAEbEGeDPwWI/1SJJq0Gs43AZcGxEHgWurx0TESER8FCAzjwF/Bjxc3W6t2s6mFRKPAo8Ak8Df91iPJKkGkTl4w/cjIyM5Pj7e7zIkaaBExL7MHFlIX39DWpJUMBwkSQXDQZJUMBwkSYXT/p6DJKm/9uyfZNfYBEemplm/dojtoxvZsmn49Bv2wHCQpAbbs3+SnbsPMH38JACTU9Ps3H0A4IwGhMNKktRgu8YmXgiGGdPHT7JrbOKMvq7hIEkNdmRquqv2uhgOktRg69cOddVeF8NBkhps++hGhtasOqVtaM0qto9uPKOv64S0JDXYzKSzVytJkk6xZdPwGQ+D2RxWkiQVDAdJUsFwkCQVDAdJUsFwkCQVDAdJUsFwkCQVDAdJUsFwkCQVDAdJUsFwkCQVDAdJUsFwkCQVDAdJUsFwkCQVDAdJUsFwkCQVDAdJUsFwkCQVDAdJUsFwkCQVDAdJUsFwkCQVDAdJUsFwkCQVDAdJUqGncIiI8yLi/og4WN2fO0e/f42IqYj43Kz2SyPioWr7eyPirF7qkSTVo9czhx3AA5l5OfBA9biTXcA7OrTfDvxVtf1zwI091iNJqkGv4bAZuLtavhvY0qlTZj4A/KS9LSICuBq473TbS5KWVq/h8JLMPApQ3b+4i23PB6Yy80T1+DAw3GM9kqQarD5dh4j4EvDSDqtu6fG1o0NbzlPHTcBNAJdcckmPLy1Jms9pwyEz3zDXuoh4OiIuzMyjEXEh8EwXr/1DYG1ErK7OHi4CjsxTxx3AHQAjIyNzhogkqXe9DivtBbZVy9uAzy50w8xM4MvADYvZXpJ05vQaDrcB10bEQeDa6jERMRIRH53pFBH/AXwKuCYiDkfEaLXqfcB7I+IQrTmIO3usR5JUg9MOK80nM38EXNOhfRz4w7bHr51j+yeBK3upQZJUP39DWpJUMBwkSQXDQZJUMBwkSQXDQZJUMBwkSQXDQZJUMBwkSQXDQZJUMBwkSQXDQZJUMBwkSQXDQZJU6OmvskorwZ79k+wam+DI1DTr1w6xfXQjWzb5P9pqeTMcpHns2T/Jzt0HmD5+EoDJqWl27j4AYEBoWXNYSZrHrrGJF4JhxvTxk+wam+hTRdLSMBykeRyZmu6qXVouDAdpHuvXDnXVLi0XhoM0j+2jGxlas+qUtqE1q9g+urFPFUlLwwlpaR4zk85eraSVxnCQTmPLpmHDQCuOw0qSpILhIEkqGA6SpILhIEkqGA6SpEJkZr9r6FpEPAv8YJGbXwD8sMZylsKg1Txo9YI1L5VBq3nQ6oX5a/6VzFy3kCcZyHDoRUSMZ+ZIv+voxqDVPGj1gjUvlUGredDqhfpqdlhJklQwHCRJhZUYDnf0u4BFGLSaB61esOalMmg1D1q9UFPNK27OQZJ0eivxzEGSdBrLNhwi4vqImIiIQxGxo8P6syPi3mr9QxGxYemrfKGWiyPiyxHx7Yh4PCL+uEOf10fE8xHxSHV7fz9qnVXT9yPiQFXPeIf1ERF/Xe3jRyPiin7U2VbPxrb990hE/Dgi3jOrT9/3c0TcFRHPRMRjbW3nRcT9EXGwuj93jm23VX0ORsS2Pte8KyK+U332n4mItXNsO+9xtIT1fjAiJts++zfNse283y1LXPO9bfV+PyIemWPb7vdxZi67G7AKeAK4DDgL+Cbwill9/gj4SLW8Fbi3j/VeCFxRLb8I+G6Hel8PfK7f+3ZWTd8HLphn/ZuALwABvAZ4qN81zzpG/ovWdd+N2s/A64ArgMfa2v4c2FEt7wBu77DdecCT1f251fK5faz5OmB1tXx7p5oXchwtYb0fBP5kAcfNvN8tS1nzrPV/Aby/rn28XM8crgQOZeaTmfkz4B5g86w+m4G7q+X7gGsiIpawxhdk5tHM/Ea1/BPg28By+BvRm4GPZcvXgLURcWG/i6pcAzyRmYv9ZcozJjP/HTg2q7n9eL0b2NJh01Hg/sw8lpnPAfcD15+xQtt0qjkzv5iZJ6qHXwMuWopaFmKOfbwQC/luOSPmq7n67vpd4J/qer3lGg7DwFNtjw9Tftm+0Kc6gJ8Hzl+S6uZRDW9tAh7qsPo3IuKbEfGFiHjlkhbWWQJfjIh9EXFTh/UL+Rz6ZStz/0Nq2n4GeElmHoXWDxPAizv0afL+fiets8hOTnccLaWbq2Gwu+YYumvqPn4t8HRmHpxjfdf7eLmGQ6czgNmXZS2kz5KKiF8CPg28JzN/PGv1N2gNgfwa8DfAnqWur4OrMvMK4I3AuyPidbPWN24fA0TEWcBbgE91WN3E/bxQTd3ftwAngE/M0eV0x9FS+TvgV4FXA0dpDdPM1sh9DPwe8581dL2Pl2s4HAYubnt8EXBkrj4RsRo4h8WdZtYiItbQCoZPZObu2esz88eZ+d/V8ueBNRFxwRKXObumI9X9M8BnaJ1yt1vI59APbwS+kZlPz17RxP1ceXpmSK66f6ZDn8bt72pS/M3A27Ma/J5tAcfRksjMpzPzZGb+L/D3c9TRxH28GngrcO9cfRazj5drODwMXB4Rl1Y/JW4F9s7qsxeYuZrjBuDBuQ7eM60aL7wT+HZm/uUcfV46MycSEVfS+ux+tHRVFvX8YkS8aGaZ1uTjY7O67QV+v7pq6TXA8zNDI302509ZTdvPbdqP123AZzv0GQOui4hzqyGR66q2voiI64H3AW/JzP+Zo89CjqMlMWs+7HfmqGMh3y1L7Q3AdzLzcKeVi97HSzHL3o8brStlvkvryoJbqrZbaR2oAD9Pa1jhEPB14LI+1vpbtE5NHwUeqW5vAt4FvKvqczPwOK2rI74G/Gaf9+9lVS3frOqa2cftNQfw4eozOACMNOC4+AVaX/bntLU1aj/TCq6jwHFaP6neSGs+7AHgYHV/XtV3BPho27bvrI7pQ8Af9LnmQ7TG52eO6ZmrA9cDn5/vOOpTvR+vjtNHaX3hXzi73upx8d3Sr5qr9n+cOX7b+va8j/0NaUlSYbkOK0mSemA4SJIKhoMkqWA4SJIKhoMkqWA4SJIKhoMkqWA4SJIK/wcYgG1NU/iqmgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#利用线性模型得到权重\n",
    "from sklearn.linear_model import ElasticNet\n",
    "enet=ElasticNet(alpha=.01,l1_ratio=0.06)\n",
    "enet.fit(x, y)\n",
    "print(enet.coef_)\n",
    "plt.plot(enet.coef_,'o', label = 'linear regression')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "#开始模拟投资 读取当天的相关截面数据 预测收益率 并对股票按收益率排序\n",
    "sample3 = get_index_stocks('399951.XSHE', date=None)#股票除选择沪深300银行指数成分股\n",
    "q3 = query(valuation.code, \n",
    "          valuation.market_cap,#市值\n",
    "          valuation.circulating_market_cap,\n",
    "          balance.total_assets - balance.total_liability,#净资产\n",
    "          balance.total_assets / balance.total_liability, \n",
    "          indicator.net_profit_to_total_revenue, #净利润/营业总收入\n",
    "          indicator.inc_revenue_year_on_year,  #营业收入增长率（同比）\n",
    "          balance.development_expenditure, #RD\n",
    "          valuation.pe_ratio, #市盈率（TTM）\n",
    "          valuation.pb_ratio, #市净率（TTM）\n",
    "          indicator.inc_net_profit_year_on_year,#净利润增长率（同比）\n",
    "          balance.dividend_payable,\n",
    "          indicator.roe,\n",
    "          indicator.roa,\n",
    "          income.operating_profit / income.total_profit, #OPTP\n",
    "          indicator.gross_profit_margin, #销售毛利率GPM\n",
    "          balance.fixed_assets / balance.total_assets, #FACR\n",
    "          valuation.pcf_ratio, #CFP\n",
    "          valuation.ps_ratio #PS\n",
    "        ).filter(\n",
    "            valuation.code.in_(sample3)\n",
    "        )\n",
    "df = get_fundamentals(q3,date=None)\n",
    "df.index = df.code.values\n",
    "del df['code']\n",
    "df = df.fillna(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "E:\\anoconda\\envs\\tensorflow\\lib\\site-packages\\ipykernel_launcher.py:12: FutureWarning: by argument to sort_index is deprecated, please use .sort_values(by=...)\n",
      "  if sys.path[0] == '':\n"
     ]
    }
   ],
   "source": [
    "#实现预测+排序\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn import preprocessing\n",
    "min_max_scaler = preprocessing.MinMaxScaler()\n",
    "df1=min_max_scaler.fit_transform(df)\n",
    "df2 = pd.DataFrame(df1, columns=df.columns,index=df.index)\n",
    "x=df2\n",
    "factor = pd.DataFrame(lr.predict(x), index = df.index, columns = ['monthreturn'])\n",
    "factor = factor.sort_index(by = 'monthreturn')#做了个排序\n",
    "stockset = list(factor.index[:10])#选排名前十的股票"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['600036.XSHG',\n",
       " '002142.XSHE',\n",
       " '601838.XSHG',\n",
       " '601009.XSHG',\n",
       " '601166.XSHG',\n",
       " '601997.XSHG',\n",
       " '601577.XSHG',\n",
       " '601229.XSHG',\n",
       " '600928.XSHG',\n",
       " '600926.XSHG']"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stockset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.5.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}