---
title: "<center> Example for Data Analysis <center>"
vignette: >
  %\VignetteIndexEntry{Example for Data Analysis}
  %\VignetteEngine{knitr::rmarkdown}
  %\VignetteEncoding{UTF-8}
output:
  knitr:::html_vignette:
    number_sections: false
    fig_caption: true
    toc: false
    theme: cosmo
    highlight: tango
---

```{r include = FALSE}
knitr::opts_chunk $ set( collapse = TRUE, comment = " ", fig.width = 7, fig.height = 7, fig.align = "center" )
```

```{r include = FALSE}
library( liver )

library( pROC )    

library( ggplot2 )  
```

The `liver` package contains a collection of helper functions that make various techniques from data science more user-friendly for non-experts. 

Here is an example to show how to use the functionality of the package by using the *churn* dataset which is available in the package.

```{r}
data( churn )       

str( churn )
```

It shows that the 'churn' dataset as a `data.frame` has `r ncol( churn )` variables and `r nrow( churn )` observations. 

# Partitioning the dataset

We partition the *churn* dataset randomly into two groups: train set (80%) and test set (20%). Here, we use the `partition` function from the *liver* package:

```{r}
set.seed( 5 )

data_sets = partition( data = churn, prob = c( 0.8, 0.2 ) )

train_set = data_sets $ part1
test_set  = data_sets $ part2

actual_test  = test_set $ churn
```

# Classification by kNN algorithm

The *churn* dataset has `r ncol( churn ) - 1` predictors along with the target variable `churn`. Here we use the following predictors:

`account.length`, `voice.plan`, `voice.messages`, `intl.plan`, `intl.mins`, `day.mins`, `eve.mins`, `night.mins`, and `customer.calls`.

First, based on the above predictors, find the k-nearest neighbor for the test set, based on the training dataset, for the k = 8 as follows

```{r}
formula = churn ~ account.length + voice.plan + voice.messages + intl.plan + intl.mins + 
                  day.mins + eve.mins + night.mins + customer.calls

predict_knn = kNN( formula, train = train_set, test = test_set, k = 8 )
```

To report Confusion Matrix:

```{r, fig.align = 'center', fig.height = 3, fig.width = 3}
conf.mat( predict_knn, actual_test )

conf.mat.plot( predict_knn, actual_test )
```

To report Mean Squared Error (MSE):
```{r}
mse( predict_knn, actual_test )
```

# Classification by kNN algorithm with data transformation

The predictors that we used in the previous part, do not have the same scale. For example, variable `day.mins` change between `r min( churn $ day.mins )` and `r max( churn $ day.mins )`, whereas variable `voice.plan` is binary. In this case, the values of variable `day.mins` will overwhelm the contribution of `voice.plan`. To avoid this situation we use normalization. So, we use min-max normalization and transfer the predictors as follows:

```{r}
predict_knn_trans = kNN( formula, train = train_set, test = test_set, k = 8, transform = "minmax" )
```

To report Confusion Matrix:

```{r fig.show = "hold", fig.align = 'default', out.width = "46%"}
conf.mat.plot( predict_knn_trans, actual_test )

conf.mat.plot( predict_knn, actual_test )
```

To report the ROC curve, we need the probability of our classification prediction. We can have it by using:

```{r}
prob_knn = kNN( formula, train = train_set, test = test_set, k = 8, type = "prob" )[ , 1 ]

prob_knn_trans = kNN( formula, train = train_set, test = test_set, transform = "minmax", k = 8, type = "prob" )[ , 1 ]
```

To visualize the model performance between the raw data and the transformed data, we could report the ROC curve plot as well as AUC (Area Under the Curve) by using the `plot.roc` function from the **pROC** package:

```{r, message = F, fig.align = "center"}
roc_knn = roc( actual_test, prob_knn )
roc_knn_trans = roc( actual_test, prob_knn_trans )

ggroc( list( roc_knn, roc_knn_trans ), size = 0.8 ) + 
    theme_minimal() + ggtitle( "ROC plots with AUC") +
  scale_color_manual( values = c( "red", "blue" ), 
    labels = c( paste( "AUC=", round( auc( roc_knn ), 3 ), "; Raw data; " ),
                paste( "AUC=", round( auc( roc_knn_trans ), 3 ), "; Transformed data" ) ) ) +
  theme( legend.title = element_blank() ) +
  theme( legend.position = c( .7, .3 ), text = element_text( size = 17 ) ) + 
    geom_segment( aes( x = 1, xend = 0, y = 0, yend = 1 ), color = "grey", linetype = "dashed" )
```

# Optimal value of k for the kNN algorithm

To find out the optimal value of `k` based on *Error Rate*, for the different values of k from 1 to 30, we run the k-nearest neighbor for the test set and compute the *Error Rate* for these models, by running `kNN.plot()` command 

```{r fig.align = "center" }
kNN.plot( formula, train = train_set, test = test_set, transform = "minmax", 
          k.max = 30, set.seed = 3 )
```

The plot shows that the minimum value of *Error Rate* is for the case that k is 13; the smaller values of *Error Rate* indicates better predictions.