The Wayback Machine - https://web.archive.org/web/20240910045945/https://www.geeksforgeeks.org/implementing-dbscan-algorithm-using-sklearn/
Open In App

Implementing DBSCAN algorithm using Sklearn

Last Updated : 22 May, 2024
Comments
Improve
Suggest changes
Like Article
Like
Save
Share
Report
News Follow

Prerequisites: DBSCAN Algorithm

Density Based Spatial Clustering of Applications with Noise(DBCSAN) is a clustering algorithm which was proposed in 1996. In 2014, the algorithm was awarded the ‘Test of Time’ award at the leading Data Mining conference, KDD.

Dataset – Credit Card

Step 1: Importing the required libraries




import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
  
from sklearn.cluster import DBSCAN
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import normalize
from sklearn.decomposition import PCA 






                        










Step 2: Loading the data













                                    




                                    

                                    




                                    




                                    

                                    

                                    
                                




















X = pd.read_csv('..input_path/CC_GENERAL.csv') 


  


# Dropping the CUST_ID column from the data 


X = X.drop('CUST_ID', axis = 1) 


  


# Handling the missing values 


X.fillna(method ='ffill', inplace = True) 


  


print(X.head()) 



















                        







                        












Step 3: Preprocessing the data













                                    




                                    

                                    




                                    




                                    

                                    

                                    
                                




















# Scaling the data to bring all the attributes to a comparable level 


scaler = StandardScaler() 


X_scaled = scaler.fit_transform(X) 


  


# Normalizing the data so that  


# the data approximately follows a Gaussian distribution 


X_normalized = normalize(X_scaled) 


  


# Converting the numpy array into a pandas DataFrame 


X_normalized = pd.DataFrame(X_normalized) 



















                        







                        










Step 4: Reducing the dimensionality of the data to make it visualizable













                                    




                                    

                                    




                                    




                                    

                                    

                                    
                                




















pca = PCA(n_components = 2) 


X_principal = pca.fit_transform(X_normalized) 


X_principal = pd.DataFrame(X_principal) 


X_principal.columns = ['P1', 'P2'] 


print(X_principal.head()) 



















                        







                        












Step 5: Building the clustering model













                                    




                                    

                                    




                                    




                                    

                                    

                                    
                                




















# Numpy array of all the cluster labels assigned to each data point 


db_default = DBSCAN(eps = 0.0375, min_samples = 3).fit(X_principal) 


labels = db_default.labels_ 



















                        







                        










Step 6: Visualizing the clustering













                                    




                                    

                                    




                                    




                                    

                                    

                                    
                                




















# Building the label to colour mapping 


colours = {} 


colours[0] = 'r'


colours[1] = 'g'


colours[2] = 'b'


colours[-1] = 'k'


  


# Building the colour vector for each data point 


cvec = [colours[label] for label in labels] 


  


# For the construction of the legend of the plot 


r = plt.scatter(X_principal['P1'], X_principal['P2'], color ='r'); 


g = plt.scatter(X_principal['P1'], X_principal['P2'], color ='g'); 


b = plt.scatter(X_principal['P1'], X_principal['P2'], color ='b'); 


k = plt.scatter(X_principal['P1'], X_principal['P2'], color ='k'); 


  


# Plotting P1 on the X-Axis and P2 on the Y-Axis  


# according to the colour vector defined 


plt.figure(figsize =(9, 9)) 


plt.scatter(X_principal['P1'], X_principal['P2'], c = cvec) 


  


# Building the legend 


plt.legend((r, g, b, k), ('Label 0', 'Label 1', 'Label 2', 'Label -1')) 


  


plt.show() 



















                        







                        












Step 7: Tuning the parameters of the model













                                    




                                    

                                    




                                    




                                    

                                    

                                    
                                




















db = DBSCAN(eps = 0.0375, min_samples = 50).fit(X_principal) 


labels1 = db.labels_ 



















                        







                        










Step 8: Visualizing the changes













                                    




                                    

                                    




                                    




                                    

                                    

                                    
                                




















colours1 = {} 


colours1[0] = 'r'


colours1[1] = 'g'


colours1[2] = 'b'


colours1[3] = 'c'


colours1[4] = 'y'


colours1[5] = 'm'


colours1[-1] = 'k'


  


cvec = [colours1[label] for label in labels] 


colors = ['r', 'g', 'b', 'c', 'y', 'm', 'k' ] 


  


r = plt.scatter( 


        X_principal['P1'], X_principal['P2'], marker ='o', color = colors[0]) 


g = plt.scatter( 


        X_principal['P1'], X_principal['P2'], marker ='o', color = colors[1]) 


b = plt.scatter( 


        X_principal['P1'], X_principal['P2'], marker ='o', color = colors[2]) 


c = plt.scatter( 


        X_principal['P1'], X_principal['P2'], marker ='o', color = colors[3]) 


y = plt.scatter( 


        X_principal['P1'], X_principal['P2'], marker ='o', color = colors[4]) 


m = plt.scatter( 


        X_principal['P1'], X_principal['P2'], marker ='o', color = colors[5]) 


k = plt.scatter( 


        X_principal['P1'], X_principal['P2'], marker ='o', color = colors[6]) 


  


plt.figure(figsize =(9, 9)) 


plt.scatter(X_principal['P1'], X_principal['P2'], c = cvec) 


plt.legend((r, g, b, c, y, m, k), 


           ('Label 0', 'Label 1', 'Label 2', 'Label 3 'Label 4', 


            'Label 5', 'Label -1'), 


           scatterpoints = 1, 


           loc ='upper left', 


           ncol = 3, 


           fontsize = 8) 


plt.show() 



















                        







                        















                                    


                                                                          

                                        

                                                                              

                                                                        

                                        

                                            

                                                

                                                    
A

        

            
        

        

                                                

                                                

                                                    AlindGupta                                                

                                            

                                            

            
                                        

                                        

                                            

                                                
                                                    News
                                                
                                            

                                            
    

        
        
    
                                            

                                                
                                                
                                            

                                            

                                            Improve
                                                
                                            

                                        

                                    



                            

                            
 
                                

                                    
                                        Next Article
                                        
                                    
                                    
                                    

                                        Implementing Agglomerative Clustering using Sklearn
                                    

                                

                                                        

                            

            

                

                    

                    
                
 
                
    
                            

                                

                            


                            


            

        
  
                        

                                                

                        
                                                    

                                
Similar Reads

                                

                                    
        
            

                
Python Sklearn –  sklearn.datasets.load_breast_cancer() Function

                
In this article, we are going to see how to convert sklearn dataset to a pandas dataframe in Python. Sklearn is a python library that is used widely for data science and machine learning operations. Sklearn library provides a vast list of tools and functions to train machine learning models. The library is available via pip install. pip install sci

            

            
            

                
                2 min read
            

        
    
        
            

                
ML | Implementing L1 and L2 regularization using Sklearn

                
Prerequisites: L2 and L1 regularizationThis article aims to implement the L2 and L1 regularization for Linear regression using the Ridge and Lasso modules of the Sklearn library of Python. Dataset - House prices dataset.Step 1: Importing the required libraries C/C++ Code import pandas as pd import numpy as np import matplotlib.pyplot as plt from sk

            

            
            

                
                3 min read
            

        
    
        
            

                
Implementing Agglomerative Clustering using Sklearn

                
Prerequisites: Agglomerative Clustering Agglomerative Clustering is one of the most common hierarchical clustering techniques. Dataset - Credit Card Dataset. Assumption: The clustering technique assumes that each data point is similar enough to the other data points that the data at the starting can be assumed to be clustered in 1 cluster. Step 1:

            

            
            

                
                3 min read
            

        
    

        
            

                
ML | OPTICS Clustering Implementing using Sklearn

                
Prerequisites: OPTICS Clustering This article will demonstrate how to implement OPTICS Clustering technique using Sklearn in Python. The dataset used for the demonstration is the Mall Customer Segmentation Data which can be downloaded from Kaggle. Step 1: Importing the required libraries OPTICS (Ordering Points To Identify the Clustering Structure)

            

            
            

                
                5 min read
            

        
    
        
            

                
DBSCAN Clustering in ML | Density based clustering

                
Clustering analysis or simply Clustering is basically an Unsupervised learning method that divides the data points into a number of specific batches or groups, such that the data points in the same groups have similar properties and data points in different groups have different properties in some sense. It comprises many different methods based on

            

            
            

                
                7 min read
            

        
    
        
            

                
Difference between CURE Clustering and DBSCAN Clustering

                
Clustering is a technique used in Unsupervised learning in which data samples are grouped into clusters on the basis of similarity in the inherent properties of the data sample. Clustering can also be defined as a technique of clubbing data items that are similar in some way. The data items belonging to the same clusters are similar to each other i

            

            
            

                
                2 min read
            

        
    
        
            

                
DBSCAN Full Form

                
DBSCAN stands for Density-Based Spatial Clustering of Applications with Noise. It is a popular unsupervised learning method used for model construction and machine learning algorithms. It is a clustering method utilized for separating high-density clusters from low-density clusters. It divides the data points into many groups so that points lying i

            

            
            

                
                2 min read
            

        
    

        
            

                
DBScan Clustering in R Programming

                
Density-Based Clustering of Applications with Noise(DBScan) is an Unsupervised learning Non-linear algorithm. It does use the idea of density reachability and density connectivity. The data is partitioned into groups with similar characteristics or clusters but it does not require specifying the number of those groups in advance. A cluster is defin

            

            
            

                
                3 min read
            

        
    
        
            

                
ML | DBSCAN reachability and connectivity

                
Prerequisite : DBSCAN Clustering in ML Density-based clustering algorithm has played a vital role in finding nonlinear shapes structure based on the density. Density-Based Spatial Clustering of Applications with Noise (DBSCAN) is the most widely used density-based algorithm. It uses the concept of density reachability and density connectivity. Cons

            

            
            

                
                2 min read
            

        
    
        
            

                
Implementing Apriori algorithm in Python

                
Prerequisites: Apriori AlgorithmApriori Algorithm is a Machine Learning algorithm which is used to gain insight into the structured relationships between different items involved. The most prominent practical application of the algorithm is to recommend products based on the products already present in the user's cart. Walmart especially has made g

            

            
            

                
                4 min read
            

        
    
        
            

                
Implementing the AdaBoost Algorithm From Scratch

                
In this article, we will learn about the AdaBoost classifier and its practical implementation over a dataset.AdaBoost algorithm falls under ensemble boosting techniques, as we will discuss it combines multiple models to produce more accurate results and this is done in two phases: Multiple weak learners are allowed to learn on training dataCombinin

            

            
            

                
                6 min read
            

        
    
        
            

                
Python | Decision Tree Regression using sklearn

                
Decision Tree is a decision-making tool that uses a flowchart-like tree structure or is a model of decisions and all of their possible results, including outcomes, input costs, and utility.Decision-tree algorithm falls under the category of supervised learning algorithms. It works for both continuous as well as categorical output variables. The bra

            

            
            

                
                4 min read
            

        
    
        
            

                
Python | Create Test DataSets using Sklearn

                
Python's Sklearn library provides a great sample dataset generator which will help you to create your own custom dataset. It's fast and very easy to use. Following are the types of samples it provides.For all the above methods you need to import sklearn.datasets.samples_generator. C/C++ Code # importing libraries from sklearn.datasets import make_b

            

            
            

                
                3 min read
            

        
    

        
            

                
ML | Implementation of KNN classifier using Sklearn

                
Prerequisite: K-Nearest Neighbours Algorithm K-Nearest Neighbors is one of the most basic yet essential classification algorithms in Machine Learning. It belongs to the supervised learning domain and finds intense application in pattern recognition, data mining and intrusion detection. It is widely disposable in real-life scenarios since it is non-

            

            
            

                
                2 min read
            

        
    
        
            

                
ML | Dummy classifiers using sklearn

                
A dummy classifier is a type of classifier which does not generate any insight about the data and classifies the given data using only simple rules. The classifier's behavior is completely independent of the training data as the trends in the training data are completely ignored and instead uses one of the strategies to predict the class label. It

            

            
            

                
                3 min read
            

        
    
        
            

                
ML | Ridge Regressor using sklearn

                
A Ridge regressor is basically a regularized version of a Linear Regressor. i.e to the original cost function of linear regressor we add a regularized term that forces the learning algorithm to fit the data and helps to keep the weights lower as possible. The regularized term has the parameter 'alpha' which controls the regularization of the model

            

            
            

                
                3 min read
            

        
    
        
            

                
ML | Voting Classifier using Sklearn

                
A Voting Classifier is a machine learning model that trains on an ensemble of numerous models and predicts an output (class) based on their highest probability of chosen class as the output. It simply aggregates the findings of each classifier passed into Voting Classifier and predicts the output class based on the highest majority of voting. The i

            

            
            

                
                3 min read
            

        
    

        
            

                
Data Pre-Processing with Sklearn using Standard and Minmax scaler

                
Data Scaling is a data preprocessing step for numerical features. Many machine learning algorithms like Gradient descent methods, KNN algorithm, linear and logistic regression, etc. require data scaling to produce good results. Various scalers are defined for this purpose. This article concentrates on Standard Scaler and Min-Max scaler. The task he

            

            
            

                
                3 min read
            

        
    
        
            

                
How To Do Train Test Split Using Sklearn In Python

                
In this article, let's learn how to do a train test split using Sklearn in Python. Train Test Split Using Sklearn The train_test_split() method is used to split our data into train and test sets. First, we need to divide our data into features (X) and labels (y). The dataframe gets divided into X_train,X_test , y_train and y_test. X_train and y_tra

            

            
            

                
                5 min read
            

        
    
        
            

                
Classification Using Sklearn Multi-layer Perceptron

                
A key machine learning method that belongs to the class of artificial neural networks is classification using Multi-Layer Perceptrons (MLP). It is a flexible and effective method for tackling a variety of classification problems, including text classification and picture recognition. Traditional linear classifiers might not be up to the challenge,

            

            
            

                
                7 min read
            

        
    
        
            

                
Classification Metrics using Sklearn

                
Machine learning classification is a powerful tool that helps us make predictions and decisions based on data. Whether it's determining whether an email is spam or not, diagnosing diseases from medical images, or predicting customer churn, classification algorithms are at the heart of many real-world applications. However, the mere creation of a cl

            

            
            

                
                14 min read
            

        
    
        
            

                
Canonical Correlation Analysis (CCA) using Sklearn

                
Canonical Correlation Analysis (CCA) is a statistical method used in data analysis to identify and quantify the relationships between two sets of variables. When working with multivariate data—that is, when there are several variables in each of the two sets and we want to know how they connect—it is very helpful. This post will explain CCA, go ove

            

            
            

                
                10 min read
            

        
    
        
            

                
Gaussian Naive Bayes using Sklearn

                
In the world of machine learning, Gaussian Naive Bayes is a simple yet powerful algorithm used for classification tasks. It belongs to the Naive Bayes algorithm family, which uses Bayes' Theorem as its foundation. The goal of this post is to explain the Gaussian Naive Bayes classifier and offer a detailed implementation tutorial for Python users ut

            

            
            

                
                8 min read
            

        
    

        
            

                
Ordering Points To Identify Cluster Structure (OPTICS) using Sklearn

                
Sklearn's OPTICS, an acronym for Ordering Points To Identify the Clustering Structure, stands as a powerful tool in the realm of machine learning and data analysis. It is a part of the Scikit-learn library, a popular machine-learning library in Python. OPTICS is particularly adept at uncovering hidden patterns and structures within datasets, making

            

            
            

                
                10 min read
            

        
    
        
            

                
Mean Shift Clustering using Sklearn

                
Clustering is a fundamental method in unsupervised device learning, and one powerful set of rules for this venture is Mean Shift clustering. Mean Shift is a technique for grouping comparable data factors into clusters primarily based on their inherent characteristics, with our previous understanding of the number of clusters. This article explores

            

            
            

                
                9 min read
            

        
    
        
            

                
Partial Least Squares Regression (PLSRegression) using Sklearn

                
Partial least square regression is a Machine learning Algorithm used for modelling the relationship between independent and dependent variables. This is mainly used when there are many interrelated independent variables. It is more commonly used in regression and latent variable modelling. It finds the directions (latent variables) in the independe

            

            
            

                
                8 min read
            

        
    
        
            

                
Linear and Quadratic Discriminant Analysis using Sklearn

                
Linear Discriminant Analysis (LDA) and Quadratic Discriminant Analysis (QDA) are two well-known classification methods that are used in machine learning to find patterns and put things into groups. They are especially helpful when you have labeled data and want to classify new observations notes into pre-defined categories. In this we will implemen

            

            
            

                
                5 min read
            

        
    

        
            

                
Bag of word and Frequency count in text using sklearn

                
Text data is ubiquitous in today's digital world, from emails and social media posts to research articles and customer reviews. To analyze and derive insights from this textual information, it's essential to convert text into a numerical form that machine learning algorithms can process. One of the fundamental methods for this conversion is the "Ba

            

            
            

                
                3 min read
            

        
    
        
            

                
Python | Linear Regression using sklearn

                
Prerequisite: Linear Regression Linear Regression is a machine learning algorithm based on supervised learning. It performs a regression task. Regression models a target prediction value based on independent variables. It is mostly used for finding out the relationship between variables and forecasting. Different regression models differ based on –

            

            
            

                
                3 min read
            

        
    
        
            

                
Target encoding using nested CV in sklearn pipeline

                
In machine learning, feature engineering plays a pivotal role in enhancing model performance. One such technique is target encoding, which is particularly useful for categorical variables. However, improper implementation can lead to data leakage and overfitting. This article delves into the intricacies of target encoding using nested cross-validat

            

            
            

                
                7 min read
            

        
                                    

                            

                        

                        

                                                            

                                    
Article Tags : 

                                    
                                                                    

                                                                                        

                                    
Practice Tags : 

                                    
                                                                    

                                                    

                                                

                                

                                    
                                                                    

                            


                        

                            

                                                                                    

                              

                            

                                                        
                        

                    

                

            

                


        

                




	
	
	

	
	

	
	    

	
	

	
	



                
        

    

    

        

            

            

        

    















	

    
  

  
  






    
        We use cookies to ensure you have the best browsing experience on our website. By using our site, you
        acknowledge that you have read and understood our
        Cookie Policy &
        Privacy Policy
            
    







   Lightbox