test-Copy1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "from datetime import datetime\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn import preprocessing\n",
    "from imblearn.over_sampling import RandomOverSampler\n",
    "from imblearn.under_sampling import  RandomUnderSampler, RepeatedEditedNearestNeighbours\n",
    "from sklearn.datasets import make_classification\n",
    "pd.set_option(\"display.max_columns\", 100)\n",
    "\n",
    "DATA_PATH = Path.cwd().parent / \"ML project\" \n",
    "\n",
    "\n",
    "\n",
    "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.compose import ColumnTransformer\n",
    "\n",
    "\n",
    "from sklearn.multioutput import MultiOutputClassifier\n",
    "\n",
    "from sklearn.pipeline import Pipeline\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "from sklearn.metrics import roc_curve, roc_auc_score\n",
    "\n",
    "RANDOM_SEED = 6    # Set a random seed for reproducibility!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 618,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "from math import cos, asin, sqrt, pi\n",
    "\n",
    "def distanceLong(lat1, lon1, lat2, lon2):\n",
    "    p = pi/180\n",
    "    latDiff = (lat2-lat1)*p\n",
    "    lonDiff = (lon2-lon1)*p\n",
    "    coslat1 = np.cos(lat1*p)\n",
    "    coslat2 = np.cos(lat2*p)\n",
    "    coslondiff = np.cos(lonDiff)\n",
    "    coslatdiff = np.cos(latDiff)\n",
    "    a = 0.5 - coslatdiff/2 + coslat1 * coslat2 * (1-coslondiff)/2\n",
    "    return 12742 * (np.arcsin(a**0.5)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 696,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def formatdata(dataFrame):\n",
    "    dataFrame.fillna(dataFrame.mean(), inplace=True)\n",
    "    dataFrame['pickup_time'] = dataFrame['pickup_time']+ '.099'\n",
    "    dataFrame['pickup_time'] = dataFrame['pickup_time'].apply(lambda x:  x.replace(\"/\",\"-\"))\n",
    "    dataFrame['drop_time'] = dataFrame['drop_time']+ '.099'\n",
    "\n",
    "    \n",
    "    dataFrame['pickup_time'] = dataFrame['pickup_time'].apply(lambda x: datetime.timestamp(datetime.strptime(x,'%m-%d-%Y %H:%M.%f')))\n",
    "    dataFrame['drop_time'] = dataFrame['drop_time'].apply(lambda x: datetime.timestamp(datetime.strptime(x,'%m/%d/%Y %H:%M.%f')))\n",
    "\n",
    "    dataFrame['timediff'] =  dataFrame['drop_time'] - dataFrame['pickup_time']\n",
    "    #dataFrame['distance'] = distanceLong(dataFrame['drop_lat'],dataFrame['drop_lon'],dataFrame['pick_lat'],dataFrame['pick_lon'])*1000\n",
    "    dataFrame['distance'] = ((dataFrame['drop_lat']-dataFrame['pick_lat'])**2+(dataFrame['drop_lon']-dataFrame['pick_lon'])**2)**0.5\n",
    "    #dataFrame['unit_meter_waiting_fair'] = dataFrame['meter_waiting_fare'] / dataFrame['meter_waiting']\n",
    "    #print(dataFrame['unit_meter_waiting_fair'])\n",
    "    \n",
    "    #dataFrame['additional_fare'] = dataFrame['meter_waiting_fare'] + dataFrame['additional_fare'] \n",
    "    #dataFrame['tripDuration'] = dataFrame['duration'] - dataFrame['meter_waiting']\n",
    "    \n",
    "    \n",
    "    return dataFrame\n",
    "\n",
    "    cols_to_norm = ['duration','meter_waiting',\n",
    "                    'meter_waiting_fare','meter_waiting_till_pickup',\n",
    "                    'pick_lat','pick_lon','drop_lat','drop_lon','fare','timediff','distance']\n",
    "    n_test = dataFrame[cols_to_norm]\n",
    "\n",
    "\n",
    "\n",
    "    x = n_test.values\n",
    "\n",
    "    min_max_scaler = preprocessing.MinMaxScaler()\n",
    "    x_scaled = min_max_scaler.fit_transform(x)\n",
    "    #normalized_df=(x-x.mean())/x.std()\n",
    "    n_test = pd.DataFrame(x_scaled, columns=cols_to_norm,index=dataFrame.index)\n",
    "\n",
    "    l_test = dataFrame.drop(cols_to_norm, axis=1)\n",
    "    train = pd.concat([n_test, l_test], axis=1)\n",
    "    return train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 848,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\User\\anaconda3\\lib\\site-packages\\pandas\\core\\generic.py:6245: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  self._update_inplace(new_data)\n",
      "C:\\Users\\User\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:3: 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: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  This is separate from the ipykernel package so we can avoid doing imports until\n",
      "C:\\Users\\User\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:4: 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: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  after removing the cwd from sys.path.\n",
      "C:\\Users\\User\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:5: 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: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  \"\"\"\n",
      "C:\\Users\\User\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:8: 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: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  \n",
      "C:\\Users\\User\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:9: 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: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  if __name__ == '__main__':\n"
     ]
    }
   ],
   "source": [
    "train_df = pd.read_csv(\n",
    "    DATA_PATH / \"train.csv\", \n",
    "    index_col=\"tripid\"\n",
    ")\n",
    "\n",
    "\n",
    "\n",
    "train_df['label'] = train_df['label'].map({\"correct\":1, \"incorrect\":0})\n",
    "train_df_cols = train_df.columns.values\n",
    "li = list(train_df_cols)\n",
    "features_df = train_df[li[0:-1]]\n",
    "labels_df = train_df[li[-1]]\n",
    "\n",
    "\n",
    "features_df = formatdata(features_df)\n",
    "\n",
    "from imblearn.combine import SMOTETomek\n",
    "\n",
    "smt = SMOTETomek()\n",
    "from imblearn.under_sampling import TomekLinks\n",
    "\n",
    "tl = TomekLinks( sampling_strategy='majority' )\n",
    "\n",
    "renn = RepeatedEditedNearestNeighbours()\n",
    "\n",
    "ros = RandomOverSampler(random_state=0)\n",
    "rus = RandomUnderSampler(random_state=0)\n",
    "#features_df, labels_df= tl.fit_resample(features_df, labels_df)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "numeric_cols = features_df.columns[features_df.dtypes != object].values\n",
    "categorical_features = features_df.columns[features_df.dtypes == object].values\n",
    "\n",
    "\n",
    "\n",
    "def removeColumns(npArry, columnNames):\n",
    "    li = list(npArry)\n",
    "    for i in columnNames:\n",
    "        li.remove(i)\n",
    "    return np.array(li)\n",
    "\n",
    "\n",
    "def powerAll(data_frame, exceptList,power):\n",
    "    allColumns = data_frame.columns.values\n",
    "    for i in allColumns:\n",
    "        if(i not in exceptList ):\n",
    "            data_frame[i] = data_frame[i]**power\n",
    " \n",
    "\n",
    "#nothing\n",
    "exceptList = ['distance']\n",
    "power = \n",
    "\n",
    "numeric_cols = removeColumns(numeric_cols,['drop_time', 'pickup_time','pick_lat','pick_lon','drop_lat','drop_lon'\n",
    "                                             ])  \n",
    "\n",
    "\n",
    "powerAll(features_df, exceptList,power)\n",
    "#exceptList = features_df.columns[features_df.dtypes == \"object\"].values\n",
    "\n",
    "numeric_preprocessing_steps = Pipeline([\n",
    "    ('standard_scaler', StandardScaler()),\n",
    "    ('simple_imputer', SimpleImputer(strategy='median'))\n",
    "])\n",
    "categorical_transformer = Pipeline(steps=[\n",
    "    ('imputer', SimpleImputer(strategy='constant', fill_value='missing')),\n",
    "    ('onehot', OneHotEncoder(handle_unknown='ignore'))])\n",
    "\n",
    "# create the preprocessor stage of final pipeline\n",
    "# each entry in the transformer list is a tuple of\n",
    "# (name you choose, sklearn transformer, list of columns)\n",
    "preprocessor = ColumnTransformer(\n",
    "    transformers = [\n",
    "        (\"numeric\", numeric_preprocessing_steps, numeric_cols),\n",
    "        ('cat', categorical_transformer, categorical_features)\n",
    "    ],\n",
    "    remainder = \"drop\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 849,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.svm import LinearSVC\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.neighbors import NearestNeighbors\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from xgboost import XGBClassifier\n",
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.ensemble import VotingClassifier\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.experimental import enable_hist_gradient_boosting\n",
    "from sklearn.ensemble import HistGradientBoostingClassifier\n",
    "\n",
    "#estimators = MultiOutputClassifier(\n",
    " #   estimator=MLPClassifier(solver='lbfgs', alpha=.55, hidden_layer_sizes=(4,2 ), random_state=1, max_iter=10000000)\n",
    "#)\n",
    "#estimators = MultiOutputClassifier(\n",
    " #   estimator=SVC(gamma='auto', probability=True),\n",
    "#)\n",
    "#estimators =SVC(gamma='auto')\n",
    "estimatorsX1=LogisticRegression(penalty=\"l2\", C=1,solver='lbfgs',max_iter=1000000)\n",
    "solver = 'lbfgs'\n",
    "alpha = 0.075\n",
    "hidden_layer_sizes=(7,2)\n",
    "random_state=2\n",
    "max_iter= 10000000\n",
    "\n",
    "activation='tanh'\n",
    "estimators=MLPClassifier(solver=solver, alpha=alpha, hidden_layer_sizes=hidden_layer_sizes, random_state=random_state,\n",
    "                         max_iter=max_iter, activation=activation)\n",
    "estimatorsX2 = GradientBoostingClassifier(n_estimators=20, learning_rate=0.5, max_features=2, max_depth=1, random_state=0)\n",
    "min_child_weight=5\n",
    "max_depth=8\n",
    "gamma=1.5\n",
    "colsample_bytree=0.75\n",
    "subsample=0.75\n",
    "n_estimators=150\n",
    "estimatorsX = XGBClassifier(min_child_weight=min_child_weight,max_depth=max_depth, \n",
    "                           gamma=gamma,colsample_bytree=colsample_bytree,subsample=subsample,\n",
    "                           n_estimators=n_estimators\n",
    "                          )\n",
    "params = { 'axgb__n_estimators': [20, 200],'cmlp__alpha':[0,1.0],'blr__C': [1.0, 100.0]}\n",
    "estimatorsX3 = AdaBoostClassifier(n_estimators=100, random_state=0, learning_rate = 0.05, \n",
    "                                algorithm='SAMME.R',base_estimator=estimatorsX)\n",
    "\n",
    "#estimators = RandomForestClassifier(n_estimators=50, criterion='entropy',max_depth=10,min_samples_split=4,\n",
    " #                                  min_samples_leaf=4,max_features='log2',max_leaf_nodes=100,bootstrap=True,\n",
    "  #                                  oob_score=True,class_weight='balanced_subsample')\n",
    "estimatorNB = GaussianNB()\n",
    "\n",
    "#estimators = KNeighborsClassifier(n_neighbors=5, weights='distance',algorithm='brute',p=2 ,leaf_size=10)\n",
    "#estimators = BaggingClassifier(base_estimator=estimatorsY,n_estimators=10,max_samples=1.0,bootstrap=True,\n",
    " #                              oob_score=False,bootstrap_features=True,max_features=1.0,warm_start=True)\n",
    "vestimators = VotingClassifier( [('axgb', estimatorsX), ('cmlp', estimatorsY), ('blr', estimatorsX1)], weights=[2,3,1])\n",
    "#estimators = GridSearchCV(estimator=vestimators, param_grid=params, cv=5)\n",
    "#estimators = HistGradientBoostingClassifier(max_iter=500,min_samples_leaf=2,max_depth=10, learning_rate=0.08)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 850,
   "metadata": {},
   "outputs": [],
   "source": [
    "full_pipeline = Pipeline([\n",
    "    (\"preprocessor\", preprocessor),\n",
    "    (\"estimators\", estimators),\n",
    "])\n",
    "\n",
    "X_train, X_eval, y_train, y_eval = train_test_split(\n",
    "    features_df,\n",
    "    labels_df,\n",
    "    test_size=0.33,\n",
    "    shuffle=True,\n",
    "    stratify=labels_df,\n",
    "    random_state=6\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 851,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 20.2 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, ..., 1, 1, 1], dtype=int64)"
      ]
     },
     "execution_count": 851,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "# Train model\n",
    "full_pipeline.fit(X_train, y_train)\n",
    "\n",
    "\n",
    "# Predict on evaluation set\n",
    "# This competition wants probabilities, not labels\n",
    "preds = full_pipeline.predict(X_eval)\n",
    "preds\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 852,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y_preds.shape: (5669, 1)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import confusion_matrix\n",
    "y_preds = pd.DataFrame(\n",
    "    preds,\n",
    "    index = y_eval.index\n",
    ")\n",
    "print(\"y_preds.shape:\", y_preds.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 853,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9518433586170401"
      ]
     },
     "execution_count": 853,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_eval, y_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 854,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 362,  193],\n",
       "       [  80, 5034]], dtype=int64)"
      ]
     },
     "execution_count": 854,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "confusion_matrix(y_eval, y_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 855,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import recall_score\n",
    "recall= recall_score(y_eval, y_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 856,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import precision_score\n",
    "precission = precision_score(y_eval, y_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 857,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9843566679702777\n",
      "0.9630763344174479\n",
      "0.9736002320858719\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import f1_score\n",
    "f1 = f1_score(y_eval, y_preds)\n",
    "print(recall)\n",
    "print(precission)\n",
    "print(f1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 787,
   "metadata": {},
   "outputs": [],
   "source": [
    "if(type(estimators) ==  XGBClassifier):\n",
    "    f = open(DATA_PATH / 'xgboostStatus.txt','a')\n",
    "    f.write(\"recall: \"+ str(recall)+\"\\t\"+\"precission: \"+ str(precission)+\"\\tf1: \"+str(f1)+\"\\n\")\n",
    "    f.write(\"min_child_weight: \"+str(min_child_weight)+\"\\tmax_depth:\"+ str(max_depth)+\"\\tgamma: \"+str(gamma)+\n",
    "            \"\\tcolsample_bytree: \"+str(colsample_bytree)+\"\\tsubsample: \"+str(subsample) +\"\\tn_estimators\"+ str(n_estimators)+\n",
    "            \"\\power: \"+ str(power)+\"\\n\\n\")\n",
    "    f.close()\n",
    "\n",
    "if(type(estimators) == MLPClassifier):\n",
    "    f = open(DATA_PATH / 'mlpStatus.txt','a')\n",
    "    f.write(\"recall: \"+ str(recall)+\"\\t\"+\"precission: \"+ str(precission)+\"\\tf1: \"+str(f1)+\"\\n\")\n",
    "    f.write(\"solver: \"+str(solver)+\"\\talpha: \"+ str(alpha)+\"\\thidden_layer_sizes: \"+str(hidden_layer_sizes)+\n",
    "            \"\\trandom_state: \"+str(random_state)+\"\\tmax_iter: \"+str(max_iter) +\"\\tlearning_rate_init: \"+ str(\"learning_rate_init\")+\n",
    "            \"\\tlearning_rate: \"+ str(\"learning_rate\")+\"\\tactivation: \"+ str(activation)+\"\\power: \"+ str(power)+\"\\n\\n\")\n",
    "    f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 442,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 24.8 s\n"
     ]
    }
   ],
   "source": [
    "%%time \n",
    "\n",
    "full_pipeline.fit(features_df, labels_df)\n",
    "\n",
    "None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 443,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_features_df = pd.read_csv(DATA_PATH / \"test.csv\", \n",
    "                               index_col=\"tripid\")\n",
    "\n",
    "test_features_df = formatdata(test_features_df)\n",
    "powerAll(test_features_df, exceptList,power)\n",
    "#exceptList = features_df.columns[features_df.dtypes == \"object\"].values\n",
    "#test_features_df = formatdata(test_features_df)\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 444,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, ..., 1, 1, 1], dtype=int64)"
      ]
     },
     "execution_count": 444,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_probas = full_pipeline.predict(test_features_df)\n",
    "\n",
    "test_probas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 445,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "test_preds = pd.DataFrame(\n",
    "    {'prediction':test_probas},\n",
    "    index = test_features_df.index\n",
    ")\n",
    "\n",
    "print(test_preds['prediction'].max())\n",
    "print(test_preds['prediction'].min())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 446,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_preds.to_csv(DATA_PATH / 'my_submission.csv', index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 447,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'submission_df' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-447-0971a60eea60>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0msubmission_df\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mhead\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'submission_df' is not defined"
     ]
    }
   ],
   "source": [
    "submission_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make sure we have the rows in the same order\n",
    "np.testing.assert_array_equal(test_features_df.index.values, \n",
    "                              submission_df.index.values)\n",
    "\n",
    "# Save predictions to submission data frame\n",
    "submission_df[\"h1n1_vaccine\"] = test_preds[1]\n",
    "\n",
    "submission_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "submission_df.to_csv(DATA_PATH / 'my_submission.csv', index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "to = '11/01/2019  00:20:00'\n",
    "to += '.099'\n",
    "froms = '11/01/2019  00:34:00'+'.099'\n",
    "dateObjectto = datetime.strptime(to, '%m/%d/%Y %H:%M:%S.%f')\n",
    "dateObjectfrom = datetime.strptime(froms, '%m/%d/%Y %H:%M:%S.%f')\n",
    "print(datetime.timestamp(dateObjectfrom) - datetime.timestamp(dateObjectto))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df = pd.read_csv(\n",
    "    DATA_PATH / \"train.csv\", \n",
    "    index_col=\"tripid\"\n",
    ")\n",
    "train_df['label'] = train_df['label'].map({\"correct\":1, \"incorrect\":0})\n",
    "train_df_cols = train_df.columns.values\n",
    "li = list(train_df_cols)\n",
    "features_df = train_df[li[0:-1]]\n",
    "labels_df = train_df[li[-1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "features_df.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(features_df.dtypes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "features_df[features_df.dtypes[(features_df.dtypes==\"float64\")]\n",
    "                        .index.values].hist(figsize=[11,11],\n",
    "                                            range=[features_df['drop_lat'].min(), features_df['drop_lat'].max()])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import preprocessing\n",
    "\n",
    "cols_to_norm = ['duration','meter_waiting',\n",
    "                'meter_waiting_fare','meter_waiting_till_pickup',\n",
    "                'pick_lat','pick_lon','drop_lat','drop_lon','fare']\n",
    "n_test = features_df[cols_to_norm]\n",
    "\n",
    "\n",
    "x = n_test.values\n",
    "\n",
    "min_max_scaler = preprocessing.MinMaxScaler()\n",
    "x_scaled = min_max_scaler.fit_transform(x)\n",
    "\n",
    "n_test = pd.DataFrame(x_scaled, columns=cols_to_norm,index=features_df.index)\n",
    "\n",
    "l_test = features_df.drop(cols_to_norm, axis=1)\n",
    "train = pd.concat([n_test, l_test], axis=1)\n",
    "train.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "def plot():\n",
    "    plt.figure(figsize=(8,6))\n",
    "\n",
    "    plt.scatter(features_df['meter_waiting_fare'], labels_df,\n",
    "            color='green', label='input scale', alpha=0.5)\n",
    "\n",
    "    \n",
    "    plt.xlabel('Alcohol')\n",
    "    plt.ylabel('Malic Acid')\n",
    "    plt.legend(loc='upper left')\n",
    "    plt.grid()\n",
    "\n",
    "    plt.tight_layout()\n",
    "\n",
    "    \n",
    "plot()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\User\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:3: 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: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  This is separate from the ipykernel package so we can avoid doing imports until\n",
      "C:\\Users\\User\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:4: 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: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  after removing the cwd from sys.path.\n",
      "C:\\Users\\User\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:5: 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: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  \"\"\"\n",
      "C:\\Users\\User\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:8: 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: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  \n",
      "C:\\Users\\User\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:9: 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: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  if __name__ == '__main__':\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "train_df = pd.read_csv(\n",
    "    DATA_PATH / \"train.csv\", \n",
    "    index_col=\"tripid\"\n",
    ")\n",
    "train_df['label'] = train_df['label'].map({\"correct\":1, \"incorrect\":0})\n",
    "train_df_cols = train_df.columns.values\n",
    "li = list(train_df_cols)\n",
    "features_df = train_df[li[0:-1]]\n",
    "labels_df = train_df[li[-1]]\n",
    "features_df = formatdata(features_df)\n",
    "features_df = features_df.join(labels_df)\n",
    "\n",
    "labels_df.fillna(0)\n",
    "features_df[features_df==np.inf]=np.nan\n",
    "features_df.fillna(0, inplace=True)\n",
    "numericOnle = ['duration','meter_waiting','meter_waiting_fare','meter_waiting_till_pickup','fare','timediff','distance','label']\n",
    "features_set = features_df[numericOnle]\n",
    "\n",
    "#get correlations of each features in dataset\n",
    "corrmat = features_set.corr()\n",
    "top_corr_features = corrmat.index\n",
    "plt.figure(figsize=(8,8))\n",
    "#plot heat map\n",
    "g=sns.heatmap(features_set[top_corr_features].corr(),annot=True,cmap=\"RdYlGn\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}