Learning Model Building in Scikit-learn : A Python Machine Learning Library

-


Scikit-learn is a free and open-source library for Python that provides tools for various aspects of machine learning. It offers a wide range of functions and algorithms that help with tasks like analyzing and processing data, creating and training machine learning models, evaluating model performance, and visualizing results.

Important features of scikit-learn: 

1. it can be freely used, modified, and distributed, even for commercial purposes.
2.  This makes scikit-learn a flexible and cost-effective choice for data analysis and machine learning  
     tasks.
3.Scikit-learn is built on top of well-established and widely used Python libraries such as NumPy, 
   SciPy, and matplotlib.

 Now we will see how we can easily build a machine learning model using scikit-learn. 

Prior to proceeding with scikit-learn installation, verify that you have NumPy and SciPy set up. This ensures that all the required dependencies are in place for a smooth installation and seamless usage of scikit-learn's machine learning capabilities.

    pip install -U scikit-learn

Loading exemplar dataset: scikit-learn comes loaded with a few example datasets like the iris datasets for classification

Load a dataset

To work with a dataset in scikit-learn, the first step is to load the data into your Python environment. This can be done using various methods, such as reading data from a file, accessing an online dataset, or generating synthetic data. Once the dataset is loaded, you will have the feature matrix 'X' and the response vector 'y' available for further analysis and modeling.

Step - by - Step Explaination:

1. Import the necessary libraries and modules.

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score

We import the required libraries for loading the dataset, splitting the data into training(80%) and testing sets(20%), creating the MLP classifier model, and calculating the accuracy of the model.

2. Load the iris dataset.

iris = load_iris()
X = iris.data
y = iris.target

We load the iris dataset, which is a popular dataset for classification tasks. 'X' represents the feature matrix (input data) and 'y' represents the target vector (output labels).

3. Split the dataset into training and testing sets.

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=1)

Using the 'train_test_split' function, we split the dataset into training and testing sets. Here, 80% of the data is allocated for testing, and the 'random_state' parameter ensures reproducibility of the split.

4. Create the MLP classifier model.

model = MLPClassifier(hidden_layer_sizes=(64, 32), max_iter=1000, random_state=1)

We create an instance of the MLPClassifier, which represents a multi-layer perceptron neural network. The 'hidden_layer_sizes' parameter specifies the number of neurons in each hidden layer. In this case, we have two hidden layers with 64 and 32 neurons respectively. The 'max_iter' parameter determines the maximum number of training iterations.

5. Train the model.

model.fit(X_train, y_train)

We train the MLP classifier model using the training data. The model learns to map the input features 'X_train' to the corresponding target labels 'y_train'.

6. Make predictions on the testing set.

y_pred = model.predict(X_test)

Using the trained model, we make predictions on the testing set ('X_test'). The model predicts the target labels for the input features.

7. Calculate the accuracy of the model.

accuracy = accuracy_score(y_test, y_pred)
print("Model accuracy:", accuracy)

We calculate the accuracy of the model by comparing the predicted labels ('y_pred') with the true labels (y_test). The 'accuracy_score' function computes the accuracy by calculating the ratio of correct predictions to the total number of samples in the testing set.

Above is the default architecture of the MLPClassifier in scikit-learn, which consists of a single hidden layer with 100 neurons.

Additional: 

If you would like to include additional layers or customize the architecture of the neural network, you can modify the 'hidden_layer_sizes' parameter when creating the MLPClassifier. For example, if you want to include two hidden layers with 64 and 32 neurons respectively, you can modify the code as follows-

model = MLPClassifier(hidden_layer_sizes=(64, 32), max_iter=1000, random_state=1)


This will create an MLP classifier model with two hidden layers, the first layer consisting of 64 neurons and the second layer consisting of 32 neurons.

Reference: 

Comments

Post a Comment

Popular posts from this blog

Variational Autoencoders in Machine Learning

-
Image
Understanding Variational Autoencoders Hey there! Have you ever heard of a special kind of computer wizard called a Variational Autoencoder (VAE)? Don't worry if it sounds like something out of a fantasy tale; I'll explain it to you in the simplest way possible, with easy-to-understand examples and some computer code sprinkled in where needed! Imagine you have a box of crayons, and your friend has to guess which colors you picked. Now, instead of telling your friend the exact colors, you give them hints. Maybe you say, "Most of them are shades of blue and green." Your friend then tries to guess the colors based on these hints. This is kind of like what a variational encoder does in ML. Introduction: The Enigma of VAEs In the vast landscape of machine learning, the Variational Autoencoder (VAE) shines as a beacon of innovation. But what exactly is a VAE? Imagine a magical entity capable of learning from images and then creating entirely new ones. This is the essence of...
Read more

Flower detection & classification using CNN

-
Image
This machine learning project aims to create a flower recognition system that can identify the name of a flower from an input image. To achieve this, we will employ Convolutional Neural Networks (CNN), a powerful algorithm known for its exceptional performance in image-related tasks. By harnessing the capabilities of CNNs, we can efficiently process and extract meaningful features from images, thereby enabling precise flower recognition. So, let's build this model. Flower Recognition System The Flower Recognition System we will develop leverages the strengths of CNNs to automatically determine the name of a flower based on an input image. Such systems find extensive applications in various domains, including popular platforms like Google Lens, which enables users to identify flowers by simply pointing their smartphone cameras at them. By building our own flower recognition system, we not only gain insights into the inner workings of CNNs but also explore their practical application...
Read more

A Beginners Guide to Neural Networks

-
Image
  “The neural network is this kind of technology that is not an algorithm, it is a network that has weights on it, and you can adjust the weights so that it learns. You teach it through trials.” — Howard Rheingold Ai is coming, AI is coming. That is all we hear these days and how it is going to severely impact everyone’s’ lives. Jobs will be lost, humans will be replaced by machines in every industry and many other dooming predictions that are written in magazines and blogs. How many people are even cognizant about what aspects of artificial intelligence there are out in the world?   This post is going to cover one of those such aspects, a beginner’s guide to neural networks. We will look at what neural networks are, how they operate, what are the different types and how they can and will impact our lives. Let’s begin by looking at what these networks are.                               ...
Read more