Copy_of_Submission_notebook_(R).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Copy of Submission notebook (R).ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "ir",
      "display_name": "R"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/markkinuthia/Insurance-Pricing-Challenge/blob/master/Copy_of_Submission_notebook_(R).ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5fHOA8YzJN1F"
      },
      "source": [
        "<div style=\"text-align: center\">\n",
        "  <img alt=\"AIcrowd\" src=\"https://gitlab.aicrowd.com/jyotish/pricing-game-notebook-scripts/raw/master/pricing-game-banner.png\">\n",
        "</div>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hs6wY5pwLLyr"
      },
      "source": [
        "# How to use this notebook 📝\n",
        "\n",
        "1. **Copy the notebook**. This is a shared template and any edits you make here will not be saved. _You should copy it into your own drive folder._ For this, click the \"File\" menu (top-left), then \"Save a Copy in Drive\". You can edit your copy however you like.\n",
        "2. **Link it to your AICrowd account**. In order to submit your code to AICrowd, you need to provide your account's API key (see [_\"Configure static variables\"_](#static-var) for details).\n",
        "3. **Stick to the function definitions**. The submission to AICrowd will look for the pre-defined function names:\n",
        "  - `install_packages`\n",
        "  - `global_imports`\n",
        "  - `fit_model`\n",
        "  - `save_model`\n",
        "  - `load_model`\n",
        "  - `predict_expected_claim`\n",
        "  - `predict_premium`\n",
        "  - `preprocess_X_data`\n",
        "\n",
        "    Anything else you write outside of these functions will not be part of the final submission (including constants and utility functions), so make sure everything is defined within them, except for:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PW1MDeDmcK99"
      },
      "source": [
        "# Your pricing model 🕵️\n",
        "\n",
        "In this notebook, you can play with the data, and define and train your pricing model.\n",
        "You can then directly submit it to the AICrowd server, with some magic code at the end.\n",
        "\n",
        "### Baseline logistic regression 💪\n",
        "You can also play with a baseline logistic regression model [implemented here](https://colab.research.google.com/drive/1hbIWxTHri1TP5cffRYzU_z4bQPvKi3FB?usp=sharing). \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cf5QtzJELOSL"
      },
      "source": [
        "# Prepare the notebook 🛠"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ljY8PLQspi3L",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "61d7618d-dfbc-4be6-9e58-0896c3ed5f2f"
      },
      "source": [
        "cat(system('curl -sL https://gitlab.aicrowd.com/jyotish/pricing-game-notebook-scripts/raw/r-functions/r/setup.sh > setup.sh && bash setup.sh', intern=TRUE), sep='\\n')\n",
        "source(\"aicrowd_helpers.R\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "⚙️ Installing AIcrowd utilities...\n",
            "✅ Installed AIcrowd utilities\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ScNf-JbfVtf6"
      },
      "source": [
        "# Configure static variables 📎\n",
        "\n",
        "<a name=\"static-var\"></a>\n",
        "\n",
        "In order to submit using this notebook, you must visit this URL https://aicrowd.com/participants/me and copy your API key. \n",
        "\n",
        "Then you must set the value of `AICROWD_API_KEY` wuth the value."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v-aU1T_9cUN5"
      },
      "source": [
        "TRAINING_DATA_PATH = 'training.csv'\n",
        "AICROWD_API_KEY = '8c94860b35be851b077ad59c13b01398'  # You can get the key from https://aicrowd.com/participants/me"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BAq7u_3KjmSv"
      },
      "source": [
        "# Download dataset files 💾"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HxNxqHFIjpHP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "623e9e8f-eda8-4dfe-badb-991ae4b9b589"
      },
      "source": [
        "# Make sure to offically join the challenge and accept the challenge rules! Otherwise you will not be able to download the data\n",
        "download_aicrowd_dataset(AICROWD_API_KEY) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "💾 Downloading dataset...\n",
            "\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\rtraining_v0.2.csv:   0%|          | 0.00/33.5M [00:00<?, ?B/s]\rtraining_v0.2.csv: 100%|██████████| 33.5M/33.5M [00:01<00:00, 24.2MB/s]\rtraining_v0.2.csv: 100%|██████████| 33.5M/33.5M [00:01<00:00, 24.2MB/s]\n",
            "\r9848975e-6687-4402-a5b7-f8ec4df938b7_data_dictionary.pdf:   0%|          | 0.00/71.3k [00:00<?, ?B/s]\r9848975e-6687-4402-a5b7-f8ec4df938b7_data_dictionary.pdf: 100%|██████████| 71.3k/71.3k [00:00<00:00, 354kB/s]\r9848975e-6687-4402-a5b7-f8ec4df938b7_data_dictionary.pdf: 100%|██████████| 71.3k/71.3k [00:00<00:00, 353kB/s]\n",
            "\rtraining.csv:   0%|          | 0.00/33.5M [00:00<?, ?B/s]\rtraining.csv: 100%|██████████| 33.5M/33.5M [00:01<00:00, 25.1MB/s]\rtraining.csv: 100%|██████████| 33.5M/33.5M [00:01<00:00, 25.1MB/s]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "izMI_KQ0c1aS"
      },
      "source": [
        "# Packages 🗃\n",
        "\n",
        "Install and require here all the packages you need to define your model. \n",
        "\n",
        "**Note**: Installing packages the first time might take some time."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IdRCnCVmcvMh"
      },
      "source": [
        "install_packages <- function() {\n",
        "  install.packages(\"caret\")\n",
        "  install.packages(\"rpart\")\n",
        "  install.packages(\"caret\")\n",
        "  install.packages(\"rpart\")\n",
        "  install.packages(\"knitr\")\n",
        "  install.packages(\"ggplot2\")\n",
        "  install.packages(\"plyr\")\n",
        "  install.packages(\"dplyr\")\n",
        "  install.packages(\"corrplot\")\n",
        "  install.packages(\"caret\")\n",
        "  install.packages(\"gridExtra\")\n",
        "  install.packages(\"scales\")\n",
        "  install.packages(\"Rmisc\")\n",
        "  install.packages(\"ggrepel\")\n",
        "  install.packages(\"randomForest\")\n",
        "  install.packages(\"psych\")\n",
        "  install.packages(\"xgboost\")\n",
        "  install.packages(\"ROCR\")\n",
        "  install.packages(\"rpart.plot\")\n",
        "  install.packages(\"rpart\")\n",
        "  install.packages(\"caret\")\n",
        "  install.packages(\"h2o\")\n",
        "  install.packages(\"pROC\")\n",
        "  install.packages(\"corrplot\")\n",
        "  install.packages(\"plyr\")\n",
        "  install.packages(\"tidyverse\")\n",
        "  }\n",
        "install_packages()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kGNATcJ5dK_G"
      },
      "source": [
        "global_imports <- function() {\n",
        "  require(\"caret\")\n",
        "  require(\"rpart\")\n",
        "  require(\"knitr\")\n",
        "  require(\"ggplot2\")\n",
        "  require(\"plyr\")\n",
        "  require(\"dplyr\")\n",
        "  require(\"corrplot\")\n",
        "  require(\"caret\")\n",
        "  require(\"gridExtra\")\n",
        "  require(\"scales\")\n",
        "  require(\"Rmisc\")\n",
        "  require(\"ggrepel\")\n",
        "  require(\"randomForest\")\n",
        "  require(\"psych\")\n",
        "  require(\"xgboost\")\n",
        "  require(\"ROCR\")\n",
        "  require(\"rpart.plot\")\n",
        "  require(\"rpart\")\n",
        "  require(\"caret\")\n",
        "  require(\"h2o\")\n",
        "  require(\"pROC\")\n",
        "  require(\"corrplot\")\n",
        "  require(\"plyr\")\n",
        "  library(\"tidyverse\")}\n",
        "global_imports()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FDwuEV9aZ9jT"
      },
      "source": [
        "library(\"h2o\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oIILubWJdVE6"
      },
      "source": [
        "# Loading the data 📲"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Hb70XooadS8x",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 212
        },
        "outputId": "2c41ef9d-fd5c-4b89-dabb-fbedafcf2e28"
      },
      "source": [
        "# Load the dataset.\n",
        "train_data = read.csv(TRAINING_DATA_PATH)\n",
        "\n",
        "# Create a model, train it, then save it.\n",
        "Xdata = within(train_data, rm('claim_amount'))\n",
        "ydata = train_data['claim_amount']"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Warning message in file(file, \"rt\"):\n",
            "“cannot open file 'training.csv': No such file or directory”\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "error",
          "ename": "ERROR",
          "evalue": "ignored",
          "traceback": [
            "Error in file(file, \"rt\"): cannot open the connection\nTraceback:\n",
            "1. read.csv(TRAINING_DATA_PATH)",
            "2. read.table(file = file, header = header, sep = sep, quote = quote, \n .     dec = dec, fill = fill, comment.char = comment.char, ...)",
            "3. file(file, \"rt\")"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GFblo2hHV9L5"
      },
      "source": [
        "## How does the data look like? 🔍"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zRsLgulNV-R1"
      },
      "source": [
        "train_data"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xGNmm0qPWEjl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6f96afb5-6567-4ccf-f6f0-228d7c5e14e8"
      },
      "source": [
        "\n",
        "# Variable 3 pol_coverage\n",
        "train_data$pol_coverage<-as.integer(revalue(train_data$pol_coverage, c('Min'=0, 'Med1'=1, 'Med2'=2, 'Max'=3)))\n",
        "str(train_data$pol_coverage)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            " int [1:228216] 2 2 1 2 1 2 3 3 1 0 ...\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dk10h86sddEq"
      },
      "source": [
        "# Training the model 🚀\n",
        "\n",
        "You must first define your first function: `fit_model`. This function takes training data as arguments, and outputs a \"model\" object -- that you define as you wish. For instance, this could be an array of parameter values. \n",
        "\n",
        "You may want to define the function `preprocess_X_data` that prepares and cleans your predictor variables for the training and prediction. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cJ1OmtTDk6zm"
      },
      "source": [
        "## Define your data preprocessing\n",
        "\n",
        "You can add any class or function in this cell for preprocessing. Just make sure that you use the functions here in the `fit_model`, `predict_expected_claim` and `predict_premium` functions if necessary. \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JMPatwIzCdqN"
      },
      "source": [
        "\n",
        "# Variable 3 pol_coverage\n",
        "train_data$pol_coverage<-as.integer(revalue(train_data$pol_coverage, c('Min'=0, 'Med1'=1, 'Med2'=2, 'Max'=3)))\n",
        "str(train_data$pol_coverage)\n",
        "\n",
        "# Variable 7 pol_pay_freq\n",
        "train_data$pol_pay_freq<-as.integer(revalue(train_data$pol_pay_freq, c('Monthly'=0, 'Quarterly'=1, 'Biannual'=2, 'Yearly'=3)))\n",
        "unique(train_data$pol_pay_freq)\n",
        "\n",
        "\n",
        "# Variable 8 pol_payd\n",
        "train_data$pol_payd<-as.integer(revalue(train_data$pol_payd, c('No'=0, 'Yes'=1)))\n",
        "unique(train_data$pol_payd)\n",
        "\n",
        "# Variable 9 pol_usage\n",
        "train_data$pol_usage<-as.integer(revalue(train_data$pol_usage, c('WorkPrivate'=0, 'Retired'=1, 'Professional'=2, 'AllTrips'=3)))\n",
        "unique(train_data$pol_usage)\n",
        "\n",
        "# Variable  10 drv_sex1\n",
        "train_data$drv_sex1<-as.integer(revalue(train_data$drv_sex1, c('M'=0, 'F'=1)))\n",
        "unique(train_data$drv_sex1)\n",
        "\n",
        "# Variable 13 drv_drv2\n",
        "train_data$drv_drv2<-as.integer(revalue(train_data$drv_drv2, c('No'=0, 'Yes'=1)))\n",
        "unique(train_data$drv_drv2)\n",
        "\n",
        "# Variable 14 drv_sex2\n",
        "train_data$drv_sex2<-as.integer(revalue(train_data$drv_sex2, c('M'=0, 'F'=1 , \"0\"=2)))\n",
        "unique(train_data$drv_sex2)\n",
        "head(train_data)\n",
        "\n",
        "# Variable 15 drv_age2\n",
        "for (i in 1:nrow(train_data)){\n",
        "  if(is.na(train_data$drv_age2[i])){\n",
        "    train_data$drv_age2[i] <- as.integer(c(\"0\"), na.rm=TRUE) \n",
        "  }\n",
        "}\n",
        "\n",
        "unique(train_data$drv_age2)\n",
        "class(train_data$drv_age2)\n",
        "\n",
        "# Variable 16 drv_age_lic2\n",
        "for (i in 1:nrow(train_data)){\n",
        "  if(is.na(train_data$drv_age_lic2[i])){\n",
        "    train_data$drv_age_lic2[i] <- as.integer(c(\"0\"), na.rm=TRUE) \n",
        "  }\n",
        "}\n",
        "\n",
        "unique(train_data$drv_age_lic2)\n",
        "class(train_data$drv_age_lic2)\n",
        "\n",
        "\n",
        "unique(train_data$vh_age)\n",
        "head(train_data)\n",
        "\n",
        "# Variable 17 vh_age\n",
        "for (i in 1:nrow(train_data)){\n",
        "  if(is.na(train_data$vh_age[i])){\n",
        "    train_data$vh_age[i] <- as.integer(c(\"0\"), na.rm=TRUE) \n",
        "  }\n",
        "}\n",
        "class(train_data$vh_age)\n",
        "unique(train_data$vh_age)\n",
        "head(train_data)\n",
        "\n",
        "\n",
        "# Variable vh_fuel\n",
        "train_data$vh_fuel<-as.integer(revalue(train_data$vh_fuel, c('Gasoline'=0, 'Diesel'=1 , \"Hybrid\"=2)))\n",
        "unique(train_data$vh_fuel)\n",
        "head(train_data)\n",
        "\n",
        "# Variable vh_type\n",
        "train_data$vh_type<-as.integer(revalue(train_data$vh_type, c('Tourism'=0, 'Commercial'=1)))\n",
        "unique(train_data$vh_type)\n",
        "head(train_data)\n",
        "\n",
        "summary(is.na(train_data))\n",
        "\n",
        "\n",
        "# Variable 21 vh_speed\n",
        "for (i in 1:nrow(train_data)){\n",
        "  if(is.na(train_data$vh_speed[i])){\n",
        "    train_data$vh_speed[i] <- as.integer(c(\"0\"), na.rm=TRUE) \n",
        "  }\n",
        "}\n",
        "class(train_data$vh_speed)\n",
        "unique(train_data$vh_speed)\n",
        "head(train_data)\n",
        "\n",
        "\n",
        "# Variable 21 vh_value\n",
        "for (i in 1:nrow(train_data)){\n",
        "  if(is.na(train_data$vh_value[i])){\n",
        "    train_data$vh_value[i] <- as.integer(c(\"0\"), na.rm=TRUE) \n",
        "  }\n",
        "}\n",
        "class(train_data$vh_value)\n",
        "unique(train_data$vh_value)\n",
        "head(train_data)\n",
        "\n",
        "\n",
        "# Variable 22 vh_weight\n",
        "for (i in 1:nrow(train_data)){\n",
        "  if(is.na(train_data$vh_weight[i])){\n",
        "    train_data$vh_weight[i] <- as.integer(c(\"0\"), na.rm=TRUE) \n",
        "  }\n",
        "}\n",
        "class(train_data$vh_weight)\n",
        "unique(train_data$vh_weight)\n",
        "head(train_data)\n",
        "str(train_data)\n",
        "\n",
        "# vh_make_model_frequency \n",
        "data.test2 <- group_by(train_data,vh_make_model)%>%\n",
        "  summarise(vh_make_model_frequency=n())\n",
        "train_data<-merge(train_data,data.test2,by = \"vh_make_model\")\n",
        "\n",
        "\n",
        "#drv_age1 & drv_age_lic1\n",
        "train_data$drv_age1_bin = cut(train_data$drv_age1,breaks = c(0,25,30,40,50,60,70,80,90,110,Inf),right = FALSE) # This \"cuts\" DriverAge into bins\n",
        "train_data$drv_age_lic1_bin = cut(train_data$drv_age_lic1,breaks = c(0,25,30,40,50,60,70,80,90,110,Inf),right = FALSE) # This \"cuts\" DriverLicAge into bins\n",
        "\n",
        "train_data$drv_age1_bin<-as.integer(revalue(train_data$drv_age1_bin, c(\"[0,25)\"=0, \"[25,30)\"=1 , \"[30,40)\"=2 , \"[40,50)\"=3 , \"[50,60)\"=4, \"[60,70)\"=5, \"[70,80)\"=6 , \"[80,90)\"=7 , \"[90,110)\"=8 )))\n",
        "train_data$drv_age_lic1_bin<-as.integer(revalue(train_data$drv_age_lic1_bin, c(\"[0,25)\"=0, \"[25,30)\"=1 , \"[30,40)\"=2 , \"[40,50)\"=3 , \"[50,60)\"=4, \"[60,70)\"=5, \"[70,80)\"=6 , \"[80,90)\"=7 , \"[90,110)\"=8 )))\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7V3EfCY-IqL4",
        "outputId": "520bcbba-8122-4dd6-e130-a85a89827cf3"
      },
      "source": [
        "#preprocessing II\n",
        "\n",
        "numericVars <- which(sapply(train_data, is.numeric)) #index vector numeric variables\n",
        "factorVars <- which(sapply(train_data, is.factor)) #index vector factor variables\n",
        "cat('There are', length(numericVars), 'numeric variables, and', length(factorVars), 'categoric variables')\n",
        "##Correlations again\n",
        "\n",
        "#Below I am checking the correlations again. As you can see, the number of variables with a correlation of at least 0.5 with the SalePrice has increased from 10 (see section 4.2.1) to 16. \n",
        "\n",
        "all_numVar <- train_data[, numericVars]\n",
        "cor_numVar <- cor(all_numVar, use=\"pairwise.complete.obs\") #correlations of all numeric variables\n",
        "#plot(all_numVar)\n",
        "\n",
        "#sort on decreasing correlations with Claim_amount\n",
        "cor_sorted <- as.matrix(sort(cor_numVar[,'claim_amount'], decreasing = TRUE))\n",
        "#select only high corelations\n",
        "CorHigh <- names(which(apply(cor_sorted, 1, function(x) abs(x)>0.0035)))\n",
        "cor_numVar <- cor_numVar[CorHigh, CorHigh]\n",
        "\n",
        "#corrplot.mixed(cor_numVar, tl.col=\"black\", tl.pos = \"lt\", tl.cex = 0.7,cl.cex = .7, number.cex=.7)\n",
        "\n",
        "\n",
        "#########Predictions\n",
        "train_data1<-train_data\n",
        "range01 <- function(x){(x-min(x))/(max(x)-min(x))}\n",
        "s<-data.frame(range01(train_data$claim_amount))\n",
        "\n",
        "train_data<-cbind(train_data,s)\n",
        "\n",
        "#convert class into discrete\n",
        "n_records_gc = nrow(train_data)\n",
        "n_train_gc = round(0.7*n_records_gc,0)\n",
        "\n",
        "training_ids = sample(1:n_records_gc,n_train_gc)\n",
        "testing_ids = setdiff(1:n_records_gc,training_ids)\n",
        "#Creating  subsets.\n",
        "training_gc= train_data[training_ids,]\n",
        "testing_gc = train_data[testing_ids,]\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "There are 28 numeric variables, and 0 categoric variables"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UT_jJRFPkx7O"
      },
      "source": [
        "## Define the training logic"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bcKm2Av9daqY"
      },
      "source": [
        "\n",
        "# The following two commands remove any previously installed H2O packages for R.\n",
        "if (\"package:h2o\" %in% search()) { detach(\"package:h2o\", unload=TRUE) }\n",
        "if (\"h2o\" %in% rownames(installed.packages())) { remove.packages(\"h2o\") }\n",
        "\n",
        "# Next, we download packages that H2O depends on.\n",
        "pkgs <- c(\"RCurl\",\"jsonlite\")\n",
        "for (pkg in pkgs) {\n",
        "  if (! (pkg %in% rownames(installed.packages()))) { install.packages(pkg) }\n",
        "}\n",
        "\n",
        "# Now we download, install and initialize the H2O package for R.\n",
        "install.packages(\"h2o\", type=\"source\", repos=\"http://h2o-release.s3.amazonaws.com/h2o/rel-zermelo/4/R\")\n",
        "\n",
        "# Finally, let's load H2O and start up an H2O cluster\n",
        "library(h2o)\n",
        "localH2O = h2o.init()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YVb9Cvbkn-5Q"
      },
      "source": [
        "\n",
        "predictors =c(\"year\" ,\"pol_no_claims_discount\" ,\"pol_coverage\" ,\"pol_duration\" ,\"pol_sit_duration\" ,\"pol_pay_freq\"          \n",
        "              ,\"pol_payd\",\"pol_usage\",\"drv_sex1\" ,\"drv_age1\" ,\"drv_age_lic1\" ,\"drv_drv2\"              \n",
        "              ,\"drv_sex2\",\"drv_age2\",\"drv_age_lic2\",\"vh_age\" ,\"vh_fuel\"  ,\"vh_type\"               \n",
        "              ,\"vh_speed\",\"vh_value\",\"vh_weight\",\"population\" ,\"town_surface_area\"      \n",
        "              ,\"vh_make_model_frequency\",\"drv_age1_bin\",\"drv_age_lic1_bin\")\n",
        "target =\"claim_amount\" \n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eL69O22XAE-q"
      },
      "source": [
        "training_gc= train_data[training_ids,]\n",
        "testing_gc = train_data[testing_ids,]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 94
        },
        "id": "n0y5NCoXXVHz",
        "outputId": "c6a9028e-5501-4c8b-8b34-14e912ab2375"
      },
      "source": [
        "training_gc.hex = as.h2o(training_gc)\n",
        "test_gc.hex = as.h2o(testing_gc)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "ERROR",
          "evalue": "ignored",
          "traceback": [
            "Error in as.h2o(training_gc): could not find function \"as.h2o\"\nTraceback:\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KOKTwZGPb-w2"
      },
      "source": [
        "## Saving your model\n",
        "\n",
        "You can save your model to a file here, so you don't need to retrain it every time."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8kMfPJKlb-w2"
      },
      "source": [
        "save_model <- function(model){\n",
        "  # Saves this trained model to a file.\n",
        "\n",
        "  # This is used to save the model after training, so that it can be used for prediction later.\n",
        "\n",
        "  # Do not touch this unless necessary (if you need specific features). If you do, do not\n",
        "  #  forget to update the load_model method to be compatible.\n",
        "\t\n",
        "  # The default is to save it in 'trained_model.RData', but change this if you \n",
        "  # are using a pacakge that requires a different saving format.\n",
        "  \n",
        "  # BE SURE TO SAVE ANY OBJECT YOU WISH INTO THE saved_objects DIRECTORY\n",
        "\n",
        "  save(model, file='saved_objects/trained_model.RData')\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fNMwNh_jt1uz"
      },
      "source": [
        "save_model(model)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vnZIECd4b-w2"
      },
      "source": [
        "If you need to load it from file, you can use this code:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z03gpfMEb-w2"
      },
      "source": [
        "load_model <- function(){ \n",
        " # Load a saved trained model from the file `trained_model.RData`.\n",
        " # This is called by the server to evaluate your submission on hidden data.\n",
        "\n",
        "\n",
        " # Only modify this *if* you modified save_model.\n",
        "\n",
        "  load('saved_objects/trained_model.RData')\n",
        "  return(model)\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8xjEHnWut6Tm"
      },
      "source": [
        "model = load_model()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OQGzojS_b-w3"
      },
      "source": [
        "# Predicting the claims 💵\n",
        "\n",
        "The second function, `predict_expected_claim`, takes your trained model and a dataframe of contracts, and outputs a prediction for the (expected) claim incurred by each contract. This expected claim can be seen as the probability of an accident multiplied by the cost of that accident.\n",
        "\n",
        "This is the function used to compute the _RMSE_ leaderboard, where the model best able to predict claims wins."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t4X3CPaZb-w3"
      },
      "source": [
        "predict_expected_claim <- function(model, x_raw){\n",
        "\t# Model prediction function: predicts the average claim based on the pricing model.\n",
        "\n",
        "\t# This functions estimates the expected claim made by a contract (typically, as the product\n",
        "\t# of the probability of having a claim multiplied by the average cost of a claim if it occurs),\n",
        "\t# for each contract in the dataset X_raw.\n",
        "\n",
        "\t# This is the function used in the RMSE leaderboard, and hence the output should be as close\n",
        "\t# as possible to the expected cost of a contract.\n",
        "\n",
        "\t# Parameters\n",
        "\t# ----------\n",
        "\t# X_raw : Dataframe, with the columns described in the data dictionary.\n",
        "\t# \tEach row is a different contract. This data has not been processed.\n",
        "\n",
        "\t# Returns\n",
        "\t# -------\n",
        "\t# avg_claims: a one-dimensional array of the same length as X_raw, with one\n",
        "\t#     average claim per contract (in same order). These average claims must be POSITIVE (>0).\n",
        "\n",
        "\n",
        "  # YOUR CODE HERE ------------------------------------------------------\n",
        "  x_clean = preprocess_X_data(x_raw) #preprocess your data before fitting \n",
        "\n",
        "  expected_frequency = predict(model$occurence,newdata = x_clean, type = \"response\")\n",
        "  expected_severity = predict(model$cost,newdata = x_clean,type = \"response\")\n",
        "\n",
        "  expected_claims = expected_frequency * expected_severity\n",
        "\n",
        "  # x_clean = preprocess_X_data(x_raw)  # preprocess your data before fitting\n",
        "  #expected_claims = predict(model, newdata = x_raw)  # tweak this to work with your model\n",
        "\n",
        "  return(expected_claims)  \n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nqOw2Xbj0i9S"
      },
      "source": [
        "claims <- predict_expected_claim(model, Xdata)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tx-WzTjXCVi-"
      },
      "source": [
        "claims"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LcQe1oASb-w3"
      },
      "source": [
        "# Pricing contracts 💰\n",
        "\n",
        "The third and final function, `predict_premium`, takes your trained model and a dataframe of contracts, and outputs a _price_ for each of these contracts. **You are free to set this prices however you want!** These prices will then be used in competition with other models: contracts will choose the model offering the lowest price, and this model will have to pay the cost if an accident occurs.\n",
        "\n",
        "This is the function used to compute the _profit_ leaderboard: your model will participate in many markets of size 10, populated by other participants' model, and we compute the average profit of your model over all the markets it participated in."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qT3c8nuWb-w3"
      },
      "source": [
        "predict_premium <- function(model, x_raw){\n",
        "  # Model prediction function: predicts premiums based on the pricing model.\n",
        "\n",
        "  # This function outputs the prices that will be offered to the contracts in X_raw.\n",
        "  # premium will typically depend on the average claim predicted in \n",
        "  # predict_expected_claim, and will add some pricing strategy on top.\n",
        "\n",
        "  # This is the function used in the average profit leaderboard. Prices output here will\n",
        "  # be used in competition with other models, so feel free to use a pricing strategy.\n",
        "\n",
        "  # Parameters\n",
        "  # ----------\n",
        "  # X_raw : Dataframe, with the columns described in the data dictionary.\n",
        "  # \tEach row is a different contract. This data has not been processed.\n",
        "\n",
        "  # Returns\n",
        "  # -------\n",
        "  # prices: a one-dimensional array of the same length as X_raw, with one\n",
        "  #     price per contract (in same order). These prices must be POSITIVE (>0).\n",
        "\n",
        "\n",
        "  # YOUR CODE HERE ------------------------------------------------------\n",
        "\n",
        "  x_clean = preprocess_X_data(x_raw)  # preprocess your data before fitting\n",
        "\n",
        "  return(predict_expected_claim(model, x_raw) * 2) # Default: bosst prices by a factor of 2\n",
        "}\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G7lD-nxa08tU",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 228
        },
        "outputId": "32a6c983-7a81-4d85-c2fd-ce59975e066a"
      },
      "source": [
        "prices <- predict_premium(model, Xdata)\n",
        "as.matrix(head(prices))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  [,1]    \n",
              "1 220.4890\n",
              "2 220.4890\n",
              "3 225.1931\n",
              "4 226.3876\n",
              "5 256.9770\n",
              "6 244.9654"
            ],
            "text/latex": "A matrix: 6 × 1 of type dbl\n\\begin{tabular}{r|l}\n\t1 & 220.4890\\\\\n\t2 & 220.4890\\\\\n\t3 & 225.1931\\\\\n\t4 & 226.3876\\\\\n\t5 & 256.9770\\\\\n\t6 & 244.9654\\\\\n\\end{tabular}\n",
            "text/markdown": "\nA matrix: 6 × 1 of type dbl\n\n| 1 | 220.4890 |\n| 2 | 220.4890 |\n| 3 | 225.1931 |\n| 4 | 226.3876 |\n| 5 | 256.9770 |\n| 6 | 244.9654 |\n\n",
            "text/html": [
              "<table class=\"dataframe\">\n",
              "<caption>A matrix: 6 × 1 of type dbl</caption>\n",
              "<tbody>\n",
              "\t<tr><th scope=row>1</th><td>220.4890</td></tr>\n",
              "\t<tr><th scope=row>2</th><td>220.4890</td></tr>\n",
              "\t<tr><th scope=row>3</th><td>225.1931</td></tr>\n",
              "\t<tr><th scope=row>4</th><td>226.3876</td></tr>\n",
              "\t<tr><th scope=row>5</th><td>256.9770</td></tr>\n",
              "\t<tr><th scope=row>6</th><td>244.9654</td></tr>\n",
              "</tbody>\n",
              "</table>\n"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QGKrsik_b-w3"
      },
      "source": [
        "#### Profit on training data\n",
        "\n",
        "In order for your model to be considered in the profit competition, it needs to make nonnegative profit over its training set. You can check that your model satisfies this condition below:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NPssEcCrb-w3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7182c832-ac8d-435b-e9c4-6d513ce33543"
      },
      "source": [
        "print(paste('Income:', sum(prices)))\n",
        "print(paste('Losses:', sum(ydata)))\n",
        "\n",
        "if (sum(prices) < sum(ydata)) {\n",
        "    print('Your model loses money on the training data! It does not satisfy market rule 1: Non-negative training profit.')\n",
        "    print('This model will be disqualified from the weekly profit leaderboard, but can be submitted for educational purposes to the RMSE leaderboard.')\n",
        "} else {\n",
        "    print('Your model passes the non-negative training profit test!')\n",
        "}"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1] \"Income: 51619469.840001\"\n",
            "[1] \"Losses: 25809734.92\"\n",
            "[1] \"Your model passes the non-negative training profit test!\"\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FE0vTPmDb-w3"
      },
      "source": [
        "# Ready? Submit to AIcrowd 🚀\n",
        "\n",
        "If you are satisfied with your code, run the code below to send your code to the AICrowd servers for evaluation! This requires the variable `trained_model` to be defined by your previous code.\n",
        "\n",
        "**Make sure you have included all packages needed to run your code in the [_\"Packages\"_](#packages) section.**\n",
        "\n",
        "**NOTE**: If you submit the baseline RMSE model without any change whatsoever, your model will not be entered into the market. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bVSbAI37f7Av",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e052eca9-3d15-4b60-dc24-ef73714dda54"
      },
      "source": [
        "aicrowd_submit(AICROWD_API_KEY)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "🚀 Preparing to submit...\n",
            "⚙️ Collecting the submission code...\n",
            "mv: cannot stat 'trained_model.RData': No such file or directory\n",
            "💾 Preparing the submission zip file...\n",
            "Verifying API Key...\n",
            "API Key valid\n",
            "Saved API Key successfully!\n",
            "submission.zip ━━━━━━━━━━━━━━━━━━━━━ 100.0% • 22.7/22.7 MB • 15.0 MB/s • 0:00:00                                          ╭─────────────────────────╮                                           \n",
            "                                          │ Successfully submitted! │                                           \n",
            "                                          ╰─────────────────────────╯                                           \n",
            "                                                Important links                                                 \n",
            "┌──────────────────┬───────────────────────────────────────────────────────────────────────────────────────────┐\n",
            "│  This submission │ https://www.aicrowd.com/challenges/insurance-pricing-game/submissions/122707              │\n",
            "│                  │                                                                                           │\n",
            "│  All submissions │ https://www.aicrowd.com/challenges/insurance-pricing-game/submissions?my_submissions=true │\n",
            "│                  │                                                                                           │\n",
            "│      Leaderboard │ https://www.aicrowd.com/challenges/insurance-pricing-game/leaderboards                    │\n",
            "│                  │                                                                                           │\n",
            "│ Discussion forum │ https://discourse.aicrowd.com/c/insurance-pricing-game                                    │\n",
            "│                  │                                                                                           │\n",
            "│   Challenge page │ https://www.aicrowd.com/challenges/insurance-pricing-game                                 │\n",
            "└──────────────────┴───────────────────────────────────────────────────────────────────────────────────────────┘\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}