{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "_cell_guid": "265ffb19-1f4b-1f36-4bd5-9dc83c50c321"
      },
      "source": [
        "Test Import Table"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "2dfb244f-f9d3-0333-d6b0-3fc8968c5b21"
      },
      "outputs": [],
      "source": [
        "library(lattice)\n",
        "library(data.table)\n",
        "library(Matrix)\n",
        "library(caret)\n",
        "library(xgboost)\n",
        "library(lattice)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "8743a023-da29-e64e-abe0-4ee4056ab900"
      },
      "outputs": [],
      "source": [
        "dt <- fread(\"../input/train_numeric.csv\",\n",
        "            drop = \"Id\",\n",
        "            nrows = 200000,\n",
        "            showProgress = F)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "a6a1f721-0e1a-9a74-cca3-7227fa14ea46"
      },
      "outputs": [],
      "source": [
        "Y  <- dt$Response\n",
        "dt[ , Response := NULL]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "e61f93d5-d352-3a83-a54e-9a5573787037"
      },
      "outputs": [],
      "source": [
        "for(col in names(dt)) set(dt, j = col, value = dt[[col]] + 2)\n",
        "for(col in names(dt)) set(dt, which(is.na(dt[[col]])), col, 0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "95a99dc2-030e-c088-3744-45dfb5e47d20"
      },
      "outputs": [],
      "source": [
        "X <- Matrix(as.matrix(dt), sparse = T)\n",
        "rm(dt)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "d37046a1-3822-6347-9927-2fed067457e8"
      },
      "outputs": [],
      "source": [
        "folds <- createFolds(as.factor(Y), k = 6)\n",
        "valid <- folds$Fold1\n",
        "model <- c(1:length(Y))[-valid]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "b7bb73c6-5fa2-f650-455b-18b71ff5751b"
      },
      "outputs": [],
      "source": [
        "param <- list(objective = \"binary:logistic\",\n",
        "              eval_metric = \"auc\",\n",
        "              eta = 0.01,\n",
        "              base_score = 0.005,\n",
        "              col_sample = 0.5) "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "98999d60-9f17-8044-f008-d27486e31085"
      },
      "outputs": [],
      "source": [
        "dmodel <- xgb.DMatrix(X[model,], label = Y[model])\n",
        "dvalid <- xgb.DMatrix(X[valid,], label = Y[valid])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "fdb9fb8e-6b14-1948-890c-bb26727e8c0e"
      },
      "outputs": [],
      "source": [
        "m1 <- xgb.train(data = dmodel, param, nrounds = 20,\n",
        "                watchlist = list(mod = dmodel, val = dvalid))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "8af4418f-c4b1-2b52-8ca2-084b666b080c"
      },
      "outputs": [],
      "source": [
        "imp <- xgb.importance(model = m1, feature_names = colnames(X))\n",
        "\n",
        "cols <- imp$Feature\n",
        "length(cols)\n",
        "head(cols, 10)\n",
        "\n",
        "rm(list = setdiff(ls(), \"cols\"))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "b6eb258c-d4f8-c82d-c09c-d1c829c046b8"
      },
      "outputs": [],
      "source": [
        "### Filter to the good stuff\n",
        "\n",
        "Read all the data for the best numeric features.\n",
        "\n",
        "```{r Process train}\n",
        "dt <- fread(\"../input/train_numeric.csv\",\n",
        "            select = c(cols, \"Response\"),\n",
        "            showProgress = F)\n",
        "\n",
        "Y  <- dt$Response\n",
        "dt[ , Response := NULL]\n",
        "\n",
        "for(col in names(dt)) set(dt, j = col, value = dt[[col]] + 2)\n",
        "for(col in names(dt)) set(dt, which(is.na(dt[[col]])), col, 0)\n",
        "\n",
        "X <- Matrix(as.matrix(dt), sparse = T)\n",
        "rm(dt)\n",
        "```\n",
        "\n",
        "### Bathe in xgboost\n",
        "\n",
        "The base_score parameter helps with the imbalanced classes.\n",
        "\n",
        "```{r xgboost}\n",
        "set.seed(7579)\n",
        "folds <- createFolds(as.factor(Y), k = 6)\n",
        "valid <- folds$Fold3\n",
        "model <- c(1:length(Y))[-valid]\n",
        "\n",
        "param <- list(objective = \"binary:logistic\",\n",
        "              eval_metric = \"auc\",\n",
        "              eta = 0.01,\n",
        "              max_depth = 7,\n",
        "              colsample_bytree = 0.5,\n",
        "              base_score = 0.005) \n",
        "\n",
        "dmodel <- xgb.DMatrix(X[model,], label = Y[model])\n",
        "dvalid <- xgb.DMatrix(X[valid,], label = Y[valid])\n",
        "\n",
        "m1 <- xgb.train(data = dmodel, param, nrounds = 20,\n",
        "                watchlist = list(mod = dmodel, val = dvalid))\n",
        "\n",
        "pred <- predict(m1, dvalid)\n",
        "\n",
        "summary(pred)\n",
        "\n",
        "imp <- xgb.importance(model = m1, feature_names = colnames(X))\n",
        "\n",
        "head(imp, 30)\n",
        "```\n",
        "\n",
        "### Gauge Matthews Coefficient\n",
        "\n",
        "Try a few thresholds and select best for Matthews Coefficient.\n",
        "\n",
        "```{r choose threshold for matthews coefficient}\n",
        "mc <- function(actual, predicted) {\n",
        "  \n",
        "  tp <- as.numeric(sum(actual == 1 & predicted == 1))\n",
        "  tn <- as.numeric(sum(actual == 0 & predicted == 0))\n",
        "  fp <- as.numeric(sum(actual == 0 & predicted == 1))\n",
        "  fn <- as.numeric(sum(actual == 1 & predicted == 0))\n",
        "  \n",
        "  numer <- (tp * tn) - (fp * fn)\n",
        "  denom <- ((tp + fp) * (tp + fn) * (tn + fp) * (tn + fn)) ^ 0.5\n",
        "  \n",
        "  numer / denom\n",
        "}\n",
        "\n",
        "matt <- data.table(thresh = seq(0.990, 0.999, by = 0.001))\n",
        "\n",
        "matt$scores <- sapply(matt$thresh, FUN =\n",
        "  function(x) mc(Y[valid], (pred > quantile(pred, x)) * 1))\n",
        "\n",
        "print(matt)\n",
        "\n",
        "best <- matt$thresh[which(matt$scores == max(matt$scores))]\n",
        "```\n",
        "\n",
        "### Test cycle\n",
        "\n",
        "This time, also select the Id to be used in the submission.\n",
        "\n",
        "```{r Process test}\n",
        "dt  <- fread(\"../input/test_numeric.csv\",\n",
        "             select = c(\"Id\", cols),\n",
        "             showProgress = F)\n",
        "\n",
        "Id  <- dt$Id\n",
        "dt[ , Id := NULL]\n",
        "\n",
        "for(col in names(dt)) set(dt, j = col, value = dt[[col]] + 2)\n",
        "for(col in names(dt)) set(dt, which(is.na(dt[[col]])), col, 0)\n",
        "\n",
        "X <- Matrix(as.matrix(dt), sparse = T)\n",
        "rm(dt)\n",
        "\n",
        "```\n",
        "\n",
        "### Submission emission\n",
        "\n",
        "Without re-training model on all data.\n",
        "\n",
        "```{r Apply model as is rather than re-train on all}\n",
        "dtest <- xgb.DMatrix(X)\n",
        "pred  <- predict(m1, dtest)\n",
        "\n",
        "summary(pred)\n",
        "\n",
        "sub   <- data.table(Id = Id,\n",
        "              Response = (pred > quantile(pred, best)) * 1)\n",
        "\n",
        "write.csv(sub, \"sub.csv\", row.names = F)\n",
        "```\n",
        "\n",
        "Check RAM use\n",
        "\n",
        "```{r}\n",
        "gc()\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "021357bc-7bf0-1c76-d0d5-fa7cdafbba8c"
      },
      "outputs": [],
      "source": ""
    }
  ],
  "metadata": {
    "_change_revision": 0,
    "_is_fork": false,
    "kernelspec": {
      "display_name": "R",
      "language": "R",
      "name": "ir"
    },
    "language_info": {
      "codemirror_mode": "r",
      "file_extension": ".r",
      "mimetype": "text/x-r-source",
      "name": "R",
      "pygments_lexer": "r",
      "version": "3.3.1"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}