How to Make Better Models in Python using SVM Classifier and RBF Kernel

Data scientists and programmers must comprehend how to create the finest models feasible as machine learning techniques continue to increase in popularity and adoption. The support vector machine (SVM) classifier, a kind of linear classifier that performs effectively for a wide variety of data sources, is one potent technique that may be used to enhance the accuracy as well as efficiency of machine learning techniques. This post will concentrate on using Python's radial basis function (RBF) kernel and SVM classifier to create more accurate designs for real datasets.

A well-liked machine learning approach for classification and regression analysis is called Support Vector Machines (SVM). SVM is a supervised training technique that divides input information into different categories by locating the optimal hyperplane in a strong higher dimensional space. The vertices nearest to the optimum hyperplane are known as support vectors, because it is this hyperplane that has the largest distance between the two classes. We will talk about utilising the SVM Classifier but also RBF kernel to improve models in Python throughout this post.

A widely used model for SVM is the radial basis function (RBF) kernel since it can detect non-linear correlations in between characteristics and the target value. The following subjects will be covered in this post:

Understand the RBF kernel and SVM Classifier
Data loading and preparation
incorporating an RBF kernel into an SVM classifier
assessing the SVM performance of the models
tweaking the hyperparameters to improve the SVM model
Seeing the outcomes
Learning the RBF Kernel and SVM Classifier

A multi-class categorization issue can be handled with SVM, a binary classification technique. The hyperplane that optimises the separation between the two classes is discovered by the SVM method. The hyperplane is selected to optimise the difference between the two classes. The margin is the name given to this region. Support vectors are really the locations that are nearest towards the hyperplane and are used to locate the hyperplane.

The data collected are mapped into a greater higher dimensional space via the non-linear RBF kernel. Finding the ideal hyperplane is made simpler by the data's linear separability in this greater higher dimensional space. The definition of the RBF kernel is as follows:

Code

Where ||x-y|| is the Euclidean distance that separates the two points, x and y are indeed the primary input, and governs the form of the radial basis functions.

Loading and Preprocessing the Data

To get the data ready for the SVM model, we'll import and prepare the data it in this part. We'll utilise the Iris dataset, which has 150 samples of iris flowers with the four characteristics sepal length, sepal width, petal length, and petal width. This is a well-known training data in the domain of machine learning.

Code

import pandas as pd
from sklearn import datasets

iris = datasets.load_iris()

df = pd.DataFrame(data=np.c_[iris['data'], iris['target']],
                  columns=iris['feature_names'] + ['target'])

After that, the data will be divided into testing and training sets. This is a crucial stage since it enables us to assess the effectiveness of the algorithm on hypothetical data.

Code

from sklearn.model_selection import train_test_split

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

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20)

Incorporating an RBF kernel into an SVM Classifier

For fitting an SVM Classifier including an RBF kernel to that same training data, we will utilise the SVC class first from sklearn.svm package.

Code

from sklearn.svm import SVC

model = SVC(kernel='rbf')
model.fit(X_train, y_train)

Assessing the SVM Model's Performance

After the model has been trained, we would assess its effectiveness using measures like correctness, accuracy, recall, and F1 score upon that testing data.

Code

from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score

y_pred = model.predict(X_test)

accuracy = accuracy_score(y_test, y_pred)
# printing the accuracy of the model
Print(" The accuracy is : ", accuracy)

The predict() function, which accepts a data matrix and outputs an array of predictions, may be used to do this.

Code

newdata = ... 
data_sc = scaler.transform(newdata)
predictions = model.predict(data_sc)

Complete Code:

Code

# import the required modules
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score

# Load the iris dataset
iris = datasets.load_iris()
X = iris.data
y = iris.target

# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Train the SVM classifier with the RBF kernel
clf = SVC(kernel='rbf')
clf.fit(X_train, y_train)

# Predict the classes of the test data
y_pred = clf.predict(X_test)

# Calculate the accuracy of the model
accuracy = accuracy_score(y_test, y_pred)
print('Accuracy: ', accuracy)

The iris dataset is imported and divided into testing sets and training sets in this piece of code. The fit technique is used to train the SVM classifier, and the kernel parameter is used to provide the RBF kernel. The predict method is employed to generate projections for the test data, and the accuracy score method from scikit-metrics learn's module is used to determine the capability of the model.

Next TopicHow to Process Incoming Data in Flask

← prev next →