Logistic.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import random\n",
    "\n",
    "df_train = pd.read_csv(\"train.csv\")\n",
    "df_test = pd.read_csv(\"test.csv\")\n",
    "df_test_result=pd.read_csv(\"gender_submission.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def transOnehot(dataSet,index):\n",
    "    length = len(dataSet)\n",
    "    max = dataSet[index].max().astype(int)\n",
    "    result = []\n",
    "    for number in dataSet[index]:\n",
    "        zero = np.zeros(max + 1)\n",
    "        zero[int(number)] = 1\n",
    "        result.append(zero.tolist())\n",
    "    return np.array(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def deal_data(dataSet,change_survived):\n",
    "    \"\"\"处理数据\"\"\"\n",
    "    #将名字中的Mr,Mrs,Miss抽出来\n",
    "    dataSet['Title'] = dataSet['Name'].apply(lambda x:x.split(',')[1]).apply(lambda x:x.split()[0])\n",
    "    dataSet.loc[~(df_train['Title'].isin(['Master.','Mrs.','Miss.','Master.'])),'Title_Val'] = 4\n",
    "    dataSet.loc[(df_train['Title'].isin(['Mr.'])),'Title_Val'] = 0\n",
    "    dataSet.loc[(df_train['Title'].isin(['Mrs.'])),'Title_Val'] = 1\n",
    "    dataSet.loc[(df_train['Title'].isin(['Miss.'])),'Title_Val'] = 2\n",
    "    dataSet.loc[(df_train['Title'].isin(['Master.'])),'Title_Val'] = 3\n",
    "    #转化成onehot类型   \n",
    "#     title_val = transOnehot(dataSet,'Title_Val')\n",
    "#     dataSet['Title_Val_0']  = title_val[:,0]\n",
    "#     dataSet['Title_Val_1']  = title_val[:,1]\n",
    "#     dataSet['Title_Val_2']  = title_val[:,2]\n",
    "#     dataSet['Title_Val_3']  = title_val[:,3]\n",
    "#     dataSet['Title_Val_4']  = title_val[:,4]\n",
    "    \n",
    "    #将性别转化成离散值Sex_Val{'male':0,'female':1}\n",
    "    sexes = dataSet['Sex'].unique()\n",
    "    genders_mapping_one = dict(zip(sexes, range(0, len(sexes) + 1)))\n",
    "    dataSet['Sex_Val'] = dataSet['Sex'].map(genders_mapping_one).astype(int)\n",
    "    \n",
    "    #将SibSp,Parch 转化成一个离散值Family\n",
    "    dataSet['FamilySize'] = dataSet['SibSp'] + dataSet['Parch']\n",
    "    #将Fare归一化\n",
    "    dataSet.loc[(dataSet['Fare'].isnull()),'Fare'] = dataSet['Fare'].median()\n",
    "    maxFare = dataSet['Fare'].max()\n",
    "    minFare = dataSet['Fare'].min()\n",
    "    dit = maxFare - minFare\n",
    "    dataSet['FareNormal'] = dataSet['Fare']/dit\n",
    "    \n",
    "    #将Cabin的有无当成一个特征Cabin_Val{'unexist':0,'exist':1}\n",
    "    dataSet.loc[ (dataSet.Cabin.notnull()), 'Cabin_Val' ] = 1\n",
    "    dataSet.loc[ (dataSet.Cabin.isnull()), 'Cabin_Val' ] = 0\n",
    "    \n",
    "     #将Embarked转化成数字Embarked_Val={'S':0,'C':1,'Q':2}\n",
    "    embarked_locs = dataSet['Embarked'].unique()\n",
    "    embarked_locs_mapping = dict(zip(embarked_locs,range(0, len(embarked_locs) + 1)))\n",
    "    dataSet['Embarked_Val'] = dataSet['Embarked'].map(embarked_locs_mapping).astype(int)\n",
    "    #用众数替换目的地的缺失值\n",
    "    if len(dataSet[dataSet['Embarked'].isnull()] > 0):\n",
    "        dataSet.replace({'Embarked_Val' : \n",
    "                   { embarked_locs_mapping[np.nan] : embarked_locs_mapping['S']}\n",
    "               },inplace=True)\n",
    "    #转化成onehot类型    \n",
    "#     embarked_val = transOnehot(dataSet,'Embarked_Val')\n",
    "#     dataSet['Embarked_Val_0']  = embarked_val[:,0]\n",
    "#     dataSet['Embarked_Val_1']  = embarked_val[:,1]\n",
    "#     dataSet['Embarked_Val_2']  = embarked_val[:,2]\n",
    "    \n",
    "    \n",
    "    #用众数(考虑性别和等级）替换缺失的Age值\n",
    "    dataSet['AgeFill'] = dataSet['Age']\n",
    "    dataSet['AgeFill'] = dataSet['AgeFill'] \\\n",
    "                        .groupby([dataSet['Sex_Val'], dataSet['Pclass']]) \\\n",
    "                        .apply(lambda x: x.fillna(x.median()))\n",
    "    dataSet['AgeFill'] = dataSet['AgeFill'] - dataSet['AgeFill'].min()\n",
    "    dit = dataSet['AgeFill'].max() - dataSet['AgeFill'].min()\n",
    "    dataSet['AgeFill'] = dataSet['AgeFill']/dit\n",
    "    \n",
    "    #剔除用不到的特征\n",
    "#     dataSet = dataSet.drop(['Name','Sex','Age','SibSp','Parch','Ticket','Fare','Cabin','Embarked','Cabin','Title','PassengerId','Title_Val','Embarked_Val'], axis=1)\n",
    "    dataSet = dataSet.drop(['Name','Sex','Age','SibSp','Parch','Ticket','Fare','Cabin','Embarked','Cabin','Title','PassengerId'], axis=1)\n",
    "    if change_survived:\n",
    "        dataSet['Survived_End'] = dataSet['Survived']\n",
    "        dataSet = dataSet.drop(['Survived'], axis=1)\n",
    "        \n",
    "#     dataSet_modify = dataSet.values\n",
    "    #对数据进行归一化\n",
    "    dataSet_modify = dataSet.values\n",
    "    return dataSet_modify"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainSet= deal_data(df_train,change_survived=True)    #shape = (?,9)\n",
    "testSet = deal_data(df_test,change_survived=False)    #shape = (?,8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(891, 9)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trainSet.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#留出法\n",
    "def hold_out(dataSet,train_size):\n",
    "    \"\"\"\n",
    "    dataSet:数据集\n",
    "    train_size:留出法中训练集所占得比例\n",
    "    \"\"\"\n",
    "    totalLen = dataSet.shape[0]\n",
    "    len = int(totalLen * train_size)\n",
    "    index = range(totalLen)\n",
    "    index_1 = np.random.choice(index,len,replace=False)     #训练集的下标\n",
    "    index_2 = np.delete(index,index_1)                      #测试集的下标\n",
    "    train = dataSet[index_1]\n",
    "    test = dataSet[index_2]\n",
    "    return train,test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#交叉验证法\n",
    "def cross_valid(dataSet,k=10):\n",
    "    \"\"\"\n",
    "    dataSet:数据集\n",
    "    k：k次交叉验证的数目\n",
    "    return : datasets：shape(k,num,feature)  list类型\n",
    "    \"\"\"\n",
    "    datasets =[]\n",
    "    num = int(dataSet.shape[0]/k)\n",
    "    start = 0\n",
    "    end = num\n",
    "    for i in range(k):\n",
    "        datasets.append(dataSet[start:end,:].tolist())\n",
    "        start += num\n",
    "        end += num\n",
    "    return datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#自助法\n",
    "def bootstrapping(dataSet):\n",
    "    m = dataSet.shape[0]\n",
    "    index1 = []\n",
    "    index2 = []\n",
    "    for i in range(m):\n",
    "        index1.append(np.random.randint(m))\n",
    "    index2 = np.delete(range(m),index1)\n",
    "    train = dataSet[index1]\n",
    "    test = dataSet[index2]\n",
    "    return train,test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(X):\n",
    "    return 1/(1 + np.exp(-X))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def grad(X,Y,learning_rate = 0.01,iter_size = 50):\n",
    "    \"\"\"\n",
    "    X:输入数据，shape：（样本数目，特征数目）\n",
    "    Y:标签，shape：（样本数目，1）\n",
    "    weithts：权重，shape：（特征数目，1）\n",
    "    learning_rate:学习率\n",
    "    \"\"\"\n",
    "    Y = Y.reshape([-1,1])\n",
    "    n = X.shape[1] \n",
    "    weights = np.ones([n,1])\n",
    "    for i in range(iter_size):\n",
    "        A = np.dot(X ,weights)\n",
    "        G = sigmoid(A) - Y\n",
    "        weights = weights - learning_rate * np.dot(X.T , G)\n",
    "    return weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def logistic(dataSet,learning_rate = 0.01,iter_size = 50):\n",
    "    X = dataSet[:,:-1]\n",
    "    Y = dataSet[:,-1]\n",
    "    weights = grad(X,Y,learning_rate,iter_size)\n",
    "    return weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(dataSet,testSet,learning_rate,iter_size,node = 0.5):\n",
    "    weights = logistic(dataSet,learning_rate,iter_size)\n",
    "    predicts = sigmoid(np.dot(testSet,weights)).reshape(-1)\n",
    "    for i in range(len(predicts)):\n",
    "        if(predicts[i] > node):\n",
    "            predicts[i] = 1\n",
    "        else:\n",
    "            predicts[i] = 0\n",
    "    return predicts.astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def information(predicts,y):\n",
    "    TP = 0\n",
    "    FP = 0\n",
    "    TN = 0\n",
    "    FN = 0\n",
    "    for i in range(len(predicts)):\n",
    "        if(predicts[i] == 1):\n",
    "            if(y[i] == 1):\n",
    "                TP += 1\n",
    "            else:\n",
    "                FP += 1\n",
    "        else:\n",
    "            if(y[i] == 1):\n",
    "                FN += 1\n",
    "            else:\n",
    "                TN += 1\n",
    "    return TP,FP,TN,FN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#准确率\n",
    "def getAccuracy(predicts,y):\n",
    "    return(predicts == y).sum()/len(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "#精确率\n",
    "def getPrecision(predicts,y):\n",
    "    TP,FP,TN,FN = information(predicts,y)\n",
    "    precision = TP/(TP + FP)\n",
    "    return precision"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#召回率\n",
    "def getRecall(predicts,y):\n",
    "    TP,FP,TN,FN = information(predicts,y)\n",
    "    recall = TP/(TP + FN)\n",
    "    return recall"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getF1Score(predicts,y):\n",
    "    predicision = getPrecision(predicts,y)\n",
    "    recall = getRecall(predicts,y)\n",
    "    F1Score =2 * predicision * recall/(predicision + recall)\n",
    "    return F1Score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getRocAndAuc(dataSet,testSet,learning_rate,iter_size):\n",
    "    testX = testSet[:,:-1]\n",
    "    testY = testSet[:,-1]\n",
    "    weights = logistic(dataSet,learning_rate,iter_size)\n",
    "    predicts = sigmoid(np.dot(testX,weights)).reshape(-1)\n",
    "    unique = set(predicts)\n",
    "    x = []\n",
    "    y = []\n",
    "    for predict in predicts:\n",
    "        z = []\n",
    "        for i in range(len(predicts)):\n",
    "            if(predicts[i] > predict):\n",
    "                z.append(1)\n",
    "            else:\n",
    "                z.append(0)\n",
    "        TP,FP,TN,FN = information(z,testY)\n",
    "        y.append(TP/(TP + FN))\n",
    "        x.append(FP/(TN + FP))\n",
    "    \n",
    "    x = np.array(x)\n",
    "    y = np.array(y)\n",
    "    index = np.argsort(x)\n",
    "    x = x[index]\n",
    "    y = y[index]\n",
    "    AUC = 0\n",
    "    for i in range(len(x) - 1):\n",
    "        AUC += (x[i+1] - x[i]) * (y[i] + y[i+1]) /2\n",
    "    plt.plot(x,y)\n",
    "    plt.xlabel(\"假正例率\",fontproperties = 'SimHei',fontsize = 15)\n",
    "    plt.ylabel(\"真正例率\",fontproperties = 'SimHei',fontsize = 15)\n",
    "    plt.title(\"ROC曲线\",fontproperties = 'SimHei',fontsize = 15)\n",
    "    plt.show()\n",
    "    return AUC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "train,test = bootstrapping(trainSet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "testX = test[:,:-1]\n",
    "testY = test[:,-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "predicts = predict(train,testX,0.001,100,0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F1Score 0.719298245614035\n",
      "accuracy: 0.8054711246200608\n",
      "precison: 0.7522935779816514\n",
      "recall: 0.6890756302521008\n"
     ]
    }
   ],
   "source": [
    "accuracy = getAccuracy(predicts,testY)\n",
    "precision = getPrecision(predicts,testY)\n",
    "recall = getRecall(predicts,testY)\n",
    "F1Score = getF1Score(predicts,testY)\n",
    "print(\"F1Score\",F1Score)\n",
    "print(\"accuracy:\",accuracy)\n",
    "print(\"precison:\",precision)\n",
    "print(\"recall:\",recall)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "AUC = getRocAndAuc(train,test,0.001,200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8520208083233292"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AUC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYkAAAEcCAYAAAAydkhNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3XmcHVWd9/HPN510Z9/oJGQlAQISkLVFkMUIZAyoBBUVkFEcFEWQeUAZeVxQgRkccXt0QAVF1FFBVDBiEJTFBQkStgiBQAiRdBKy71unu3/PH1Xduen07b6d3K37ft+vV79St+pU1a86Sf3uqVPnHEUEZmZm7elV6gDMzKx8OUmYmVlWThJmZpaVk4SZmWXlJGFmZlk5SZgVkaQBknp3UuZASQPbrDtS0uGFjc5sd04SZgUk6fuSfp2xahHwwU52+w5wa5t1FwPflDRS0lcl1eQxTLOsnCTMCmsLsL7N5+3ZCks6CjgSuLTNppXAcmBVuv2q/IZp1j4nCatIki6QFOlPo6RXJF0jqZekGknfkbRW0vq0NtAvY99aSXdK2izpJUnnd3CqZqAp43PW3quSBHwV+DSwSdLtkl6Xbm4EiIhmklrFPEkf3sPLN8tZh89GzXq4NcABQF/geODHwGvA64C3pz8NwJ0kN+9L0v1+TXLzrwP2B+6UtCAiZks6AfgrUE+SHIaT3P9PS/cdB3xD0nXpeUcBtRGxGvg8IOCHwOXAUcBgSWcDJwBHS1pMUht5Hni0EL8Us0zysBxWiSRdAHw1Imoz1v0K2AC8G/hURNycrv8w8A2SG/6xJElgv4h4Nd3+S2BVRHxM0jHAHGB0RLwm6ZvAwIj4cFp2EfC5iPhfSVOBh4AhwFZgGUntfnt6rqnA+4CxJMljIjA1Ijalx+oF9IuIzQX4FZkBrkmYASBpMvBG4EZgEPBkxuangYEktYY3A6+0JIjUHcDIdDnz0VKumiNih6S3AkuA9wMHRsSjpLUFSWcB/w2cJOn1JMnqFOC/SGo5ZgXhJGGVbLikdSTf3vsBPwP+nG5bm1GuZXkfksdFyzIPEhF35iOYiHhC0gHAR4E3AEj6OHA+MIWkxvExkqR1F0nj9cv5OLdZNk4SVsnWAUeTtD18GbgMODTdpoxyLS94BFBNbrWFJyU1k9zYe0manq7fF/iWpC8Du7zGKulYkkR1LzBd0hCSR1dPAs8A/yRJDKuAx4CvRMSCnK/WbA/47SarZM0RsQi4GdgEXEhyAwYYllFuaPrnapJaxfDMg0j6uqTftzn20RExDvgB8POIGJd+rgcuS5ff02afk0iS0CHAdGBoRPw9ImZHxFaStpAPAX8AXgB+vmeXbZY7JwmreBHRQNKB7RKSzm7rSd5canFMum4h8DhwsKTMJHIgybf8vfX1iJgQEadFxIeAuyTtn7H9j8CVJI+YzoqI9e0exSyPnCTMEt8leYtoOsm3/89JOlHSG4HPArdFRCMwkySR3JYOn3Fuus/P8hDDpZJukfSwpFUk7Q6HAEj6EHA9SaLaHhENkqZJ+tc8nNcsK7dJmAERsVzS7STtEmeQ9GG4h+SL1O0kHdyIiG2SppG8BfUPYDFwQUT8KT1Uy/+prrRJtLR/VKV/fhN4GNgInCXpUWA/YAbwIjBb0s9J3rZaCPwkX78Hs7bcT8IsjySdCPyFtJ9EJ2WnkvSTaOlM116Z/yFpML86Itam6yaR1FxGAydFxOL8XYHZrpwkzMwsK7dJmJlZVk4SZmaWlZOEmZll5SRhZmZZdftXYGtra2PixImlDsPMrFt54oknVkXEiM7KdfskMXHiRObMmVPqMMzMuhVJOY0S4MdNZmaWlZOEmZll5SRhZmZZOUmYmVlWRUsSkm6VtELSs1m2S9K3JC2QNFfS0cWKzczM2lfMmsRtJEMqZ3M6MDn9uYhkfH8zMyuhor0CGxF/ljSxgyIzgB9HMuLgbElDJY2OiGUd7GNm1qM8+vJq1m9tyKns/iMGctCoQQWNp5z6SYwlGZu/RX26brckIekiktoGEyZMKEpwZmaF9sqqzZx7y+ycy1/6lgP51FsPLmBE5ZUk1M66dscxj4ibSeYlpq6uzmOdm1nRPL14HQ88v5wdTUH92i15PfaGbY0AfO5th3DCgbWdlt9nYHVez9+eckoS9cD4jM/jgKUlisXMbDcLVmzkrBsfaf28f+2A9r/e7oVDxwzm1ENGMal2QH4PvIfKKUnMJJnj93bgjcB6t0eYWb5d/Ztnuf3vixkxqIYl67bu8XEuO+VArviXwj7qKQdFSxLpnLxTgVpJ9cAXgD4AEfFdYBbJ3MILgC3Ah4oVm5n1XC8t38j85RsBePG1jfz40WTIoq07mrjslANBuVcFegmOnTic1zZs451HjS1IvOWmmG83ndvJ9gAuKVI4ZlYhLv7pkyxYsWm39T/4YB1HTRhWgoi6l3J63GRmljeLVm3mtr8tYt2WBk47ZCSfnv46JDGpdgCbtjcypF+fUofYLThJmFnJNTdH+68y7qE1mxuY+tWHWz+fcGAtkzP6EzhB5M5JwsxK6q6n6rn8jmcKdvxjJw3ngjdNLNjxezonCTMriUdfXs3itVv4j1/ObV13xbSD8nb8uv2GsWTdVmYcORZ1oXHaduUkYWZFt3HbDs77/mwi4xnTZ854HRedfEDpgrJ2OUmYWZdt2t7IV++bz8jBNTz5z3Vd3r+hqZmIpK/Bx6YewPYdzQwbUPjew9Z1ThJmtosdTc00NWdvRm5qDt7z3Ud5ftkGAMYO7bdHDcFHjBvCtCn70r+6N/2dH8qWk4SZtfrN00u48pdzaWhsznmf+y8/mQE1vpX0VP6bNeuhtjQ08sDzK3K+4a/fuoPr732ew8cN5dRDRnZYdvLIQWzd0cSJB9Y6QfRw/ts164EaGpv5yI/n8MiC1V3a7+BRg7j1g29gSH/3I7CEk4RZCd0zdym/eqI+78dduWk7zy7ZwHVnHcbJk0fkvN/ooX3pU1XMCSut3DlJmHWiuTno1UtsaWjc5ZXNfLhzTj2PvbI677OL9ZK4ZsahnH/cfnk9rlUeJwmzDixcuYlTvvYn+vWpYuuOpoKc44jxQ/nNJScU5Nhme8tJwipSRPD7Z19jw7YdHZSBmx5+GUiGlT77mHEcNGpg3mOpmzg878c0yxcnCatILy7fxMU/fbLTcgOqqwB446Th3HD24R7ewSqOk4QV3T1zl3LH44tLGsOm7clcwv/97tdzUgcNu4P79aF3L1HTu5cThFUkJwnbY1sbmmhoyr3TVYtfPVHP44vWcMjowQWIKndvOmAfTpo8gjFD+5U0DrNy5iRhXTbxqt8BUF3Va4+SBMDh44Zw18fdWGtW7pwkbI8dNnYwbzt8zB7te8x+njbSrDtwkrA9dusFb2CoR2Yz69GcJKzL3nzQCFZs3O4EYVYBnCQsJxHB2i1Jn4Km5qBPld/0MasEThLWofVbd3DEl+7fbf3RE4aWIBozKzYnCevQyo3bW5c/ctIkxg3rD7jh2axSOElYh/qnPY4BPvu2KSWMxMxKwWMCW4f69kmSxJfOPLTEkZhZKThJWFYRwZrN2zsvaGY9lpOEZXXb3xZx2tf/DOCJaMwqlNskjM3bG7n76SVs37HrEBt/fH45Vb3E9e98Pae/ft8SRWdmpeQkYTz4wgo+e9ez7W7bv3YA733D+CJHZGbloqhJQtJ04P8BVcD3I+LLbbZPAH4EDE3LXBURs4oZYyX46WP/ZP5rG3ll1WY2b29kzeYGAH576YlMGN5/l7L9Mt5uMrPKU7QkIakKuBGYBtQDj0uaGRHzMop9DvhFRHxH0hRgFjCxWDFWgubmaK01DB9QzaFjBjOgpjdHjB/KwfsOorq32x7MbKdi1iSOBRZExEIASbcDM4DMJBFAyyQDQ4ClRYyvIvxjyfrW5R//27EcNnZICaMxs3JXzCQxFsicjqweeGObMl8E7pf0CWAAcFpxQqscD76wonXZCcLMOlPMZwvtjQgXbT6fC9wWEeOAM4CfSNotRkkXSZojac7KlSsLEGrP9dD8FZ0XMjNLFbMmUQ9kviYzjt0fJ10ITAeIiEcl9QVqgV3ubBFxM3AzQF1dXdtEYxkam5q5+KdPsmLDNgDm1q/vZA8zs52KWZN4HJgsaZKkauAcYGabMq8CpwJIOgToC7iqsBfWbG7gD/OWs3VHE8MGVPPWQ0dx7MThnPK6kaUOzcy6gaLVJCKiUdKlwH0kr7feGhHPSboGmBMRM4FPArdIupzkUdQFEeGawl5YsGITAMP6V3Pbh44tcTRm1t0UtZ9E2udhVpt1V2cszwNOKGZMPdmrq7dw3vcfA+DllZtKHI2ZdUd+Kb6HWrZ+Kyff8FDr5/OOnVDCaMysu/KwHD3MnEVruOaeeSxdt7V13d2XnMCR4z2TnJl1nZNEN7e1oYk+VeK1DdtoaGzmvudeY279eqZNGUXdfsPY0dTsBGFme8xJohtbtn4rx1//4G7re/cSN553tIfYMLO95iTRDVzysyd5X914nlm8bpf198xd1rr8rqPH8uaDRgAwZmg/JwgzywsniTL37JL1/G7uMn6XkRBaDKrpzcCa3kwZM5gbzj6Cql7tdWo3M9tzThJlbntjU+vyeW+cwDUZc033kpBAcnIws8JwkuhGjpkwjN6eRtTMish3nDK3dvOO1uWjJvgtJTMrLieJMvfzv7/aujypdkAJIzGzSuQkUcbWbWnggYz5H9z2YGbF5jaJMtTcHOz/mVkMH1Dduu7AkQNLGJGZVSoniTK0uaERSIb5Pn7/fThmv2G8/ziPvWRmxeckUeY+fNIkTj1kVKnDMLMK5TaJMveWgz05kJmVjpNEGeqT9oWoHVhNL/eiNrMS8uOmMrF5eyOX/fwpeleJl5YnEwR96IRJJY7KzCqdk0QJLVixkeEDali6bitfvX8+D89PpvM+dMxg3n30ON56qNsizKy0nCRK5Pt/Wch1v3u+3W13fPR4Btb4r8bMSs93ohKZ/9rG1uULT5zEO44Yw8Ca3owaXOMEYWZlw3ejMnDhiZMYM7RfqcMwM9uN324qA04QZlaunCRKZOO2pFd17cCaEkdiZpadk0SJ1PRJfvXnHTu+xJGYmWXnJFEiUw9O5qOeNmXfEkdiZpadk0SJXHnnXACeWry2xJGYmWXnJFEijc0BQN/eVSWOxMwsu71OEpJOy0cgleS19dtKHYKZWU46TRKSvihpoKR9M9aNkfT+9OOdBYuuhzru+gdal8cO8+uvZla+cqlJnAe8BXhYUn9JvYA7gJYahL8W52hHUzPX37tzKI5bPlDHCQfWljAiM7OO5ZIktgP3Ak8DPwTeD9QAH0m37yhMaD3PrX99he/9aSEAU0YPZtoUD+BnZuUtlyQREdFIkhT+C/hf4ErgXkkDgJwnPJA0XdJ8SQskXZWlzHslzZP0nKSf5Xrs7uC5pRtal3932YkljMTMLDddabi+AVgInA78HhjUlf0lVQE3pvtPAc6VNKVNmcnA/wVOiIhDgf/ThfjK3ovLk0H9xg7th+TJhMys/HV4k5e0DzBAUh9gIklyeAm4FFgQERuByCjf0RgTx6b7LIyIBuB2YEabMh8BboyItQARsaJrl1PeXkhHfj3R7RBm1k1kTRLpt/ylJMlhGnAmsA9Ju8T9wHmSmoCxkpokNQNbOjjXWGBxxuf6dF2mg4CDJD0iabak6V28nm5hYF8Pvmtm3UNHd6uXSL7pfx24DpgKbACeAm4CngfeC/yR5E0nAX06OF57z1eizefewOT0XOOAv0g6LCLW7XIg6SLgIoAJEyZ0cMry0dDYXOoQzMy6LGtNIiJ2RMTvgUbgZGB/4HDg18B8YDwwD2iMiOci4tmIeKqDc9Wn+7QYR1JTaVvmN+m5X0nPM7md2G6OiLqIqBsxYkSnF1kOXl3TUSXLzKw85dTwHBGbgA8A/0NyI/828E06rjm09TgwWdIkSdXAOcDMNmXuJumTgaRaksdPC7twjrL1yqrNpQ7BzKzLcnk4rvTNpGvZecOeDRwREQ2S2j4yaldENEq6FLgPqAJujYjnJF0DzImImem2f5E0D2gCroyI1V28prK0yEnCzLqhXJJEX+AI4H3AMRGxXNK3gV9ImgZU53qyiJgFzGqz7uqM5QCuSH96hObm4Gt/mM8f5/WoF7XMrELk8rjpRuAF4KSIWJ6uuwFYRNJXYkBhQusZlqzbyo0PvczS9Vt50wH7APD2w0eXOCozs9x0WpOIiG+mi69krNsBXAAg6cyCRNZDRPow7ovvOJR3HzOutMGYmXXRXg8VHhEP5SOQnmjjth089kqPaFIxswrVYU1C0ovAZnbvz9Ce9cA3I+I3+QisJ/jWAy9xy1+SCtggd6Azs26oszvXlcBGkjeNOjMD+DzgJJH628tJLeKeT5zIlNGDSxyNmVnXdZgkWmoFki4nqSk0tinSC1gVEfdIGgkcWZAou6GIaB319bCxQ0ocjZnZnsn1Gci7SIbkaNttuA+wALgHuDsiPEtdqqUWYWbWnXXWJrE/8IGIOCn9fBnwGvAq8GQ6mivQ+saTpW796yudFzIzK3Odvd00iGQE2BbXkgyncSuwStLdkt4nT46wi207mnhwvjvPmVn319njpkZghKQZJENyNEfEuwAkfQt4E/Al4D8kvS8iFhQ02m7g6cXr+OO85UTAZadO5n1vGN/5TmZmZSqXNokRwBeACcAQSXcBNwOvB94OrCIZTvwRSVMj4vlCBVvuFqzYyFk3PtL6uW6/YYwd2q+EEZmZ7Z3OHjf1Bp6IiKMjohY4imQ4jl8Dq4F1EdEYEZcBvyOZZ6JiffynT7Yuf3LaQZx8UPcYxtzMLJvOahLvI5mqFICIeAa4XNItwL9GxLaMsleQzFxXURau3MRLKzYByXDgb3v9aKYePIKzPQSHmfUAWZOEpFHA20jaG/5G8qpr2zK3ZnzsA9SQzFZXMT76kydakwTAlDGDeU+d2yHMrGfImiTSEV+PkHQASW3i30hGfP0Z8Fg7u1STJImKERG8tGITA6qr+MXHjqeXxOSRA0sdlplZ3uQyCuzLJI+YriOZ6/rDwK8j4u5CB1fubnr4ZQA2NzRx6Bj3qjaznifnUWAjYnVEXAycBvy2cCF1D88sXscN980vdRhmZgXV5aFJI+JPhQiku1mybisAbz10FGcf4zYIM+uZOqxJSKqS9C5J1W3W7zZlqaT9Jc3Nd4Dl7oppBzNtyqhSh2FmVhCd1ST6AHeSdKhbA60JYqukgRGxNaOsgP0KEmWZ2NLQyDf+8CLjhvXn7qeXlDocM7OC62yo8G3puExNGesaJKlNgoBkCI9c5p3otm566OXWSYSGD6jmDROHMXaYe1SbWc+VS5tEsPvMdLnMVNfjLF67c6T0a2ccxtsOH13CaMzMCi+Xt5s8wmtq2fqdHcxPOqi2hJGYmRVHrm83XSApcwgOSfoIuyaQHj8kx2sZSWJw3z4ljMTMrDhyTRLnsGt7wyPAB9qU6fG9rV9dkzxumnqwB+4zs8qQa5KYHhEbOiogaSLwZEdleoopoweXOgQzs6LIucd1Dnp0Y3bEzsvr5Yn4zKxCdKnHtaR+JI+etrezuUe35G7c3ljqEMzMii7XV2BbvjoPBP4TaGD3mkOXh/joTjIbrc3MKkWHN/a0d7VIel4TESuBMVnKTqIHt0ksc5IwswrUYZtERDQA40mmKu1MH6BvPoIqR6+tb9vB3Mys5+u04ToilkRmq20bkvpIOh54mU7GbpI0XdJ8SQskXdVBubMlhaS6zuIrlk//6h+ty/1rqkoYiZlZ8XSaJCSdL6mjcgOBByOiCRglqd3JnSVVATcCpwNTgHMlTWmn3CDgMtqf/a4kbnxo58ytZ7x+Xy46af8SRmNmVjy5vAJ7HR0PzdGQ/gB8AfhSlnLHAgsiYmH6GOt2YEY75a4FvgKURSPA44vW7DK50E3vP4beVfl8c9jMrHzl8kZSQ0Q0SZpDcuNubrO9F9AkaSzwduCILMcZCyzO+FwPvDGzgKSjgPERcY+kT2ULSNJFwEUAEyZMyOES9tyKDTvf9v3wiZMKei4zs3LTla/E+wM/AQ4jach+CTgE+EW6/T3AryIi25ye7dVGWts60kda3wA+2VkgEXFzRNRFRN2IEYUdIuO3zyxtXR491MOCm1ll6UqS2BQR3wM2A48DDwIbgR+QJIB90+Vs6knelGoxDlia8XkQSQJ6WNIi4DhgZqkbrzOHBx85qMcPT2VmtovO+knkPNNcRGR9Wyn1ODA57U+xhKTn9nkZ+68no9e2pIeBT0XEnFxjKIT6tTtffXWSMLNKkzVJSKoBXgGaJT2ytyeKiEZJlwL3AVXArRHxnKRrgDkRMXNvz1EI67fuaF0eObjHdgMxM2tX1iQREdsl7Q88DNwEXN/RgSSNALZFxMYOjjkLmNVm3dVZyk7t6Hyl4JqEmVWaznpcLyJ5u+mnHRVL/7wGuCRPcZWlATU9engqM7PddKXheoikq4HBwCnAO4GhwGdIEsWPgH+X1GOmbGtu7tGjn5uZdaorSeJR4EjgfmAtSWJ4gKT3NBExG3ia9jvIdUurNrU3IrqZWeXI5flJH0lVETG9vY3pMBr16cdbgHOBX+YpvpJavNaD+plZZcslSfywk+017Jzf+h5g0d4EVE7qM/pImJlVok6TRERc00mRdSTjMrUMLd5j5pSod03CzCrcXr+uExGNwNw8xFJ2lq5zkjCzyuZ3OttYvWk7L6/czJrN25m3bAP7Du7L8AHV3P7R40odmplZ0TlJtHHm/zzCkowaxNEThvLrj59QwojMzErHSSLDxKt+17o848gxfPEdhzKwr39FZla5fAfM4itnH05Nb09TamaVzVOsteP0w/Z1gjAzw0miXR7Iz8ws4SSRamzaOSurhwQ3M0s4SaTWbtk5b8QI1yTMzAAniVaZg/n5cZOZWcJJIrV6U0Pr8shBftxkZgZOEq12qUkMdk3CzAycJFplJonh/atLGImZWflwkkitynjc1KuXShiJmVn5cJJIrfYsdGZmu3GSSK3e3NB5ITOzCuMkASxes4UHX1hR6jDMzMqOkwRw4Y8eb12+7NTJJYzEzKy8OEkALy7fBMC0KaO4YtpBJY7GzKx8OElk8EtNZma7cpLIMHpIv1KHYGZWVpwkMnhgPzOzXTlJZNhngHtam5llcpLI4JqEmdmuipokJE2XNF/SAklXtbP9CknzJM2V9ICk/QodU2ZP6wNHDiz06czMupWiJQlJVcCNwOnAFOBcSVPaFHsKqIuIw4FfAl8pdFzHXPfH1uUBNb0LfTozs26lmDWJY4EFEbEwIhqA24EZmQUi4qGI2JJ+nA2MK1ZwIwfVUDvQj5vMzDIVM0mMBRZnfK5P12VzIXBvQSPKcP5xBX+yZWbW7RTz+Up7XdWi3YLS+UAd8OYs2y8CLgKYMGHCHgfU1Lzz9EP799nj45iZ9VTFrEnUA+MzPo8DlrYtJOk04LPAmRHR7vjdEXFzRNRFRN2IESP2OKD1W3e0Lg/p5yRhZtZWMZPE48BkSZMkVQPnADMzC0g6CvgeSYIo+LCsazKGBx/sJGFmtpuiJYmIaAQuBe4Dngd+ERHPSbpG0plpsRuAgcCdkp6WNDPL4fJi7ZadScI1CTOz3RX1nc+ImAXMarPu6ozl04oZz+qMKUuHOkmYme2montcuyZhZtaxik4SbpMwM+uYk0SqT1VF/yrMzNpV0XfGtRlJwszMdlfRSWK1k4SZWYcqOklkNlybmdnuKjZJRARz69eXOgwzs7JWsUniy/e+0Lo8dqjntjYza0/FJonnlm4AYMyQvtx3+ckljsbMrDxVbJJoef31kNGDGejJhszM2lWxSaKl0Xr4gOoSR2JmVr4qNkm0vP7qJGFmll3FJomGxmYAhniyITOzrCo2SbSoUnsT5pmZGThJmJlZB5wkzMwsKycJMzPLyknCzMyyqtgkceT4oQCM9pAcZmZZVWySqB2Y9I/o16eqxJGYmZWvik0SZmbWOScJMzPLyknCzMyycpIwM7OsnCTMzCwrJwkzM8vKScLMzLJykjAzs6ycJMzMLCsnCTMzy8pJwszMsipqkpA0XdJ8SQskXdXO9hpJd6TbH5M0sZjxmZnZroqWJCRVATcCpwNTgHMlTWlT7EJgbUQcCHwD+O9ixWdmZrsrZk3iWGBBRCyMiAbgdmBGmzIzgB+ly78ETpU8CbWZWakUM0mMBRZnfK5P17VbJiIagfXAPm0PJOkiSXMkzVm5cuUeBXP+cfsBULffsD3a38ysEhQzSbRXI4g9KENE3BwRdRFRN2LEiD0KZurBI1n05bcxbED1Hu1vZlYJipkk6oHxGZ/HAUuzlZHUGxgCrClKdGZmtptiJonHgcmSJkmqBs4BZrYpMxP4YLp8NvBgROxWkzAzs+LoXawTRUSjpEuB+4Aq4NaIeE7SNcCciJgJ/AD4iaQFJDWIc4oVn5mZ7a5oSQIgImYBs9qsuzpjeRvwnmLGZGZm2bnHtZmZZeUkYWZmWTlJmJlZVk4SZmaWlbr7G6aSVgL/3MPda4FVeQynu6jE6/Y1VwZfc+72i4hOeyN3+ySxNyTNiYi6UsdRbJV43b7myuBrzj8/bjIzs6ycJMzMLKtKTxI3lzqAEqnE6/Y1VwZfc55VdJuEmZl1rNJrEmZm1oGKSBKVOLd2Dtd8haR5kuZKekDSfqWIM586u+aMcmdLCkk94i2YXK5b0nvTv+/nJP2s2DHmWw7/vidIekjSU+m/8TNKEWe+SLpV0gpJz2bZLknfSn8fcyUdnbeTR0SP/iEZcfZlYH+gGngGmNKmzMeB76bL5wB3lDruIlzzW4D+6fLFlXDNablBwJ+B2UBdqeMu0t/1ZOApYFj6eWSp4y7CNd8MXJwuTwEWlTruvbzmk4GjgWezbD8DuJdk4rbjgMfyde5KqElU4tzanV5zRDwUEVvSj7NJJoHqznL5ewa4FvgKsK2YwRVQLtf9EeDGiFgLEBErihxjvuVyzQEMTpeHsPsEZ91KRPyZjidgmwH8OBKzgaGSRufj3JWQJPI2t3Y3kss1Z7qQ5FtId9bpNUs6ChgfEfcUM7ACy+Xv+iBnlJjFAAAGb0lEQVTgIEmPSJotaXrRoiuMXK75i8D5kupJpif4RHFCK5mu/p/PWVHnkyiRvM2t3Y3kfD2SzgfqgDcXNKLC6/CaJfUCvgFcUKyAiiSXv+veJI+cppLUGP8i6bCIWFfg2Aoll2s+F7gtIr4m6XiSycwOi4jmwodXEgW7h1VCTaIS59bO5ZqRdBrwWeDMiNhepNgKpbNrHgQcBjwsaRHJc9uZPaDxOtd/37+JiB0R8QownyRpdFe5XPOFwC8AIuJRoC/JGEc9VU7/5/dEJSSJSpxbu9NrTh+9fI8kQXT3Z9TQyTVHxPqIqI2IiRExkaQd5syImFOacPMml3/fd5O8qICkWpLHTwuLGmV+5XLNrwKnAkg6hCRJrCxqlMU1E/hA+pbTccD6iFiWjwP3+MdNUYFza+d4zTcAA4E70zb6VyPizJIFvZdyvOYeJ8frvg/4F0nzgCbgyohYXbqo906O1/xJ4BZJl5M8drmgO3/xk/RzkseFtWk7yxeAPgAR8V2SdpczgAXAFuBDeTt3N/69mZlZgVXC4yYzM9tDThJmZpaVk4SZmWXlJGFmZlk5SZiZWVZOElZxJL1f0m5DFkiqSt+7L8Q5983TcaolHZqPY5nlwknCKkqaBG4B3i2pWdI6SRskLQWmAa9Iqpe0uWUI6rSDUk1ngz6m5fqlvfbbul/SlyUdKemw9OdISQdk7H+WpJc6uYRTgKfSTnFmBdfjO9OZtTEV2AHcAVwREROVzB/yp4j4PemgaJJuAzan+7QOnpbj4MDvIRlNmHSfA0iGBDkH+DZwDEnv31XAH4Cr06IbSTpCtex3OXAJsJ2d4/BUkXSielxSS3wCaoCfRUTLsczywknCKs15JD11245V1V6v0h3pn8uAUennzHL3kowP9MP0s0hu4pvaHOdS4G8RMY9kGPqngGsj4tcAkv4K3AU80eb4t5DMfTE3InZIGgT8BTgTuL9lvC1JfYDTgYc7u3izrvLjJqsY6U32XcCLO1dpINAf6CWpd5tHRQKIiKaIWBERayNiXcsPyRAXWzPWrY2IVRGxLeOctSSDzS3IOO4EkklzWmwgGZ6+rZEkY/J8RdIAkmT0R+B+4DeSbpY0GPgJ8FWSYVbM8spJwirJRSSjwbYYC7xActNdBXwYWCZpCXBa250ljZTUv4vnvJaMm7ekI4HhwJ/TtpB/J3nE1Nh2x4hYSDKM+0LgGpIaxFRgLslIxVeSzM5WBRwTEd16Yh0rT37cZBVB0gTgc8AjGavr0zaJXiT/F6aQDJLW8sin7Siaz6TH+EGWcwiozngMNJUkMWXOKf1B4LcRcaaku4DlHcUdEcsk3UdSq5kFvJOkTeMC4ESSR16/JaMtwyyfXJOwSrEK+Azw+4x1EyStI3nU8zngP4GbgP9D0vD8jjbHaGD3tozvSApJATQD2yT1Tbf9laQRezZA+urqxSRDtAO8jmRI63alr7t+hqQdYjtJu8MkkgbwE4Ffkcx9/AngT5K6+xS0VoacJKwiRMSWiPhOm9WvRsTQiBiUvhX0I+DRiDifpBbxVNvDtHPoiyNCESGS/08DW9okIqKxpXE69QGS2sB/SPo2ySQxT3YQ9i0kieFIknaNj5E8XlpEMlfCXODzwAkkbRxv6eh3YLYn/LjJbKc/A19IawKTSB4v5Sydr2BzB9s/nbZpDCV5RPRQRGxL305q7wvbFcDGiGiQdB3JHAJTgH9ExHlpo3VzRDSwc9Iss7xykrBK1vK4qRr4XkRcLmklcD1wV+ZbSvkSEVsk7SBpzP55uvplksdhrSSdQvJm0xZJDRmbeqfb6zPKtqzvB7wnIu7Pd9xWuZwkrJK9mtFw3fJN/gfAj4GjC3jer5E0NN8BEBFXQGtDN+m6B2nnlVZJh5HUJNz+YEXhJGGVpiUh9GlZERHNQLOk00leWX0Y+Kak9wOvAQeQNFr3Jpk+cmK6aw2wT8Zn0jIREZn9IKqBPpKGkSSIdwAnRkQTtA4VchZwPO33l8ikdB915+k4rftwkrBKUw30JbnBt5I0i6RX9Xsj4u+SPk/SJnF0+mfL0BhfTH9aXJn+tKgC/kkyDEeLmvRnH5KE85aImN+yMW1zuJik78O1ncTfktz6Als7KWu21zzHtRkgaTiwNvPbuaShac9qs4rlJGFmZlm5n4SZmWXlJGFmZlk5SZiZWVZOEmZmlpWThJmZZfX/AYfthoLE38K1AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "AUC = getRocAndAuc(train,test,0.001,100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8526810724289714"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "AUC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "result = predict(trainSet,testSet,0.001,100,0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test['Survived'] = result\n",
    "df_test[['PassengerId','Survived']].to_csv('results-rf2.csv',index=False)"
   ]
  },
  {
   "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}