another_try - Copy.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",
    "pd.set_option(\"display.max_columns\", 100)\n",
    "from sklearn.metrics import f1_score\n",
    "DATA_PATH = Path.cwd().parent / \"ML project\" \n",
    "from imblearn.combine import SMOTETomek, SMOTEENN\n",
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.preprocessing import StandardScaler, OneHotEncoder, MinMaxScaler\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.preprocessing import Normalizer\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.impute import MissingIndicator\n",
    "from sklearn.model_selection import train_test_split\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",
    "from lightgbm import LGBMClassifier\n",
    "from sklearn.model_selection import KFold\n",
    "from imblearn.over_sampling import SMOTE, SVMSMOTE\n",
    "from sklearn.metrics import roc_curve, roc_auc_score\n",
    "from sklearn.preprocessing import Normalizer\n",
    "RANDOM_SEED = 6    # Set a random seed for reproducibility!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def formatdata(dataFrame):\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",
    "    pd.to_datetime(dataFrame['pickup_time'], format='%m-%d-%Y %H:%M:%S.%f', errors='ignore')\n",
    "    pd.to_datetime(dataFrame['drop_time'], format='%m/%d/%Y %H:%M:%S.%f', errors='ignore')\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['timediff1'] =  dataFrame['timediff']**2\n",
    "    dataFrame['distance'] = distanceLong(dataFrame['drop_lat'],dataFrame['drop_lon'],dataFrame['pick_lat'],dataFrame['pick_lon'])*100\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['_fare'] = dataFrame['fare'] - dataFrame['additional_fare'] \n",
    "    #dataFrame['tripDuration'] = dataFrame['duration'] - dataFrame['meter_waiting']\n",
    "    \n",
    "    \n",
    "    return dataFrame\n",
    "\n",
    " \n",
    "bestDegree = 0\n",
    "bestBias = False\n",
    "bestInteraction = False\n",
    "bestscore = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\User\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:2: 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: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: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",
      "C:\\Users\\User\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:10: 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",
      "  # Remove the CWD from sys.path while we load stuff.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "solver = 'lbfgs'\n",
    "alpha = 0.2\n",
    "hidden_layer_sizes=(10,2 )\n",
    "random_state=2\n",
    "max_iter= 10000000\n",
    "activation='tanh'\n",
    "estimatorsX=MLPClassifier(solver=solver, alpha=alpha, hidden_layer_sizes=hidden_layer_sizes, random_state=random_state,\n",
    "                         max_iter=max_iter, activation=activation)\n",
    "\n",
    "min_child_weight=1.5\n",
    "max_depth=5\n",
    "gamma=2.5\n",
    "colsample_bytree=0.8\n",
    "subsample=0.8\n",
    "n_estimators=200\n",
    "threads = 4\n",
    "estimatorsXX = 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_jobs=threads\n",
    "                          )\n",
    "params = { 'min_child_weight': [1.5,2,2.5],'max_depth':[8,9,7]}\n",
    "\n",
    "#estimatorsY = LGBMClassifier(boosting_type='gbdt', num_leaves=40, max_depth=6,learning_rate=0.2,\n",
    " #                          n_estimators=1000,random_state=42)\n",
    "\n",
    "estimators = BaggingClassifier(base_estimator=estimatorsXX,n_estimators=10,max_samples=0.65,\n",
    "                             max_features=1.0, random_state=1,bootstrap=False)\n",
    "#estimators = VotingClassifier( [('xgb', estimatorsX), ('mlp', estimatorsY)], weights=[1,1])\n",
    "#estimators = GridSearchCV(estimator=estimatorsXX, param_grid=params, cv=10)\n",
    "\n",
    "\n",
    "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",
    "features_df = formatdata(features_df)\n",
    "features_df = features_df.fillna(features_df.mean())\n",
    "numeric_cols = 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 = []\n",
    "power = 1\n",
    "\n",
    "numeric_cols = removeColumns(numeric_cols,['drop_time', 'pickup_time','drop_lat','drop_lon','pick_lat','pick_lon'\n",
    "                                             ])  \n",
    "\n",
    "#powerAll(features_df, exceptList,1)\n",
    "#exceptList = features_df.columns[features_df.dtypes == \"object\"].values\n",
    "#polyList1 = ['meter_waiting_fare','fare']\n",
    "polyList1 = ['additional_fare','distance','meter_waiting']\n",
    "polyList2 = ['timediff','distance']\n",
    "polyList3 = ['meter_waiting','duration']\n",
    "polyList4 = ['timediff','fare']\n",
    "polyList5 = ['distance','fare']\n",
    "polyList6 = ['meter_waiting_fare','additional_fare']\n",
    "numeric_preprocessing_steps = Pipeline([ \n",
    "    ('standard_scaler', StandardScaler()),\n",
    "])\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "feature_transformer2 = PolynomialFeatures(degree=4, include_bias=False,interaction_only=False)\n",
    "            \n",
    "feature_transformer3 = PolynomialFeatures(degree=4, include_bias=True,interaction_only=False)\n",
    "feature_transformer4 = PolynomialFeatures(degree=4, include_bias=True,interaction_only=False)\n",
    "feature_transformer5 = PolynomialFeatures(degree=4, include_bias=True,interaction_only=False)\n",
    "feature_transformer6 = PolynomialFeatures(degree=7, include_bias=False,interaction_only=False)\n",
    "            \n",
    "normalizer_transformer = Normalizer(norm ='l2')\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",
    "        \n",
    "        ('poly2', feature_transformer2,polyList2),\n",
    "        ('poly3', feature_transformer3,polyList3),\n",
    "        ('poly4', feature_transformer4,polyList4),\n",
    "        ('poly5', feature_transformer5,polyList5),\n",
    "        ('poly6', feature_transformer6,polyList6),\n",
    "        (\"numeric\", numeric_preprocessing_steps, numeric_cols),\n",
    "        (\"nomalizer\", normalizer_transformer, numeric_cols)\n",
    "    ],\n",
    "    remainder = \"drop\"\n",
    ")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1    8161\n",
      "0     415\n",
      "Name: prediction, dtype: int64\n",
      "bestscore 0.9825119236883942\n",
      "1    8163\n",
      "0     413\n",
      "Name: prediction, dtype: int64\n",
      "bestscore 0.9803416048984853\n",
      "1    8166\n",
      "0     410\n",
      "Name: prediction, dtype: int64\n",
      "bestscore 0.9811802232854864\n",
      "1    8166\n",
      "0     410\n",
      "Name: prediction, dtype: int64\n",
      "bestscore 0.9801073571203032\n",
      "1    8166\n",
      "0     410\n",
      "Name: prediction, dtype: int64\n",
      "bestscore 0.9807145115396776\n"
     ]
    }
   ],
   "source": [
    "clf1 = ''\n",
    "clf2 = ''\n",
    "clf3 = ''\n",
    "clf4 = ''\n",
    "clf5 = ''\n",
    "statesList = [3,6,0,8,1]\n",
    "for i in statesList:    \n",
    "    kf = KFold(n_splits=10, random_state=i, shuffle=True)\n",
    "\n",
    "\n",
    "    kf.get_n_splits(features_df)\n",
    "    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",
    "\n",
    "    bestscore = 0\n",
    "    bestModelx = \"\"\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "    for train_index, test_index in kf.split(features_df):\n",
    "\n",
    "        X_train, X_eval, y_train, y_eval = features_df.iloc[train_index], features_df.iloc[test_index],labels_df.iloc[train_index], labels_df.iloc[test_index]\n",
    "        full_pipeline = Pipeline([\n",
    "            (\"preprocessor\", preprocessor),\n",
    "            (\"estimators\", estimators),\n",
    "        ])\n",
    "        full_pipeline.fit(X_train, y_train)\n",
    "        preds = full_pipeline.predict(X_eval)\n",
    "        y_preds = pd.DataFrame(\n",
    "            preds,\n",
    "            index = y_eval.index\n",
    "        )\n",
    "        test_probas = full_pipeline.predict(test_features_df)\n",
    "        test_preds = pd.DataFrame(\n",
    "            {'prediction':test_probas},\n",
    "            index = test_features_df.index\n",
    "        )\n",
    "        f1 = f1_score(y_eval, y_preds)\n",
    "        if(f1 > bestscore):\n",
    "            bestscore = f1\n",
    "            bestModelx = full_pipeline\n",
    "\n",
    "\n",
    "    \n",
    "    test_probas1 = bestModelx.predict(test_features_df)\n",
    "    test_preds1 = pd.DataFrame(\n",
    "        {'prediction':test_probas1},\n",
    "        index = test_features_df.index\n",
    "    )\n",
    "    if(i == 3):\n",
    "        \n",
    "        clf1 = pd.DataFrame(\n",
    "            {'prediction':test_probas1},\n",
    "            index = test_features_df.index\n",
    "        )\n",
    "        print(clf1.prediction.value_counts())\n",
    "    elif(i==6):\n",
    "        clf2 = pd.DataFrame(\n",
    "            {'prediction':test_probas1},\n",
    "            index = test_features_df.index\n",
    "        )\n",
    "        print(clf2.prediction.value_counts())\n",
    "    elif(i==0):\n",
    "        clf4 = pd.DataFrame(\n",
    "            {'prediction':test_probas1},\n",
    "            index = test_features_df.index\n",
    "        )\n",
    "        print(clf4.prediction.value_counts())\n",
    "    elif(i==8):\n",
    "        clf5 = pd.DataFrame(\n",
    "            {'prediction':test_probas1},\n",
    "            index = test_features_df.index\n",
    "        )\n",
    "        print(clf5.prediction.value_counts())\n",
    "    else:\n",
    "        clf3 = pd.DataFrame(\n",
    "            {'prediction':test_probas1},\n",
    "            index = test_features_df.index\n",
    "        ) \n",
    "        print(clf3.prediction.value_counts())\n",
    "    print('bestscore', bestscore)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "1    8161\n",
      "0     415\n",
      "Name: prediction, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "print(clf4.equals(clf1))\n",
    "print(clf1.prediction.value_counts())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1    8161\n",
      "0     415\n",
      "Name: prediction, dtype: int64\n",
      "1    8163\n",
      "0     413\n",
      "Name: prediction, dtype: int64\n",
      "1    8166\n",
      "0     410\n",
      "Name: prediction, dtype: int64\n",
      "1    8166\n",
      "0     410\n",
      "Name: prediction, dtype: int64\n",
      "1    8166\n",
      "0     410\n",
      "Name: prediction, dtype: int64\n",
      "1    8167\n",
      "0     409\n",
      "Name: prediction, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "test_preds1 = clf1\n",
    "print(test_preds1.prediction.value_counts())\n",
    "\n",
    "test_preds2 = clf2\n",
    "print(test_preds2.prediction.value_counts())\n",
    "\n",
    "test_preds3 = clf3\n",
    "print(test_preds3.prediction.value_counts())\n",
    "\n",
    "test_preds4 = clf4\n",
    "print(test_preds4.prediction.value_counts())\n",
    "\n",
    "test_preds5 = clf5\n",
    "print(test_preds5.prediction.value_counts())\n",
    "\n",
    "final_preds = copy.copy(clf1)\n",
    "\n",
    "for index, row in test_preds1.iterrows():\n",
    "    df1_row_value =  test_preds1.loc[index].prediction\n",
    "    df2_row_value =  test_preds2.loc[index].prediction\n",
    "    df3_row_value =  test_preds3.loc[index].prediction\n",
    "    df4_row_value =  test_preds4.loc[index].prediction\n",
    "    df5_row_value =  test_preds5.loc[index].prediction\n",
    "\n",
    "    if(df1_row_value + df2_row_value + df3_row_value + df4_row_value + df5_row_value >= 3):\n",
    "        final_preds.loc[index].prediction = 1\n",
    "    else:\n",
    "        final_preds.loc[index].prediction = 0\n",
    "    \n",
    "print(final_preds.prediction.value_counts())\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#0.9828134945894335 state 3 k=10\n",
    "#0.9816188326346339 state 6 k=10\n",
    "final_preds.to_csv(DATA_PATH / 'my_submission.csv', index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "solver = 'lbfgs'\n",
    "alpha = 0.2\n",
    "hidden_layer_sizes=(10,2 )\n",
    "random_state=2\n",
    "max_iter= 10000000\n",
    "activation='tanh'\n",
    "estimatorsX=MLPClassifier(solver=solver, alpha=alpha, hidden_layer_sizes=hidden_layer_sizes, random_state=random_state,\n",
    "                         max_iter=max_iter, activation=activation)\n",
    "\n",
    "min_child_weight=1.5\n",
    "max_depth=5\n",
    "gamma=2.5\n",
    "colsample_bytree=0.8\n",
    "subsample=0.8\n",
    "n_estimators=200\n",
    "threads = 4\n",
    "estimators = 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_jobs=threads\n",
    "                          )\n",
    "params = { 'max_features': [0.8,0.85,0.9,0.95,1.0],'max_samples':[0.6,0.65,0.7,0.75,0.8]}\n",
    "\n",
    "#estimatorsY = LGBMClassifier(boosting_type='gbdt', num_leaves=40, max_depth=6,learning_rate=0.2,\n",
    " #                          n_estimators=1000,random_state=42)\n",
    "\n",
    "#estimators = BaggingClassifier(base_estimator=estimatorsY,n_estimators=10,max_samples=0.65,\n",
    " #                            max_features=1.0, random_state=1,bootstrap=False)\n",
    "#estimators = VotingClassifier( [('xgb', estimatorsX), ('mlp', estimatorsY)], weights=[1,1])\n",
    "#estimators = GridSearchCV(estimator=estimatorsB, param_grid=params, cv=5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "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=2\n",
    ")\n",
    "smt = SMOTE(sampling_strategy='all', random_state=None, k_neighbors=5, n_jobs=1)\n",
    "svmus = SVMSMOTE(sampling_strategy='auto',  k_neighbors=10, random_state=42,\n",
    "                                n_jobs=4, out_step=0.1)\n",
    "smottomek = SMOTETomek(sampling_strategy ='all', random_state=2, n_jobs=1)\n",
    "\n",
    "#X_train, y_train = svmus.fit_resample(X_train, y_train)\n",
    "full_pipeline = Pipeline([\n",
    "    (\"preprocessor\", preprocessor),\n",
    "    (\"estimators\", estimators),\n",
    "])\n",
    "\n",
    "full_pipeline.fit(X_train, y_train)\n",
    "preds = full_pipeline.predict(X_eval)\n",
    "y_preds = pd.DataFrame(\n",
    "    preds,\n",
    "    index = y_eval.index\n",
    ")\n",
    "\n",
    "f1 = f1_score(y_eval, y_preds)\n",
    "print(f1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(full_pipeline.named_steps['estimators'].best_params_, full_pipeline.named_steps['estimators'].best_score_)\n",
    "print(f1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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",
    "\n",
    "\n",
    "test_probas = full_pipeline.predict(test_features_df)\n",
    "test_preds = pd.DataFrame(\n",
    "    {'prediction':test_probas},\n",
    "    index = test_features_df.index\n",
    ")\n",
    "\n",
    "test_preds.to_csv(DATA_PATH / 'my_submission.csv', index=True)\n",
    "\n",
    "print(confusion_matrix(y_eval, y_preds))\n",
    "print(test_preds.prediction.value_counts())\n",
    "print(f1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(confusion_matrix(y_eval, y_preds))\n",
    "print(test_preds.prediction.value_counts())\n",
    "print(f1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#median\n",
    "#0.9762502413593357\n",
    "#1    8113\n",
    "#0     463\n",
    "#[[ 367  188]\n",
    " #[  58 5056]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#mean\n",
    "#0.9754447022428461\n",
    "#1    8124\n",
    "#0     452\n",
    "#[[ 370  185]\n",
    "# [  69 5045]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#most_frequent\n",
    "#0.9740121727369336\n",
    "#1    8126\n",
    "#0     450\n",
    "#[[ 359  196]\n",
    "# [  73 5041]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#constant\n",
    "0.9746713070378964\n",
    "#1    8123\n",
    "#0     453\n",
    "#[[ 366  189]\n",
    "# [  73 5041]]"
   ]
  },
  {
   "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": 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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "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": 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": []
  }
 ],
 "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
}