DensityBasedScan_DBScan.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This particluar method is a clustering method and this helps in clustering our data based on density, its a classification method in machine learning."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two major inputs for the algorithm\n",
    "\n",
    "    -   epsilon - This is just the radius created with the center point (our data point)\n",
    "    -   Min Point - Default value for this is 3 in the algorithm and this suggests that there should be minimum of three data points inside of the circle that's created with the epsilon radius.\n",
    "    -   As discussed above , if this minimum three point criteria is fulfilled here then the central point denoted over in the previous section will be called as a core point."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Boundary & Noise point\n",
    "\n",
    "    -   Suppose a data point has only one core point as neighbor and not satisfying the requirement of minimum 3 points within it's circle , it will be called as a boundary point\n",
    "    -   If a data point remains completely aloof and it's radius circle doesn't include any other core point or data point , then that particular data point will be called as noise point/outliers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Lets try to apply dbscan on a created dataset\n",
    "#importing the libraries\n",
    "from sklearn.cluster import DBSCAN\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# creating a numpy array\n",
    "X = np.array([[1, 2], [2, 2], [2, 3],[8, 7], [8, 8], [25, 80]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  0,  0,  1,  1, -1], dtype=int64)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#applying dbscan on the data\n",
    "clustering = DBSCAN(eps=3, min_samples=2).fit(X)\n",
    "clustering.labels_"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above cluster label signifies as below \n",
    "\n",
    "    -   The first three datapoints belong to cluster 0\n",
    "    -   The fourth and fifth data points belong to cluster 1\n",
    "    -   The sixth data point is a noise here hence it's output came in negative"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will see what can happen if we change the parameter value here. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1, -1, -1, -1, -1, -1], dtype=int64)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clustering = DBSCAN(eps=3, min_samples=9).fit(X)\n",
    "clustering.labels_"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that by changing the minimum sample number as 9 every single data point went into noise. Let's understand what happened here.. our total data point here is 9. And by changing the sample number we are asking our algoritham to make one sample for eveyr single data point , hence every single item acted as outlier/Noise."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will see what can happen if we change the epsilon value here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0, 0, 0], dtype=int64)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clustering = DBSCAN(eps=100, min_samples=3).fit(X)\n",
    "clustering.labels_"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now with the higher value of eps , the entire data point came into one cluster , which is cluster 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1  0 -1  0 -1 -1 -1  2 -1 -1  1 -1  2 -1 -1  2  2  3  1 -1 -1  3  2  1\n",
      "  1 -1  3  2 -1 -1 -1  0 -1 -1  0 -1  0 -1  1  3 -1  1 -1 -1  1  1  0  1\n",
      "  0 -1  1  3 -1  3 -1  1 -1 -1  0  3 -1  2 -1  1  1  1 -1  3 -1  1  2 -1\n",
      "  0  1 -1  0  1  2  3  0 -1  2 -1  3  0 -1  3  2 -1  0  2  3 -1  1  1 -1\n",
      " -1  3 -1 -1 -1 -1 -1  3  2  3 -1  2 -1 -1 -1  1  3 -1  3 -1  0 -1 -1 -1\n",
      " -1  3  1  3 -1  3  3  1 -1  1 -1  1  1 -1  0 -1 -1  0 -1 -1 -1  1 -1 -1\n",
      " -1  1  0 -1  0  0  0  2 -1  2 -1  1  0  1  3  2 -1  2  2 -1  2 -1 -1 -1\n",
      " -1 -1  2  0  3 -1 -1  0 -1  3  2  1  3 -1  1  1  2  2 -1  2 -1  0 -1  1\n",
      "  2  2  1  1 -1 -1  1  0 -1  1 -1  1 -1 -1  1 -1  2 -1  2  1 -1 -1  0  1\n",
      "  1  3 -1  2  0  3  3 -1 -1 -1 -1 -1  0 -1  2 -1  2 -1  1  2  3  1 -1  1\n",
      " -1  2 -1  0  0  0  0  1  1 -1 -1  1  3  2  1 -1 -1 -1  3  0  2  2 -1  3\n",
      " -1  1 -1 -1 -1  3  3 -1  1 -1 -1 -1 -1 -1  0  0 -1  3 -1  3  3 -1  0 -1\n",
      " -1  2 -1  3  0 -1  0 -1 -1  2 -1  1]\n",
      "['y', 'b', 'g', 'r']\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from sklearn.cluster import DBSCAN\n",
    "from sklearn import metrics\n",
    "from sklearn.datasets import make_blobs\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn import datasets\n",
    "\n",
    "# Load data in X\n",
    "X, y_true = make_blobs(n_samples=300, centers=4,\n",
    "\t\t\t\t\tcluster_std=0.50, random_state=0)\n",
    "db = DBSCAN(eps=0.3, min_samples=10).fit(X)\n",
    "core_samples_mask = np.zeros_like(db.labels_, dtype=bool)\n",
    "core_samples_mask[db.core_sample_indices_] = True\n",
    "labels = db.labels_\n",
    "\n",
    "# Number of clusters in labels, ignoring noise if present.\n",
    "n_clusters_ = len(set(labels)) - (1 if -1 in labels else 0)\n",
    "\n",
    "print(labels)\n",
    "\n",
    "# Plot result\n",
    "\n",
    "# Black removed and is used for noise instead.\n",
    "unique_labels = set(labels)\n",
    "colors = ['y', 'b', 'g', 'r']\n",
    "print(colors)\n",
    "for k, col in zip(unique_labels, colors):\n",
    "\tif k == -1:\n",
    "\t\t# Black used for noise.\n",
    "\t\tcol = 'k'\n",
    "\n",
    "\tclass_member_mask = (labels == k)\n",
    "\n",
    "\txy = X[class_member_mask & core_samples_mask]\n",
    "\tplt.plot(xy[:, 0], xy[:, 1], 'o', markerfacecolor=col,\n",
    "\t\t\tmarkeredgecolor='k',\n",
    "\t\t\tmarkersize=6)\n",
    "\n",
    "\txy = X[class_member_mask & ~core_samples_mask]\n",
    "\tplt.plot(xy[:, 0], xy[:, 1], 'o', markerfacecolor=col,\n",
    "\t\t\tmarkeredgecolor='k',\n",
    "\t\t\tmarkersize=6)\n",
    "\n",
    "plt.title('number of clusters: %d' % n_clusters_)\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.cluster import DBSCAN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('Mall_Customers.csv')\n",
    "X_train = df[['Age', 'Annual Income (k$)', 'Spending Score (1-100)']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "clustering = DBSCAN(eps=12.5, min_samples=4).fit(X_train)\n",
    "DBSCAN_dataset = X_train.copy()\n",
    "DBSCAN_dataset.loc[:,'Cluster'] = clustering.labels_ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Cluster</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>112</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>34</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>24</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>-1</th>\n",
       "      <td>18</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    Cluster\n",
       " 0      112\n",
       " 2       34\n",
       " 3       24\n",
       "-1       18\n",
       " 1        8\n",
       " 4        4"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "DBSCAN_dataset.Cluster.value_counts().to_frame()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CustomerID                0\n",
       "Gender                    0\n",
       "Age                       0\n",
       "Annual Income (k$)        0\n",
       "Spending Score (1-100)    0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}