Logistic_result_v2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "from sklearn import metrics\n",
    "from sklearn.model_selection import train_test_split , cross_val_score\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "import multiprocessing\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class data_proc():\n",
    "    \n",
    "    def process_zip():\n",
    "        #dealing with zipcode\n",
    "        zip_data=pd.read_csv('ZIP.csv')\n",
    "        zip_data['Zip']=zip_data['Zip'].astype(str)\n",
    "        for i in range(len(zip_data['Zip'])):\n",
    "            if len(zip_data['Zip'][i])==4:\n",
    "                zip_data['Zip'][i]='0'+zip_data['Zip'][i]\n",
    "        zip_data['Zip']=[zip_data['Zip'][i][0:3] for i in range(len(zip_data))] \n",
    "        zip_data.iloc[:,-3:]=zip_data[['Median','Mean','Pop']].apply(lambda x: x.str.replace(',',''))\n",
    "        for i in range(1,4):\n",
    "            zip_data.iloc[:,-i]=pd.to_numeric(zip_data.iloc[:,-i],errors='coerce')\n",
    "        zip_data['weight']=zip_data['Pop']/zip_data.groupby('Zip')['Pop'].transform(sum)\n",
    "        zip_data['new_mean']=zip_data['Mean']*zip_data['weight']\n",
    "        zip_data['new_median']=zip_data['Median']*zip_data['weight']\n",
    "        zip_new=pd.DataFrame()\n",
    "        zip_new=zip_data.groupby('Zip')['new_mean','new_median'].sum()\n",
    "        return zip_new\n",
    "        \n",
    "    def readcsv():\n",
    "        LARGE_FILE = \"C:\\\\Users\\Administrator\\Desktop\\practicum_regression\\loan_data_no_current_converted.csv\"\n",
    "        CHUNKSIZE = 100000 # processing 100,000 rows at a time\n",
    "        reader = pd.read_csv(LARGE_FILE, chunksize=CHUNKSIZE, low_memory=False)\n",
    "        frames = []\n",
    "        for df in reader:\n",
    "            frames.append(df)\n",
    "        loan_data = pd.concat(frames)\n",
    "        return loan_data   \n",
    "    def cleaning(df,zip_new,keep_desc=True,categorical_to_binary=True):\n",
    "        df=df.dropna(axis=0,how='all')\n",
    "        drop_list=['installment','term','settlement_date','pymnt_plan','hardship_length', 'settlement_percentage', 'settlement_term', 'sec_app_earliest_cr_line','policy_code','hardship_end_date','settlement_amount',\n",
    "           'payment_plan_start_date','hardship_start_date','out_prncp','emp_title','title','earliest_cr_line','desc','issue_d','id','member_id','url','grade','sub_grade',\n",
    "                   'int_rate','avg_cur_bal','out_prncp_inv','debt_settlement_flag_date','hardship_amount','hardship_reason','addr_state','funded_amnt','funded_amnt_inv','collection_recovery_fee',\n",
    "                   'collections_12_mths_ex_med','mths_since_last_major_derog','next_pymnt_d','recoveries','total_pymnt',\n",
    "                   'total_pymnt_inv','total_rec_int','last_pymnt_d','last_credit_pull_d',\n",
    "                  'total_rec_prncp','settlement_status','hardship_loan_status','hardship_status','debt_settlement_flag',\n",
    "                   'verification_status','total_rec_late_fee','verification_status_joint','hardship_flag', 'hardship_type', 'hardship_reason',\n",
    "                    'hardship_status','hardship_loan_status','acc_now_delinq','delinq_amnt','deferral_term','hardship_amount',\n",
    "                    'hardship_length','hardship_dpd','hardship_payoff_balance_amount','hardship_last_payment_amount']\n",
    "        df.drop(drop_list,inplace=True,axis=1,errors='ignore')\n",
    "        #deal with percentage mark\n",
    "        df['revol_util']=df['revol_util'].replace('%','',regex=True).astype('float')/100\n",
    "        #merge zipcode with census data\n",
    "        df['zip_code']=df['zip_code'].apply(lambda x: x[:3])\n",
    "        df=df.join(zip_new,on='zip_code')\n",
    "        df.drop('zip_code',inplace=True,axis=1)\n",
    "        #drop the observation that was missing for ALL field\n",
    "        df=df.dropna(axis=0,how='all')\n",
    "        #drop the features for which greater than 10% of the loans were missing data for\n",
    "        num_rows=df.count(axis=0)\n",
    "        df=df.iloc[:,(num_rows>=0.8*len(df)).tolist()]\n",
    "        #drop the observation that was missing for any field\n",
    "        df=df.dropna(axis=0,how='any')\n",
    "        #label the dataset to create y\n",
    "        #0:fully paid, does not meet policy:fully paid\n",
    "        #1:Does not meet the credit policy. Status:Charged Off\",default,charge of\n",
    "        df=df[(True^df['loan_status'].isin([4]))] \n",
    "        df=df[(True^df['loan_status'].isin([5]))]\n",
    "        df=df[(True^df['loan_status'].isin([6]))] \n",
    "        #label the dataset to create y\n",
    "        y=df['loan_status'].replace(1,0)\n",
    "        y=y.replace(2,0)\n",
    "        y=y.replace(3,1)\n",
    "        y=y.replace(7,1)\n",
    "        y=y.replace(8,1)\n",
    "        df=df.drop(['loan_status'],axis=1) \n",
    "        return df,y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = data_proc.readcsv()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "891823"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(df1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "drop_list=['installment','term','settlement_date','pymnt_plan','hardship_length', 'settlement_percentage', 'settlement_term', 'sec_app_earliest_cr_line','policy_code','hardship_end_date','settlement_amount',\n",
    "           'payment_plan_start_date','hardship_start_date','out_prncp','emp_title','title','earliest_cr_line','desc','issue_d','id','member_id','url','grade','sub_grade',\n",
    "                   'int_rate','avg_cur_bal','out_prncp_inv','debt_settlement_flag_date','hardship_amount','hardship_reason','addr_state','funded_amnt','funded_amnt_inv','collection_recovery_fee',\n",
    "                   'collections_12_mths_ex_med','mths_since_last_major_derog','next_pymnt_d','recoveries','total_pymnt',\n",
    "                   'total_pymnt_inv','total_rec_int','last_pymnt_d','last_credit_pull_d',\n",
    "                  'total_rec_prncp','settlement_status','hardship_loan_status','hardship_status','debt_settlement_flag',\n",
    "                   'verification_status','total_rec_late_fee','verification_status_joint','hardship_flag', 'hardship_type', 'hardship_reason',\n",
    "                    'hardship_status','hardship_loan_status','acc_now_delinq','delinq_amnt','deferral_term','hardship_amount',\n",
    "                    'hardship_length','hardship_dpd','hardship_payoff_balance_amount','hardship_last_payment_amount']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "def readcsv_FE():\n",
    "        LARGE_FILE = \"C:\\\\Users\\Administrator\\Desktop\\practicum_regression\\This_week_FE.csv\"\n",
    "        CHUNKSIZE = 100000 # processing 100,000 rows at a time\n",
    "        reader = pd.read_csv(LARGE_FILE, chunksize=CHUNKSIZE, low_memory=False)\n",
    "        frames = []\n",
    "        for df in reader:\n",
    "            frames.append(df)\n",
    "        loan_data = pd.concat(frames)\n",
    "        return loan_data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "df2 = readcsv_FE()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.concat([df1,df2],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['coll_to_cur'].replace('#DIV/0!',0.01177,inplace=True)\n",
    "df['ratio_rev_acct'].replace('#DIV/0!',0.42676,inplace=True)\n",
    "df['loan_amt_to_avg_inc'].replace('#DIV/0!',0,inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "zipdata = data_proc.process_zip()\n",
    "x,y = data_proc.cleaning(df,zipdata,keep_desc=False,categorical_to_binary=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "59"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(x.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "657786"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "class log_reg():\n",
    "    # Evaluate the model by splitting into train and test sets\n",
    "    def split(x,y,rand=0):\n",
    "        \n",
    "        y = np.ravel(y)\n",
    "        x_train, x_test, y_train, y_test = train_test_split(x,y, test_size=0.25,random_state=rand)\n",
    "        \n",
    "        return x_train, x_test, y_train, y_test \n",
    "    #we need to add validation dataset here\n",
    "    \n",
    "    # Find binary column method one\n",
    "    def bool_cols(df,isbool=True):\n",
    "        bool_cols=[]\n",
    "        for col in df:\n",
    "            if isbool==True:\n",
    "                if df[col].dropna().value_counts().index.isin([0,1]).all():\n",
    "                    bool_cols.append(col)\n",
    "            else:\n",
    "                if not df[col].dropna().value_counts().index.isin([0,1]).all():\n",
    "                    bool_cols.append(col)\n",
    "        return bool_cols\n",
    "    # this above step is to facilitate normalization later\n",
    "    # method two\n",
    "    def not_bi(x):\n",
    "        not_bi=[]\n",
    "        for i in list(x):\n",
    "            u=x[i].unique()\n",
    "            if not (0 in u and 1 in u and len(u)==2): #if not binary\n",
    "                not_bi.append(i)\n",
    "        return not_bi\n",
    "    \n",
    "    def reg(x_train, y_train):\n",
    "           \n",
    "        model = LogisticRegression(penalty='l2',class_weight='balanced',solver='sag',n_jobs=-1)\n",
    "        \n",
    "        \"\"\"\n",
    "        Why we need standardize?\n",
    "        \n",
    "        Note that ‘sag’ and ‘saga’ fast convergence is only guaranteed on features \n",
    "        with approximately the same scale. You can preprocess the data with \n",
    "        a scaler from sklearn.preprocessing.\n",
    "        \"\"\"\n",
    "        \n",
    "        model = model.fit(x_train, y_train)\n",
    "        \n",
    "        return model\n",
    "    \n",
    "    def ModelValuation(x_test,y_test,model):\n",
    "        \n",
    "        probs = model.predict_proba(x_test)\n",
    "        fpr, tpr, thresholds = metrics.roc_curve(y_test, probs[:, 1])\n",
    "        \n",
    "        plt.figure(1)\n",
    "        plt.plot(fpr, tpr, label='LogisticRegression')\n",
    "        plt.xlabel('False positive rate')\n",
    "        plt.ylabel('True positive rate')\n",
    "        plt.title('ROC curve')\n",
    "        plt.legend(loc='best')\n",
    "        plt.show()\n",
    "        \n",
    "        print(\"Area Under the Curve (AUC) from prediction score is %f\" % metrics.roc_auc_score(y_test, probs[:, 1]))\n",
    "    \n",
    "        return None  \n",
    "    \n",
    "    def y_pred(x_test,threshold=0.5):\n",
    "        \n",
    "        if threshold == 0.5:\n",
    "            y_predicted = model.predict(x_test)\n",
    "        else:\n",
    "            probs = model.predict_proba(x_test)\n",
    "            y_predicted = np.array(probs[:,1] >= threshold).astype(int)\n",
    "        \n",
    "        return y_predicted    \n",
    "    \n",
    "    def GetScores(y_test,y_predicted):\n",
    "        #G means score \n",
    "        CM = metrics.confusion_matrix(y_test, y_predicted)\n",
    "        TN = CM[0,0]\n",
    "        FN = CM[1,0]\n",
    "        TP = CM[1,1]\n",
    "        FP = CM[0,1]\n",
    "        \n",
    "        sensitivity = float(TP)/float(TP+FN)\n",
    "        specificity = float(TN)/float(TN+FP)\n",
    "        G = np.sqrt(sensitivity*specificity)\n",
    "        print(\"G score is %f\" % G)\n",
    "        print(\"Specificity is %f\" % specificity)\n",
    "        \n",
    "        # Generate and display different evaluation metrics\n",
    "        print(\"Mean accuracy score is %f\" % metrics.accuracy_score(y_test, y_predicted))\n",
    "          \n",
    "        print(\"Confusion Marix\")\n",
    "        print(CM)\n",
    "        \n",
    "        return specificity , G\n",
    "        \n",
    "    # Convenience function to plot confusion matrix\n",
    "    def confusion(y_test,y_predicted,title):\n",
    "        \n",
    "        # Define names for the three Iris types\n",
    "        names = ['Default', 'Not Default']\n",
    "    \n",
    "        # Make a 2D histogram from the test and result arrays\n",
    "        pts, xe, ye = np.histogram2d(y_test, y_predicted, bins=2)\n",
    "    \n",
    "        # For simplicity we create a new DataFrame\n",
    "        pd_pts = pd.DataFrame(pts.astype(int), index=names, columns=names )\n",
    "        \n",
    "        # Display heatmap and add decorations\n",
    "        hm = sns.heatmap(pd_pts, annot=True, fmt=\"d\")\n",
    "        hm.axes.set_title(title)\n",
    "        \n",
    "        return None\n",
    "            \n",
    "    def find_threshold(x_test,y_test):\n",
    "    \n",
    "        probs = model.predict_proba(x_test)\n",
    "        fpr, tpr, thresholds = metrics.roc_curve(y_test, probs[:, 1])\n",
    "        \n",
    "        sensitivity = tpr\n",
    "        specificity = 1 - fpr\n",
    "        G = np.sqrt(sensitivity*specificity)\n",
    "        \n",
    "        plt.figure(2)\n",
    "        plt.plot(thresholds,G)\n",
    "        plt.xlabel('Thresholds')\n",
    "        plt.ylabel('G-Scores')\n",
    "        plt.title('G-Scores with different thresholds')\n",
    "        plt.show()\n",
    "        \n",
    "        \n",
    "        print(\"The highest G score is %f with threshold at %f\" % (np.amax(G),thresholds[np.argmax(G)]) )\n",
    "        \n",
    "        return thresholds[np.argmax(G)]\n",
    "    # this is just testing, we add weight so we don't need to adjust threshold"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "F:\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:11: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  # This is added back by InteractiveShellApp.init_path()\n",
      "F:\\Anaconda3\\lib\\site-packages\\pandas\\core\\indexing.py:537: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  self.obj[item] = s\n",
      "F:\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  if sys.path[0] == '':\n",
      "F:\\Anaconda3\\lib\\site-packages\\sklearn\\linear_model\\sag.py:326: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n",
      "  \"the coef_ did not converge\", ConvergenceWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area Under the Curve (AUC) from prediction score is 0.934670\n",
      "G score is 0.873911\n",
      "Specificity is 0.788450\n",
      "Mean accuracy score is 0.826984\n",
      "Confusion Marix\n",
      "[[101930  27349]\n",
      " [  1103  34065]]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXMAAAEICAYAAACtXxSQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xd4HNXZxuHfI8kNcC9gbIIhmA4BAgQnEAgQOhhCTQjVxAm9JUAgmP4FElogBOJQDYQSQ+hgegs9dNNsbIrBGPeOi/R+f8xIWYvVarWWLGn03L7m0u6ZMzNnV+tXZ985c0YRgZmZtW5lzd0AMzNbeg7mZmYZ4GBuZpYBDuZmZhngYG5mlgEO5mZmGeBg3gJJOlLSJElzJPVcyn19Imn7xmrb0pDUSdL9kmZK+tdS7OdASY82Ztuag6SHJR3S3O2wbHAwb2Rp8JwvabakGZJekPQbSUW915LaAZcCO0TEChExtRHbdrakW4qo9wtJr6V/TCamQWfLRmjCPsCKQM+I2LfUnUTErRGxQyO0ZwmStpEUku6uVf69tPzpIvdT1PscETtHxE0lNtdsCQ7mTWP3iOgMrApcCJwKXFfktisCHYHRTdS2giSdBFwO/F/alu8AfwMGN8LuVwU+iojFjbCvpjIZ+GGtb0SHAB811gGU8P89a1wR4aURF+ATYPtaZZsDVcD66fMOwMXAZ8Ak4BqgE7AmMBcIYA7wZFr/L8DnwCzgv8BWOfu+ETg/5/k2wITa7QF2AhYCi9J9v5Wn7V3TdfsWeH0dSIL9l+lyOdAh99jAycDXwETgsHTdObWOPwQ4G7glZ98D0tdekT4/FBgHzAbGAwfmlD+fs90PgVeBmenPH+asexo4D/hPup9HgV51vLbq9l8DHJ2Wladlw4Cnc+rm/Z3U9T6n7bggbcd8YI207Ih0/dXAyJz9XwQ8Aai5P9NeWsfi3sEyEBGvkASErdKii0gC90Yk/6n7AcMi4iNgvbROt4jYNn38alq3B/BP4F+SOjawDY+Q9LbviCR987081QaRfCv4d4FdnQFskbbneyR/qP6Qs34lkj8K/UgC9lWSukfEWbWOX/CbiqTlgSuAnSP5lvND4M089XoAD6Z1e5KkqB6s1bP+BXAY0AdoD/y20LGBEcDB6eMdSb4lfVmrTt7fST3v80HAUKAz8Gmt/Z0MbCjpUElbkbx3h0SE59uwojiYLztfAj0kCfgVcGJETIuI2ST/+Q+oa8OIuCUipkbE4oi4hKR3vFYTtLEnMCUKp0EOBM6NiK8jYjJJj/ugnPWL0vWLIuIhkt5pqW2tAtaX1CkiJkZEvtTTrsCYiLg5fX9uAz4Ads+pc0NEfBQR84E7SYJwnSLiBZLf1VokQX1Enjql/E5ujIjR6TaLau1vHvBLkj9GtwDHRsSEevZnVsPBfNnpB0wDegPLAf9NT5DOAB5Jy/OSdLKk99NRIDNIer69mqCNU4FekioK1FmZJXuVn6ZlNfuo9cdgHrBCQxsSEXOB/YHfABMlPShp7SLaU92mfjnPvyqhPTcDxwA/Ic83lRJ/J58XWpl+gxsHiOSPjlnRHMyXAUmbkQSX54EpJDnT9SKiW7p0jYi8ASb9yn0qsB/QPSK6keSGlVaZS/LHodpKBZpS31f2F4FvgD0L1PmS5ERmte/w7RREsQq2PSJGRcRPgb4kve1/FNGe6jZ9UWKbqt0MHAU8lPaaaxTxO6nrfS74/ks6mqSH/yVwSulNt7bIwbwJSeoiaTfgdpITfe9ERBVJULpMUp+0Xj9JO9axm87AYpJRFhWShgFdcta/CewiqYeklYATCjRpEjCgrpEUETGT5ETfVZL2lLScpHaSdpb0p7TabcAfJPWW1CutX+8wvDq8CfxY0nckdQV+X71C0oqS9khz5wtI0jWVefbxELBmOpyyQtL+wLrAAyW2CYCIGA9sTXKOoLb6ficF3+d8JK0JnE+SajkIOEVSwXSQWS4H86Zxv6TZJF+rzyDJgx6Ws/5UYCzwkqRZwOPUnW8dBTxMMjTuU5Kec+7X9ZuBt0hGrTwK3FGgXdUX6kyV9Hq+ChFxKXASyUnNyemxjgHuSaucD7wGvA28A7yeljVYRDyWtvdtkhEhuQG4jOSk4Jck6amtSXrKtfcxFdgtrTuVpEe7W0RMKaVNtfb9fETk+9ZR3++k3vc5V5rWugW4KCLeiogxwOnAzZI6LM1rsLZDPlluZtb6uWduZpYBDuZmZhngYG5mlgEO5mZmGVDo4pBGsWjKOJ9htW85atNTm7sJ1gL945N/qf5ahTUk5rTrtfpSH6+lcM/czKwOkq6X9LWkd3PKekh6TNKY9Gf3tFySrpA0VtLbkjbJ2eaQtP6Y3DnsJX1f0jvpNlek033UeYxCHMzNLFuqKotf6ncjyUyYuU4DnoiIgSQzW56Wlu8MDEyXoSQzYVZPBncW8AOSienOygnOV6d1q7fbqZ5j1MnB3MyypXJx8Us9IuJZkovWcg0Gqm8qchP/m/5iMDAiEi8B3ST1JZl587F0Yr3pwGPATum6LhHxYjo75oha+8p3jDo1ec7czGxZSmbMaFIrRsTE5FgxsXpaDpL5l3KvBJ6QlhUqn5CnvNAx6uRgbmbZUlV8MJc0lCTNUW14RAwv8cj5TqZGCeUlcTA3s2xpQM88DdwNDd6TJPVNe8x9Se6qBUnPepWcev1J5haaQHIXq9zyp9Py/nnqFzpGnZwzN7NsadwToPncR3JfWNKf9+aUH5yOatkCmJmmSkYBO0jqnp743AEYla6bLWmLdBTLwbX2le8YdXLP3MyypRFz5pJuI+lV95I0gWRUyoXAnZKGkNzHd9+0+kPALiQzos4jnSk1IqZJOo/kVoOQ3Imr+qTqkSQjZjqRzMT5cFpe1zHq5GBuZpkSRYxSKXpfET+vY9V2eeoGcHQd+7keuD5P+WvA+nnKp+Y7RiEO5maWLQ04AZolDuZmli1NPzSxRXIwN7NsKf3EZqvmYG5m2eKeuZlZBjTiCdDWxMHczLLFJ0DNzFq/COfMzcxaP+fMzcwywGkWM7MMcM/czCwDKhc1dwuahYO5mWWL0yxmZhngNIuZWQa4Z25mlgEO5mZmrV/4BKiZWQY4Z25mlgFOs5iZZYB75mZmGeCeuZlZBrhnbmaWAYt9cwozs9bPPXMzswxwztzMLAPcMzczywD3zM3MMsA9czOzDPBoFjOzDIho7hY0CwdzM8sW58zNzDLAwdzMLAN8AtTMLAMqK5u7Bc3CwdzMsqWNplnKmrsBZmaNqqqq+KUekk6UNFrSu5Juk9RR0mqSXpY0RtIdktqndTukz8em6wfk7Of3afmHknbMKd8pLRsr6bSledkO5maWLVFV/FKApH7AccCmEbE+UA4cAFwEXBYRA4HpwJB0kyHA9IhYA7gsrYekddPt1gN2Av4mqVxSOXAVsDOwLvDztG5JHMzNLFOiKopeilABdJJUASwHTAS2BUam628C9kwfD06fk67fTpLS8tsjYkFEjAfGApuny9iIGBcRC4Hb07olcTA3s2xppDRLRHwBXAx8RhLEZwL/BWZERPVlphOAfunjfsDn6baL0/o9c8trbVNXeUkczM0sWyori14kDZX0Ws4ytHo3krqT9JRXA1YGlidJidRW3cVXHesaWl4Sj2Yxs2xpwGiWiBgODK9j9fbA+IiYDCDpbuCHQDdJFWnvuz/wZVp/ArAKMCFNy3QFpuWUV8vdpq7yBnPP3MyypfFGs3wGbCFpuTT3vR3wHvAUsE9a5xDg3vTxfelz0vVPRkSk5Qeko11WAwYCrwCvAgPT0THtSU6S3lfqy3bPvAh/+L9LefY/r9CjezfuueUaAGbOms3JZ/6RL7+axMorrcgl5/2erl06M+7Tzznzgkt576OxHDf0EA77xT41+7n5znu4675HiAj22WMnDtp/LwCuHD6CJ59/kTKV0aN7Vy4442T69O5JRPDHy6/huRdfpWPHDlxwxsmsu9YazfIeWGHd+/bk8EuPoWvvbkRV8Oxtj/PEDQ8x9K8nstLqKwPQqctyzJ81j3N3+R0DvrcGB//x18nGgvsv/xdvjHqlZn8qK+MP91/IjK+mceWQCwFYe9D67HPGQVS0q+DTd8dx0ylXU1XZNsdUF9RIE21FxMuSRgKvA4uBN0h68Q8Ct0s6Py27Lt3kOuBmSWNJeuQHpPsZLelOkj8Ei4GjI6ISQNIxwCiSkTLXR8ToUturaOIZxhZNGdfqpzB77c13WK5TJ04/7+KaYH7JVdfRtUtnjjhoP669+U5mzZ7NSUcNYer0GXz51SSefPZFunReoSaYjxn3Cb8bdiG3XXs57Sra8ZuT/8CZvz2GVVfpx5y5c1lh+eUBuOVf9/Lx+M8465RjefaFV/jnXfdz9cXn8vboD7jwL3/ntn9c3mzvQ2M6atNTm7sJjapr72507dOdz0aPp8PyHTnz/ou4auifmTh2Qk2dfc84mPmz5/HAFSNp37E9ixctpqqyiq69uzHs4Yv53Q+G1gTnnw7ZjVU3/C6dVujElUMuRBIX/udvXHrguUwaP5E9TtyfaV9M5vk7n2yul9wk/vHJv/LlkRtk3qW/KjrmLHfSP5b6eC1FUWkWSccXU5ZVm260AV27dF6i7KnnXmTwztsDMHjn7Xny2RcB6Nm9GxussxYVFUt+6Rn3yedsuN7adOrYkYqKcjbdaAOeePYFgJpADjB//jco/Xg99fxL7LHTdkjie+uvw+zZc5g8ZVpTvUxbCjMnz+Cz0eMBWDD3GyZ+/AXdVuqxRJ1Ndx3EK/c9D8DCbxbWBO52Hdov0ZvsvlIPNth2E56//YmasuW7d2bxwsVMGj8RgPeff4tNdv5Bk76mVqsqil8ypNic+SF5yg5txHa0OlOnz6B3r+Q/a+9ePZg2Y2bB+musvir/fetdZsycxfxvvuG5F1/lq0mTa9b/5e83st1eB/Hgo09xzBEHATBp8lRW6tOrps6KfXoxafKUJng11ph69u/NKuuuxvg3x9SUDdx8HWZNmcnXn3xVU7baRmtwzqOXctaoS7jlD/+oCe77DzuMkX+8haqci1rmTJtFeUU5q26wOgCb7DKI7n3/99mwHA0YzZIlBYO5pJ9Luh9YTdJ9OctTwNQC29UM97l2xG2N3eZW6bsDvsPhB+7Lr044nd+cdCZrrrE65eXlNeuP//WhPPHvm9l1h5/wz7vuByBfCkzKzLfCTOqwXEeOvPq33HHuDXwzZ35N+eZ7bFnTK682/s2xnLXDSVywx2nsfOReVHRox4bbbsKsqTP57N1x39r38OMuZ/8zD+X0e/7IgjnzqcpYMGosUVVV9JIl9Z0AfYFksHwv4JKc8tnA23VtlDvcJws583x6du/G5CnT6N2rB5OnTKNHt671brP37juy9+7JtAyXX3PjEr3uarvusA1H/fYsjjniIFbq04uvvv5fT3zS11Po06tn470Ia1TlFeUcec3JvHzPc0uczCwrL2OTHTfn/N3znyf46uMvWDD/G/qtuQrf3XRtNtp+Uzb4yca069Cejit0Yshlx3LdiVcy7vWP+NN+wwBYd6sNWXG1vsvkdbU6GUufFKtgzzwiPo2IpyNiUEQ8k7O8nnMFVJu0zZZbcO/DjwNw78OP85OtBtW7zdTpMwCY+NXXPPHMf9h5+60B+PTzL2rqPPXcS6y2av+aY9z3yBNEBG+9+z4rrLB8TWrHWp5DLjqSiWO/4LHrHliifJ0tN2TiuC+Z/tX/znf06t+HsvLkv1+Pfr1YafWVmTphMv/+0z85ZdBv+P2WRzP82Mv48IV3ue7EKwHo3LMLABXtK9jpN3vyzK2PLaNX1so00twsrU3Bnrmk2eS/IklARESXJmlVC/O7sy7k1TfeZsaMWWy35y85ashBHHHQfpx85v9x9wOj6Ltiby49/wwApkydxv5DjmPO3HmUlZVxy533cO+tf2eF5ZfnxNPPZ8asWVRUVHDGyUfVnFS97Oob+OSzCahMrLxSH4b97lgAfjxoM5578VV23u9wOnXsyHmnn9hs74EVtsamazNo762Z8P6nDHvozwDc/ad/8u7Tb7D57j/i1VopljU2W5udj9yTysWVVFVVceuZ1zJn+uyCx9hx6GA23G4TpDKevnUUH7z4bpO9nlatjfbMPTTRmkXWhiZa42iMoYlzhx1QdMxZ/tzbM3MSqqiLhiR9J195RHzWuM0xM1tKGUufFKvYK0AfzHnckWTimQ9J5uc1M2s52miapahgHhEb5D6XtAnw6yZpkZnZUsjakMNilTQ3S0S8Lmmzxm6MmdlSc8+8bpJOynlaBmwCTK6juplZ83EwLyh3YpLFJDn0uxq/OWZmS6mNXhlbbM78nKZuiJlZYyjy3p6ZU2yapTdwCsnolY7V5RGxbRO1y8ysNG00mBc7a+KtwAckQxLPAT4huUuGmVnL0nh3GmpVig3mPSPiOmBROjfL4cAWTdguM7PStNH5zIs9Aboo/TlR0q4kNx3t3zRNMjNbChkL0sUqNpifL6krcDJwJdAF8KxPZtbiRBu9L2p9syZeFBGnAp0iYiYwE/jJMmmZmVkp2mjPvL6c+S6S2gG/XxaNMTNbWlEVRS9ZUl+a5RFgCrC8pFmk85jTxuYzN7NWJGNBulj13WnodxHRFXgwIrpEROfcn8uojWZmxatqwJIhxV4BOljSqsDAiHhcUiegIiIK3xrFzGwZi8UZi9JFKmqcuaRfASOBv6dF/YF7mqpRZmYlc8+8oKOBzYGXASJijKQ+TdYqM7MSZe3EZrGKDeYLImKhlNwuT1IF+W/0bGbWvDLW4y5WscH8GUmnA50k/RQ4Cri/6ZplZlaattozL3ZultNIbkbxDsnt4h4C/tBUjTIzK5lz5nWLiCpJ9wD3RITvMGRmLVYsbu4WNI+CPXMlzpY0hWQK3A8lTZY0bNk0z8ysYaKq+CVL6kuznAD8CNgsInpGRA/gB8CPJHmiLTNredpomqW+YH4w8POIGF9dEBHjgF+m68zMWpS22jOvL2feLiKm1C6MiMnpBFxmZi1K1oJ0seoL5gtLXGdm1iyiUs3dhGZRX5rle5Jm5VlmAxssiwaamTVEY6ZZJHWTNFLSB5LelzRIUg9Jj0kak/7sntaVpCskjZX0tqRNcvZzSFp/jKRDcsq/L+mddJsrVH1lZgnqmzWxPJ0lsfbSOSKcZjGzFieqVPRShL8Aj0TE2sD3gPdJrrt5IiIGAk+kzwF2Bgamy1DgagBJPYCzSAaPbA6cVf0HIK0zNGe7nUp93cVeNGRm1io0Vs9cUhfgx8B1ABGxMCJmAIOBm9JqNwF7po8HAyMi8RLQTVJfYEfgsYiYFhHTgceAndJ1XSLixYgIYETOvhrMwdzMMiVCRS+Shkp6LWcZmrOr1UmufL9B0huSrpW0PLBiRExMjhUTgepJB/sBn+dsPyEtK1Q+IU95SYqdm8XMrFVoyGiWiBgODK9jdQWwCXBsRLws6S/8L6WST768TZRQXhL3zM0sU6oqVfRSjwnAhIh4OX0+kiS4T0pTJKQ/v86pv0rO9v2BL+sp75+nvCQO5maWKY11AjQivgI+l7RWWrQd8B5wH1A9IuUQ4N708X3Awemoli2AmWkaZhSwg6Tu6YnPHYBR6brZkrZIR7EcnLOvBnOaxcwypchRKsU6FrhVUntgHHAYSSf4TklDgM+AfdO6DwG7AGOBeWldImKapPOAV9N650bEtPTxkcCNQCfg4XQpiYO5mWVKNOJ05hHxJrBpnlXb5akbJHdly7ef64Hr85S/Bqy/lM0EHMzNLGMauWfeajiYm1mmRDiYm5m1epVtdG4WB3MzyxT3zM3MMsA5czOzDGjM0SytiYO5mWWKe+ZmZhlQWdU2L2x3MDezTHGaxcwsA6o8msXMrPXz0EQzswxwmqWJdFp5q6Y+hLVCw/pu09xNsIxymsXMLAM8msXMLAPaaJbFwdzMssVpFjOzDPBoFjOzDKhq7gY0EwdzM8uUwD1zM7NWb7HTLGZmrZ975mZmGeCcuZlZBrhnbmaWAe6Zm5llQKV75mZmrV8bvWucg7mZZUuVe+ZmZq2fJ9oyM8sAnwA1M8uAKjnNYmbW6lU2dwOaiYO5mWWKR7OYmWWAR7OYmWVAWx3N0jbvfGpmmVWl4pdiSCqX9IakB9Lnq0l6WdIYSXdIap+Wd0ifj03XD8jZx+/T8g8l7ZhTvlNaNlbSaUvzuh3MzSxTqhqwFOl44P2c5xcBl0XEQGA6MCQtHwJMj4g1gMvSekhaFzgAWA/YCfhb+geiHLgK2BlYF/h5WrckDuZmlimVKn6pj6T+wK7AtelzAdsCI9MqNwF7po8Hp89J12+X1h8M3B4RCyJiPDAW2DxdxkbEuIhYCNye1i2Jg7mZZUpDeuaShkp6LWcZWmt3lwOn8L+OfE9gRkQsTp9PAPqlj/sBnwOk62em9WvKa21TV3lJfALUzDKlIVeARsRwYHi+dZJ2A76OiP9K2qa6ON9u6llXV3m+znTJ528dzM0sUxrxFqA/AvaQtAvQEehC0lPvJqki7X33B75M608AVgEmSKoAugLTcsqr5W5TV3mDOc1iZpnSWCdAI+L3EdE/IgaQnMB8MiIOBJ4C9kmrHQLcmz6+L31Ouv7JiIi0/IB0tMtqwEDgFeBVYGA6OqZ9eoz7Sn3d7pmbWaYsg8v5TwVul3Q+8AZwXVp+HXCzpLEkPfIDACJitKQ7gfeAxcDREVEJIOkYYBRQDlwfEaNLbZSDuZllSlNczh8RTwNPp4/HkYxEqV3nG2DfOra/ALggT/lDwEON0UYHczPLFE+Ba2aWAQ7mZmYZ0FbnZnEwN7NM8RS4ZmYZ4JtTmJllQFUbTbQ4mJtZpvgEqJlZBrTNfrmDuZlljHvmZmYZsFhts2/uYG5mmdI2Q7mDuZlljNMsZmYZ4KGJZmYZ0DZDuYO5mWWM0yxmZhlQ2Ub75g7mZpYp7pmbmWVAuGduZtb6uWduJfnH8EvYdZft+XryFDbaeDsA9t57N4adeRLrrD2QQT/clf++/nZN/VNPOYbDDj2AyqoqTjzxTB597Bk6dOjA00/eRfsOHaioKOfuux/knHMvaa6XZCUo79COQ+88k/L2FZRVlPP+Q6/wzGV31azf6ZyD2Wjfrblw3SFJ/fYV7HnpkfTdYADzp89h5DFXMnPCFAD6rL0Ku/1xCO1X6ERUBdfucSaVCxZx8O1nsEKfbiz+ZhEAtxx0IfOmzlr2L7aF89BEK8mIEXfyt7/dwA03/KWmbPToD9h3v19x9VUXLlF3nXUGst9+g9lwo21ZeeUVGfXw7ayz3lYsWLCA7XfYj7lz51FRUcGzT/+bRx55ipdfeX1ZvxwrUeWCRYz4+QUsmreAsopyDhs5jLFPv8UXb4yl7war0bHL8kvU33j/bZg/cy5/3fpk1tt9C7Y/7efcdcyVqLyMvS4/intOvJpJ739Gp24rULVocc12/z7+b0x8Z/yyfnmtStsM5VBWXwVJHYopa6uee/5lpk2fsUTZBx+M5aOPPv5W3T1235E777yXhQsX8sknn/Pxx5+w+WYbAzB37jwA2rWroKJdOyLa6key9Vo0bwEAZRXllLUrhwhUJn56xi94/I+3LVF3rZ9+n7fvehaA9x56hdV+tB4A3/3xBkz64DMmvf8ZAPNnzCGq/FloiMVE0UuWFNMzfxHYpIgyq8fKK6+0RG97whcTWbnfSgCUlZXxysuPsMZ3B3D1NTfyyqtvNFczrUQqE7964AJ6DFiRV0c8xhdvfszmh+3Ih4/9lzlfL/kHv/NK3Zn55TQAorKKb2bPo1P3Fei5Wl8IOHDEqSzXszOj73uJF/7+QM12e1z8a6KyivcfeYXnrrhnmb6+1sInQGuRtBLQD+gkaWOg+s56XYDlCu1U0lBgKIDKu1JWtnyh6m2G9O2bE1b3wKuqqth0sx3o2rULd/3rOtZbby1Gj/5wWTfRlkJUBcN3OZ0OXZZj/+En8p3N12bdXX/ATfuf/+3KeT4LBJRVlLHKZmty7e5nsmj+Qg6+7XQmvjue8f8Zzb+P/xuzJ02n/fId2feaE9jwZ1vy9t3PN/0La2Xa6gnQQmmWHYGLgf7ApcAl6XIScHqhnUbE8IjYNCI2dSD/ny++mMgq/Veued6/X18mfjlpiTozZ87imWdfYMcdtlnGrbPGsmDWPD558X0GDFqXHquuyLHPXMpxz19Ou07tOeaZ5MT27InT6LpyDwBUXkbHzssxf8YcZk2cxqcvfcD86XNY/M1Cxjz1JiutPyDZZtJ0ABbO/YZ3732BlTf6brO8vpYuGvAvS+oM5hFxU0T8BDg0In6Ss+wREXcvwzZmxv0PPMp++w2mffv2DBiwCmussRqvvPoGvXr1oGvXLgB07NiR7bbdig8//HbO3Vqu5Xp0pkOX5AtrRYd2rL7lekx8ZzyXbnY0V2x5AldseQKL5i/kr1ufDMCHj7/Ohnv/GIB1d9mc8S+MBuDjZ95mxXVWoaJje1Rexqo/WIcpY75A5WV06r4CkOTkB263MZM/nNAMr7Tlq2rAkiWF0iwn5XtcLSIubapGtSa33HwVW/94EL169eCTca9xzrkXM236DP5y2fn07t2D++4dwVtvjWaX3Q7kvfc+YuTI+3nnradYXFnJccefQVVVFX37rsj1111OeXkZZWVljBx5Pw8+9HhzvzRrgBX6dGPwpb+hrKwMlYn3HniZMU/Wfd7jjTueZq/LjuSYZy5h/oy53HXMlQB8M2seL137MEfcfx5EMPaptxjz5Ju069SBA28+jfKKclRexvjn3+X1255cVi+vValso4MHVNeoCUlnFdowIs4p5gAV7fu1zXfWChrWd5vmboK1QMM+vTXPyYSG+cWqexUdc/756b+X+ngtRZ0982KDtZlZS5K1XHix6h2aKOkG8ozDj4jDm6RFZmZLIWu58GIVM878gZzHHYG9gC+bpjlmZkvHl/PXISLuyn0u6TbAZ+fMrEVymqV4A4HvNHZDzMwaQ1sdzVJMznw2Sc5c6c+vgFObuF1mZiVpq2mWeifaiojOEdEl5+eatVMvZmYtRWNdNCRpFUlPSXpf0mhJx6flPSQ9JmlM+rN7Wi5JV0jUv3iqAAAJRklEQVQaK+ltSZvk7OuQtP4YSYfklH9f0jvpNlco35wfRao3mKcH7C5pc0k/rl5KPaCZWVNqxMv5FwMnR8Q6wBbA0ZLWBU4DnoiIgcAT6XOAnUnS0ANJ5qa6GpLgD5wF/ADYHDir+g9AWmdoznY7lfq6i5kC9wjgWWAUcE768+xSD2hm1pSqiKKXQiJiYkS8nj6eDbxPMvngYOCmtNpNwJ7p48HAiEi8BHST1JdknqvHImJaREwHHgN2Std1iYgXI7l6c0TOvhqsmJ758cBmwKfpXC0bA5NLPaCZWVOKiKIXSUMlvZazDM23T0kDSGLfy8CKETExPdZEoE9arR/wec5mE9KyQuUT8pSXpJjRLN9ExDeSkNQhIj6QtFapBzQza0qVDTgBGhHDgeGF6khaAbgLOCEiZhVIa+dbESWUl6SYnvkESd2Ae4DHJN2LLxoysxaqsdIsAJLakQTyW3Nmi52UpkhIf36dlk8AVsnZvD9JrCxU3j9PeUnqDOaSVgOIiL0iYkZEnA2cCVzHUuR1zMyaUkPSLIWkI0uuA96vNUvsfUD1iJRDgHtzyg9OR7VsAcxM0zCjgB3SgSTdgR2AUem62ZK2SI91cM6+GqxQmmUk8H1JT0TEdgAR8UypBzIzWxYacZz5j4CDgHckvZmWnQ5cCNwpaQjwGbBvuu4hYBdgLDAPOAwgIqZJOg94Na13bkRMSx8fCdwIdAIeTpeSFArmZek0uGt6PnMzay0a63L+iHie/HltgO3y1A/g6Dr2dT1wfZ7y14D1l6KZNQoF8wNI0ikVQOfGOJiZWVPz5fy1RMSHwEWS3o6Ikrv+ZmbLki/nr9vrkq6T9DCApHXTXJGZWYvTmKNZWpNigvmNJGdjq28r/xFwQlM1yMxsaTTWaJbWpphg3isi7iSdlyYiFgOVTdoqM7MStdWeeTFXgM6V1JP0yqTq8ZNN2iozsxL55hR1O4lkMPx3Jf0H6A3s06StMjMrUWW0zbuAFnPbuNclbQ2sRTLm8sOIWNTkLTMzK0HWcuHFKhjM0/TKL4C106L3SeYOmFbnRmZmzShrufBiFZqbZR3gXeD7JCNYxpBMhfuupLXr2s7MrDk14s0pWpVCPfPzgOPTkSw1JO0NXADs3ZQNMzMrRVUbTbMUGpq4Qe1ADpDe/7NR5hIwM2ts7pl/29wS15mZNRuPZvm2PvlmSyQZ0dK7idpjZrZU2mqapVAw/wd1z5Z4bRO0xcxsqWUtfVKsQrMmnrMsG2Jm1hjcMzczywD3zM3MMqAy2uY8gPXOmlh9Y+f6yszMWgJPgVu3u/KUjWzshpiZNQZPgVtLesn+ekBXST/LWdUF6NjUDTMzK0XWetzFKpQzXwvYDegG7J5TPhv4VVM2ysysVB7NUktE3AvcK2lQRLy4DNtkZlaytjqapZic+eeS/i3pa0mTJN0lqX+Tt8zMrASVUVX0kiXFBPMbSO40tDLQD7g/LTMza3E8mqVufSLihohYnC434rlZzKyFqoooesmSYoL5ZEm/lFSeLr8EpjZ1w8zMSuGeed0OB/YDvgImktzM+fCmbJSZWak8zrwOEfEZsMcyaIuZ2VLLWo+7WIUuGhpWYLuIiPOaoD1mZksla6NUitXQOw0tDwwBepLcI9TMrEXJ2onNYhW6aOiS6seSOgPHA4cBtwOX1LWdmVlzcpolD0k9gJOAA4GbgE0iYvqyaJiZWSna6hWghXLmfwZ+BgwHNoiIOcusVWZmJXLP/NtOBhYAfwDOkFRdLpIToF2auG1mZg3WVnPmaqt/xZqDpKERMby522Etiz8X1hiKuWjIGs/Q5m6AtUj+XNhSczA3M8sAB3MzswxwMF+2nBe1fPy5sKXmE6BmZhngnrmZWQY4mJuZZYCDeZEkVUp6U9JoSW9JOklSve+fpD+n2/y5xOPOSX8OkPSLUvZhDSMpJOXOTfRbSWfXs82ektatY93Zkr5IPz9jJN1dV91a262dbvOGpO+W8DrOlvTb9PGhklZu6D6s9XAwL978iNgoItYDfgrsApxVxHa/JpnT5ndLefwBgIP5srEA+JmkXg3YZk+gUIC+LP38DATuAJ6UVN/tF/cE7o2IjSPi4wa0JZ9DSe7jaxnlYF6CiPia5EKPY5QoT3vgr0p6W9KvASTdRzJt8MuS9pe0u6SX057W45JWTOvV9KDS5+9KGlDrsBcCW6U9tROXxetswxaTjDD51vssaVVJT6S/5yckfUfSD0lu4PLn9PdTsBcdEXcAj5L+cZb0fUnPSPqvpFGS+kraBTgBOELSU2m9e9I6oyXVXGhU/e0tfbyPpBtrtXkfYFPg1rR9nUp6V6xFq/dOQ5ZfRIxL0yx9gMHAzIjYTFIH4D+SHo2IPSTNiYiNACR1B7aIiJB0BHAKyRw4xTgN+G1E7NYEL8e+7SrgbUl/qlX+V2BERNwk6XDgiojYM/3D/UBEjCxy/68Da0tqB1wJDI6IyZL2By6IiMMlXQPMiYiL020Oj4hpaTB+VdJdEVHv/XgjYqSkY0g+P68V2T5rZRzMl0717GM7ABumPSCArsBAYHyt+v2BOyT1BdrnWW8tRETMkjQCOA6Yn7NqEMlsogA3A7WDfbGqPztrAesDj6WT2ZWT3Gs3n+Mk7ZU+XoXkM+abqxvgYF4ySasDlcDXJP8xj42IUfVsdiVwaUTcJ2kb4Oy0fDFLprw6Nm5rrUSXk/SgbyhQp9QLNTYGXiP57IyOiEGFKqefl+2BQRExT9LT/O9zktsGf3baKOfMS5CeuLoG+GskV12NAo5MvzIjaU1Jy+fZtCvwRfr4kJzyT4BN0m03AVbLs+1soHOjvAArSkRMA+4kuVVitReAA9LHBwLPp4+L/v1I2pvk29xtwIdAb0mD0nXtJK2XZ7OuwPQ0kK8NbJGzbpKkddK03155tm1Q+6x1cjAvXqfqoYnA4yQnsM5J110LvAe8Luld4O/k/9ZzNvAvSc8BU3LK7wJ6SHoTOBL4KM+2bwOL02GRPgG67FwC5I5qOQ44TNLbwEEkt1OE5HaKvyswjPDE6qGJwC+BbSNickQsBPYBLpL0FvAm8MM82z8CVKTHPQ94KWfdacADwJPUnaK5EbjGJ0Czy5fzm5llgHvmZmYZ4GBuZpYBDuZmZhngYG5mlgEO5mZmGeBgbmaWAQ7mZmYZ8P9IT425uEdwtAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Split\n",
    "x_train, x_test, y_train, y_test = log_reg.split(x,y,rand=None)\n",
    "# Normalize\n",
    "not_bi = log_reg.not_bi(x)\n",
    "scaler = StandardScaler()\n",
    "scaler.fit(x_train[not_bi]) \n",
    "\n",
    "x_train_scaled=x_train\n",
    "x_test_scaled=x_test\n",
    "\n",
    "x_train_scaled[not_bi] = scaler.transform(x_train[not_bi])\n",
    "x_test_scaled[not_bi]  = scaler.transform(x_test[not_bi])\n",
    "\n",
    "# Fit model\n",
    "model = log_reg.reg(x_train_scaled,y_train)\n",
    "# Evaluate model\n",
    "log_reg.ModelValuation(x_test_scaled,y_test,model)\n",
    "y_predicted = log_reg.y_pred(x_test_scaled,threshold=0.5)\n",
    "spec , G = log_reg.GetScores(y_test,y_predicted)\n",
    "log_reg.confusion(y_test,y_predicted,'Default Confusion Matrix')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}