AutoVarFit2D_Clustering.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#The imports\n",
    "from sklearn.cluster import DBSCAN\n",
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(408, 4)\n"
     ]
    }
   ],
   "source": [
    "#Read the parameters of the fitted nested variogram structures, which were saved as a GEO-EAS point set.\n",
    "# 1st column: parameter a (main range)\n",
    "# 2nd column: parameter b/a (minor/main ranges ratio)\n",
    "# 3rd column: parameter theta (azimuth)\n",
    "# 4th column: parameter cc (contribution)\n",
    "\n",
    "varParameters = pd.read_csv(\"Scat_V1_smth_pls_noise_GA_FIM_408.xyz\", sep='\\t', skiprows=0)\n",
    "print(varParameters.values.shape)\n",
    "\n",
    "numberOfClusters = 2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Perform the clustering using only range, ranges ratio and azimuth (does not use contribution)\n",
    "#clusteringData = SpectralClustering(n_clusters=numberOfClusters, \n",
    "#                                    assign_labels=\"discretize\", \n",
    "#                                    random_state=0).fit( varParameters.values[:,:3] )\n",
    "\n",
    "#Perform the clustering using all variables\n",
    "clusteringData = DBSCAN(eps=0.5).fit( varParameters )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cluster 1 :\n",
      "  a= 20.8889074041 b/a= 0.4279050447096 az= 62.35645619068 cc= 1.450642427874\n",
      "Cluster 2 :\n",
      "  a= 10.967378125345556 b/a= 0.3085486301846454 az= 81.30262464483322 cc= 1.4610126309873446\n"
     ]
    }
   ],
   "source": [
    "#Stores the mean parameters for each cluster\n",
    "rangeMeans       = np.zeros( numberOfClusters )\n",
    "rangeRatioMeans  = np.zeros( numberOfClusters )\n",
    "azimuthMeans     = np.zeros( numberOfClusters )\n",
    "ccMeans          = np.zeros( numberOfClusters )\n",
    "\n",
    "#The counts of samples for each cluster \n",
    "sampleCounts     = np.zeros( numberOfClusters )\n",
    "\n",
    "#Accumulate the sums of parameters per cluster for the computation of the means (cluster centers)\n",
    "for iRow in range(0, clusteringData.labels_.shape[0] ) :\n",
    "    rangeV                 = varParameters.values[ iRow, 0 ]\n",
    "    rangeRatio             = varParameters.values[ iRow, 1 ]\n",
    "    azimuth                = varParameters.values[ iRow, 2 ]\n",
    "    covarianceContribution = varParameters.values[ iRow, 3 ]\n",
    "    \n",
    "    clusterId = clusteringData.labels_[ iRow ]\n",
    "    \n",
    "    rangeMeans     [ clusterId ] += rangeV \n",
    "    rangeRatioMeans[ clusterId ] += rangeRatio \n",
    "    azimuthMeans   [ clusterId ] += azimuth \n",
    "    ccMeans        [ clusterId ] += covarianceContribution \n",
    "\n",
    "    sampleCounts   [ clusterId ] += 1\n",
    "   \n",
    "#Compute the means of parameters per cluster (cluster centers)\n",
    "for iCluster in range(0, numberOfClusters) :\n",
    "    rangeMeans     [ iCluster ] /= sampleCounts [ iCluster ] \n",
    "    rangeRatioMeans[ iCluster ] /= sampleCounts [ iCluster ] \n",
    "    azimuthMeans   [ iCluster ] /= sampleCounts [ iCluster ] \n",
    "    ccMeans        [ iCluster ] /= sampleCounts [ iCluster ] \n",
    "    \n",
    "    print(\"Cluster\", iCluster+1, \":\")\n",
    "    print(\"  a=\", rangeMeans[iCluster], \n",
    "          \"b/a=\", rangeRatioMeans[iCluster], \n",
    "          \"az=\", azimuthMeans[iCluster], \n",
    "          \"cc=\", ccMeans[iCluster])\n",
    " \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Code to plot the clusters\n",
    "#print(__doc__)\n",
    "\n",
    "#import numpy as np\n",
    "\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",
    "\n",
    "\n",
    "# #############################################################################\n",
    "# Generate sample data\n",
    "#centers = [[1, 1], [-1, -1], [1, -1]]\n",
    "#X, labels_true = make_blobs(n_samples=750, centers=centers, cluster_std=0.4,\n",
    "                            random_state=0)\n",
    "\n",
    "#X = StandardScaler().fit_transform(X)\n",
    "\n",
    "# #############################################################################\n",
    "# Compute DBSCAN\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_noise_ = list(labels).count(-1)\n",
    "\n",
    "#print('Estimated number of clusters: %d' % n_clusters_)\n",
    "#print('Estimated number of noise points: %d' % n_noise_)\n",
    "#print(\"Homogeneity: %0.3f\" % metrics.homogeneity_score(labels_true, labels))\n",
    "#print(\"Completeness: %0.3f\" % metrics.completeness_score(labels_true, labels))\n",
    "#print(\"V-measure: %0.3f\" % metrics.v_measure_score(labels_true, labels))\n",
    "#print(\"Adjusted Rand Index: %0.3f\"\n",
    "#      % metrics.adjusted_rand_score(labels_true, labels))\n",
    "#print(\"Adjusted Mutual Information: %0.3f\"\n",
    "#      % metrics.adjusted_mutual_info_score(labels_true, labels))\n",
    "#print(\"Silhouette Coefficient: %0.3f\"\n",
    "#      % metrics.silhouette_score(X, labels))\n",
    "\n",
    "# #############################################################################\n",
    "# Plot result\n",
    "#import matplotlib.pyplot as plt\n",
    "\n",
    "# Black removed and is used for noise instead.\n",
    "#unique_labels = set(labels)\n",
    "#colors = [plt.cm.Spectral(each)\n",
    "#          for each in np.linspace(0, 1, len(unique_labels))]\n",
    "#for k, col in zip(unique_labels, colors):\n",
    "#    if k == -1:\n",
    "        # Black used for noise.\n",
    "#        col = [0, 0, 0, 1]\n",
    "\n",
    "#    class_member_mask = (labels == k)\n",
    "\n",
    "#    xy = X[class_member_mask & core_samples_mask]\n",
    "#    plt.plot(xy[:, 0], xy[:, 1], 'o', markerfacecolor=tuple(col),\n",
    "#             markeredgecolor='k', markersize=14)\n",
    "\n",
    "#    xy = X[class_member_mask & ~core_samples_mask]\n",
    "#    plt.plot(xy[:, 0], xy[:, 1], 'o', markerfacecolor=tuple(col),\n",
    "#             markeredgecolor='k', markersize=6)\n",
    "\n",
    "#plt.title('Estimated number of clusters: %d' % n_clusters_)\n",
    "#plt.show()"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}