AlphaNet_v1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import torch\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from torch import nn\n",
    "from datetime import datetime\n",
    "import matplotlib.pyplot as plt\n",
    "from torchvision import datasets\n",
    "from collections import OrderedDict\n",
    "from sklearn.model_selection import KFold\n",
    "from torchvision.transforms import ToTensor\n",
    "from torch.utils.data import DataLoader,Dataset\n",
    "from torch_intermediate_layer_getter import IntermediateLayerGetter as MidGetter\n",
    "os.environ['CUDA_LAUNCH_BLOCKING'] = '1'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DATA\n",
    "- input X: data \"images\" that contains stocks' information such as open, high, low, close, vwap, volume, return1, turn, free_turn, in a given time interval\n",
    "- label Y: the normalized return of the input stock in the given time interval"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalize(y):\n",
    "    y_norm = np.empty((y.shape))\n",
    "    for i in range(len(y)):\n",
    "        return_ = y[i]\n",
    "        mean_   = np.nanmean(return_)\n",
    "        std_    = np.nanstd(return_)\n",
    "        y_norm[i] = (return_-mean_) / std_\n",
    "    return y_norm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_dataset():\n",
    "    '''\n",
    "    load 数据并使时间成为第一个维度\n",
    "    '''\n",
    "    X_5  = np.load('x5.npy')\n",
    "    X_10 = np.load('x10.npy')\n",
    "    Y_5  = np.load('y5.npy')\n",
    "    Y_10 = np.load('y10.npy')\n",
    "    ts_code_list = np.load('ts_code_list.npy')\n",
    "    sample_date = X_5[:,0,:,0,-1] # 采样日期\n",
    "    sample_date = [datetime.strptime(str(int(item)),\"%Y%m%d\") for item in sample_date]\n",
    "    X_5  = X_5[:,:,:,1:,:]\n",
    "    X_10 = X_10[:,:,:,1:,:]\n",
    "    return X_5, X_10, Y_5, Y_10, sample_date, ts_code_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_layer_stride = 10\n",
    "pooling_layer_stride = 3\n",
    "batch_size           = 1000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feature Extract Layer Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generateC(n):\n",
    "    '''\n",
    "    生成组合数数对\n",
    "    '''\n",
    "    pair = []\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            if all([i!=j,i<j]):\n",
    "                pair.append([i,j])\n",
    "    return pair\n",
    "\n",
    "def ts_corr(X,pairs,d=10,stride=10):\n",
    "    \"\"\"\n",
    "    过去d天X值构成的时序数列和Y值构成的时序数列的相关系数\n",
    "    corr = cov(X,Y) / ( std(X) * std(Y) )\n",
    "    \"\"\"\n",
    "    shape1,shape2,shape3,shape4,shape5 = X.shape\n",
    "    all_corr = np.empty((shape1,shape2,shape3,len(pairs),3))\n",
    "    X_ = np.reshape(X,(shape1,shape2,shape3,shape4,-1,stride))\n",
    "    mean = np.mean(X_,axis=-1,keepdims=True)\n",
    "    std  = np.std(X_,axis=-1,keepdims=True)\n",
    "    x_center = X_ - mean\n",
    "    for i, pair in enumerate(pairs):\n",
    "        x_idx,y_idx = pair[0],pair[1]\n",
    "        x = x_center[:,:,:,x_idx:x_idx+1,...]\n",
    "        y = x_center[:,:,:,y_idx:y_idx+1,...]\n",
    "        x_std = std[:,:,:,x_idx:x_idx+1,...]\n",
    "        y_std = std[:,:,:,y_idx:y_idx+1,...]\n",
    "        cov = np.sum(x*y,axis=-1,keepdims=True) / d\n",
    "        corr = (cov / (x_std*y_std))[:,:,:,:,:,0]\n",
    "        all_corr[:,:,:,i:i+1,:] = corr\n",
    "    return all_corr\n",
    "\n",
    "def ts_cov(X,pairs,d=10,stride=10):\n",
    "    \"\"\"\n",
    "    过去d天X值构成的时序数列和Y值构成的时序数列的协方差\n",
    "    Sum( (X-mean(X)) * (Y-mean(Y)) ) / # of time segment\n",
    "    \"\"\"\n",
    "    shape1,shape2,shape3,shape4,shape5 = X.shape\n",
    "    all_cov = np.empty((shape1,shape2,shape3,len(pairs),3))\n",
    "    X_ = np.reshape(X,(shape1,shape2,shape3,shape4,-1,stride))\n",
    "    mean = np.mean(X_,axis=-1,keepdims=True)\n",
    "    x_center = X_ - mean\n",
    "    for i, pair in enumerate(pairs):\n",
    "        x_idx,y_idx = pair[0],pair[1]\n",
    "        x = x_center[:,:,:,x_idx:x_idx+1,...]\n",
    "        y = x_center[:,:,:,y_idx:y_idx+1,...]\n",
    "        cov = np.sum(x*y,axis=-1) / d\n",
    "        all_cov[:,:,:,i:i+1,:] = cov\n",
    "    return all_cov\n",
    "\n",
    "def ts_stddev(X,d=10,stride=10):\n",
    "    \"\"\"\n",
    "    过去 d 天 X 值构成的时序数列的标准差\n",
    "    \"\"\"\n",
    "    shape1,shape2,shape3,shape4,shape5 = X.shape\n",
    "    X_ = np.reshape(X,(shape1,shape2,shape3,shape4,-1,stride))\n",
    "    std  = np.std(X_,axis=-1)\n",
    "    return std\n",
    "\n",
    "def ts_zscore(X,d=10,stride=10):\n",
    "    \"\"\"\n",
    "    过去 d 天 X 值构成的时序数列的平均值除以标准差。\n",
    "    \"\"\"\n",
    "    shape1,shape2,shape3,shape4,shape5 = X.shape\n",
    "    X_ = np.reshape(X,(shape1,shape2,shape3,shape4,-1,stride))\n",
    "    mean = np.mean(X_,axis=-1)\n",
    "    std  = np.std(X_,axis=-1)\n",
    "    zscore = mean / (std+1e-5)\n",
    "    return zscore\n",
    "\n",
    "def ts_return(X,d=10,stride=10):\n",
    "    \"\"\"\n",
    "    (X - delay(X, d))/delay(X, d)-1, delay(X, d)为 X 在 d 天前的取值。\n",
    "    \"\"\"\n",
    "    shape1,shape2,shape3,shape4,shape5 = X.shape\n",
    "    X_ = np.reshape(X,(shape1,shape2,shape3,shape4,-1,stride))\n",
    "    x = X_[:,:,:,:,:,-1:]\n",
    "    delay = X_[:,:,:,:,:,0:1]\n",
    "    return_ = (x-delay) / (delay-1)\n",
    "    return return_.reshape(shape1,shape2,shape3,shape4,-1)\n",
    "\n",
    "def ts_decaylinear(X,d=10,stride=10):\n",
    "    \"\"\"\n",
    "    过去 d 天 X 值构成的时序数列的加权平均值，权数为 d, d – 1, …, 1(权数之和应为 1，需进行归一化处理)，\n",
    "    其中离现在越近的日子权数越大\n",
    "    \"\"\"\n",
    "    shape1,shape2,shape3,shape4,shape5 = X.shape\n",
    "    X_ = np.reshape(X,(shape1,shape2,shape3,shape4,-1,stride))\n",
    "    weight = np.arange(1,d+1)\n",
    "    weight = (weight / np.sum(weight)).reshape(1,-1)\n",
    "    decaylinear = np.sum(X_*weight,axis=-1) / np.sum(weight)\n",
    "    return decaylinear\n",
    "\n",
    "def ts_mean(X,d=10,stride=10):\n",
    "    \"\"\"\n",
    "    过去 d 天 X 值构成的时序数列之和\n",
    "    \"\"\"\n",
    "    shape1,shape2,shape3,shape4,shape5 = X.shape\n",
    "    X_ = np.reshape(X,(shape1,shape2,shape3,shape4,-1,stride))\n",
    "    mean = np.mean(X_,axis=-1)\n",
    "    return mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def feature_extract(input_):\n",
    "    '''\n",
    "    param: data image\n",
    "    return: feature layer\n",
    "    '''\n",
    "    pairs = generateC(9)\n",
    "    ts_corr10        = ts_corr(input_,pairs)\n",
    "    ts_cov10         = ts_cov(input_,pairs)\n",
    "    ts_stddev10      = ts_stddev(input_)\n",
    "    ts_zscore10      = ts_zscore(input_)\n",
    "    ts_return10      = ts_return(input_)\n",
    "    ts_decaylinear10 = ts_decaylinear(input_)\n",
    "    ts_mean10        = ts_mean(input_)\n",
    "    feature_layer = np.concatenate((ts_corr10,ts_cov10,ts_stddev10,ts_zscore10,ts_return10,ts_decaylinear10,ts_mean10),axis=3)\n",
    "    return feature_layer\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def replace_nan_w_zero(x,y):\n",
    "    nan_idx = (x != x).nonzero()\n",
    "    date  = nan_idx[0]\n",
    "    stock = nan_idx[1]\n",
    "    date_stock_pair = [p for p in zip(date,stock) if None not in p]\n",
    "    date_stock_pair = list(set(date_stock_pair))\n",
    "    date_stock_pair = sorted(date_stock_pair,key=lambda tup:(tup[0],tup[1]))\n",
    "    for idx in date_stock_pair:\n",
    "        x[idx] = 0\n",
    "        y[idx] = 0\n",
    "    return x,y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess_input(x,y):\n",
    "    '''\n",
    "    feature extract后, BN前的输入\n",
    "    '''\n",
    "    x = feature_extract(x)\n",
    "    x,y = replace_nan_w_zero(x,y)\n",
    "    shape1,shape2,shape3,shape4,shape5 = x.shape\n",
    "    x = np.reshape(x,(-1,shape3,shape4,shape5))\n",
    "    y = np.reshape(y,(-1,shape3))\n",
    "    return x, y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get dataloader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def shuffle_dataset(x,y):\n",
    "    idx = np.arange(len(x))\n",
    "    np.random.shuffle(idx)\n",
    "    x = x[idx]\n",
    "    y = y[idx]\n",
    "    return x,y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "class alphanet_dataset(Dataset):\n",
    "    def __init__(self,data,label):\n",
    "        self.data = torch.from_numpy(data)\n",
    "        self.label = torch.from_numpy(label)\n",
    "    def __getitem__(self,index):\n",
    "        return self.data[index],self.label[index]\n",
    "    def __len__(self):\n",
    "        return len(self.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalize_input(x):\n",
    "    mean = np.nanmean(x,axis=(3,4))[...,np.newaxis,np.newaxis]\n",
    "    std  = np.nanstd(x,axis=(3,4))[...,np.newaxis,np.newaxis]\n",
    "    norm = (x - mean) / (std + 1e-5)\n",
    "    return norm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\vnstudio\\lib\\site-packages\\ipykernel_launcher.py:2: RuntimeWarning: Mean of empty slice\n",
      "  \n",
      "C:\\Users\\Administrator\\AppData\\Roaming\\Python\\Python37\\site-packages\\numpy\\lib\\nanfunctions.py:1671: RuntimeWarning: Degrees of freedom <= 0 for slice.\n",
      "  keepdims=keepdims)\n",
      "c:\\vnstudio\\lib\\site-packages\\ipykernel_launcher.py:5: RuntimeWarning: Mean of empty slice\n",
      "  \"\"\"\n"
     ]
    }
   ],
   "source": [
    "X_5, X_10, Y_5, Y_10, sample_date, ts_code_list = load_dataset()\n",
    "# normalize label\n",
    "# print(X_5[-3,500])\n",
    "X_5 = normalize_input(X_5)\n",
    "X_10 = normalize_input(X_10)\n",
    "Y_norm5  = normalize(Y_5)\n",
    "Y_norm10 = normalize(Y_10)\n",
    "dev_idx   = int(len(sample_date)*0.5)\n",
    "\n",
    "x_train5 = X_5[:dev_idx]\n",
    "y_train5 = Y_norm5[:dev_idx]\n",
    "x_train10 = X_10[:dev_idx]\n",
    "y_train10 = Y_norm10[:dev_idx]\n",
    "\n",
    "x_dev5 = X_5[dev_idx:]\n",
    "y_dev5 = Y_norm5[dev_idx:]\n",
    "x_dev10 = X_10[dev_idx:]\n",
    "y_dev10 = Y_norm10[dev_idx:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(543, 583, 1, 9, 30)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_5.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_dataloader(x,y,shuffle):\n",
    "    # if shuffle:\n",
    "    #     x,y = shuffle_dataset(x,y)\n",
    "    x_,y_ = preprocess_input(x,y)\n",
    "    dataset = alphanet_dataset(x_,y_)\n",
    "    dataloader = DataLoader(dataset,batch_size=583*2,shuffle=False)\n",
    "    return dataloader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# train dataloader\n",
    "tr_loader5   = get_dataloader(x_train5,y_train5,True)\n",
    "tr_loader10  = get_dataloader(x_train10,y_train10,True)\n",
    "\n",
    "dev_loader5  = get_dataloader(x_dev5,y_dev5,False)\n",
    "dev_loader10 = get_dataloader(x_dev10,y_dev10,False)\n",
    "\n",
    "# te_loader5,te_nan5   = get_dataloader(x_test5,y_test5,False)\n",
    "# te_loader10,te_nan10 = get_dataloader(x_test10,y_test10,False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "wholeloader5 = get_dataloader(X_5,Y_norm5,False)\n",
    "wholeloader10 = get_dataloader(X_10,Y_norm10,False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2020年开始\n",
    "wholeloader2020 = get_dataloader(X_5[473:],Y_norm5[473:],False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AlphaNet(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(AlphaNet,self).__init__()\n",
    "        self.bn1 = nn.BatchNorm2d(117)\n",
    "        self.bn2 = nn.BatchNorm2d(351)\n",
    "\n",
    "        self.maxpool = nn.MaxPool2d(kernel_size=(1,3))\n",
    "        self.avgpool = nn.AvgPool2d(kernel_size=(1,3))\n",
    "        self.minpool = nn.MaxPool2d(kernel_size=(1,3))\n",
    "\n",
    "        self.flatten1 = nn.Flatten(start_dim=1)\n",
    "        self.flatten2 = nn.Flatten(start_dim=1)\n",
    "        self.fc      = nn.Linear(702,30)\n",
    "        self.dropout = nn.Dropout(0.5)\n",
    "        self.relu    = nn.ReLU()\n",
    "        self.output  = nn.Linear(30,1)\n",
    "        self._init_weight()\n",
    "\n",
    "    def _init_weight(self):\n",
    "        nn.init.trunc_normal_(self.fc.weight)\n",
    "        nn.init.trunc_normal_(self.output.weight)\n",
    "        nn.init.trunc_normal_(self.fc.bias)\n",
    "        nn.init.trunc_normal_(self.output.bias)\n",
    "\n",
    "    def forward(self,input_):\n",
    "        feature = self.bn1(input_)\n",
    "        maxpool = self.maxpool(feature)\n",
    "        avgpool = self.avgpool(feature)\n",
    "        minpool = -self.maxpool(-1*feature)\n",
    "        pool_feature = torch.cat((maxpool,avgpool,minpool),axis=1)\n",
    "        pool_feature = self.bn2(pool_feature)\n",
    "\n",
    "        feature_flatten      = self.flatten1(feature)\n",
    "        pool_feature_flatten = self.flatten2(pool_feature)\n",
    "        output_ = torch.hstack([feature_flatten,pool_feature_flatten])\n",
    "\n",
    "        output_       = self.fc(output_)\n",
    "        output_       = self.relu(output_)\n",
    "        output_       = self.dropout(output_)\n",
    "        output_       = self.output(output_)\n",
    "        return output_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Train & Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "learning_rate        = 0.0001\n",
    "early_stopping       = 10\n",
    "\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "model = AlphaNet().to(device)\n",
    "loss_fn = nn.MSELoss()\n",
    "optimizer = torch.optim.RMSprop(model.parameters(),lr=learning_rate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(trainloader, devloader, model, loss_fn, optimizer, path):\n",
    "\n",
    "    min_valid_loss = np.inf\n",
    "    cnt = 0\n",
    "    save_model = False\n",
    "    epochs = 400\n",
    "\n",
    "    train_loss_list = []\n",
    "    eval_loss_list = []\n",
    "    for epoch in range(epochs):\n",
    "        optimizer = torch.optim.RMSprop(model.parameters(),lr=0.00001)\n",
    "\n",
    "        print('\\nEpoch {} / {}'.format(epoch+1,epochs))\n",
    "        model.train()\n",
    "        train_loss = 0.0\n",
    "        for data,label in trainloader:\n",
    "            data = np.transpose(data,(0,2,1,3))\n",
    "            data,label = data.to(device),label.to(device) \n",
    "            pred = model(data.float())\n",
    "\n",
    "            loss = loss_fn(pred,label.float())\n",
    "            train_loss += loss\n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "        train_loss_list.append(train_loss.item()/len(trainloader))\n",
    "        model.eval()\n",
    "        eval_loss = 0.0\n",
    "        for data,label in devloader:\n",
    "            data = np.transpose(data,(0,2,1,3))\n",
    "            data,label = data.to(device),label.to(device) \n",
    "            pred = model(data.float())\n",
    "            loss = loss_fn(pred,label.float())\n",
    "            eval_loss += loss\n",
    "        eval_loss_list.append(eval_loss.item()/len(devloader))\n",
    "        print('train loss: ', train_loss.item()/len(trainloader),'| dev loss: ', eval_loss.item()/len(devloader))\n",
    "        if eval_loss < min_valid_loss:\n",
    "            min_valid_loss = eval_loss\n",
    "            cnt = 0\n",
    "            print('save model')\n",
    "            torch.save(model.state_dict(), path)\n",
    "            save_model = True\n",
    "        # loss没有update, increment cnt\n",
    "        cnt += 1\n",
    "        if cnt >= early_stopping and save_model == True:\n",
    "            print('early stop')\n",
    "            break\n",
    "        elif cnt >= early_stopping and save_model == False:\n",
    "            print('early stop and save model')\n",
    "            torch.save(model.state_dict(),path)\n",
    "            save_model = True\n",
    "            break\n",
    "        \n",
    "    plt.figure(figsize=(20,12))\n",
    "    plt.plot(train_loss_list,label='train loss')\n",
    "    plt.plot(eval_loss_list,label='dev loss')\n",
    "    plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "# train(x_tr5,y_tr5,model,loss_fn,optimizer)\n",
    "path = './model_param.pth'\n",
    "path5 = './model_param5.pth'\n",
    "path10 = './model_param10.pth'\n",
    "\n",
    "good_model_path = './model_param_v2.pth'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 1 / 400\n"
     ]
    },
    {
     "ename": "RuntimeError",
     "evalue": "CUDA out of memory. Tried to allocate 20.00 MiB (GPU 0; 4.00 GiB total capacity; 2.99 GiB already allocated; 0 bytes free; 3.44 GiB reserved in total by PyTorch) If reserved memory is >> allocated memory try setting max_split_size_mb to avoid fragmentation.  See documentation for Memory Management and PYTORCH_CUDA_ALLOC_CONF",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-57-0c4a65208e10>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mtrain\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtr_loader5\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mdev_loader5\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mmodel\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mloss_fn\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0moptimizer\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mpath5\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-55-8bfea0f3309b>\u001b[0m in \u001b[0;36mtrain\u001b[1;34m(trainloader, devloader, model, loss_fn, optimizer, path)\u001b[0m\n\u001b[0;32m     16\u001b[0m         \u001b[1;32mfor\u001b[0m \u001b[0mdata\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mlabel\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mtrainloader\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     17\u001b[0m             \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtranspose\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 18\u001b[1;33m             \u001b[0mdata\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mlabel\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mto\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mlabel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mto\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     19\u001b[0m             \u001b[0mpred\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfloat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     20\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mRuntimeError\u001b[0m: CUDA out of memory. Tried to allocate 20.00 MiB (GPU 0; 4.00 GiB total capacity; 2.99 GiB already allocated; 0 bytes free; 3.44 GiB reserved in total by PyTorch) If reserved memory is >> allocated memory try setting max_split_size_mb to avoid fragmentation.  See documentation for Memory Management and PYTORCH_CUDA_ALLOC_CONF"
     ]
    }
   ],
   "source": [
    "train(tr_loader5,dev_loader5,model,loss_fn,optimizer,path5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torchsummary import summary\n",
    "# summary(model,( 117,1, 3))\n",
    "# model.fc.weight.grad#, model.output.weight.grad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def layering(alpha,origin, sample_date):\n",
    "    layer_size = 5\n",
    "    layer=[[] for i in range(layer_size)]\n",
    "    alpha = np.nan_to_num(alpha)\n",
    "    for i in range(len(alpha)):\n",
    "        alpha_daily = pd.DataFrame(alpha[i,...],columns=['return']) # 每天每股因子值\n",
    "        alpha_daily = alpha_daily.sort_values(by='return',ascending=False,na_position='last') # 按照因子值排序\n",
    "        rank_idx = list(alpha_daily.index)\n",
    "        return_daily = pd.DataFrame(origin[i,...],columns=['return'])\n",
    "        return_daily = return_daily.reindex(rank_idx)\n",
    "        return_daily_cent = return_daily - return_daily.mean()\n",
    "        split = np.array_split(return_daily_cent,layer_size) # 分层\n",
    "        for j in range(layer_size):\n",
    "            mean_ = split[j]['return'].mean()\n",
    "            layer[j].append(mean_)\n",
    "\n",
    "    for i in range(layer_size):\n",
    "        layer[i] = np.nancumsum(layer[i])\n",
    "    plt.figure(figsize=(20,10))\n",
    "    plt.plot(sample_date,layer[0],label = \"top\")\n",
    "    # plt.plot(sample_date,layer[1],label = \"m1\")\n",
    "    # plt.plot(sample_date,layer[2],label = \"m2\")\n",
    "    # plt.plot(sample_date,layer[3],label = \"m3\")\n",
    "    plt.plot(sample_date,layer[4],label = \"bot\")\n",
    "    plt.legend()\n",
    "    return\n",
    "\n",
    "def RankIC_mean_std(original,pred,sample_date):\n",
    "    rankic = []\n",
    "    for i in range(len(original)): # 每个截面\n",
    "        ori_cross = original[i]\n",
    "        pred_cross = pred[i]\n",
    "        rankic.append(pd.DataFrame([ori_cross.reshape(-1),pred_cross.reshape(-1)]).T.corr(method='spearman').iloc[0,1])\n",
    "    rankic_mean = np.nanmean(rankic)\n",
    "    rankic_std = np.nanstd(rankic)\n",
    "    rankic_cumsum = np.nancumsum(rankic)\n",
    "    plt.figure(figsize=(20,10))\n",
    "    plt.plot(sample_date,rankic_cumsum,label='rankic')\n",
    "    plt.legend()\n",
    "    return rankic_mean,rankic_std,rankic_cumsum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(testloader,origin,sample_date,model, loss_fn):\n",
    "    model.eval()\n",
    "    test_loss_list = []\n",
    "    alpha = []\n",
    "    with torch.no_grad():\n",
    "        test_loss = 0.0\n",
    "        for data,label in testloader:\n",
    "            data = np.transpose(data,(0,2,1,3))\n",
    "            data,label = data.to(device),label.to(device) \n",
    "            pred = model(data.float())\n",
    "            loss = loss_fn(pred,label.float())\n",
    "            test_loss += loss\n",
    "            alpha.append(pred.cpu().numpy())\n",
    "            return_layer = {\n",
    "                'bn1':'bn1',\n",
    "                'bn2':'bn2',\n",
    "                'flatten1':'flatten1',\n",
    "                'flatten2':'flatten2',\n",
    "                'fc':'fc',\n",
    "                # 'relu':'relu',\n",
    "                # 'output':'output'\n",
    "            }\n",
    "            mid_getter = MidGetter(model,return_layers=return_layer,keep_output=True)\n",
    "            mid_outputs, model_output = mid_getter(data.float())\n",
    "            # print(mid_outputs['bn1'][:,0,:,:].nanmean())\n",
    "            # print(mid_outputs['flatten2'].shape)\n",
    "            # print(mid_outputs['fc'].shape)\n",
    "            # print(model_output)\n",
    "        test_loss_list.append(test_loss.item()/len(testloader))\n",
    "        print('test loss: ', test_loss.item()/len(testloader))\n",
    "    arr = np.vstack(alpha)\n",
    "    # pred = reconstruct_alpha(arr,origin,nan_pair)\n",
    "    pred = np.reshape(arr,(-1,583,1))\n",
    "    rankic_mean,rankic_std,rankic_cumsum = RankIC_mean_std(origin,pred,sample_date)\n",
    "    print('RankIC mean: {} | RankIC std {}'.format(rankic_mean,rankic_std))\n",
    "    layering(pred,origin, sample_date)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## test for 5天调仓周期"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test loss:  1.4322370228014494\n",
      "RankIC mean: 0.09871033400547406 | RankIC std 0.11650199936952975\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# model.load_state_dict(torch.load('./model_rankic_correct.pth'))\n",
    "model.load_state_dict(torch.load(path5))\n",
    "\n",
    "# test(te_loader5,Y_5[test_idx:],te_nan5,sample_date[test_idx:],model,loss_fn)\n",
    "test(wholeloader2020,Y_5[473:],sample_date[473:],model,loss_fn)\n",
    "# test(wholeloader5,Y_5,sample_date,model,loss_fn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.load_state_dict(torch.load(path5))\n",
    "test(wholeloader5,Y_5,sample_date,model,loss_fn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.load_state_dict(torch.load('./model_rankic_correct.pth'))\n",
    "param_dict = {}\n",
    "for name,param in model.named_parameters():\n",
    "    if param.requires_grad:\n",
    "        param_dict[name] = param.data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def batchnorm(x,param_dict,model):\n",
    "    x = x.cpu().numpy()\n",
    "    channel_mean = np.nanmean(x,axis=(0,2,3)).reshape(-1,1)\n",
    "    channel_std  = np.nanstd(x,axis=(0,2,3)).reshape(-1,1)\n",
    "    # channel_var = np.power(np.nanstd(x,axis=(0,2,3)),2)\n",
    "    bn1_weight = param_dict['bn1.weight'].cpu().numpy().reshape(-1,1) # 117\n",
    "    bn1_bias = param_dict['bn1.bias'].cpu().numpy().reshape(-1,1)     # 117\n",
    "    bn = ((np.squeeze(x)-channel_mean) /(channel_std+1e-5)) * bn1_weight + bn1_bias\n",
    "    # bn = ((np.squeeze(x)-model.bn1.running_mean.cpu().numpy().reshape(-1,1)) /(np.power(model.bn1.running_var.cpu().numpy().reshape(-1,1),0.5)+1e-5)) * bn1_weight + bn1_bias\n",
    "    return bn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\vnstudio\\lib\\site-packages\\ipykernel_launcher.py:14: RuntimeWarning: Mean of empty slice\n",
      "  \n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def test_(x,model,loss_fn):\n",
    "    model.eval()\n",
    "    alpha_list = []\n",
    "    with torch.no_grad():\n",
    "        x = np.transpose(x,(0,2,1,3))\n",
    "        x = torch.from_numpy(x)\n",
    "        x = x.to(device)\n",
    "        pred = model(x.float())\n",
    "        alpha_list.append(pred.cpu().numpy())\n",
    "    alpha = np.vstack(alpha_list)\n",
    "    # print(alpha)\n",
    "    test_layering(alpha)\n",
    "    return \n",
    "# model.load_state_dict(torch.load(good_model_path))\n",
    "model.eval()\n",
    "x829  = np.load('x829.npy')\n",
    "# x92 = X_5[-3]\n",
    "# x92 = x92[np.newaxis,...]\n",
    "# print(x92.shape)\n",
    "\n",
    "# y92  = np.load('y92.npy')\n",
    "x829 = x829[np.newaxis,:,np.newaxis,1:,:]\n",
    "# print(x92[0,500])\n",
    "\n",
    "x829 = normalize_input(x829)\n",
    "# x724 = normalize_input(X_5[-3][np.newaxis,...])\n",
    "# diff_idx = (X_5[-3][np.newaxis,...] != x724).nonzero()\n",
    "# diff = list(np.setdiff1d(x724.reshape(-1),X_5[-3].reshape(-1)))\n",
    "# # print(len(diff))\n",
    "# diff_pair = [p for p in zip(diff_idx[0],diff_idx[1],diff_idx[2],diff_idx[3]) if None not in p]\n",
    "# diff_pair = list(set(diff_pair))\n",
    "# print(diff_pair)\n",
    "\n",
    "# y92 = y92[np.newaxis,...]\n",
    "x_feature = feature_extract(x829)\n",
    "x_feature = np.reshape(x_feature,(-1,1,117,3))\n",
    "test_(x_feature,model,loss_fn)\n",
    "x = torch.from_numpy(x_feature)\n",
    "x = np.transpose(x,(0,2,1,3))\n",
    "x = x.to(device)\n",
    "return_layer = { ## layer to read\n",
    "    'bn1':'bn1',\n",
    "    'bn2':'bn2',\n",
    "    'maxpool':'maxpool',\n",
    "    'avgpool':'avgpool',\n",
    "    'minpool':'minpool',\n",
    "    'flatten1':'flatten1',\n",
    "    'flatten2':'flatten2',\n",
    "    'fc':'fc',\n",
    "    'relu':'relu',\n",
    "    'output':'output'\n",
    "}\n",
    "# # 得到中间layer的结果\n",
    "mid_getter = MidGetter(model,return_layers=return_layer,keep_output=True)\n",
    "mid_outputs, model_output = mid_getter(x.float())\n",
    "# flatten_layer = torch.cat((mid_outputs['flatten1'],mid_outputs['flatten2']),axis=1)\n",
    "# fc_layer = torch.inner(flatten_layer,param_dict['fc.weight'])# + param_dict['fc.bias']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2020, 7, 24, 0, 0)"
      ]
     },
     "execution_count": 311,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x5tmp = X_5[-3][np.newaxis,...]\n",
    "# for i in range(len(diff_pair)):\n",
    "    \n",
    "#     print(i,x5tmp[diff_pair[i]],x724[diff_pair[i]])\n",
    "# X_5[-3].shape,x724[0].shape\n",
    "# diff_pair[107]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "      <th>8</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>4.11</td>\n",
       "      <td>4.14</td>\n",
       "      <td>4.04</td>\n",
       "      <td>4.06</td>\n",
       "      <td>4.077769</td>\n",
       "      <td>17872080.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.010914</td>\n",
       "      <td>0.011669</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.10</td>\n",
       "      <td>4.15</td>\n",
       "      <td>4.05</td>\n",
       "      <td>4.06</td>\n",
       "      <td>4.081959</td>\n",
       "      <td>9543113.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.005828</td>\n",
       "      <td>0.006231</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.10</td>\n",
       "      <td>4.13</td>\n",
       "      <td>4.04</td>\n",
       "      <td>4.06</td>\n",
       "      <td>4.079227</td>\n",
       "      <td>14494916.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.008852</td>\n",
       "      <td>0.009464</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.02</td>\n",
       "      <td>4.10</td>\n",
       "      <td>3.98</td>\n",
       "      <td>4.06</td>\n",
       "      <td>4.063407</td>\n",
       "      <td>13239127.0</td>\n",
       "      <td>-0.009852</td>\n",
       "      <td>0.008085</td>\n",
       "      <td>0.008644</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4.08</td>\n",
       "      <td>4.10</td>\n",
       "      <td>4.02</td>\n",
       "      <td>4.02</td>\n",
       "      <td>4.044300</td>\n",
       "      <td>9006903.0</td>\n",
       "      <td>0.012438</td>\n",
       "      <td>0.005500</td>\n",
       "      <td>0.005881</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>4.05</td>\n",
       "      <td>4.09</td>\n",
       "      <td>4.05</td>\n",
       "      <td>4.07</td>\n",
       "      <td>4.066762</td>\n",
       "      <td>9414171.0</td>\n",
       "      <td>-0.004914</td>\n",
       "      <td>0.005749</td>\n",
       "      <td>0.006147</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>4.05</td>\n",
       "      <td>4.07</td>\n",
       "      <td>3.98</td>\n",
       "      <td>4.05</td>\n",
       "      <td>4.030943</td>\n",
       "      <td>11796314.0</td>\n",
       "      <td>0.002469</td>\n",
       "      <td>0.007204</td>\n",
       "      <td>0.007702</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>4.06</td>\n",
       "      <td>4.08</td>\n",
       "      <td>4.02</td>\n",
       "      <td>4.06</td>\n",
       "      <td>4.050609</td>\n",
       "      <td>8644420.0</td>\n",
       "      <td>0.007389</td>\n",
       "      <td>0.005279</td>\n",
       "      <td>0.005644</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>4.04</td>\n",
       "      <td>4.09</td>\n",
       "      <td>4.04</td>\n",
       "      <td>4.09</td>\n",
       "      <td>4.066936</td>\n",
       "      <td>12609606.0</td>\n",
       "      <td>-0.022005</td>\n",
       "      <td>0.007700</td>\n",
       "      <td>0.008233</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>4.09</td>\n",
       "      <td>4.13</td>\n",
       "      <td>3.99</td>\n",
       "      <td>4.00</td>\n",
       "      <td>4.052745</td>\n",
       "      <td>16522118.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.010090</td>\n",
       "      <td>0.010788</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>4.03</td>\n",
       "      <td>4.05</td>\n",
       "      <td>3.97</td>\n",
       "      <td>4.00</td>\n",
       "      <td>3.999123</td>\n",
       "      <td>11422048.0</td>\n",
       "      <td>-0.010000</td>\n",
       "      <td>0.006975</td>\n",
       "      <td>0.007458</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>4.01</td>\n",
       "      <td>4.03</td>\n",
       "      <td>3.96</td>\n",
       "      <td>3.96</td>\n",
       "      <td>3.984874</td>\n",
       "      <td>8106967.0</td>\n",
       "      <td>-0.022727</td>\n",
       "      <td>0.004951</td>\n",
       "      <td>0.005293</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>3.96</td>\n",
       "      <td>3.97</td>\n",
       "      <td>3.84</td>\n",
       "      <td>3.87</td>\n",
       "      <td>3.895048</td>\n",
       "      <td>12934839.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.007899</td>\n",
       "      <td>0.008446</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>3.90</td>\n",
       "      <td>3.90</td>\n",
       "      <td>3.85</td>\n",
       "      <td>3.87</td>\n",
       "      <td>3.868815</td>\n",
       "      <td>12901040.0</td>\n",
       "      <td>-0.005168</td>\n",
       "      <td>0.007878</td>\n",
       "      <td>0.008424</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>3.90</td>\n",
       "      <td>3.90</td>\n",
       "      <td>3.83</td>\n",
       "      <td>3.85</td>\n",
       "      <td>3.858038</td>\n",
       "      <td>14102873.0</td>\n",
       "      <td>0.028571</td>\n",
       "      <td>0.008612</td>\n",
       "      <td>0.009208</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>3.86</td>\n",
       "      <td>3.96</td>\n",
       "      <td>3.83</td>\n",
       "      <td>3.96</td>\n",
       "      <td>3.899034</td>\n",
       "      <td>20678911.0</td>\n",
       "      <td>0.101010</td>\n",
       "      <td>0.012628</td>\n",
       "      <td>0.013502</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>4.05</td>\n",
       "      <td>4.36</td>\n",
       "      <td>4.01</td>\n",
       "      <td>4.36</td>\n",
       "      <td>4.232035</td>\n",
       "      <td>78833016.0</td>\n",
       "      <td>0.061927</td>\n",
       "      <td>0.048141</td>\n",
       "      <td>0.051473</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>4.55</td>\n",
       "      <td>4.80</td>\n",
       "      <td>4.31</td>\n",
       "      <td>4.63</td>\n",
       "      <td>4.595914</td>\n",
       "      <td>98854089.0</td>\n",
       "      <td>0.017279</td>\n",
       "      <td>0.060367</td>\n",
       "      <td>0.064545</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>4.63</td>\n",
       "      <td>4.80</td>\n",
       "      <td>4.51</td>\n",
       "      <td>4.71</td>\n",
       "      <td>4.689977</td>\n",
       "      <td>70581512.0</td>\n",
       "      <td>0.033970</td>\n",
       "      <td>0.043102</td>\n",
       "      <td>0.046085</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>4.67</td>\n",
       "      <td>4.94</td>\n",
       "      <td>4.65</td>\n",
       "      <td>4.87</td>\n",
       "      <td>4.849767</td>\n",
       "      <td>59216367.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.036162</td>\n",
       "      <td>0.038664</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>4.84</td>\n",
       "      <td>4.95</td>\n",
       "      <td>4.81</td>\n",
       "      <td>4.87</td>\n",
       "      <td>4.879802</td>\n",
       "      <td>46811962.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.028587</td>\n",
       "      <td>0.030565</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>4.89</td>\n",
       "      <td>5.13</td>\n",
       "      <td>4.82</td>\n",
       "      <td>4.87</td>\n",
       "      <td>4.941834</td>\n",
       "      <td>62807030.0</td>\n",
       "      <td>0.039014</td>\n",
       "      <td>0.038354</td>\n",
       "      <td>0.041009</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>4.89</td>\n",
       "      <td>5.10</td>\n",
       "      <td>4.88</td>\n",
       "      <td>5.06</td>\n",
       "      <td>5.000056</td>\n",
       "      <td>46884257.0</td>\n",
       "      <td>-0.007905</td>\n",
       "      <td>0.028631</td>\n",
       "      <td>0.030612</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>5.11</td>\n",
       "      <td>5.19</td>\n",
       "      <td>4.95</td>\n",
       "      <td>5.02</td>\n",
       "      <td>5.054991</td>\n",
       "      <td>49111477.0</td>\n",
       "      <td>-0.037849</td>\n",
       "      <td>0.029991</td>\n",
       "      <td>0.032067</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>5.08</td>\n",
       "      <td>5.25</td>\n",
       "      <td>4.82</td>\n",
       "      <td>4.83</td>\n",
       "      <td>5.027431</td>\n",
       "      <td>79908379.0</td>\n",
       "      <td>-0.012422</td>\n",
       "      <td>0.048798</td>\n",
       "      <td>0.052175</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25</th>\n",
       "      <td>4.92</td>\n",
       "      <td>5.15</td>\n",
       "      <td>4.73</td>\n",
       "      <td>4.77</td>\n",
       "      <td>4.967387</td>\n",
       "      <td>72655536.0</td>\n",
       "      <td>-0.025157</td>\n",
       "      <td>0.044368</td>\n",
       "      <td>0.047439</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26</th>\n",
       "      <td>4.76</td>\n",
       "      <td>4.82</td>\n",
       "      <td>4.56</td>\n",
       "      <td>4.65</td>\n",
       "      <td>4.650452</td>\n",
       "      <td>51867642.0</td>\n",
       "      <td>0.098925</td>\n",
       "      <td>0.031674</td>\n",
       "      <td>0.033866</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>27</th>\n",
       "      <td>4.69</td>\n",
       "      <td>5.12</td>\n",
       "      <td>4.69</td>\n",
       "      <td>5.11</td>\n",
       "      <td>5.026958</td>\n",
       "      <td>87075347.0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.053174</td>\n",
       "      <td>0.056855</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>5.13</td>\n",
       "      <td>5.15</td>\n",
       "      <td>5.02</td>\n",
       "      <td>5.11</td>\n",
       "      <td>5.091945</td>\n",
       "      <td>43741822.0</td>\n",
       "      <td>0.029354</td>\n",
       "      <td>0.026712</td>\n",
       "      <td>0.028561</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>29</th>\n",
       "      <td>5.15</td>\n",
       "      <td>5.42</td>\n",
       "      <td>5.04</td>\n",
       "      <td>5.26</td>\n",
       "      <td>5.252883</td>\n",
       "      <td>67321603.0</td>\n",
       "      <td>-0.003802</td>\n",
       "      <td>0.041111</td>\n",
       "      <td>0.043957</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       0     1     2     3         4           5         6         7         8\n",
       "0   4.11  4.14  4.04  4.06  4.077769  17872080.0  0.000000  0.010914  0.011669\n",
       "1   4.10  4.15  4.05  4.06  4.081959   9543113.0  0.000000  0.005828  0.006231\n",
       "2   4.10  4.13  4.04  4.06  4.079227  14494916.0  0.000000  0.008852  0.009464\n",
       "3   4.02  4.10  3.98  4.06  4.063407  13239127.0 -0.009852  0.008085  0.008644\n",
       "4   4.08  4.10  4.02  4.02  4.044300   9006903.0  0.012438  0.005500  0.005881\n",
       "5   4.05  4.09  4.05  4.07  4.066762   9414171.0 -0.004914  0.005749  0.006147\n",
       "6   4.05  4.07  3.98  4.05  4.030943  11796314.0  0.002469  0.007204  0.007702\n",
       "7   4.06  4.08  4.02  4.06  4.050609   8644420.0  0.007389  0.005279  0.005644\n",
       "8   4.04  4.09  4.04  4.09  4.066936  12609606.0 -0.022005  0.007700  0.008233\n",
       "9   4.09  4.13  3.99  4.00  4.052745  16522118.0  0.000000  0.010090  0.010788\n",
       "10  4.03  4.05  3.97  4.00  3.999123  11422048.0 -0.010000  0.006975  0.007458\n",
       "11  4.01  4.03  3.96  3.96  3.984874   8106967.0 -0.022727  0.004951  0.005293\n",
       "12  3.96  3.97  3.84  3.87  3.895048  12934839.0  0.000000  0.007899  0.008446\n",
       "13  3.90  3.90  3.85  3.87  3.868815  12901040.0 -0.005168  0.007878  0.008424\n",
       "14  3.90  3.90  3.83  3.85  3.858038  14102873.0  0.028571  0.008612  0.009208\n",
       "15  3.86  3.96  3.83  3.96  3.899034  20678911.0  0.101010  0.012628  0.013502\n",
       "16  4.05  4.36  4.01  4.36  4.232035  78833016.0  0.061927  0.048141  0.051473\n",
       "17  4.55  4.80  4.31  4.63  4.595914  98854089.0  0.017279  0.060367  0.064545\n",
       "18  4.63  4.80  4.51  4.71  4.689977  70581512.0  0.033970  0.043102  0.046085\n",
       "19  4.67  4.94  4.65  4.87  4.849767  59216367.0  0.000000  0.036162  0.038664\n",
       "20  4.84  4.95  4.81  4.87  4.879802  46811962.0  0.000000  0.028587  0.030565\n",
       "21  4.89  5.13  4.82  4.87  4.941834  62807030.0  0.039014  0.038354  0.041009\n",
       "22  4.89  5.10  4.88  5.06  5.000056  46884257.0 -0.007905  0.028631  0.030612\n",
       "23  5.11  5.19  4.95  5.02  5.054991  49111477.0 -0.037849  0.029991  0.032067\n",
       "24  5.08  5.25  4.82  4.83  5.027431  79908379.0 -0.012422  0.048798  0.052175\n",
       "25  4.92  5.15  4.73  4.77  4.967387  72655536.0 -0.025157  0.044368  0.047439\n",
       "26  4.76  4.82  4.56  4.65  4.650452  51867642.0  0.098925  0.031674  0.033866\n",
       "27  4.69  5.12  4.69  5.11  5.026958  87075347.0  0.000000  0.053174  0.056855\n",
       "28  5.13  5.15  5.02  5.11  5.091945  43741822.0  0.029354  0.026712  0.028561\n",
       "29  5.15  5.42  5.04  5.26  5.252883  67321603.0 -0.003802  0.041111  0.043957"
      ]
     },
     "execution_count": 313,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x5tmp[0,145]\n",
    "pd.DataFrame(X_5[-4,145,0].T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## train and test for 10天调仓周期"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train(tr_loader10,dev_loader10,model,loss_fn,optimizer,path10)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "28088\n",
      "28088\n",
      "RankIC mean: 0.1053174917082928 | RankIC std 0.11199283106099467\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# model.load_state_dict(torch.load(path10))\n",
    "\n",
    "test(te_loader10,Y_10[test_idx:],te_nan10,sample_date[test_idx:],model,loss_fn)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3977\n"
     ]
    }
   ],
   "source": [
    "print(len(te_nan10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.DataFrame([original.reshape(-1),new.detach().numpy().reshape(-1)]).T.corr(method='spearman').iloc[0,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.1 64-bit (system)",
   "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.1"
  },
  "vscode": {
   "interpreter": {
    "hash": "5a98bc0709bb551cb0b40a68bfcb118c11ed773779c4b4ca5eb3852e4a8f5446"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}