model.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 导模块"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module 'MyPrepaData' from 'D:\\\\python_programming\\\\jupyter\\\\再分析的预测2\\\\MyPrepaData.py'>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "from MyEvalCriteria import mae,rmse,corr,KGE,ia,BHV\n",
    "\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.neural_network import MLPRegressor\n",
    "from sklearn.metrics import  mean_absolute_error \n",
    "\n",
    "import pickle\n",
    "\n",
    "from imp import reload\n",
    "import MyPrepaData\n",
    "reload(MyPrepaData)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1722\n"
     ]
    }
   ],
   "source": [
    "# 计算阈值\n",
    "data = pd.read_csv('2011-2018再分析和流量数据.csv',index_col=0)\n",
    "d1 = list(data.Q.sort_values(ascending=False).values)\n",
    "a = len(d1)\n",
    "# plt.vlines(ymin=0,ymax=6000,x=a*0.2)\n",
    "# plt.plot(d1)\n",
    "print(d1[int(a*0.2)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 准备数据\n",
    "data = pd.read_csv('2011-2018再分析和流量数据.csv',index_col=0)\n",
    "micQ1 = pd.read_excel('result.xls',index_col=1,header=None)\n",
    "reanalysis = micQ1.index[:8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['stl3', 'd2m', 'tcwv', 'tcw', 'stl2', 'mn2t', 'tsn', 'stl4'], dtype='object', name=1)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reanalysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcAllEC(y_true,y_fore):\n",
    "    return ['%.4f' % mae(y_true, y_fore),\n",
    "            '%.4f' % rmse(y_true, y_fore),\n",
    "            '%.4f' % corr(y_true, y_fore),\n",
    "            '%.4f' % KGE(y_true, y_fore),\n",
    "            '%.4f' % BHV(y_true, y_fore),\n",
    "            '%.4f' % ia(y_true, y_fore),]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def readdata(leadtime):\n",
    "    para = pd.read_csv('leadtime%d_lbfgs_self.csv' % leadtime, index_col=0, header=[0, 1, 2])\n",
    "\n",
    "    idx = pd.IndexSlice\n",
    "    logistic_test_mae = para.loc[:, idx[:, ['logistic'], 'test_mae']]\n",
    "    tanh_test_mae = para.loc[:, idx[:, ['tanh'], 'test_mae']]\n",
    "    identity_test_mae = para.loc[:, idx[:, ['identity'], 'test_mae']]\n",
    "    relu_test_mae = para.loc[:, idx[:, ['relu'], 'test_mae']]\n",
    "    logistic_test_mae.columns = range(2, 21, 1)\n",
    "    tanh_test_mae.columns = range(2, 21, 1)\n",
    "    identity_test_mae.columns = range(2, 21, 1)\n",
    "    relu_test_mae.columns = range(2, 21, 1)\n",
    "    df = None\n",
    "    for i in logistic_test_mae:\n",
    "        df_temp = pd.DataFrame(logistic_test_mae[i].iloc[:-2].values, columns=['MAE'])\n",
    "        df_temp['Activation function'] = ['logistic' for k in range(df_temp.shape[0])]\n",
    "        df_temp['Number of nodes'] = [i for k in range(df_temp.shape[0])]\n",
    "\n",
    "        df_temp1 = pd.DataFrame(tanh_test_mae[i].iloc[:-2].values, columns=['MAE'])\n",
    "        df_temp1['Activation function'] = ['tanh' for k in range(df_temp1.shape[0])]\n",
    "        df_temp1['Number of nodes'] = [i for k in range(df_temp1.shape[0])]\n",
    "\n",
    "        df_temp2 = pd.DataFrame(identity_test_mae[i].iloc[:-2].values, columns=['MAE'])\n",
    "\n",
    "        df_temp2['Activation function'] = ['identity' for k in range(df_temp2.shape[0])]\n",
    "        df_temp2['Number of nodes'] = [i for k in range(df_temp2.shape[0])]\n",
    "\n",
    "        df_temp3 = pd.DataFrame(relu_test_mae[i].iloc[:-2].values, columns=['MAE'])\n",
    "        df_temp3['Activation function'] = ['relu' for k in range(df_temp3.shape[0])]\n",
    "        df_temp3['Number of nodes'] = [i for k in range(df_temp3.shape[0])]\n",
    "        if df is None:\n",
    "            df = pd.concat([df_temp, df_temp1, df_temp2, df_temp3], axis=0)\n",
    "        else:\n",
    "            df = pd.concat([df, df_temp, df_temp1, df_temp2, df_temp3], axis=0)\n",
    "    df['MAE'] = df['MAE'].astype('float')\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('4', 'tanh'),\n",
       " ('2', 'tanh'),\n",
       " ('3', 'logistic'),\n",
       " ('2', 'logistic'),\n",
       " ('2', 'logistic'),\n",
       " ('2', 'logistic'),\n",
       " ('2', 'logistic'),\n",
       " ('2', 'logistic'),\n",
       " ('2', 'tanh'),\n",
       " ('2', 'tanh')]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ANNpara = []\n",
    "for leadtime in range(1,11):\n",
    "    idx = pd.IndexSlice\n",
    "    para = pd.read_csv('leadtime%d_lbfgs_self.csv' % leadtime, index_col=0, header=[0, 1, 2])\n",
    "    temp = para.loc[:,idx[:,:,'test_mae']].median().idxmin()\n",
    "    ANNpara.append((temp[0],temp[1]))\n",
    "ANNpara"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 神经网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用所有的特征\n",
    "idx = pd.IndexSlice\n",
    "names = locals()\n",
    "itera = 50\n",
    "result = pd.DataFrame(columns=pd.MultiIndex.from_product([range(1,11),['obs','pred'],['train','val','test']]),index=range(1451))\n",
    "for leadtime in range(1,11,1):\n",
    "    X, y =  MyPrepaData.Preparation(data=data,Qlag=[1,4],Rlag=range(1,7),reanalysis=reanalysis,isreanalysis=True,leadtime=leadtime)\n",
    "    scalemodely = MinMaxScaler().fit(np.array(y).reshape(-1, 1)) \n",
    "    scalemodelx = MinMaxScaler().fit(X)\n",
    "    y_scale = scalemodely.transform(np.array(y).reshape(-1, 1))\n",
    "    X_scale = scalemodelx.transform(X)\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X_scale,y_scale,test_size=730,shuffle=False)\n",
    "    X_train_val, X_test_val, y_train_val, y_test_val = train_test_split(X_train,y_train,test_size=731,shuffle=False)\n",
    "    model = MLPRegressor(hidden_layer_sizes=(int(ANNpara[leadtime-1][0]),), activation=ANNpara[leadtime-1][1], solver='lbfgs',\n",
    "                         alpha=0.0001,batch_size='auto',learning_rate='constant',learning_rate_init=0.001, power_t=0.5,\n",
    "                         max_iter=3000, shuffle=True,random_state=None,tol=1e-5, verbose=False, warm_start=False,momentum=0.9, \n",
    "                         nesterovs_momentum=True,early_stopping=True, validation_fraction=0.1,beta_1=0.9,beta_2=0.999, \n",
    "                         epsilon=1e-08,n_iter_no_change=10)\n",
    "    names['trainset%d'%leadtime] = pd.DataFrame()\n",
    "    names['valset%d'%leadtime] = pd.DataFrame()\n",
    "    names['testset%d'%leadtime] = pd.DataFrame()\n",
    "    for i in range(itera):\n",
    "        model.fit(X_train,y_train.ravel())\n",
    "\n",
    "        y_fit = model.predict(X_train_val)\n",
    "        y_fit_val = model.predict(X_test_val)\n",
    "        y_pred = model.predict(X_test)\n",
    "\n",
    "        y_train_val_,y_test_val_,y_test_,y_fit_,y_fit_val_,y_pred_ = scalemodely.inverse_transform(y_train_val.reshape(-1, 1)),\\\n",
    "        scalemodely.inverse_transform(y_test_val.reshape(-1, 1)),scalemodely.inverse_transform(y_test.reshape(-1, 1)),\\\n",
    "        scalemodely.inverse_transform(y_fit.reshape(-1, 1)),scalemodely.inverse_transform(y_fit_val.reshape(-1, 1)),\\\n",
    "         scalemodely.inverse_transform(y_pred.reshape(-1, 1))\n",
    "        names['trainset%d'%leadtime][i] = y_fit_.ravel()\n",
    "        names['valset%d'%leadtime][i] = y_fit_val_.ravel()\n",
    "        names['testset%d'%leadtime][i] = y_pred_.ravel()\n",
    "    result.loc[:,idx[[leadtime],['pred'],['train']]] = names['trainset%d'%leadtime].median(axis=1)\n",
    "    result.loc[:,idx[[leadtime],['pred'],['val']]] = names['valset%d'%leadtime].median(axis=1)\n",
    "    result.loc[:,idx[[leadtime],['pred'],['test']]] = names['testset%d'%leadtime].median(axis=1)\n",
    "    result.loc[:,idx[[leadtime],['obs'],['train']]] = pd.Series(y_train_val_.ravel())\n",
    "    result.loc[:,idx[[leadtime],['obs'],['val']]] =  pd.Series(y_test_val_.ravel())\n",
    "    result.loc[:,idx[[leadtime],['obs'],['test']]] =  pd.Series(y_test_.ravel())\n",
    "result.to_csv('ANNresult.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 支持向量机"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.svm import SVR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'C': 6.2105263157894735, 'epsilon': 0.0068736842105263166, 'gamma': 0.03226315789473684}\n",
      "{'C': 1.0, 'epsilon': 0.008436842105263158, 'gamma': 0.05831578947368421}\n",
      "{'C': 1.0, 'epsilon': 0.0016631578947368423, 'gamma': 0.08436842105263158}\n",
      "{'C': 1.0, 'epsilon': 0.00791578947368421, 'gamma': 0.02705263157894737}\n",
      "{'C': 11.421052631578947, 'epsilon': 0.0016631578947368423, 'gamma': 0.006210526315789474}\n",
      "{'C': 1.0, 'epsilon': 0.0001, 'gamma': 0.021842105263157895}\n",
      "{'C': 1.0, 'epsilon': 0.0021842105263157894, 'gamma': 0.03747368421052632}\n",
      "{'C': 6.2105263157894735, 'epsilon': 0.0006210526315789474, 'gamma': 0.01663157894736842}\n",
      "{'C': 1.0, 'epsilon': 0.004789473684210527, 'gamma': 0.06873684210526315}\n",
      "{'C': 6.2105263157894735, 'epsilon': 0.004268421052631579, 'gamma': 0.01663157894736842}\n"
     ]
    }
   ],
   "source": [
    "for leadtime in range(1,11,1):\n",
    "    with open('svr_para%d.pickle'%(leadtime), 'rb') as f:\n",
    "        svr_cv = pickle.load(f)\n",
    "    print(svr_cv.best_params_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 / 10\n",
      "2 / 10\n",
      "3 / 10\n",
      "4 / 10\n",
      "5 / 10\n",
      "6 / 10\n",
      "7 / 10\n",
      "8 / 10\n",
      "9 / 10\n",
      "10 / 10\n"
     ]
    }
   ],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "idx = pd.IndexSlice\n",
    "result = pd.DataFrame(columns=pd.MultiIndex.from_product([range(1,11),['obs','pred'],['train','val','test']]),index=range(1451))\n",
    "for leadtime in range(1,11,1):\n",
    "    with open('svr_para%d.pickle'%(leadtime), 'rb') as f:\n",
    "        svr_cv = pickle.load(f)\n",
    "    X, y =  MyPrepaData.Preparation(data=data,Qlag=[1,4],Rlag=range(1,7),reanalysis=reanalysis,isreanalysis=True,leadtime=leadtime)\n",
    "    scalemodely = MinMaxScaler().fit(np.array(y).reshape(-1, 1)) \n",
    "    scalemodelx = MinMaxScaler().fit(X)\n",
    "    y_scale = scalemodely.transform(np.array(y).reshape(-1, 1))\n",
    "    X_scale = scalemodelx.transform(X)\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X_scale,y_scale,test_size=730,shuffle=False)\n",
    "    X_train_val, X_test_val, y_train_val, y_test_val = train_test_split(X_train,y_train,test_size=731,shuffle=False)\n",
    "    \n",
    "    model = SVR(**svr_cv.best_params_)   \n",
    "    model.fit(X_train,y_train.ravel())\n",
    "    y_fit = model.predict(X_train_val)\n",
    "    y_fit_val = model.predict(X_test_val)\n",
    "    y_pred = model.predict(X_test)\n",
    "\n",
    "    y_train_val_,y_test_val_,y_test_,y_fit_,y_fit_val_,y_pred_ = scalemodely.inverse_transform(y_train_val.reshape(-1, 1)),\\\n",
    "    scalemodely.inverse_transform(y_test_val.reshape(-1, 1)),scalemodely.inverse_transform(y_test.reshape(-1, 1)),\\\n",
    "    scalemodely.inverse_transform(y_fit.reshape(-1, 1)),scalemodely.inverse_transform(y_fit_val.reshape(-1, 1)),\\\n",
    "     scalemodely.inverse_transform(y_pred.reshape(-1, 1))\n",
    "    result.loc[:,idx[[leadtime],['pred'],['train']]] = pd.Series(y_fit_.ravel())\n",
    "    result.loc[:,idx[[leadtime],['pred'],['val']]] = pd.Series(y_fit_val_.ravel())\n",
    "    result.loc[:,idx[[leadtime],['pred'],['test']]] = pd.Series(y_pred_.ravel())\n",
    "    result.loc[:,idx[[leadtime],['obs'],['train']]] = pd.Series(y_train_val_.ravel())\n",
    "    result.loc[:,idx[[leadtime],['obs'],['val']]] =  pd.Series(y_test_val_.ravel())\n",
    "    result.loc[:,idx[[leadtime],['obs'],['test']]] =  pd.Series(y_test_.ravel())\n",
    "    print(leadtime,'/','10')\n",
    "result.to_csv('SVRresult.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 梯度提升回归"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import GradientBoostingRegressor\n",
    "\n",
    "import pickle\n",
    "import copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 / 10\n",
      "2 / 10\n",
      "3 / 10\n",
      "4 / 10\n",
      "5 / 10\n",
      "6 / 10\n",
      "7 / 10\n",
      "8 / 10\n",
      "9 / 10\n",
      "10 / 10\n",
      "Wall time: 23min 42s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "names = locals()\n",
    "result = pd.DataFrame(columns=pd.MultiIndex.from_product([range(1,11),['obs','pred'],['train','val','test']]),index=range(1461))\n",
    "with open('gbrt_allpara_learn_est.pickle', 'rb') as f:\n",
    "    optpara = pickle.load(f)\n",
    "n_estimators= [_['n_estimators'] for _ in optpara]\n",
    "learning_rate = [_['learning_rate'] for _ in optpara]\n",
    "with open('gbrt_allpara.pickle', 'rb') as f:\n",
    "    optpara = pickle.load(f)\n",
    "min_samples_split= [_['min_samples_split'] for _ in optpara]\n",
    "min_samples_leaf = [_['min_samples_leaf'] for _ in optpara]\n",
    "max_depth = [_['max_depth'] for _ in optpara]\n",
    "max_leaf_nodes = [_['max_leaf_nodes'] for _ in optpara]\n",
    "gbrtresult = {}\n",
    "itera = 50\n",
    "for leadtime in range(1,11,1): \n",
    "    X,y = MyPrepaData.Preparation(data=data,Qlag=[1,4],Rlag=range(1,7),reanalysis=reanalysis,isreanalysis=True,leadtime=leadtime)\n",
    "    scalemodely = MinMaxScaler().fit(np.array(y).reshape(-1, 1)) \n",
    "    scalemodelx = MinMaxScaler().fit(X)\n",
    "    y_scale = scalemodely.transform(np.array(y).reshape(-1, 1))\n",
    "    X_scale = scalemodelx.transform(X)\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X_scale,y_scale,test_size=730,shuffle=False)\n",
    "    X_train_val, X_test_val, y_train_val, y_test_val = train_test_split(X_train,y_train,test_size=731,shuffle=False)\n",
    "    model = GradientBoostingRegressor(n_estimators = n_estimators[leadtime-1],min_samples_split= min_samples_split[leadtime-1],\n",
    "                                          max_depth = max_depth[leadtime-1],max_leaf_nodes=max_leaf_nodes[leadtime-1],\n",
    "                                          min_samples_leaf=min_samples_leaf[leadtime-1],learning_rate=learning_rate[leadtime-1])\n",
    "    names['trainset%d'%leadtime] = pd.DataFrame()\n",
    "    names['valset%d'%leadtime] = pd.DataFrame()\n",
    "    names['testset%d'%leadtime] = pd.DataFrame()\n",
    "#     feature importance\n",
    "    if leadtime == 1:\n",
    "        feature_importance1 = []\n",
    "    elif leadtime==10:\n",
    "        feature_importance10 = []\n",
    "    for i in range(itera):\n",
    "        model.fit(X_train,y_train.ravel())\n",
    "\n",
    "        y_fit = model.predict(X_train_val)\n",
    "        y_fit_val = model.predict(X_test_val)\n",
    "        y_pred = model.predict(X_test)\n",
    "\n",
    "        y_train_val_,y_test_val_,y_test_,y_fit_,y_fit_val_,y_pred_ = scalemodely.inverse_transform(y_train_val.reshape(-1, 1)),\\\n",
    "        scalemodely.inverse_transform(y_test_val.reshape(-1, 1)),scalemodely.inverse_transform(y_test.reshape(-1, 1)),\\\n",
    "        scalemodely.inverse_transform(y_fit.reshape(-1, 1)),scalemodely.inverse_transform(y_fit_val.reshape(-1, 1)),\\\n",
    "         scalemodely.inverse_transform(y_pred.reshape(-1, 1))\n",
    "        names['trainset%d'%leadtime][i] = y_fit_.ravel()\n",
    "        names['valset%d'%leadtime][i] = y_fit_val_.ravel()\n",
    "        names['testset%d'%leadtime][i] = y_pred_.ravel()\n",
    "        \n",
    "        if leadtime==1:\n",
    "            feature_importance1.append(model.feature_importances_)\n",
    "        elif leadtime==10:\n",
    "            feature_importance10.append(model.feature_importances_)\n",
    "    if leadtime==1:\n",
    "        fi1 = pd.DataFrame(feature_importance1)\n",
    "        fi1.columns = X.columns\n",
    "        fi1 = fi1.mean().sort_values()\n",
    "    elif leadtime==10:\n",
    "        fi10 = pd.DataFrame(feature_importance10)\n",
    "        fi10.columns = X.columns\n",
    "        fi10 = fi10.mean().sort_values()\n",
    "    result.loc[:,idx[[leadtime],['pred'],['train']]] = names['trainset%d'%leadtime].median(axis=1)\n",
    "    result.loc[:,idx[[leadtime],['pred'],['val']]] = names['valset%d'%leadtime].median(axis=1)\n",
    "    result.loc[:,idx[[leadtime],['pred'],['test']]] = names['testset%d'%leadtime].median(axis=1)\n",
    "    result.loc[:,idx[[leadtime],['obs'],['train']]] = pd.Series(y_train_val_.ravel())\n",
    "    result.loc[:,idx[[leadtime],['obs'],['val']]] =  pd.Series(y_test_val_.ravel())\n",
    "    result.loc[:,idx[[leadtime],['obs'],['test']]] =  pd.Series(y_test_.ravel())\n",
    "    print(leadtime,'/','10')\n",
    "fi1.to_csv('featureimportance1.csv')\n",
    "fi10.to_csv('featureimportance10.csv')\n",
    "result.to_csv('GBRTresult.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 / 10\n",
      "2 / 10\n",
      "3 / 10\n",
      "4 / 10\n",
      "5 / 10\n",
      "6 / 10\n",
      "7 / 10\n",
      "8 / 10\n",
      "9 / 10\n",
      "10 / 10\n",
      "Wall time: 3min 25s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "result = pd.DataFrame(columns=pd.MultiIndex.from_product([range(1,11),['obs','pred'],['train','val','test']]),index=range(1451))\n",
    "with open('gbrt_allpara_learn_est_nore.pickle', 'rb') as f:\n",
    "    optpara = pickle.load(f)\n",
    "n_estimators= [_['n_estimators'] for _ in optpara]\n",
    "learning_rate = [_['learning_rate'] for _ in optpara]\n",
    "with open('gbrt_allpara_nore.pickle', 'rb') as f:\n",
    "    optpara = pickle.load(f)\n",
    "min_samples_split= [_['min_samples_split'] for _ in optpara]\n",
    "min_samples_leaf = [_['min_samples_leaf'] for _ in optpara]\n",
    "max_depth = [_['max_depth'] for _ in optpara]\n",
    "max_leaf_nodes = [_['max_leaf_nodes'] for _ in optpara]\n",
    "gbrtresult = {}\n",
    "itera = 50\n",
    "for leadtime in range(1,11,1):\n",
    "    X,y = MyPrepaData.Preparation(data=data,Qlag=[1,4],Rlag=range(1,7),reanalysis=reanalysis,isreanalysis=False,leadtime=leadtime)\n",
    "    scalemodely = MinMaxScaler().fit(np.array(y).reshape(-1, 1)) \n",
    "    scalemodelx = MinMaxScaler().fit(X)\n",
    "    y_scale = scalemodely.transform(np.array(y).reshape(-1, 1))\n",
    "    X_scale = scalemodelx.transform(X)\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X_scale,y_scale,test_size=730,shuffle=False)\n",
    "    X_train_val, X_test_val, y_train_val, y_test_val = train_test_split(X_train,y_train,test_size=731,shuffle=False)\n",
    "    model = GradientBoostingRegressor(n_estimators = n_estimators[leadtime-1],min_samples_split= min_samples_split[leadtime-1],\n",
    "                                          max_depth = max_depth[leadtime-1],max_leaf_nodes=max_leaf_nodes[leadtime-1],\n",
    "                                          min_samples_leaf=min_samples_leaf[leadtime-1],learning_rate=learning_rate[leadtime-1])\n",
    "    names['trainset%d'%leadtime] = pd.DataFrame()\n",
    "    names['valset%d'%leadtime] = pd.DataFrame()\n",
    "    names['testset%d'%leadtime] = pd.DataFrame()\n",
    "    for i in range(itera):\n",
    "        model.fit(X_train,y_train.ravel())\n",
    "\n",
    "        y_fit = model.predict(X_train_val)\n",
    "        y_fit_val = model.predict(X_test_val)\n",
    "        y_pred = model.predict(X_test)\n",
    "\n",
    "        y_train_val_,y_test_val_,y_test_,y_fit_,y_fit_val_,y_pred_ = scalemodely.inverse_transform(y_train_val.reshape(-1, 1)),\\\n",
    "        scalemodely.inverse_transform(y_test_val.reshape(-1, 1)),scalemodely.inverse_transform(y_test.reshape(-1, 1)),\\\n",
    "        scalemodely.inverse_transform(y_fit.reshape(-1, 1)),scalemodely.inverse_transform(y_fit_val.reshape(-1, 1)),\\\n",
    "         scalemodely.inverse_transform(y_pred.reshape(-1, 1))\n",
    "        names['trainset%d'%leadtime][i] = y_fit_.ravel()\n",
    "        names['valset%d'%leadtime][i] = y_fit_val_.ravel()\n",
    "        names['testset%d'%leadtime][i] = y_pred_.ravel()\n",
    "    result.loc[:,idx[[leadtime],['pred'],['train']]] = names['trainset%d'%leadtime].median(axis=1)\n",
    "    result.loc[:,idx[[leadtime],['pred'],['val']]] = names['valset%d'%leadtime].median(axis=1)\n",
    "    result.loc[:,idx[[leadtime],['pred'],['test']]] = names['testset%d'%leadtime].median(axis=1)\n",
    "    result.loc[:,idx[[leadtime],['obs'],['train']]] = pd.Series(y_train_val_.ravel())\n",
    "    result.loc[:,idx[[leadtime],['obs'],['val']]] =  pd.Series(y_test_val_.ravel())\n",
    "    result.loc[:,idx[[leadtime],['obs'],['test']]] =  pd.Series(y_test_.ravel())\n",
    "    print(leadtime,'/','10')\n",
    "result.to_csv('GBRTREresult.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 多元回归"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LinearRegression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 / 10\n",
      "2 / 10\n",
      "3 / 10\n",
      "4 / 10\n",
      "5 / 10\n",
      "6 / 10\n",
      "7 / 10\n",
      "8 / 10\n",
      "9 / 10\n",
      "10 / 10\n"
     ]
    }
   ],
   "source": [
    "result = pd.DataFrame(columns=pd.MultiIndex.from_product([range(1,11),['obs','pred'],['train','val','test']]),index=range(1451))\n",
    "\n",
    "for leadtime in range(1,11,1):\n",
    "    X,y = MyPrepaData.Preparation(data=data,Qlag=[1,4],Rlag=range(1,7),reanalysis=reanalysis,isreanalysis=True,leadtime=leadtime)\n",
    "    scalemodely = MinMaxScaler().fit(np.array(y).reshape(-1, 1)) \n",
    "    scalemodelx = MinMaxScaler().fit(X)\n",
    "    y_scale = scalemodely.transform(np.array(y).reshape(-1, 1))\n",
    "    X_scale = scalemodelx.transform(X)\n",
    "    X_train, X_test, y_train, y_test = train_test_split(X_scale,y_scale,test_size=730,shuffle=False)\n",
    "    X_train_val, X_test_val, y_train_val, y_test_val = train_test_split(X_train,y_train,test_size=731,shuffle=False)\n",
    "    \n",
    "    model = LinearRegression()\n",
    "    model.fit(X_train,y_train.ravel())\n",
    "    y_fit = model.predict(X_train_val)\n",
    "    y_fit_val = model.predict(X_test_val)\n",
    "    y_pred = model.predict(X_test)\n",
    "\n",
    "    y_train_val_,y_test_val_,y_test_,y_fit_,y_fit_val_,y_pred_ = scalemodely.inverse_transform(y_train_val.reshape(-1, 1)),\\\n",
    "    scalemodely.inverse_transform(y_test_val.reshape(-1, 1)),scalemodely.inverse_transform(y_test.reshape(-1, 1)),\\\n",
    "    scalemodely.inverse_transform(y_fit.reshape(-1, 1)),scalemodely.inverse_transform(y_fit_val.reshape(-1, 1)),\\\n",
    "     scalemodely.inverse_transform(y_pred.reshape(-1, 1))\n",
    "    result.loc[:,idx[[leadtime],['obs'],['train']]] = pd.Series(y_train_val_.ravel())\n",
    "    result.loc[:,idx[[leadtime],['obs'],['val']]] = pd.Series(y_test_val_.ravel())\n",
    "    result.loc[:,idx[[leadtime],['obs'],['test']]] = pd.Series(y_test_.ravel())\n",
    "    result.loc[:,idx[[leadtime],['pred'],['train']]] = pd.Series(y_fit_.ravel())\n",
    "    result.loc[:,idx[[leadtime],['pred'],['val']]] =  pd.Series(y_fit_val_.ravel())\n",
    "    result.loc[:,idx[[leadtime],['pred'],['test']]] =  pd.Series(y_pred_.ravel())\n",
    "    print(leadtime,'/','10')\n",
    "result.to_csv('MLRresult.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 计算指标"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "idx = pd.IndexSlice\n",
    "estimate_criteria = pd.DataFrame(columns=pd.MultiIndex.from_product([['GBRT','ANN','SVR','MLR','GBRTRE'],\n",
    "                                                                     ['train','val','test'],\n",
    "                                                                     ['MAE', 'RMSE','CORR','KGE','BHV','ia']]))\n",
    "for model in ['GBRT','ANN','SVR','MLR','GBRTRE']:\n",
    "    result = pd.read_csv('%sresult.csv'%model,index_col=0,header=[0, 1, 2])\n",
    "    for leadtime in range(1,11):\n",
    "        y_train_val_ = result.loc[:,idx[[str(leadtime)],['obs'],['train']]].dropna().values\n",
    "        y_test_val_ = result.loc[:,idx[[str(leadtime)],['obs'],['val']]].dropna().values\n",
    "        y_test_ = result.loc[:,idx[[str(leadtime)],['obs'],['test']]].dropna().values\n",
    "        \n",
    "        y_fit_ = result.loc[:,idx[[str(leadtime)],['pred'],['train']]].dropna().values\n",
    "        y_fit_val_ = result.loc[:,idx[[str(leadtime)],['pred'],['val']]].dropna().values\n",
    "        y_pred_ = result.loc[:,idx[[str(leadtime)],['pred'],['test']]].dropna().values\n",
    "        \n",
    "        estimate_criteria.loc[leadtime,idx[model,'train',:]],estimate_criteria.loc[leadtime,idx[model,'val',:]],\\\n",
    "        estimate_criteria.loc[leadtime,idx[model,'test',:]] = [calcAllEC(y_fit_, y_train_val_),calcAllEC(y_fit_val_, y_test_val_),\\\n",
    "        calcAllEC(y_pred_, y_test_)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "estimate_criteria.astype('float').to_csv('finalresult.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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>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",
       "      <th>9</th>\n",
       "      <th>10</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>GBRT-MIC</td>\n",
       "      <td>0.9856</td>\n",
       "      <td>0.9753</td>\n",
       "      <td>0.9710</td>\n",
       "      <td>0.9686</td>\n",
       "      <td>0.9661</td>\n",
       "      <td>0.9601</td>\n",
       "      <td>0.9571</td>\n",
       "      <td>0.9535</td>\n",
       "      <td>0.9485</td>\n",
       "      <td>0.9419</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>SVR-MIC</td>\n",
       "      <td>0.9869</td>\n",
       "      <td>0.9763</td>\n",
       "      <td>0.9676</td>\n",
       "      <td>0.9568</td>\n",
       "      <td>0.9495</td>\n",
       "      <td>0.9421</td>\n",
       "      <td>0.9396</td>\n",
       "      <td>0.9372</td>\n",
       "      <td>0.9351</td>\n",
       "      <td>0.9326</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>ANN-MIC</td>\n",
       "      <td>0.9872</td>\n",
       "      <td>0.9779</td>\n",
       "      <td>0.9701</td>\n",
       "      <td>0.9637</td>\n",
       "      <td>0.9590</td>\n",
       "      <td>0.9532</td>\n",
       "      <td>0.9486</td>\n",
       "      <td>0.9442</td>\n",
       "      <td>0.9405</td>\n",
       "      <td>0.9408</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>MLR-MIC</td>\n",
       "      <td>0.9865</td>\n",
       "      <td>0.9759</td>\n",
       "      <td>0.9661</td>\n",
       "      <td>0.9577</td>\n",
       "      <td>0.9511</td>\n",
       "      <td>0.9441</td>\n",
       "      <td>0.9392</td>\n",
       "      <td>0.9360</td>\n",
       "      <td>0.9320</td>\n",
       "      <td>0.9295</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              1       2       3       4       5       6       7       8   \\\n",
       "GBRT-MIC  0.9856  0.9753  0.9710  0.9686  0.9661  0.9601  0.9571  0.9535   \n",
       "SVR-MIC   0.9869  0.9763  0.9676  0.9568  0.9495  0.9421  0.9396  0.9372   \n",
       "ANN-MIC   0.9872  0.9779  0.9701  0.9637  0.9590  0.9532  0.9486  0.9442   \n",
       "MLR-MIC   0.9865  0.9759  0.9661  0.9577  0.9511  0.9441  0.9392  0.9360   \n",
       "\n",
       "              9       10  \n",
       "GBRT-MIC  0.9485  0.9419  \n",
       "SVR-MIC   0.9351  0.9326  \n",
       "ANN-MIC   0.9405  0.9408  \n",
       "MLR-MIC   0.9320  0.9295  "
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.interactiveshell import InteractiveShell \n",
    "InteractiveShell.ast_node_interactivity = 'all'\n",
    "order = ['GBRT','SVR','ANN', 'MLR']\n",
    "df  = estimate_criteria.loc[:,idx[:,'test','ia',:]].droplevel(axis=1,level=(1,2))\n",
    "df = df[order].T.astype('float')\n",
    "df = df.applymap(lambda x:'%.4f'%x)\n",
    "df.index = ['GBRT-MIC','SVR-MIC','ANN-MIC', 'MLR-MIC']\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 绘图，绘制预测结果的时序图和散点图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 396.72x459 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from matplotlib import rcParams\n",
    "import matplotlib.ticker as ticker\n",
    "import numpy as np\n",
    "rcParams.update({'font.size': 7})\n",
    "rcParams['font.sans-serif'] = 'Times New Roman'\n",
    "ftd = {'family':'Times New Roman','size':7}\n",
    "paralegend = {'title':None,'frameon':None,'handlelength':2,'handletextpad':0.5}\n",
    "# paralegend = {}\n",
    "# data = pd.read_csv(open(r'data\\result.csv'),index_col=[0],header=[0,1,2])\n",
    "data = estimate_criteria\n",
    "idx = pd.IndexSlice\n",
    "data = data.drop(['GBRTRE'],axis='columns',level=0) #删除GBRT\n",
    "data.index.name='leadtime'\n",
    "data.columns.name = ['model','set','ec']\n",
    "# print(data.loc[:,idx[['GBRTMIC','SVR','ANN','MLR'], ['test'], :]])\n",
    "# print(data.sort_index(axis=1,level=2))\n",
    "# exit(1)\n",
    "plt.figure(figsize=(5.51,6.375))\n",
    "for indice,ix,num in zip(['MAE', 'RMSE','CORR','KGE','BHV','ia'],range(1,7),['(a)','(b)','(c)','(d)','(e)','(f)']):\n",
    "    ax = plt.subplot('32%d'%(ix))\n",
    "    k = 0\n",
    "    names = locals()\n",
    "    names[indice] = data.loc[:, idx[:, ['test'], [indice]]]\n",
    "#     print(names[indice])\n",
    "#     break\n",
    "    \n",
    "    names[indice] = names[indice].astype('float32')\n",
    "    names[indice].columns=['GBRTMIC','ANN','SVR','MLR']\n",
    "    names[indice] = names[indice][['GBRTMIC','SVR','ANN','MLR']]\n",
    "    for i,marker in zip(names[indice].columns,['o', 's', '^', 'X']):\n",
    "        plt.plot(names[indice][i], marker=marker, linestyle='dashed', linewidth=1, markersize=4)\n",
    "\n",
    "    plt.xticks(range(1,11))\n",
    "\n",
    "    if indice == 'RMSE':\n",
    "        plt.ylim(190,450)\n",
    "        plt.yticks(np.linspace(200,450,6))\n",
    "        plt.ylabel('%s (m$^3$/s)'%indice,labelpad=0.1)\n",
    "        plt.text(x=0.05,y=0.92,s=num, transform=ax.transAxes,fontdict=ftd)\n",
    "        loc = (0.5, 0.01)\n",
    "    elif indice=='MAE':\n",
    "        plt.ylim(120,280)\n",
    "        plt.yticks(np.linspace(120,280,5))\n",
    "        plt.ylabel('%s (m$^3$/s)'%indice,labelpad=0.1)\n",
    "        plt.text(x=0.05,y=0.92,s=num, transform=ax.transAxes,fontdict=ftd)\n",
    "        loc = (0.5, 0.01)\n",
    "    elif indice=='KGE':\n",
    "        plt.ylim(0.75,1.0)\n",
    "        plt.yticks(np.linspace(0.75,1.0,6))\n",
    "        formatter = ticker.FormatStrFormatter('%1.2f')\n",
    "        ax.yaxis.set_major_formatter(formatter)\n",
    "        plt.ylabel(indice,labelpad=0.1)\n",
    "        plt.text(x=0.05, y=0.92, s=num, transform=ax.transAxes, fontdict=ftd)\n",
    "        loc = (0.53, 0.57)\n",
    "    elif indice=='CORR':\n",
    "        formatter = ticker.FormatStrFormatter('%1.2f')\n",
    "        ax.yaxis.set_major_formatter(formatter)\n",
    "        plt.ylim(0.85,1.0)\n",
    "        plt.yticks(np.linspace(0.85,1.0,5))\n",
    "        plt.ylabel(indice,labelpad=0.1)\n",
    "        plt.text(x=0.05, y=0.92, s=num, transform=ax.transAxes, fontdict=ftd)\n",
    "        loc = (0.01, 0.01)\n",
    "    elif indice=='BHV':\n",
    "        formatter = ticker.FormatStrFormatter('%d')\n",
    "        ax.yaxis.set_major_formatter(formatter)\n",
    "        plt.ylim(-12,2)\n",
    "        plt.yticks(np.linspace(-12,2,8))\n",
    "        plt.axhline(y=0,lw=0.5,ls='--',c='k')\n",
    "        plt.ylabel('%s(%s)'%(indice,'%'),labelpad=0.1)\n",
    "        plt.text(x=0.05, y=0.92, s=num, transform=ax.transAxes, fontdict=ftd)\n",
    "        loc = (0.0, 0.0)\n",
    "    elif indice=='ia':\n",
    "        formatter = ticker.FormatStrFormatter('%1.2f')\n",
    "        ax.yaxis.set_major_formatter(formatter)\n",
    "        plt.ylim(0.92,1.0)\n",
    "        # plt.yticks(np.linspace(0.85,1.0,5))\n",
    "        plt.ylabel(indice,labelpad=0.1)\n",
    "        plt.text(x=0.05, y=0.92, s=num, transform=ax.transAxes, fontdict=ftd)\n",
    "        loc = (0.51, 0.57)\n",
    "        plt.ylabel('IA')\n",
    "\n",
    "    # if indice in ['KGE','CORR']:\n",
    "    #     loc = (0.5,0.55)\n",
    "    plt.legend(['GBRT-MIC','SVR-MIC','ANN-MIC','MLR-MIC'],loc=loc,**paralegend)\n",
    "    plt.xlabel('Leadtime (day)',labelpad=0.1)\n",
    "plt.subplots_adjust(wspace =0.3)#调整子图间距\n",
    "plt.savefig('fig\\Model_comparision.tif',dpi=500,bbox_inches = 'tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 396.72x459 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import rcParams\n",
    "import matplotlib.ticker as ticker\n",
    "from matplotlib.pyplot import MultipleLocator\n",
    "import numpy as np\n",
    "rcParams['font.sans-serif'] = 'Times New Roman'\n",
    "rcParams.update({'font.size': 7})\n",
    "#paralegend = {'title':None,'frameon':None,'handlelength':3,'handletextpad':1.5,'borderpad':0.8}\n",
    "paralegend = {}\n",
    "data = estimate_criteria\n",
    "idx = pd.IndexSlice\n",
    "data = data.drop(['SVR','ANN','MLR'],axis='columns',level=0) #'SVR','ANN','MLR'\n",
    "\n",
    "ftd = {'family':'Times New Roman','size':7}\n",
    "plt.figure(figsize=(5.51,6.375))\n",
    "for indice,ix,num in zip(['MAE', 'RMSE','CORR','KGE','BHV','ia'],range(1,7),['(a)','(b)','(c)','(d)','(e)','(f)']):\n",
    "    ax = plt.subplot('32%d' % (ix))\n",
    "    names = locals()\n",
    "    names[indice] = data.loc[:, idx[['GBRT', 'GBRTRE'],['test'],[indice]]]\n",
    "    names[indice] = names[indice].astype('float32')\n",
    "    width = 0.35\n",
    "    para = {'alpha': 1.0, 'width': width}\n",
    "\n",
    "    # 添加差异变化量\n",
    "    gbrt = names[indice].values[:, 1]\n",
    "    gbrtmic = names[indice].values[:, 0]\n",
    "    plt.bar(x=np.arange(1, 11) - width / 2, height=gbrt, label='GBRT', **para)\n",
    "    plt.bar(x=np.arange(1, 11) + width / 2, height=gbrtmic, label='GBRT-MIC', hatch='/////',**para)\n",
    "    linealpha = 0.4\n",
    "    if indice=='CORR':\n",
    "        for para_paint in [(2,0.013,0.025),(10,0.02,0.02)]:\n",
    "            leadtime,a,b = para_paint\n",
    "            plt.vlines(x=leadtime - width / 2, ymin=gbrt[leadtime - 1], ymax=gbrt[leadtime - 1] + a, lw=0.5,alpha=linealpha)\n",
    "            plt.hlines(y=gbrt[leadtime - 1] + a, xmin=leadtime - width, xmax=leadtime, lw=0.5,alpha=linealpha)\n",
    "            plt.text(x=leadtime - width / 2, y=gbrt[leadtime - 1] + a, s='%.2f' % (gbrt[leadtime - 1]), ha='center',\n",
    "                     va='bottom', fontdict={'fontsize':6})\n",
    "            plt.text(x=leadtime + width / 2, y=gbrtmic[leadtime - 1] + b, s='%.2f' % (gbrtmic[leadtime - 1]), ha='center',\n",
    "                     va='bottom', fontdict={'fontsize':6})\n",
    "            plt.vlines(x=leadtime + width / 2, ymin=gbrtmic[leadtime - 1], ymax=gbrtmic[leadtime - 1] + b, lw=0.5,alpha=linealpha)\n",
    "            plt.hlines(y=gbrtmic[leadtime - 1] + b, xmin=leadtime + width, xmax=leadtime, lw=0.5,alpha=linealpha)\n",
    "        plt.ylabel(indice,labelpad=0.1)\n",
    "        plt.ylim(0.8, 1.0)  # CORR\n",
    "        y_major_locator = MultipleLocator(0.05)\n",
    "        ax.yaxis.set_major_locator(y_major_locator)\n",
    "        formatter = ticker.FormatStrFormatter('%1.2f')\n",
    "        ax.yaxis.set_major_formatter(formatter)\n",
    "        plt.legend(loc=(0.4, 0.75), **paralegend)\n",
    "        plt.text(x=0.05, y=0.9, s=num, transform=ax.transAxes, fontdict=ftd)\n",
    "        # ax2 = ax.twinx()\n",
    "        # ax2.plot(range(1,11),gbrtmic-gbrt,  'o-')\n",
    "        # ax2.plot(range(1, 11), (gbrtmic - gbrt)/gbrtmic, 'o-')\n",
    "    elif indice=='KGE':\n",
    "        for para_paint in [(2,0.01,0.03),(10,0.03,0.02)]:\n",
    "            leadtime,a,b = para_paint\n",
    "            plt.vlines(x=leadtime - width / 2, ymin=gbrt[leadtime - 1], ymax=gbrt[leadtime - 1] + a, lw=0.5,alpha=linealpha)\n",
    "            plt.hlines(y=gbrt[leadtime - 1] + a, xmin=leadtime - width, xmax=leadtime, lw=0.5,alpha=linealpha)\n",
    "            plt.text(x=leadtime - width / 2, y=gbrt[leadtime - 1] + a, s='%.2f' % (gbrt[leadtime - 1]), ha='center',\n",
    "                     va='bottom', fontdict={'fontsize':6})\n",
    "            plt.text(x=leadtime + width / 2, y=gbrtmic[leadtime - 1] + b, s='%.2f' % (gbrtmic[leadtime - 1]), ha='center',\n",
    "                     va='bottom', fontdict={'fontsize':6})\n",
    "            plt.vlines(x=leadtime + width / 2, ymin=gbrtmic[leadtime - 1], ymax=gbrtmic[leadtime - 1] + b, lw=0.5,alpha=linealpha)\n",
    "            plt.hlines(y=gbrtmic[leadtime - 1] + b, xmin=leadtime + width, xmax=leadtime, lw=0.5,alpha=linealpha)\n",
    "        plt.ylabel(indice,labelpad=0.1)\n",
    "        formatter = ticker.FormatStrFormatter('%1.2f')\n",
    "        ax.yaxis.set_major_formatter(formatter)\n",
    "        plt.ylim(0.7,1.0)  # NSE\n",
    "        yticks = np.linspace(0.7,1.0,6)\n",
    "        plt.yticks(yticks)\n",
    "        # y_major_locator = MultipleLocator(0.05)\n",
    "        # ax.yaxis.set_major_locator(y_major_locator)\n",
    "        plt.legend(loc=(0.45, 0.77),**paralegend)\n",
    "        plt.text(x=0.05, y=0.9, s=num, transform=ax.transAxes, fontdict=ftd)\n",
    "\n",
    "        # ax2 = ax.twinx()\n",
    "        # ax2.plot(range(1,11),gbrtmic-gbrt,  'o-')\n",
    "        # ax2.plot(range(1, 11), (gbrtmic - gbrt)/gbrtmic, 'o-')\n",
    "    elif indice=='MAE':\n",
    "        for para_paint in [(2,10,20),(10,15,15)]:\n",
    "            leadtime,a,b = para_paint\n",
    "            plt.vlines(x=leadtime - width / 2, ymin=gbrt[leadtime - 1], ymax=gbrt[leadtime - 1] + b, lw=0.5,alpha=linealpha)\n",
    "            plt.hlines(y=gbrt[leadtime - 1] + b, xmin=leadtime - width, xmax=leadtime, lw=0.5,alpha=linealpha)\n",
    "            plt.text(x=leadtime - width / 2, y=gbrt[leadtime - 1] + b, s='%.d' % (gbrt[leadtime - 1]), ha='center',\n",
    "                     va='bottom', fontdict={'fontsize':6})\n",
    "            plt.text(x=leadtime + width / 2, y=gbrtmic[leadtime - 1] + a, s='%.d' % (gbrtmic[leadtime - 1]), ha='center',\n",
    "                     va='bottom', fontdict={'fontsize':6})\n",
    "            plt.vlines(x=leadtime + width / 2, ymin=gbrtmic[leadtime - 1], ymax=gbrtmic[leadtime - 1] + a, lw=0.5,alpha=linealpha)\n",
    "            plt.hlines(y=gbrtmic[leadtime - 1] + a, xmin=leadtime + width, xmax=leadtime, lw=0.5,alpha=linealpha)\n",
    "\n",
    "        plt.ylabel('%s (m$^3$/s)' % indice,labelpad=0.1)\n",
    "        plt.ylim(80,320)  # CORR\n",
    "        yticks = np.linspace(80,320,5)\n",
    "        plt.yticks(yticks)\n",
    "        # y_major_locator = MultipleLocator(40)\n",
    "        # ax.yaxis.set_major_locator(y_major_locator)\n",
    "        # 把y轴的主刻度设置为40的倍数\n",
    "        plt.legend(loc=(0.15, 0.77),**paralegend)\n",
    "        plt.text(x=0.05, y=0.9, s=num, transform=ax.transAxes, fontdict=ftd)\n",
    "        # ax2 = ax.twinx()\n",
    "        # ax2.plot(range(1,11),gbrt-gbrtmic,  'o-')\n",
    "        # ax2.plot(range(1,11), (gbrt - gbrtmic)/gbrtmic, 'o-')\n",
    "    elif indice == 'RMSE':\n",
    "        for para_paint in [(2,35,20),(10,20,20)]:\n",
    "            leadtime,a,b = para_paint\n",
    "            plt.vlines(x=leadtime - width / 2, ymin=gbrt[leadtime - 1], ymax=gbrt[leadtime - 1] + a, lw=0.5,alpha=linealpha)\n",
    "            plt.hlines(y=gbrt[leadtime - 1] + a, xmin=leadtime - width, xmax=leadtime, lw=0.5,alpha=linealpha)\n",
    "            plt.text(x=leadtime - width / 2, y=gbrt[leadtime - 1] + a, s='%.d' % (gbrt[leadtime - 1]), ha='center',\n",
    "                     va='bottom', fontdict={'fontsize':6})\n",
    "            plt.text(x=leadtime + width / 2, y=gbrtmic[leadtime - 1] + b, s='%.d' % (gbrtmic[leadtime - 1]), ha='center',\n",
    "                     va='bottom', fontdict={'fontsize':6})\n",
    "            plt.vlines(x=leadtime + width / 2, ymin=gbrtmic[leadtime - 1], ymax=gbrtmic[leadtime - 1] + b, lw=0.5,alpha=linealpha)\n",
    "            plt.hlines(y=gbrtmic[leadtime - 1] + b, xmin=leadtime + width, xmax=leadtime, lw=0.5,alpha=linealpha)\n",
    "\n",
    "        error = (names[indice].values[:, 1] - names[indice].values[:, 0]) / names[indice].values[:, 0]\n",
    "        # plt.text(x=2, y=names[indice].values[:, 1][1] + 10, s='%.2f%%' % (error[1] * 100), ha='center', va='bottom')\n",
    "        # plt.text(x=10, y=names[indice].values[:, 1][-1] + 10, s='%.2f%%' % (error[-1] * 100), ha='center', va='bottom')\n",
    "        plt.ylabel('%s (m$^3$/s)' % indice,labelpad=0.1)\n",
    "        plt.ylim(150,500)  # RMSE\n",
    "        yticks = np.linspace(150,500,6)\n",
    "        plt.yticks(yticks)\n",
    "        plt.legend(loc=(0.15,0.77),**paralegend)\n",
    "        plt.text(x=0.05, y=0.9, s=num, transform=ax.transAxes, fontdict=ftd)\n",
    "        # ax2 = ax.twinx()\n",
    "        # ax2.plot(range(1,11),gbrt-gbrtmic,  'o-')\n",
    "        # ax2.plot(range(1, 11), (gbrt - gbrtmic)/gbrtmic, 'o-')\n",
    "    elif indice == 'BHV':\n",
    "        for para_paint in [(2, -0.4, 0.3), (10, -0.45, -0.85)]:\n",
    "            leadtime, a, b = para_paint\n",
    "            plt.vlines(x=leadtime - width / 2, ymin=gbrt[leadtime - 1], ymax=gbrt[leadtime - 1] + a, lw=0.5,\n",
    "                       alpha=linealpha)\n",
    "            plt.hlines(y=gbrt[leadtime - 1] + a, xmin=leadtime - width, xmax=leadtime, lw=0.5, alpha=linealpha)\n",
    "\n",
    "            if leadtime == 10:\n",
    "                plt.text(x=leadtime - width / 2, y=gbrt[leadtime - 1] + a-0.5, s='%.2f' % (gbrt[leadtime - 1]), ha='center',\n",
    "                     va='bottom', fontdict={'fontsize': 6})\n",
    "                plt.text(x=leadtime + width / 2, y=gbrtmic[leadtime - 1] + b-0.5, s='%.2f' % (gbrtmic[leadtime - 1]),\n",
    "                         ha='center',\n",
    "                         va='bottom', fontdict={'fontsize': 6})\n",
    "            else:\n",
    "                plt.text(x=leadtime - width / 2, y=gbrt[leadtime - 1] + a-0.6, s='%.2f' % (gbrt[leadtime - 1]), ha='center',\n",
    "                     va='bottom', fontdict={'fontsize': 6})\n",
    "                plt.text(x=leadtime + width / 2, y=gbrtmic[leadtime - 1] + b, s='%.2f' % (gbrtmic[leadtime - 1]),\n",
    "                         ha='center',\n",
    "                         va='bottom', fontdict={'fontsize': 6})\n",
    "            plt.vlines(x=leadtime + width / 2, ymin=gbrtmic[leadtime - 1], ymax=gbrtmic[leadtime - 1] + b, lw=0.5,\n",
    "                       alpha=linealpha)\n",
    "            plt.hlines(y=gbrtmic[leadtime - 1] + b, xmin=leadtime + width, xmax=leadtime, lw=0.5, alpha=linealpha)\n",
    "        plt.ylabel('%s(%s)'%(indice,'%'), labelpad=0.1)\n",
    "        formatter = ticker.FormatStrFormatter('%d')\n",
    "        ax.yaxis.set_major_formatter(formatter)\n",
    "        plt.ylim(-8, 2.0)  # NSE\n",
    "        yticks = np.linspace(-8, 2.0, 6)\n",
    "        plt.yticks(yticks)\n",
    "        # y_major_locator = MultipleLocator(0.05)\n",
    "        # ax.yaxis.set_major_locator(y_major_locator)\n",
    "        plt.legend(loc=(0.15, 0.1), **paralegend)\n",
    "        plt.text(x=0.05, y=0.9, s=num, transform=ax.transAxes, fontdict=ftd)\n",
    "    elif indice == 'ia':\n",
    "        for para_paint in [(2, 0.005, 0.012), (10, 0.005, 0.005)]:\n",
    "            leadtime, a, b = para_paint\n",
    "            plt.vlines(x=leadtime - width / 2, ymin=gbrt[leadtime - 1], ymax=gbrt[leadtime - 1] + a, lw=0.5,\n",
    "                       alpha=linealpha)\n",
    "            plt.hlines(y=gbrt[leadtime - 1] + a, xmin=leadtime - width, xmax=leadtime, lw=0.5, alpha=linealpha)\n",
    "            plt.text(x=leadtime - width / 2, y=gbrt[leadtime - 1] + a, s='%.2f' % (gbrt[leadtime - 1]), ha='center',\n",
    "                     va='bottom', fontdict={'fontsize': 6})\n",
    "            plt.text(x=leadtime + width / 2, y=gbrtmic[leadtime - 1] + b, s='%.2f' % (gbrtmic[leadtime - 1]),\n",
    "                     ha='center',\n",
    "                     va='bottom', fontdict={'fontsize': 6})\n",
    "            plt.vlines(x=leadtime + width / 2, ymin=gbrtmic[leadtime - 1], ymax=gbrtmic[leadtime - 1] + b, lw=0.5,\n",
    "                       alpha=linealpha)\n",
    "            plt.hlines(y=gbrtmic[leadtime - 1] + b, xmin=leadtime + width, xmax=leadtime, lw=0.5, alpha=linealpha)\n",
    "        plt.ylabel(indice, labelpad=0.1)\n",
    "        plt.ylim(0.9, 1.0)  # CORR\n",
    "        y_major_locator = MultipleLocator(0.02)\n",
    "        ax.yaxis.set_major_locator(y_major_locator)\n",
    "        formatter = ticker.FormatStrFormatter('%1.2f')\n",
    "        ax.yaxis.set_major_formatter(formatter)\n",
    "        plt.legend(loc=(0.4, 0.75), **paralegend)\n",
    "        plt.text(x=0.05, y=0.9, s=num, transform=ax.transAxes, fontdict=ftd)\n",
    "        plt.ylabel('IA')\n",
    "    plt.xlabel(xlabel='Leadtime (day)',labelpad=0.1)\n",
    "    # plt.xlabel()\n",
    "    plt.xticks(range(0, 11))\n",
    "plt.subplots_adjust(wspace =0.3)#调整子图间距\n",
    "plt.savefig('fig\\Input_comparision.tif',dpi=500,bbox_inches = 'tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 396.72x234 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import rcParams\n",
    "import matplotlib.ticker as ticker\n",
    "rcParams['font.sans-serif'] = 'Times New Roman'\n",
    "fig = plt.figure(figsize=(5.51,3.25))\n",
    "rcParams.update({'font.size': 7})\n",
    "ax1 = plt.subplot(121)\n",
    "leadtime=1\n",
    "\n",
    "data = pd.read_csv('featureimportance%d.csv'%leadtime,header=None)\n",
    "data[1] = data[1]*100\n",
    "data.columns = ['pos','feature_importance']\n",
    "plt.barh(data['pos'], data['feature_importance'], align='center')\n",
    "xtick = [i[:-5]+'$_{%s}$'%i[-4:-1] for i in data['pos']]\n",
    "# print(xtick)\n",
    "plt.yticks(data['pos'], xtick)\n",
    "plt.xlabel('Relative Importance')\n",
    "plt.xticks(range(0,101,20))\n",
    "plt.xlim(0,100)\n",
    "plt.text(x=0.9, y=0.05, s='(a)', transform=ax1.transAxes)\n",
    "ax2 = plt.subplot(122)\n",
    "leadtime=10\n",
    "\n",
    "data = pd.read_csv('featureimportance%d.csv'%leadtime,header=None)\n",
    "data[1] = data[1]*100\n",
    "data.columns = ['pos','feature_importance']\n",
    "plt.barh(data['pos'], data['feature_importance'], align='center')\n",
    "xtick = [i[:-6]+'$_{%s}$'%(i[-5:-3]+str(int(i[-3:-1])-9)) for i in data['pos']]\n",
    "plt.text(x=0.9, y=0.05, s='(b)', transform=ax2.transAxes)\n",
    "plt.yticks(data['pos'], xtick)\n",
    "plt.xlabel('Relative Importance')\n",
    "plt.xticks(range(0,41,10))\n",
    "plt.xlim(0,40)\n",
    "fig.tight_layout()#调整整体空白\n",
    "plt.savefig('fig\\Feature_importance.tif',dpi=500)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-3.568946573720978 319.05757070171876\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 538.56x448.56 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import rcParams\n",
    "import numpy as np\n",
    "from scipy.stats import norm\n",
    "idx = pd.IndexSlice\n",
    "rcParams.update({'font.size': 7})\n",
    "paralegend = {'title':None,'frameon':None,'handlelength':3,'handletextpad':1.5,'borderpad':0.8}\n",
    "# paralegend={}\n",
    "ftd = {'family':'Times New Roman','size':7}\n",
    "rcParams['font.sans-serif'] = 'Times New Roman'\n",
    "leadtime = 5\n",
    "GBRTresult = pd.read_csv('GBRTresult.csv',index_col=0,header=[0, 1, 2])\n",
    "GBRTREresult = pd.read_csv('GBRTREresult.csv',index_col=0,header=[0, 1, 2])\n",
    "GBRTtest = {'real':GBRTresult.loc[:,idx['%d'%leadtime,'obs','test']].dropna(),'pred':GBRTresult.loc[:,idx['%d'%leadtime,'pred','test']].dropna()}\n",
    "GBRTrealtest = {'real':GBRTresult.loc[:,idx['%d'%leadtime,'obs','test']].dropna(),'pred':GBRTREresult.loc[:,idx['%d'%leadtime,'pred','test']].dropna()}\n",
    "# MLRtest = pd.read_csv(open(r'data\\leadtime%d_MLRtestresult.csv'%leadtime),index_col=0)\n",
    "# SVRtest = pd.read_csv(open(r'data\\leadtime%d_SVRtestresult.csv'%leadtime),index_col=0)\n",
    "# ANNtest = pd.read_csv(open(r'data\\leadtime%d_ANNtestresult.csv'%leadtime),index_col=0)\n",
    "\n",
    "plt.figure(figsize=(7.48,6.23))\n",
    "#图（a）\n",
    "ls = ['solid','dotted','dashdot']\n",
    "alpha = [1.0,1.0,1.0,1.0]\n",
    "color = ['green','red','black']\n",
    "label = ['GBRT','GBRT-MIC']\n",
    "ax = plt.subplot(221)\n",
    "def plot_trendline(x, y,ls,color,alpha,label=None,n=1):\n",
    "    plt.scatter(x, y,s=2,alpha=alpha,c=color,label=label)\n",
    "    parameter = np.polyfit(x, y, n)\n",
    "    f = np.poly1d(parameter)\n",
    "    plt.plot(x, f(x), ls=ls, c=color)\n",
    "    return parameter\n",
    "para1 = plot_trendline(GBRTtest['real'],GBRTrealtest['pred'],ls=ls[0],color=color[0],alpha=alpha[0],label=label[0])\n",
    "para2 = plot_trendline(GBRTrealtest['real'],GBRTtest['pred'],ls=ls[1],color=color[1],alpha=alpha[1],label=label[1])\n",
    "x = np.linspace(0,GBRTrealtest['real'].max(),100)\n",
    "plt.plot(x,x,ls=ls[2],color=color[2],alpha=alpha[2],marker=None)\n",
    "plt.ylim(0,)\n",
    "plt.xlim(0,)\n",
    "plt.legend(loc=(0.2,0.72),**paralegend)\n",
    "plt.text(x=0.62, y=0.67, s='y = x',rotation=41 ,transform=ax.transAxes, fontdict=ftd)\n",
    "if leadtime ==5:\n",
    "    plt.text(x=0.62, y=0.61, s='y = %.2fx+%d'%(para2[0],para2[1]),rotation=35 ,transform=ax.transAxes, fontdict=ftd,color='red')\n",
    "    plt.text(x=0.62, y=0.50, s='y = %.2fx+%d'%(para1[0],para1[1]),rotation=32 ,transform=ax.transAxes, fontdict=ftd,color='green')\n",
    "elif leadtime==1:\n",
    "    plt.text(x=0.82, y=0.73, s='y = %.2fx+%d'%(para2[0],para2[1]),rotation=38 ,transform=ax.transAxes, fontdict=ftd,color='red')\n",
    "    plt.text(x=0.62, y=0.54, s='y = %.2fx+%d'%(para1[0],para1[1]),rotation=38 ,transform=ax.transAxes, fontdict=ftd,color='green')\n",
    "elif leadtime==10:\n",
    "    plt.text(x=0.62, y=0.56, s='y = %.2fx+%d'%(para2[0],para2[1]),rotation=32 ,transform=ax.transAxes, fontdict=ftd,color='red')\n",
    "    plt.text(x=0.62, y=0.44, s='y = %.2fx+%d'%(para1[0],para1[1]),rotation=32 ,transform=ax.transAxes, fontdict=ftd,color='green')\n",
    "plt.text(x=0.05, y=0.9, s='(a)', transform=ax.transAxes, fontdict=ftd)\n",
    "plt.ylabel('Forecasted inflow (m$^3$/s)')\n",
    "plt.xlabel('Observed inflow (m$^3$/s)')\n",
    "\n",
    "#图（b）\n",
    "ax = plt.subplot(222)\n",
    "alpha = 0.6\n",
    "x = (GBRTrealtest['real']-GBRTrealtest['pred']).values\n",
    "mu =np.mean(x) #计算均值\n",
    "\n",
    "sigma =np.std(x)\n",
    "num_bins = 100 #直方图柱子的数量\n",
    "n, bins, patches = plt.hist(x, num_bins,density=True, fill=True,facecolor='green',edgecolor='green', alpha=1.0,label=label[0])\n",
    "#直方图函数，x为x轴的值，normed=1表示为概率密度，即和为一，绿色方块，色深参数0.5.返回n个概率，直方块左边线的x值，及各个方块对象\n",
    "y = norm.pdf(bins, mu, sigma)#拟合一条最佳正态分布曲线y\n",
    "plt.plot(bins, y, '-',c='green') #绘制y的曲线\n",
    "\n",
    "x = (GBRTtest['real']-GBRTtest['pred']).values\n",
    "mu2 = np.mean(x) #计算均值\n",
    "sigma2 =np.std(x)\n",
    "n, bins, patches = plt.hist(x, num_bins,density=True, fill = False,facecolor='white',edgecolor='red', alpha=1.0,label=label[1],lw=0.5)\n",
    "#直方图函数，x为x轴的值，normed=1表示为概率密度，即和为一，绿色方块，色深参数0.5.返回n个概率，直方块左边线的x值，及各个方块对象\n",
    "y = norm.pdf(bins, mu2, sigma2)#拟合一条最佳正态分布曲线y\n",
    "print(mu2,sigma2)\n",
    "plt.plot(bins, y, '--',c='red') #绘制y的曲线\n",
    "label = ['GBRT \\n ($\\mu$=%.2f, $\\sigma$=%.2f)'%(mu,sigma),'GBRT-MIC \\n($\\mu$=%.2f, $\\sigma$=%.2f)'%(mu2,sigma2)]\n",
    "plt.legend(label,loc = (0.47,0.42), borderpad=0.2)\n",
    "plt.text(x=0.05, y=0.9, s='(b)', transform=ax.transAxes, fontdict=ftd)\n",
    "plt.ylabel('Probability')\n",
    "plt.xlabel('Error (m$^3$/s)')\n",
    "plt.subplots_adjust(wspace =0.3)#调整子图间距\n",
    "#图（c）\n",
    "ax = plt.subplot(212)\n",
    "ls = ['dashdot','dashed','solid']\n",
    "color = ['green','red','black']\n",
    "alpha = [1.0,1.0,0.5,0.5]\n",
    "label = ['GBRT','GBRT-MIC','Observed']\n",
    "lw=1.2\n",
    "dates = pd.date_range('20170101','20181231',freq='1D')\n",
    "plt.plot(dates,GBRTrealtest['pred'].values,ls=ls[0],color=color[0],alpha=alpha[0],label=label[0],lw=lw)\n",
    "plt.plot(dates,GBRTtest['pred'].values,ls=ls[1],color=color[1],alpha=alpha[1],label=label[1],lw=lw)\n",
    "plt.plot(dates,GBRTtest['real'].values,ls=ls[2],color=color[2],alpha=alpha[2],label=label[2],lw=lw)\n",
    "ix = GBRTtest['real'].index\n",
    "plt.legend(loc = (0.45,0.5),**paralegend)\n",
    "plt.text(x=0.02, y=0.9, s='(c)', transform=ax.transAxes, fontdict=ftd)\n",
    "plt.ylim(0,)\n",
    "plt.ylabel('Observed inflow (m$^3$/s)')\n",
    "plt.xlabel('Time (day)')\n",
    "xticks = ['2017/01/01','2017/04/01','2017/07/01','2017/10/01',\n",
    "          '2018/01/01','2018/04/01','2018/07/01','2018/10/01', '2018/12/31']\n",
    "plt.xticks(xticks,xticks)\n",
    "plt.savefig('fig\\Input_comparision_result%d.tif'%leadtime,dpi=500,bbox_inches = 'tight')\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "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.4"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "165px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}