optics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### OPTICS\n",
    "\n",
    "&nbsp;\n",
    "\n",
    "OPTICS is a variation of DBSCAN. One of the biggest malaises for DBSCAN is to find the appropriate ε. OPTICS uses a special ordering based upon the organic order and the reachability distance to skip the needle search of optimal ε in the haystack. Although the quadratic time complexity of the algorithm can be avoided with the input of ε. As a result of quid pro quoi, ξ is a new parameter to determine the steep upward and downward areas in reachability plot. The valleys between steep upward and downward areas would be identified as clusters.\n",
    "\n",
    "For technical details of DBSCAN, you can click the link below.\n",
    "\n",
    "https://github.com/je-suis-tm/machine-learning/blob/master/dbscan.ipynb\n",
    "\n",
    "For technical details of OPTICS, you can read the original paper.\n",
    "\n",
    "https://www.dbs.ifi.lmu.de/Publikationen/Papers/OPTICS.pdf\n",
    "\n",
    "&nbsp;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sklearn.cluster\n",
    "import sklearn.decomposition\n",
    "import sklearn.datasets\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import scipy.spatial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#compute euclidean distance matrix\n",
    "def get_distance_matrix(data,use_scipy=True):\n",
    "    \n",
    "    #you can use scipy spatial matrix to achieve better performance\n",
    "    if use_scipy:\n",
    "        return scipy.spatial.distance_matrix(data,data)\n",
    "\n",
    "    #initialize\n",
    "    dist_mat=np.empty((len(data),len(data)))\n",
    "    dist_mat.fill(float('inf'))\n",
    "\n",
    "    #computing only upper triangle matrix to boost efficiency\n",
    "    for i in range(len(data)):\n",
    "        for j in range(i+1,len(data)):\n",
    "            euclidean_dist=sum((data[j]-data[i])**2)**0.5\n",
    "            dist_mat[i][j]=euclidean_dist\n",
    "            dist_mat[j][i]=euclidean_dist\n",
    "        \n",
    "    return dist_mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#prepare core distance for ordering\n",
    "#based upon definition 5 in the original paper\n",
    "def get_core_dist(dist_mat,minpts):\n",
    "\n",
    "    #computing core distance\n",
    "    #basically the minimum epsilon to make a random point core\n",
    "    #a core point must have at least minpts points within the radius of epsilon\n",
    "    #thus core distance would be the minpts-th data inside the distance matrix\n",
    "    core_dist=[sorted(dist_mat[i])[minpts-1] for i in range(len(dist_mat))]\n",
    "                        \n",
    "    return core_dist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#the idea of ordering by reachability distance\n",
    "#can be thought of as mapping high dimensional data into one dimension\n",
    "#data points with small reachability distance become neighbors on one axis\n",
    "#then we determine the area of clusters on one axis based upon ξ and minpts\n",
    "#based upon figure 6 and 7 in the original paper\n",
    "def order_points(core_dist,dist_mat):\n",
    "\n",
    "    ordering=[]\n",
    "    reach_dist=[]\n",
    "    priority_queue=dict(zip(range(len(core_dist)),\n",
    "                            [float('inf')]*len(core_dist)))\n",
    "    pred=dict(zip(range(len(core_dist)),\n",
    "                            [-1]*len(core_dist)))\n",
    "\n",
    "    while priority_queue:\n",
    "\n",
    "        #while iterating through the priority queue\n",
    "        #pick the data point with the smallest reachability distance\n",
    "        ind=list(priority_queue.keys())[0]\n",
    "        ordering.append(ind)\n",
    "        reach_dist.append(priority_queue[ind])\n",
    "\n",
    "        #current data point has been processed\n",
    "        del priority_queue[ind]\n",
    "\n",
    "        #definition 1 in the original paper\n",
    "        for i in np.where(core_dist[ind]>=dist_mat[ind])[0]:\n",
    "            \n",
    "            #each data point is only processed once\n",
    "            if i not in ordering:\n",
    "                \n",
    "                #definition 6 in the original paper\n",
    "                reachability=np.array([max(core_dist[ind],\n",
    "                                           dist_mat[i][ind]) for i in range(len(core_dist))])\n",
    "                \n",
    "                #always update the smallest reachability distance\n",
    "                for j in priority_queue:\n",
    "                    if priority_queue[j]>reachability[j]:\n",
    "                        priority_queue[j]=reachability[j]\n",
    "                        pred[j]=ind\n",
    "                        \n",
    "        #sort the queue by reachability distance\n",
    "        priority_queue=dict(sorted(priority_queue.items(),key=lambda x:x[1]))\n",
    "        \n",
    "    return ordering,reach_dist,pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#get upward and downward areas based upon definition 10 in the original paper\n",
    "def get_up_down_areas(reach_dist_df,minpts):\n",
    "\n",
    "    start=None;end=None\n",
    "    steep_areas=[]\n",
    "\n",
    "    #detect steep areas regardless of upward/downward\n",
    "    for i in range(len(reach_dist_df)):\n",
    "\n",
    "        if start!=None:\n",
    "\n",
    "            #inside the steep areas\n",
    "            #reachability distance change should be the same direction\n",
    "            sign_condition=reach_dist_df.at[i,'xi']*reach_dist_df.at[start,'xi']>=0\n",
    "\n",
    "            #inside the steep areas\n",
    "            #there should not be more than minpts consecutive non-ξ data points\n",
    "            #otherwise they can form a cluster\n",
    "            core_condition='0'*minpts not in ''.join(reach_dist_df['xi'].loc[start:i].astype(str))\n",
    "\n",
    "            #both start and end should be the same direction\n",
    "            xi_condition=reach_dist_df.at[i,'xi']==reach_dist_df.at[start,'xi']\n",
    "\n",
    "            #only increment when both conditions are met\n",
    "            if sign_condition and core_condition:\n",
    "\n",
    "                #new end identified\n",
    "                if xi_condition:\n",
    "                    end=i  \n",
    "\n",
    "            #one steep area is identified\n",
    "            else:\n",
    "\n",
    "                #only add steep area when we have more than one ξ data point\n",
    "                #except beginning and ending\n",
    "                if start!=None and end!=None:\n",
    "                    steep_areas.append([start,end])\n",
    "                start=None;end=None\n",
    "\n",
    "        #should not use else condition\n",
    "        #when if current data point has opposite ξ to start\n",
    "        #current data point should become the new start\n",
    "        if start==None:        \n",
    "            if reach_dist_df.at[i,'xi']!=0:\n",
    "                start=i\n",
    "\n",
    "    #end of dataframe append\n",
    "    if start!=None and end!=None:\n",
    "        steep_areas.append([start,end])\n",
    "\n",
    "    #differentiate upward and downward areas\n",
    "    up_areas=[]\n",
    "    down_areas=[]\n",
    "    for i in steep_areas:\n",
    "        if reach_dist_df.at[i[0],'xi']==1:\n",
    "            up_areas.append(i)\n",
    "        else:\n",
    "            down_areas.append(i)\n",
    "            \n",
    "    #the beginning is always downward area\n",
    "    if down_areas[0][0]!=0:\n",
    "        down_areas.insert(0,[0,0])\n",
    "    \n",
    "    #the ending is always upward area\n",
    "    if up_areas[-1][-1]!=reach_dist_df.index[-1]:\n",
    "        up_areas.append([reach_dist_df.index[-1],reach_dist_df.index[-1]])\n",
    "\n",
    "    return up_areas,down_areas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#get clusters based upon definition 11 in the original paper\n",
    "def identify_cluster_structure(up_areas,down_areas,reach_dist,xi,minpts):\n",
    "    \n",
    "    #add the last data point to avoid empty in between sequence\n",
    "    reach_plot=reach_dist+[float('inf')]\n",
    "    \n",
    "    clusters=[]\n",
    "    for i in down_areas:\n",
    "\n",
    "        start_down=i[0]\n",
    "        end_down=i[-1]\n",
    "        \n",
    "        #up areas start must be larger than down areas end\n",
    "        valid_up_areas=[ii for ii in up_areas if ii[0]>end_down]\n",
    "\n",
    "        for j in valid_up_areas:\n",
    "\n",
    "            start_up=j[0]\n",
    "            end_up=j[-1]\n",
    "            \n",
    "            #condition 3b\n",
    "            mib=max(reach_plot[start_down+1:end_up])\n",
    "            sc_1_star=mib<=reach_plot[start_down]*(1-xi)\n",
    "            sc_2_star=mib<=reach_plot[end_up]*(1-xi)        \n",
    "\n",
    "            if sc_1_star and sc_2_star:\n",
    "                \n",
    "                #condition 4\n",
    "                fig_18_b=reach_plot[start_down]*(1-xi)>=reach_plot[end_up+1]\n",
    "                fig_18_a=reach_plot[end_up+1]*(1-xi)>=reach_plot[start_down]\n",
    "\n",
    "                if fig_18_b:\n",
    "                    down_areas_mib=max([ii for ii in reach_plot[start_down:end_down+1] if ii>reach_plot[end_up+1]])\n",
    "                    cluster_start=start_down+reach_plot[start_down:end_down+1].index(down_areas_mib)\n",
    "                    cluster_end=end_up\n",
    "                elif fig_18_a:\n",
    "                    cluster_start=start_down\n",
    "                    up_areas_mib=min([ii for ii in reach_plot[start_up:end_up+1] if ii<reach_plot[start_down]])\n",
    "                    cluster_end=start_up+reach_plot[start_up:end_up+1].index(up_areas_mib)\n",
    "                else:\n",
    "                    cluster_start=start_down\n",
    "                    cluster_end=end_up\n",
    "\n",
    "                #condition 3a\n",
    "                if cluster_end-cluster_start>minpts-1:\n",
    "                    clusters.append([cluster_start,cluster_end])\n",
    "                    \n",
    "    return clusters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#sklearn uses a cluster correction algorithm\n",
    "#based upon a paper called Improving the Cluster Structure Extracted from OPTICS Plots\n",
    "# http://ceur-ws.org/Vol-2191/paper37.pdf\n",
    "def cluster_correction(start,end,reach_dist,pred):\n",
    "    while start<end:\n",
    "        if reach_dist[start]>reach_dist[end]:\n",
    "            return [start,end]\n",
    "        for i in range(start,end):\n",
    "            if i==pred(end):\n",
    "                return [start,end]\n",
    "        end-=1\n",
    "    return []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#think of it as extracting maximal cliques from cliques\n",
    "#as we have used greedy search to get all potential clusters\n",
    "#the maximal cluster is the biggest cluster end given the same cluster start\n",
    "def get_maximal_clusters(clusters):\n",
    "    \n",
    "    maximal_clusters=[]\n",
    "    cluster_starts=[i[0] for i in clusters]\n",
    "\n",
    "    #start with the smallest cluster start\n",
    "    #obtain the largest cluster end given the cluster start\n",
    "    #remove any invalid cluster start smaller than the cluster end\n",
    "    #iterate until all maximal clusters are found\n",
    "    while cluster_starts:\n",
    "        cluster_start=sorted(cluster_starts)[0]\n",
    "        cluster_end=max([ii[1] for ii in clusters if ii[0]==cluster_start])\n",
    "        maximal_clusters.append([cluster_start,cluster_end])\n",
    "        cluster_starts=[i for i in cluster_starts if i>cluster_end]\n",
    "        \n",
    "    return maximal_clusters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#use optics to forecast the cluster structure\n",
    "def optics_forecast(data,minpts,xi,viz_reach_plot=True):\n",
    "\n",
    "    #prepare distance matrix and core distance\n",
    "    dist_mat=get_distance_matrix(data)\n",
    "    core_dist=get_core_dist(dist_mat,minpts)\n",
    "\n",
    "    #due to the python float issue\n",
    "    #the ordering isnt exactly the same as sklearn\n",
    "    ordering,reach_dist,pred=order_points(core_dist,\n",
    "                                          dist_mat)\n",
    "\n",
    "    if viz_reach_plot:\n",
    "        fig=plt.figure(figsize=(10,5))\n",
    "        ax=fig.add_subplot(111)\n",
    "        plt.bar(range(0,len(ordering)),\n",
    "                reach_dist,color='#05a96f',\n",
    "                width=1)\n",
    "        plt.title('OPTICS Reachability Plot')\n",
    "        plt.xlabel('Cluster Ordering')\n",
    "        plt.xlabel('Reachability Distance')\n",
    "        plt.show()\n",
    "\n",
    "    #i know dataframe is slower numpy array\n",
    "    #but its much more convenient in python\n",
    "    #as we dont really reinvent the wheel in practice\n",
    "    #the performance does not matter in our demonstration\n",
    "    reach_dist_df=pd.DataFrame()\n",
    "    reach_dist_df['data']=reach_dist\n",
    "\n",
    "    #determine ξ steep points\n",
    "    reach_dist_df['pct']=reach_dist_df['data'].pct_change().shift(-1)\n",
    "    reach_dist_df['xi']=pd.Series(\n",
    "        np.select([reach_dist_df['pct']>=xi,\n",
    "                   reach_dist_df['pct']<=-xi],[1,-1]))\n",
    "\n",
    "    #set the last one upward point\n",
    "    reach_dist_df.at[len(reach_dist)-1,'xi']=1\n",
    "\n",
    "    #unlike figure 19 in the original paper\n",
    "    #we scan all upward/downward areas based upon definition 10\n",
    "    up_areas,down_areas=get_up_down_areas(reach_dist_df,\n",
    "                                          minpts)\n",
    "    \n",
    "    #then we scan all potential clusters based upon definition 11\n",
    "    clusters=identify_cluster_structure(up_areas,\n",
    "                                        down_areas,\n",
    "                                        reach_dist,\n",
    "                                        xi,minpts)\n",
    "    \n",
    "    #cluster correction\n",
    "    for ind,val in enumerate(clusters):\n",
    "        new_cluster=cluster_correction(val[0],val[1],reach_dist,pred)\n",
    "        if new_cluster:\n",
    "            clusters[ind]=new_cluster\n",
    " \n",
    "    maximal_clusters=get_maximal_clusters(clusters)\n",
    "\n",
    "    #make forecast based upon maximal clusters\n",
    "    projection=np.empty(len(core_dist))\n",
    "\n",
    "    #those who do not fit in become noise\n",
    "    projection.fill(-1)\n",
    "    for ind,val in enumerate(maximal_clusters):\n",
    "        projection[ordering[val[0]:val[1]+1]]=ind\n",
    "    \n",
    "    return projection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#aggregate all functions into one big main function\n",
    "def xi_optics(df,xcol,minpts,xi,\n",
    "              viz_reach_plot=True,\n",
    "              viz_iris_plot=True):\n",
    "    \n",
    "    data=df.copy()\n",
    "    data['predict']=optics_forecast(np.array(data[xcol]),minpts,xi,\n",
    "                                   viz_reach_plot=viz_reach_plot)\n",
    "    \n",
    "    #compute accuracy\n",
    "    erreur=0\n",
    "    checked=[]\n",
    "    for i in data['y'].unique():\n",
    "        erreur+=get_accuracy(data,i,checked)\n",
    "        checked.append(i)\n",
    "    accuracy=1-erreur/len(df)\n",
    "    print('accuracy: %s'%(accuracy))\n",
    "    \n",
    "    #plot iris in 2d\n",
    "    if viz_iris_plot:\n",
    "        plot_iris(data,xcol)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#for unsupervised learning, clf.score doesnt return the accuracy\n",
    "#there is no cross validation, no known labels\n",
    "#the only way to detect the accuracy is vote of the majority\n",
    "#for each label given\n",
    "#we check which iris type is the majority\n",
    "#we consider the majority as the correct classification\n",
    "#all we need to do is to count the minority\n",
    "def get_accuracy(data,class_,checked):\n",
    "    \n",
    "    df=data.copy()\n",
    "    \n",
    "    #use dictionary to keep track of everything\n",
    "    d={}\n",
    "    \n",
    "    #counting\n",
    "    for i in df['predict'][df['y']==class_].unique():\n",
    "        if i not in checked and i!=-1:\n",
    "            d[i]=df['predict'][df['y']==class_].tolist().count(i)\n",
    "\n",
    "    #comparison\n",
    "    large=-1\n",
    "    lbl=None\n",
    "    for i in d:\n",
    "        if d[i]>large:\n",
    "            lbl=i\n",
    "            large=d[i]\n",
    "\n",
    "    return len(df['predict'][df['y']==class_][df['predict']!=lbl])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#optics implemented by sklearn\n",
    "def skl_optics(df,xcol,minpts,xi,\n",
    "               viz_reach_plot=True,\n",
    "              viz_iris_plot=True):\n",
    "    \n",
    "    data=df.copy()\n",
    "    \n",
    "    #machine learning\n",
    "    clf=sklearn.cluster.OPTICS(min_samples=minpts,xi=xi)\n",
    "    clf.fit(data[xcol])    \n",
    "    data['predict']=clf.fit_predict(data[xcol])\n",
    "    \n",
    "    #reachability plot\n",
    "    if viz_reach_plot:\n",
    "        fig=plt.figure(figsize=(10,5))\n",
    "        ax=fig.add_subplot(111)\n",
    "        plt.bar(range(0,len(clf.ordering_)),\n",
    "                clf.reachability_[clf.ordering_],\n",
    "                color='#9abbe3',\n",
    "                width=1)\n",
    "        plt.title('OPTICS Reachability Plot')\n",
    "        plt.xlabel('Cluster Ordering')\n",
    "        plt.xlabel('Reachability Distance')\n",
    "        plt.show()\n",
    "    \n",
    "    #compute accuracy\n",
    "    erreur=0\n",
    "    checked=[]\n",
    "    for i in data['predict'].unique():\n",
    "        erreur+=get_accuracy(data,i,checked)\n",
    "        checked.append(i)\n",
    "    accuracy=1-erreur/len(data)\n",
    "    print('accuracy: %s'%(accuracy))\n",
    "    \n",
    "    #plot iris in 2d\n",
    "    if viz_iris_plot:\n",
    "        plot_iris(data,xcol)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#plot iris cluster in 2 dimensions\n",
    "def plot_iris(df,xcol):\n",
    "\n",
    "    #for the purpose of visualization\n",
    "    #we reduce 4 dimensions to 2\n",
    "    #check the link below for more details of pca\n",
    "    # https://github.com/je-suis-tm/machine-learning/blob/master/principal%20component%20analysis.ipynb\n",
    "    dims=2\n",
    "    x=sklearn.decomposition.PCA(n_components=dims).fit_transform(df[xcol])\n",
    "\n",
    "    df['dim1']=x[:,0]\n",
    "    df['dim2']=x[:,1]\n",
    "\n",
    "    #viz\n",
    "    fig=plt.figure(figsize=(10,5))\n",
    "    ax=fig.add_subplot(111)\n",
    "\n",
    "    for i in set(df['predict']):\n",
    "        if i!=-1:\n",
    "            plt.scatter(df['dim1'][df['predict']==i],\n",
    "                        df['dim2'][df['predict']==i],\n",
    "                        label=f'Label {int(i)}',alpha=0.7)\n",
    "        else:\n",
    "            plt.scatter(df['dim1'][df['predict']==i],\n",
    "                        df['dim2'][df['predict']==i],\n",
    "                        label='Noise',alpha=0.7)\n",
    "\n",
    "    plt.title('OPTICS')\n",
    "    plt.legend(loc=0)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#create dataframe\n",
    "xcol=['x0','x1','x2','x3']\n",
    "ycol='y'\n",
    "iris=sklearn.datasets.load_iris()\n",
    "df=pd.DataFrame(iris.data,columns=xcol)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "#each input factor has to be float/int\n",
    "#sklearn has already done that for us\n",
    "#but if you are using the dataset inside the repository\n",
    "#you can use np.unique to convert categorical data to int\n",
    "df[ycol]=iris.target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#minpts denotes the minimum requirement to form a cluster\n",
    "#minpts should be larger than 2\n",
    "#there are different empirical rules\n",
    "#it can be 2 times dimensions\n",
    "#or it can be dimensions+1\n",
    "minpts=1+len(xcol)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#ξ determines the steep upward and downward areas in reachability plot\n",
    "#the valleys between steep upward and downward areas\n",
    "#would be identified as clusters\n",
    "#the optimal ξ is the elephant in the room\n",
    "#nobody fucking talks about it!!!!\n",
    "#let me know if you have found any good method for that\n",
    "xi=0.05"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy: 0.6666666666666667\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#surprisingly result is similar to self implemented dbscan\n",
    "xi_optics(df,xcol,minpts,xi,\n",
    "          viz_reach_plot=True,viz_iris_plot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy: 0.26\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#even though the ordering looks similar\n",
    "#it creates a lot more clusters than self implemented optics\n",
    "skl_optics(df,xcol,minpts,xi,\n",
    "           viz_reach_plot=True,viz_iris_plot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.6.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}