# Python Classification

Identification and grouping of items or concepts into specified categories this process is known the classification. Data can be separated and sorted in data management according to predetermined criteria for various professional or individualized goals.

In machine learning (ML) predictive modeling, classification is used to assign input data with a class label. Natural language processing (NLP), for instance, may be used by an email security program to classify emails as "spam" or "not spam" based on their content.

## Classification in python

Classification is a vast domain that plays a significant role in statistics and machine learning.

Classification is sub-divided into two types that are:

- Binary classification
- Multiclass classification

In python, we have many libraries which help in data classification. The famous and most used libraries in machine learning and statistics are **scikit-learn **and** pandas.**

**Binary classification**: In Binary classification, we group the outcome into one of two true or false groups.

**Multiclass classification: **In Multiclass classification, we group the outcome into many groups and place the result into these groups.

In python, we use scikit-learn and pandas majorly for classifying the data. And **scikit-learn **is used for loading and using the machine learning models. Whereas we use **pandas **for loading the dataset into your program, you can import data using pandas and use them as data frames.

Suppose you are not having these libraries installed on your local machine. You can install them using pip. Pip is a python package installer that helps in the process of installation of packages.

You can install scikit-learn and pandas using the commands specified below:

```
pip install sklearn
pip install pandas
```

Typing these commands on your command prompt, and by doing this, both the libraries will be installed on your computer.

### Binary classification

We are interested in categorizing data into one of two binary groups for binary classification; these are typically represented in our data as 0s and 1s.

In this classification, we only output true or false, which is used in machine learning models to predict where a person has heart disease and many others like that.

And using the below code, you import your data into the machine learning model:

**Syntax**

```
import pandas as pd
data = pd.read_csv(“filename”)
```

Using the method read_csv, you can read the data stored in CSV file format.

You can also visualize the data using the head () method in pandas, which returns the top 5 rows of your data.

**Syntax**

```
import pandas as pd
data = pd.read_csv(“filename”)
pd.head()
```

### Logistic Regression

We are interested in categorizing data into one of two binary groups for binary classification; these are typically represented as 0s. Predictive analytics and categorization frequently use this kind of statistical model, also referred to as a logit model. Based on a given dataset of independent variables, logistic regression calculates the likelihood that an event will occur, such as voting or not voting. Given that the result is a probability, the dependent variable's range is 0 to 1. In logistic regression, the odds—the likelihood of success divided by the possibility of failure—are transformed using the logit formula. The natural logarithm of the odds 1's in our data, or the log chances, is another name for this.

The model logistic regression is present in the sklearn package, where we have to import the model from sklearn to use it. You must fit the model with x and y values, which are two parameters. You can predict the probabilities of new data using the predict () method; you also have a score () approach to find the mean of the expected value accuracy.

**The syntax for using Logistic Regression:**

```
import sklearn as sk
from sklearn.linear_model import LogisticRegression
import pandas as pd
data = pd.read_csv(“filename”)
pd.head()
y = data.iloc[:,8]
X = data.iloc[:,:8]
lr = LogisticRegression().fit(X, y)
lr.predict(X.iloc[320:,:])
round(lr.score(X,y), 2)
```

Using the above-given syntax, you can load the Logistic regression from the sklearn package and use it for predicting the different values by training it with the presented weights using the fit () method; you can fit the Logistic regression model and using predict () form you can generate the outcome for new values, and you can find the score of the predicted values that is the accuracy using score () method.

### Support vector machines

Support vector machine (SVM) is one of the classification algorithms. Support vector machine is more flexible than many other classification algorithms. It is a kind of linear classification that uses other non-linear basis methods.

The following is the syntax to import the support vector machine (SVM), fit the SVM, and predict the values after classifying the data.

Support vector machine (SVM) is a part of the sklearn package where we have to import the SVM from sklearn to use this classification algorithm.

**The syntax for using a Support vector machine (SVM)**

```
import pandas as pd
import sklearn as SK
from sklearn import svm # Importing support vector machine
data = pd.read_csv(“filename”)
pd.head()
y = data.iloc[:,8]
X = data.iloc[:,:8]
model = svm.LinearSVC ()
model.fit (X, y)
model.predict (X.iloc[320:,:])
round (SVM.score(X, y), 2)
```

Using the above-given syntax, you can load the support vector machine (SVM) from the sklearn package and use it for predicting the other values; by training it with the presented weights using the fit () method, you can fit the support vector machine model and using predict () form you can generate the outcome for new values. You can find the score of the predicted values, that is, the accuracy using the score () method.

### The random forests classification algorithm

The Random Forest classifier uses a randomly chosen portion of the training data to generate a collection of decision trees. It simply consists of a group of decision trees from a randomly selected subset of the training set, which is subsequently used to decide the final prediction.

You can also say random forest as an ensemble learning model. Random forest fits the multiple Decision Tress on a subset of the data and returns the average results of that tress.

You should import this Random forest model from sklearn. The ensemble as a random forest is an ensemble learning model.

**The syntax for using a random forest classification algorithm**

```
import pandas as pd
import sklearn as sk
from sklearn.ensemble import RandomForestClassifier # Importing the model
data = pd.read_csv(“filename”)
pd.head()
y = data.iloc[:,8]
X = data.iloc[:,:8]
model = RandomForestClassifier ()
model.fit (X, y)
model.predict (X.iloc[320:,:])
round (model.score(X, y), 2)
```

Using the above syntax, you can load the Random Forest Classifier from the sklearn package where you have to sklearn. ensemble as Random Forest is an ensemble model used for predicting the different values by training it with the presented values; using the fit () method, you can fit the Random Forest Classifier model, and using predict () method, you can generate the outcome for new values, and you can find the score of the predicted values that is the accuracy using score () method.

### Neural Networks

Classifying existing classes according to their characteristics is known as classification. Most classification problems can be solved using machine learning algorithms, but a neural network is necessary to organize a vast dataset of information.

The Neural Networks algorithm involves fitting many hidden layers. This model is built similarly to that of the brain model that is used for predicting values.

We import the neural network model MLP classifier from the sklearn package where sklearn.neural_network is a sub-package in which this MLP classifier is available.

```
import pandas as pd
import sklearn as sk
from sklearn.neural_network import MLPclassifier # Importing the model
data = pd.read_csv(“filename”)
pd.head()
y = data.iloc[:,8]
X = data.iloc[:,:8]
model = MLPclassifier ()
model.fit (X, y)
model.predict (X.iloc[320:,:])
round (model.score(X, y), 2)
```

Using the above-given syntax, you can load the neural network model MLP classifier from the sklearn package where sklearn.neural_network is a sub-package in which this MLP classifier is available; after loading the model, you can use it for predicting the different values by training it with the presented values using the fit () method, you can fit the neural network model MLPclassifier and using predict () method you can generate the outcome for new values. You can find the score of the predicted values, that is, the accuracy using the score () method.

### Multiclass Classification

Multiclass classification is a classification problem including more than two classes, such as classifying a collection of fruit photos that could represent oranges, apples, or pears; multiclass classification works under the premise that each sample is given one and only one label. For example, fruit can only be an apple or a pear at any given time.

This is how we can classify data in python using the abovementioned algorithms.