How to use KNN algorithm for classification in Python?

K nearest neighbor algorithm (KNN) is a simple and effective algorithm that can be used for classification and regression. Its basic idea is to identify the category to which a sample belongs by measuring the distance between different features. In this article, we will explore how to classify KNN in Python.

1. Prepare the data set

First, we need to prepare the data set. In this example, we will use the Iris dataset, which contains 3 different iris flowers (Setosa, Versicolour and Virginica), each with 4 features (Sepal Length, Sepal Width, Petal Length, Petal Width).

We will use the Pandas library to read and preprocess the data. First, we need to import the required libraries:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

Then, we will load the dataset:

url = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"
names = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'class']
dataset = pd.read_csv(url, names=names)

Now that we have a dataset, we can start exploring it.

2. Data Visualization

Before classifying, we need to visualize and explore the data. We will plot a scatterplot of each feature against another feature, as well as a histogram of each feature. We can use Matplotlib library and Seaborn library for visualization.

Scatter plot between features:

import seaborn as sns
sns.pairplot(dataset, hue="class")

386b528fdcaa97c71a1406e01fb1e3a3

As can be seen from this picture, the characteristics of different iris flowers are very different, which is the basis for classification.

Histogram of each feature:

dataset.hist()
plt.show()

71cdfbdb6f2fd1462c933c87bd29df3e

As can be seen from this figure, each feature in the data set has a different distribution, which is the basis for normalization.

3. Data preprocessing

Before classification, we need to preprocess the data. We can split the dataset into input features and output categories, and then scale the feature values ​​to the range of 0 to 1.

First, we split the dataset into input features and output categories:

X = dataset.iloc[:, :-1].values
y = dataset.iloc[:, 4].values

Then, we scale the feature values ​​to the range of 0 to 1:

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X = scaler.fit_transform(X)

Now, we have our preprocessed dataset.

4. Split the data set

Before classification, we need to split the data set into a training set and a test set. We can do this using the train_test_split function from the Scikit-learn library.

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

This will create a training set and a test set with a ratio of 80:20.

5. Training the KNN model

Now, we can start training the KNN model. We first import the KNeighborsClassifier class, create an instance, and use the fit function to fit the model.

from sklearn.neighbors import KNeighborsClassifier
classifier = KNeighborsClassifier(n_neighbors=5)
classifier.fit(X_train, y_train)

This will create a KNN classifier and train it to classify using the training set.

6. Prediction

Now, we can use the KNN model to predict the test set. We use the predict function to make predictions and save the results into a variable.

y_pred = classifier.predict(X_test)

7. Model Evaluation

Finally, we need to evaluate our model and determine its accuracy. We can use the confusion_matrix and classification_report functions in the Scikit-learn library to evaluate the accuracy of the model.

from sklearn.metrics import confusion_matrix, classification_report
print(confusion_matrix(y_test, y_pred))
print(classification_report(y_test, y_pred))

This will output a confusion matrix and classification report showing the accuracy of our model.

Summary

Using the KNN algorithm for classification in Python requires the following steps:

1. Preparing the data set
2. Data visualization
3. Data Preprocessing
4.Split the data set
5.Train KNN model
6.Prediction
7.Model evaluation

The KNN algorithm is a simple and effective algorithm that can Used for classification and regression. Using the KNN algorithm for classification in Python requires following the above steps. At the same time, we also need to perform data visualization and preprocessing to ensure that our model can accurately classify.

The above is the detailed content of How to use KNN algorithm for classification in Python?. For more information, please follow other related articles on the PHP Chinese website!