proba7.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.feature_selection import RFE\n",
    "from sklearn.linear_model import Lasso\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import roc_auc_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Segédfüggvények"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def limitalt_dummy_valtozo(indf, oszlop, limit, drop_last=True):\n",
    "    uj_valtozok = []\n",
    "    df = indf.copy()\n",
    "    egyedi_elemszam=df[oszlop].nunique()\n",
    "    if egyedi_elemszam <= limit and drop_last is True:\n",
    "        egyedi_elemszam = egyedi_elemszam - 1\n",
    "    tmp = df[oszlop].value_counts()[:limit]\n",
    "    for value in list(tmp.index):\n",
    "        def f(x):\n",
    "            if x == value:\n",
    "                return 1\n",
    "            else:\n",
    "                return 0\n",
    "        df[oszlop+'='+str(value)] = df[oszlop].apply(f)\n",
    "        uj_valtozok.append(oszlop + '=' + str(value))\n",
    "    return df, uj_valtozok"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myxval(model,train_df,bemeno_valtozok,fold_num=3):\n",
    "    train_df['xval']=train_df['ID']%fold_num\n",
    "    auc_list=[]\n",
    "    for i in range(fold_num):\n",
    "        mini_train=train_df[train_df['xval']!=i].copy()\n",
    "        mini_test=train_df[train_df['xval']==i].copy()\n",
    "        model.fit(mini_train[bemeno_valtozok],mini_train['TARGET'])\n",
    "        mini_test['p1']=model.predict_proba(mini_test[bemeno_valtozok])[:,1]\n",
    "        auc=roc_auc_score(mini_test['TARGET'],mini_test['p1'])\n",
    "        auc_list.append(auc)\n",
    "    return np.mean(auc_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import roc_auc_score\n",
    "\n",
    "def myxval_multi(models,train_df,bemeno_valtozok,fold_num=3):\n",
    "    train_df['xval']=train_df['ID']%fold_num\n",
    "    auc_list=[]\n",
    "    for i in range(fold_num):\n",
    "        mini_train=train_df[train_df['xval']!=i].copy()\n",
    "        mini_test=train_df[train_df['xval']==i].copy()\n",
    "        predict_list = None\n",
    "        for model in models:\n",
    "            model.fit(mini_train[bemeno_valtozok],mini_train['TARGET'])\n",
    "            predictions=model.predict_proba(mini_test[bemeno_valtozok])[:,1]\n",
    "            predictions = predictions.reshape((1, len(predictions)))\n",
    "            if predict_list is None:\n",
    "                predict_list = predictions\n",
    "            else:\n",
    "                predict_list = np.concatenate([predict_list, predictions], axis=0)\n",
    "        mini_test['p1'] = np.mean(predict_list, axis=0)\n",
    "        auc=roc_auc_score(mini_test['TARGET'],mini_test['p1'])\n",
    "        auc_list.append(auc)\n",
    "    return np.mean(auc_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### --------------------------------------------------------------------- ###"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Programs\\miniconda\\envs\\dap2020_jupyter\\lib\\site-packages\\IPython\\core\\interactiveshell.py:3062: DtypeWarning: Columns (44,45) have mixed types.Specify dtype option on import or set low_memory=False.\n",
      "  has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n"
     ]
    }
   ],
   "source": [
    "train_data = pd.read_csv('./data/public_train.csv')\n",
    "test_data = pd.read_csv('./data/public_test.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train or test?\n",
    "train_data['train_or_test'] = 'train'\n",
    "test_data['train_or_test'] = 'test'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.concat([train_data, test_data], sort=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hiányzó adatok"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hianyzo adatok kitoltese\n",
    "for att in df.columns:\n",
    "    if att==\"TARGET\":\n",
    "        pass\n",
    "    #amik nem számok (string értékek stb...)\n",
    "    elif df[att].dtype==\"object\": \n",
    "        #print(att)\n",
    "        df[att]=df[att].fillna(\"nincs_adat\")\n",
    "    else:\n",
    "        #test és train közös mediánja\n",
    "        #ha van benne NaN, akkor azzal töltötte volna fel, de ez nem jó, ezért kell a nanmedian függvény\n",
    "        #de nem a mediánra kéne itt kitölteni az fix!!!\n",
    "        #df[att]=df[att].fillna(0) ez is lehetne\n",
    "        df[att]=df[att].fillna(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Float64 to int64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# float64 to int64\n",
    "for att in df.columns:\n",
    "    if att ==\"TARGET\":\n",
    "        pass\n",
    "    elif df[att].dtype == \"float64\":\n",
    "        df[att] = df[att].astype('int64')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fizetési adatok"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['MEAN_BILL_AMOUNT_MONTH'] = (df['BILL_AMOUNT_MONTH_1'] + df['BILL_AMOUNT_MONTH_2'] \n",
    "                                + df['BILL_AMOUNT_MONTH_3'] + df['BILL_AMOUNT_MONTH_4']\n",
    "                                + df['BILL_AMOUNT_MONTH_5'] + df['BILL_AMOUNT_MONTH_6']) / 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['MEAN_PAY_MONTH'] = (df['PAY_MONTH_0'] + df['PAY_MONTH_2'] + df['PAY_MONTH_3'] \n",
    "                        + df['PAY_MONTH_4'] + df['PAY_MONTH_5'] + df['PAY_MONTH_6']) / 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['MEAN_PAY_AMOUNT_MONTH'] = (df['PAY_AMOUNT_MONTH_1'] + df['PAY_AMOUNT_MONTH_2'] \n",
    "                               + df['PAY_AMOUNT_MONTH_3'] + df['PAY_AMOUNT_MONTH_4']\n",
    "                               + df['PAY_AMOUNT_MONTH_5'] + df['PAY_AMOUNT_MONTH_6']) / 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Változók szűrése"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "bemeno_valtozok = ['AGE', 'AME_FLAG', 'APP_SUB_TYPE', 'CARS_FLAG', 'C_PRODUCT', 'DAY_OF_PAYMENT', 'EDU_LEVEL',\n",
    "       'EMAIL_FLAG', 'HOME_PHONE_FLAG', 'L_BALANCE', 'MATE_PROF_CODE',\n",
    "       'MCARD_FLAG', 'MONTHS_IN_RES', 'M_IN_THE_JOB', 'M_STATUS', 'NAT',\n",
    "       'NUMBERO_OF_BANK_ACCOUNTS', 'NUMBER_OF_DEPENDANTS',\n",
    "       'NUMBER_OF_SPECIAL_BANK_ACCOUNTS', 'OCARDS_FLAG', 'OCC_TYPE',\n",
    "       'O_INCOMES', 'PROF_BOROUGH', 'P_ADDRESS_TYPE', 'P_ASSETS_VALUE',\n",
    "       'P_MONTHLY_INCOME', 'RES_BOROUGH', 'RES_TYPE', 'SEX', 'S_FLAG',\n",
    "       'VISA_FLAG', 'MEAN_PAY_AMOUNT_MONTH', 'MEAN_PAY_MONTH', 'MEAN_BILL_AMOUNT_MONTH']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dummy változók"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "object_valtozok = []\n",
    "uj_valtozok = []\n",
    "for att in bemeno_valtozok:\n",
    "    if df[att].dtype == 'object':\n",
    "        df, val = limitalt_dummy_valtozo(df, att, 6)\n",
    "        object_valtozok.append(att)\n",
    "        uj_valtozok.extend(val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "bemeno_valtozok = bemeno_valtozok + uj_valtozok\n",
    "bemeno_valtozok = [val for val in bemeno_valtozok if val not in object_valtozok]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['AGE',\n",
       " 'AME_FLAG',\n",
       " 'CARS_FLAG',\n",
       " 'C_PRODUCT',\n",
       " 'DAY_OF_PAYMENT',\n",
       " 'EDU_LEVEL',\n",
       " 'EMAIL_FLAG',\n",
       " 'L_BALANCE',\n",
       " 'MATE_PROF_CODE',\n",
       " 'MCARD_FLAG',\n",
       " 'MONTHS_IN_RES',\n",
       " 'M_IN_THE_JOB',\n",
       " 'M_STATUS',\n",
       " 'NAT',\n",
       " 'NUMBERO_OF_BANK_ACCOUNTS',\n",
       " 'NUMBER_OF_DEPENDANTS',\n",
       " 'NUMBER_OF_SPECIAL_BANK_ACCOUNTS',\n",
       " 'OCARDS_FLAG',\n",
       " 'OCC_TYPE',\n",
       " 'O_INCOMES',\n",
       " 'P_ASSETS_VALUE',\n",
       " 'P_MONTHLY_INCOME',\n",
       " 'RES_TYPE',\n",
       " 'S_FLAG',\n",
       " 'VISA_FLAG',\n",
       " 'MEAN_PAY_AMOUNT_MONTH',\n",
       " 'MEAN_PAY_MONTH',\n",
       " 'MEAN_BILL_AMOUNT_MONTH',\n",
       " 'APP_SUB_TYPE=W',\n",
       " 'APP_SUB_TYPE=Z',\n",
       " 'APP_SUB_TYPE=C',\n",
       " 'HOME_PHONE_FLAG=yes',\n",
       " 'HOME_PHONE_FLAG=no',\n",
       " 'PROF_BOROUGH=nincs_adat',\n",
       " 'PROF_BOROUGH=Borough0',\n",
       " 'PROF_BOROUGH=Borough732',\n",
       " 'PROF_BOROUGH=Borough48',\n",
       " 'PROF_BOROUGH=Borough634',\n",
       " 'PROF_BOROUGH=Borough315',\n",
       " 'P_ADDRESS_TYPE=A',\n",
       " 'P_ADDRESS_TYPE=B',\n",
       " 'RES_BOROUGH=nincs_adat',\n",
       " 'RES_BOROUGH=Borough0',\n",
       " 'RES_BOROUGH=Borough48',\n",
       " 'RES_BOROUGH=Borough116',\n",
       " 'RES_BOROUGH=Borough101',\n",
       " 'RES_BOROUGH=Borough152',\n",
       " 'SEX=female',\n",
       " 'SEX=male',\n",
       " 'SEX=nincs_adat']"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bemeno_valtozok"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modellezés"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df = df[df['train_or_test'] == 'train'].copy()\n",
    "test_df = df[df['train_or_test'] == 'test'].copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "model_rfc = RandomForestClassifier(random_state=42, n_estimators=300, max_depth=15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "model_gbc = GradientBoostingClassifier(random_state=42, n_estimators=150, max_depth=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7361476122023035"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myxval_multi([model_rfc, model_gbc], train_df, bemeno_valtozok)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "GradientBoostingClassifier(ccp_alpha=0.0, criterion='friedman_mse', init=None,\n",
       "                           learning_rate=0.1, loss='deviance', max_depth=10,\n",
       "                           max_features=None, max_leaf_nodes=None,\n",
       "                           min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                           min_samples_leaf=1, min_samples_split=2,\n",
       "                           min_weight_fraction_leaf=0.0, n_estimators=150,\n",
       "                           n_iter_no_change=None, presort='deprecated',\n",
       "                           random_state=42, subsample=1.0, tol=0.0001,\n",
       "                           validation_fraction=0.1, verbose=0,\n",
       "                           warm_start=False)"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_rfc.fit(train_df[bemeno_valtozok], train_df['TARGET'])\n",
    "model_gbc.fit(train_df[bemeno_valtozok], train_df['TARGET'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "prediction_rfc = model_rfc.predict_proba(test_df[bemeno_valtozok])[:,1]\n",
    "prediction_gbc = model_gbc.predict_proba(test_df[bemeno_valtozok])[:,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([prediction_rfc, prediction_gbc])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_df['p1'] = np.mean(a, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "submission_df = test_df[['ID', 'p1']]\n",
    "submission_df.columns = ['Id', 'Predicted']\n",
    "submission_df.to_csv('proba7.csv', index=False)"
   ]
  },
  {
   "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}