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.

University of Michigan - Ann Arbor

Linear regression is a linear approach to model a target prediction value based on independent variables.

Linear Regression

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

James, G., Witten, D., Hastie, T., & Tibshirani, R. (2013). An introduction to statistical learning (Vol. 112, pp. 3-7). New York: springer.

An Introduction to Statistical Learning with Applications in R

Based on the number of independent variables used, there are two types of linear regression:
- Simple Linear Regression
- Multiple Linear Regression

Types of linear regression

Logistic regression is used to model discontinuous output choices - for example, when a variable is 'yes' or 'no' rather than a continuous value. In this case, logistic regression calculates the probability of a given categorical output, and decides on a threshold at which the model decides between categories to select for output. 

Logistic Regression

The terms of a linear model can be one of the following:
	
	- The Constant
	- A parameter multiplied by an independent variable (I.V)


Then, you build the equation by only adding the terms together. These rules limit the form to just one type:
Dependent variable = constant + parameter * IV + … + parameter * IV

Nonlinear regression models don’t fit this type.

Examples of nonlinear models include: 
	

When is a model considered linear?

This is a series of videos that introduces linear regression models and breaks down the process of linear regression.

[StatQuest with Josh Starmer]. (2020, February 21). Linear Regression and Linear Models [Video File]. Retrieved from [www.youtube.com/playlist?list=PLblh5JKOoLUIzaEkCLIUxQFjPIlapw8nU](https://www.youtube.com/playlist?list=PLblh5JKOoLUIzaEkCLIUxQFjPIlapw8nU) 

Linear Regression and Linear Models Videos

Here is an example of using R to do a simple linear regression. 
```R
#MASS package is a very large collection of data sets and #functions
library(MASS) 

#ISLR package includes the data sets associated with this #book
library(ISLR) 

lm.fit=lm(medv∼lstat,data=Boston) 
# medv as a response, lstat as a predictor

summary(lm.fit) # gives us pvalues and standard errors for the coeﬃcients, as well as the R2 statistic and F-statistic for the model

confint(lm.fit) # obtain a confidence interval

predict (lm.fit ,data.frame(lstat=c(5,10,15)), interval="confidence") #prediction in confidence intervals

predict (lm.fit ,data.frame(lstat=c(5,10,15)), interval="prediction") #prediction in prediction intervals

attach(Boston) # attach data to Boston

plot(lstat ,medv) 
abline(lm.fit ,lwd=3,col="red") 
# draw out the regression line
```
Expected output (plot and abline only):
![The expected output from the plot and abline commands](https://firebasestorage.googleapis.com/v0/b/onecademy-1.appspot.com/o/UploadedImages%2FWenfei-Tang_Wed%2C%2026%20Feb%202020%2020%3A51%3A58%20GMT.png?alt=media&token=5cf41866-c6fe-4732-88c5-2233fe889aa3) 

Example of Linear Regression Using R

We estimate the parameters $\beta_0, \beta_1, \beta_2, \dots, \beta_p$ such that we minimize the error in the following approximation:
$$Y = \beta_0 + \beta_1 X_1 + \beta_2 X_2 + \dots + \beta_p X_p + \epsilon$$

Training or Fitting a linear regression model

The extent to which the linear regression model fits the data, the quality of linear regression fit, can be achieved by:
1. $ R^2 $
2. Residual Standard Error
3. Goodnesss of Fit
4. F Statistics
5. Mean Square Error (MSE)

Assessing the accuracy of linear regression

Comparison of Linear Regression with K-Nearest Neighbors

- Linearity of the response-predictor relations
- Normal distribution of residuals
-  Error terms, e1,e2,...e3, are uncorrelated
-  Error terms have a constant variance
-  Little or no Multicollinearity between the features
-  Homoscedasticity Assumption
-  Large sample size and few or no outliers

Assumptions of Linear Regression

The regression coefficient is $$\beta_1$$, in the regression equation $$y \approx \beta_0 + \beta_1 X$$, is an esitmate of the rate of change (slope) between X and Y.

Regression Coefficient

It is easier to implement, interpret, and infer from the estimation of linear regression. However, one can rarely find a perfect linear relationship in the real world. Estimation using nonlinear regression is more difficult to implement, interpret, and infer from, but it gives us more predictive power by relaxing the assumption of linearity of the model.

Linear regression vs. nonlinear regression

- L1 Regularization
- L2 Regularization
- Dropout Regularization
- Data Augmentation
- Early Stopping
- Tangent Distance
- Tangent Prop
- Manifold Tangent Classifier

Popular Regularization Techniques in Deep Learning

We can use  polynomial future transformation to transform a problem into a higher dimensional regression space. Adding these extra polynomial features allows us a much richer set of complex functions that we can use to fit to the data. This is like allowing polynomials to be fit to the training data instead of simply a straight line, but using the same least-squares criterion that minimizes mean squared error. This approach of adding new features like polynomial features is also very effective with classification.

Polynomial Future Transformation

To make up for the under-fitting or over-fitting problems of ordinary linear regression models, locally weighted linear regression introduce weights to loss function. 
Its loss is transmitted to:
$J(\theta)=\sum_{i=1}^m w^i (y^{(i)} - \theta^T x^{(i)})^2$
w is used to represent the weights. Its value is calculated using Gaussian kernel function:
$w^i = exp(\frac{(x-x^i)^2}{-2k^2})$

Locally Weighted Linear Regression

In the context of linear regression, specific mathematical notation is used to systematically describe the dataset. Typically, $$n$$ denotes the total number of examples. Superscripts are utilized to enumerate individual samples and their corresponding targets, while subscripts are used to index their specific coordinates or features. For instance, $$\mathbf{x}^{(i)}$$ represents the complete $$i^{\textrm{th}}$$ sample, and $$x_j^{(i)}$$ designates the $$j^{\textrm{th}}$$ coordinate of that $$i^{\textrm{th}}$$ sample.

Linear Regression Dataset Notation

The foundational concepts of linear regression date back to the early 19th century, with significant contributions from mathematicians Carl Friedrich Gauss in 1809 and Adrien-Marie Legendre in 1805. Despite its historical age, linear regression remains one of the simplest and most popular standard tools for tackling modern regression problems.

History of Linear Regression

In the simplest case of one-dimensional inputs, a linear regression model attempts to fit a straight line through the observed data points. The fitness of this line depends purely on the choice of model parameters (the weight and the bias), which are adjusted to minimize the distance between the line's predictions and the true target values.

Linear Regression One-Dimensional Fit

The squared error is the standard loss function for regression problems, used to quantify the discrepancy between a single predicted value $$\hat{y}^{(i)}$$ and its true corresponding label $$y^{(i)}$$. The loss for a single example is defined mathematically as $$l^{(i)}(\mathbf{w}, b) = \frac{1}{2} \left(\hat{y}^{(i)} - y^{(i)}ight)^2$$. The quadratic form heavily penalizes large differences, and the constant fraction $$\frac{1}{2}$$ is conventionally added because it cleanly cancels out when taking the derivative during optimization.

Squared Error Loss

A fundamental assumption of linear regression is that the relationship between the features $$\mathbf{x}$$ and the target $$y$$ is approximately linear. This means the expected value of the target, defined as the conditional mean $$E[Y \mid X=\mathbf{x}]$$, can be mathematically expressed as a weighted sum of the input features $$\mathbf{x}$$. This framework allows the actual target values to deviate from their expected conditional mean due to observation noise.

Linear Regression Conditional Mean Assumption

In a multiple-feature linear regression model, weights are parameters that determine the influence of each individual feature on the target prediction. When the model is expressed as a weighted sum, such as $$\hat{y} = w_1 x_1 + \dots + w_d x_d + b$$, each weight quantifies the specific contribution of its corresponding feature. In compact linear algebra notation, these parameters are collected into a weight vector $$\mathbf{w} \in \mathbb{R}^d$$.

Linear Regression Weight Parameters

In a linear regression model, the bias (also referred to as an offset or intercept) is a parameter that determines the baseline value of the model's estimate when all input features are exactly zero. The addition of the bias term $$b$$ is mathematically necessary because it permits the model to express general linear functions as an affine transformation, rather than restricting predictions to lines that must pass directly through the origin.

Linear Regression Bias Parameter

Linear regression can be conceptualized as a single-layer, fully connected neural network. In this representation, each given input feature $$x_1, \ldots, x_d$$ corresponds to an input neuron. Since the goal is to predict a single numerical value, all input neurons are directly connected to a single computed output neuron $$o_1$$. The total number of inputs $$d$$ is referred to as the feature dimensionality in the input layer.

Linear Regression as a Neural Network

To evaluate machine learning models, we often generate synthetic datasets where the underlying ground truth relationship is known. For a linear regression task, we can draw a design matrix $$\mathbf{X}$$ of features from a standard normal distribution. The corresponding labels $$\mathbf{y}$$ are computed by applying a ground truth linear function defined by true weights $$\mathbf{w}$$ and bias $$b$$, and then corrupting the output with additive noise $$\boldsymbol{\epsilon}$$ drawn from a normal distribution with mean $$\mu=0$$ and standard deviation $$\sigma = 0.01$$: $$\mathbf{y}= \mathbf{X} \mathbf{w} + b + \boldsymbol{\epsilon}$$. This procedure ensures that the generated labels simulate realistically observed data containing inherent random variation.

Synthetic Data Generation for Linear Regression

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

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)

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