A foray into SVM w/ Scikit-Learn

Amdirpherian — Sat, 16 Jul 2022 05:40:14 +0000

Hey, Josiah here. Today I’ll be discussing the concept of SVMs (Support Vector Machine), a subset of Machine Learning used commonly for classification and regression analysis. First off, we must discuss how SVM works from a theoretical standpoint.

A simple example of an SVM classifying data
Suppose some given data points each belong to one of two classes (”Black” & “White”), and the goal is to decide which class a new data point will be in.

The three lines seen (H1, H2, and H3) are known as “Hyperplanes”, which divide our data into classes. To define a hyperplane, one must follow a simple procedure:

Draw a line between the two classes such that the closest data point from each class (known as the support vector) are equidistant from the line. Thus, we have defined a Hyperplane.

However, it soon becomes apparent that an infinite number of hyperplanes can be derived. The obvious question arises: “How do we determine which hyperplane to use?” The answer is, we use the hyperplane which maximizes the distance to the support vectors. This maximized gap between the two classes is known as the maximum-margin hyperplane, and is the ideal hyperplane to predict the class of future data points.

Now that we have discussed the basic theoretical concepts of SVM classification, let us get into a simple example involving the breast-cancer dataset from Scikit-learn. (Relatively trivial code snippets will be captioned)

import sklearn from sklearn import metrics from sklearn import svm cn = sklearn.datasets.load_breast_cancer() # load data set x = cn.data # set x to the entries y = cn.target # set y to the labels
Here, we set two variables x and y equal to our data’s entries and labels, respectively. We will need this in the next snippet to separate the data further.

x_train, x_test, y_train, y_test = sklearn.model_selection.train_test_split(x, y, test_size=0.2)
We use Scikit-learn’s model_selection.train_test_split method to take our entries and labels and split them into training and testing subcomponents. By setting test_size to 0.2, we allocate 20% of our data for testing purposes, and the other 80% for training purposes. Note that it’s not recommended to set test_size to be greater than 0.3.

# Create an SVC clf = svm.SVC()
# train the training set clf.fit(x_train, y_train)
Here, we create the Support Vector Machine along with the SVC (Support Vector Classifier) and assign it to the variable clf. Next, we train the model on the training entries and labels (20% of the dataset as defined by test_size previously).

# Predict the labels for the training data y_predict = clf.predict(x_test)
# compare the predicted labels to the actual labels and conver to percentage to output acc = metrics.accuracy_score(y_test, y_predict)*100 print(f"{acc}% accuracy")
We set a variable y_predict equal to the results of the classifier predicting the labels of the testing entries. We then use the sklearn.metrics.accuracy_score() method to compare the actual testing labels to that of y_predict, which was the machine’s attempt at classifying them. We then convert this to a percentage by multiplying by a factor of 100, and printing this result. The accuracy you should get is ~96%, which is a very good accuracy!

If you enjoy articles like this and find it useful or have any feedback, message me on Discord @Necloremius#6412

An Introduction to Asynchronous Programming in Python and the Asyncio module (Part 1)

Amdirpherian — Thu, 10 Jun 2021 01:57:00 +0000

First, before we begin talking about Asyncio, we must differentiate between Asynchronous Programming and Synchronous Programming. Synchronous Programming is essentially “normal” programming, in which code is ran sequentially from the first line to last. Asynchronous Programming, on the other hand, is essentially code that can run different operations while waiting on a function to meet a certain necessary requirement. Now that we know the difference between Synchronous and Asynchronous programming, lets look at how to set up a basic asynchronous program.

import asyncio

Coroutine: A function that is defined asynchronously (allowing it to run asynchronously)
Without coroutine:

def x():
    print('Hello World')

With coroutine:

import asyncio

async def x():
    print('Hello World')

When you call a coroutine, it won’t execute the function as expected. Instead, it returns a warning.

RuntimeWarning: coroutine 'main' was never awaited

The reason this error happens is because in Asyncio, to run a program, one must first create an event loop. The event loop is essentially the behind-the-scenes loop that runs all the asynchronous tasks in the program. To add a function to the event loop, we must use a certain syntax. Let us take a look.

import asyncio

async def x():
    print('Hello World')
asyncio.run(x())

First, we see the standard definition of a coroutine. Then, we see “asyncio.run(a())”. This line of code adds the function a() to the event loop, which runs it. Then, ‘Hello World’ is printed through a().
However, it is completely redundant to add each coroutine to the event loop individually, as this is very tedious and eliminates the whole point of using Asynchronous Programming. To unlock the full potential of Asynchronous Programming, one must use the ‘await’ keyword.
Let me explain this mysterious keyword with an example.

import asyncio

async def a():
    print('a')
    await b()
    print('c')

async def b():
    print('b')

asyncio.run(a())

Ok, lets break down what is happening here (in terms of run sequence, not line by line). on the first line, we simply import the Asyncio module. Next, we run the asynchronous program by adding the coroutine main() to the event loop and running it. Running a() prints ‘a’, and then we see the following line of code: ‘await b()’. What await does is it tells Python ‘Stop running this coroutine and run the specified coroutine instead, then after the specified coroutine is finished running, return to running this coroutine until completion.’ ‘await b()’ runs b(), which prints out ‘b’. Now, since b() has completed its execution, the program returns to running a(), which in turn prints out ‘c’ and completing the program. You see, this is what is so insanely powerful about Asynchronous Programming. The ability to run different functions at different times based on the state of other functions has an abundant amount of applications.
This concludes the article. Some other basic aspects of Asyncio (such as tasks and futures, to list two examples) will be explained in Part Two. If you would like to contact me about anything, please email me josmo314@gmai.com. I hope you enjoyed!

~Josiah Mo, with love

DEV Community: Amdirpherian

A foray into SVM w/ Scikit-Learn

An Introduction to Asynchronous Programming in Python and the Asyncio module (Part 1)