Algorithm：
Given a training set X_train with labels y_train, and given a new instance x_test to be classified:
1. Find the most similar instances (let's call them X_NN) to x_test that are in X_train.
2. Get the labels y_NN for the instances in X_NN
3. Predict the label for x_test by combining the labels y_NN
Implementation：
from sklearn.neighbors import KNeighborsClassifier
X_train, X_test, y_train, y_test = train_test_split(X_C1, y_C1, random_state = 0)
knnc = KNeighborsClassifier(n_neighbors = 5).fit(X_train, y_train)
knnc.predict(X_test)
knnc.score(X_test, y_test)

University of Michigan - Ann Arbor

When using KNN for regression problems, the model is based off of ‘feature similarity’ which means that the output value of an observation you are trying to find is based on how closely it resembles the points in the training data set. With regression using KNN, this similarity is based on the average distance, typically using Euclidean distance, between the chosen observation and those around it.

KNN Regression

Linear regression is an example of a parametric method because it assumes a linear functional form for f(X). But if the specified functional form is far from the truth, and prediction accuracy is our goal, then the parametric method will perform poorly. This leads to higher bias. There is also a well known statistical theory behind linear regression.

KNN is an example of non parametric method that uses feature similarity. It is pretty useful, because in the real world, most of the practical data does not obey the typical theoretical assumptions made (eg gaussian mixtures, linearly separable etc). Non-parametric methods do not explicitly assume a parametric form for f(X), and thereby provide an alternative and more flexible approach for performing regression. This means it will have less bias and is more robust with highly non-linear settings. However, KNN regression is not as widely studied as linear regression.

Comparison of Linear Regression with K-Nearest Neighbors

For regression problems, a K value is first chosen, as well as a prediction point ($x_0$). The algorithm starts off by finding the K training observations that are closes to $x_0$. These training observations are denoted by $N_0$. In order to find $f(x_0)$, or the response value of your predicted point, KNN uses the average of the training observations in $N_0$. To do this, it does the following:

1. Depending on the value of k, it finds the distance (typically Euclidean) between it and the other observations.
2. It then chooses the k closest observations based on this distance ($N_0$).
3. The response values of the chosen k observations are averaged to predict the output of $x_0$.

Formally, the equation for this process is:

$$\hat{f}(x_0) =  \frac{1}{K} \sum_{x_i \in N_0}y_i$$
 
    

Regression Process of K-Nearest Neighbors

To implement KNN in R you need to install package "class"

Step 1: Clean your dataset, change categorical variables into dummy variables
Don't forget to change  your dataset since the input of knn must be numerical variables. To change categorical variables into dummy variables you can use the code below.
data_cleaned<- as.data.frame(model.matrix(~ . -1, data = dataset you want to use)

Step 2: Normalize your dataset

normalize <- function(x){
  return ((x - min(x)) / (max(x) - min(x)))
}
data_normalized <- as.data.frame(lapply(data_cleaned, normalize))


Step 3: Split your dataset into trainning data and test data, and get labels for these data

output<-data_normalized$outputcolumn
data_normalized$outputcolumn<-NULL
(This step is to get labels from dataset and delete label column from dataset as it's dependent variables)

test <- data_normalized[1:n, ]
train <- data_normalized[n:datasize,]
test_label <- output[1:n]
train_label <- output[n:datasize]

n depends on how you want to split your dataset

Step 4: Build your KNN model 
prediction <- knn(train = train, test = test, cl = train_label, k = n)

you can use any value for n

Step 5: See the accuracy using CrossTable
library(gmodels)
CrossTable(test_label, prediction)

accuracy=(true positive + true negative)/number of test labels


Step 6: Improve your accuracy
change k to improve accuracy



Implemention of KNN in R

(1) n_neighbors: the number of nearest neighbors to consider. The default value is 5. For a very low value of n_neighbors leads to overfitting on the training data, while high value of n_neighbors will make the model perform poorly on both train and validation set. We can draw a validation error curve to determine the optimal value of n_neighbors.
(2) metric: distance function between data points. The default value is Minkowski distance with power parameter p=2, which is equivalent to the standard Euclidean metric.

The important parameters of KNN classifier and regressor

The k-Nearest Neighbor (k-NN) Classifier
Algorithm

The k-Nearest Neighbor (k-NN) Classifier Algorithm

Implemention of KNN in Python

Exponentially weighted average is a technique frequently used for time-series data. By taking the average sum of previous data, you could smooth your data series and get an approximate trend of it. 

Consider you have a series of data points $\theta_0,...,\theta_n$,
$$\left\{ \begin{array}{ll}v_t = \theta_t & t=0 \\
v_t = \beta v_{t-1} +(1-\beta)\theta_t & otherwise \end{array}\right.$$
If we expand the second formula,
$v_t  = \beta v_{t-1}+(1-\beta)\theta_t$ 
      $= (1-\beta)\theta_t+\beta(\beta v_{t-2}+(1-\beta)\theta_{t-1})$
      $= (1-\beta)\theta_t + (1-\beta)\beta\theta_{t-1}+ (1-\beta)\beta^2\theta_{t-2}+...$
To get a sense of how the weighted term changes as $\beta$ gets closer to 1,
$$(1 - \epsilon)^{1 / \epsilon}\approx \frac{1}{\epsilon} \Rightarrow \beta^{1/(1-\beta)}\approx \frac{1}{\epsilon}$$
If we denote $w_i$ be the weight we assign to $\theta_i$, then
                                         $w_{t-1/(1-\beta)}=\frac{1}{\epsilon}w_t$
Therefore, we are approximately average over $1/(1-\beta)$ days when calculating $v_t$.

Learn Before

Related