## Understanding K-NN Algorithm: A Powerful Supervised Machine Learning Algorithm

Have you ever wanted to develop a system that can classify objects based on their features? If you have, then you must understand K-Nearest Neighbor (KNN) algorithm, a popular supervised machine learning algorithm you can use to classify data points.

In this article, we’ll delve deeper into the KNN algorithm, understand its steps, and give a real-life example to illustrate it. What is KNN Algorithm?

KNN is a simple and intuitive algorithm used in classification and regression tasks. In classification, the algorithm assigns a class label to the new data point based on the classification labels of the K-nearest neighbors.

In regression, KNN predicts the value of a target variable based on the average of the K-nearest neighbors.

## Steps Followed by KNN Algorithm

For KNN algorithm to work, you need a training dataset to train the model and prediction data to make predictions. Here are the steps to follow when implementing KNN algorithm:

### Step 1: Collect and Preprocess the Data

At this stage, you need to collect data and preprocess it.

Preprocessing involves cleaning the data, handling missing values, encoding categorical data, and scaling the data.

### Step 2: Calculate Distance

The distance between two data points is calculated using either Euclidean distance or Manhattan distance.

Euclidean distance is commonly used for continuous features, while Manhattan distance is used for categorical features.

### Step 3: Determine the Neighbors

The KNN algorithm selects the K-nearest points from the dataset.

The value of K is an odd number and randomly selected.

### Step 4: Predict the Class Label

In the final step, the algorithm assigns the new data point the class label that is the most frequent among the K-nearest neighbors.

## Real-Life Example of K-NN

Let’s say you have a collection of beads that are either green or blue. You would like to predict the color of a new bead based on its features.

To accomplish this, you can use KNN algorithm.

### Problem Statement:

Predict the color of an unseen bead.

### Solution:

Here are the steps you’ll follow to predict the color of a new bead:

### Step 1: Collect Data

The data consists of the length and width of beads. You record the length and width of beads to use it in training and testing the KNN model.

### Step 2: Calculate Distance

At this stage, you calculate the distance between each new bead and the existing beads.

### Step 3: Determine the Neighbors

In this step, you select the K-nearest neighbors based on the shortest distance.

### Step 4: Predict the Color

Once you determine the neighbors, you will predict the color of the new bead based on the majority of the color among the K-nearest neighbors. For example, if three of the K-nearest neighbors are blue and two neighbors are green, you can predict the new bead would be blue.

## Conclusion

In conclusion, KNN algorithm is a powerful yet simple machine learning algorithm used in classifying data points. By following the steps outlined above, you can implement KNN to classify new data points with high accuracy.

The real-life example of KNN clearly highlights how the algorithm works in practice. Hopefully, this article has provided you with a deeper insight into KNN algorithm and how it can be used in solving classification problems.

## Implementation of KNN in Python: A Comprehensive Guide to Machine Learning

Machine learning, particularly supervised learning, has great practical significance in solving classification and regression problems. K-Nearest Neighbor (KNN) is an essential supervised machine learning algorithm that is commonly used in classification problems.

In this article, we will show you how to implement KNN in Python for a regression problem, covering how to preprocess data, selecting features, splitting data, defining error metrics, building models, and evaluating the accuracy.

### Load the Dataset

The first step is to load the dataset into Python. We’ll use the pandas module and the pandas.read_csv() function to load the dataset.

It’s recommended to save the dataset in a CSV file format.

```
import pandas as pd
data = pd.read_csv('filename.csv')
```

### Select the Right Features

After loading the dataset, the next step is to select the most relevant features to use. To select the right features, we can use the correlation regression analysis technique.

The correlation matrix helps to identify the strength of the relationship between two variables. Consequently, we’ll select the features with the highest correlation with our target variable.

```
corr_matrix = data.corr()
target_correlation = corr_matrix['target']
features = target_correlation[target_correlation > 0.5].index.tolist()
```

### Split the Dataset

Before splitting the dataset, we need to define our dependent and independent variables. In a regression problem, we need to train a model to predict a continuous target value.

We’ll define our target variable as the dependent variable, while the independent variables are the features we selected earlier. We’ll then split the dataset using the train_test_split() function from the sklearn.model_selection module.

```
from sklearn.model_selection import train_test_split
X = data[features]
y = data['target']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
```

### Define Error Metrics

To evaluate the accuracy of our model, we need to define an error metric. We’ll use the mean absolute percentage error (MAPE), which calculates the error rate of our predictions in percentage.

For the MAPE calculation, we’ll use the following formula:

```
MAPE = ((y_test - y_pred) / y_test).abs().mean() * 100
```

### Build the Model

Now that we’ve preprocessed the data, selected the relevant features, and defined the error metrics, we’ll build the KNN regression model. For this, we’ll use the sklearn.neighbors module and the KNeighborsRegressor() method.

```
from sklearn.neighbors import KNeighborsRegressor
k_value = 3
regressor = KNeighborsRegressor(n_neighbors=k_value)
regressor.fit(X_train, y_train)
```

### Accuracy Check!

The accuracy check involves checking the misclassification error of our predictions and the overall accuracy level. Let’s make some predictions on the testing data and calculate the MAPE error metrics to check the accuracy of our model.

```
y_pred = regressor.predict(X_test)
MAPE = ((y_test - y_pred) / y_test).abs().mean() * 100
print('Misclassification error:', MAPE, '%')
print('Accuracy level: ', 100 - MAPE, '%')
```

### Accuracy Evaluation of KNN

The MAPE calculation helps us estimate the error rate of our model’s predictions, which gives us an idea of how well our model has performed. A lower MAPE value indicates higher accuracy of the model, while a higher value indicates lower accuracy.

Besides, we can check the overall accuracy level of our model by subtracting the MAPE value from 100, which gives us the percentage of accurate predictions.

In this article, we have shown how to implement KNN in Python for a regression problem.

We’ve covered the steps involved in loading the dataset, preprocessing data, selecting features, splitting data, defining error metrics, building models, and evaluating the accuracy. By following these steps, you can now implement the KNN algorithm in Python and solve your classification and regression problems with ease.

In conclusion, the KNN algorithm is a powerful machine learning algorithm that can be used for both classification and regression problems. Understanding KNN algorithm involves collecting and preprocessing data, calculating distance, determining neighbors, and predicting the class label.

Real-life examples of KNN show how it can be used in various scenarios. Python implementation of KNN requires loading the dataset, selecting the right features, splitting the dataset, defining error metrics, building the model, and evaluating accuracy.

The most commonly used accuracy metric is the MAPE error, which calculates the error rate of the model’s predictions. By understanding and implementing KNN, users can analyze and classify large data sets with ease.