Exercise_09_Clustering.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Temporal and spatial data mining\n",
    "\n",
    "## Time Series [Clustering](https://scikit-learn.org/stable/modules/clustering.html#)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1\n",
    "\n",
    "**a)** What is \"clustering\" and why it is an unsupervised learning process? \n",
    "\n",
    "**b)** Which aspects can influence the outcome of the clusters at the pre-processing stage?\n",
    "\n",
    "**c)** In which application areas could be necessary to cluster time series data? Think about an use-case.\n",
    "\n",
    "**d)** why is a hiererchical clustering considered advantageous or disadvantageous?\n",
    "\n",
    "**e)** What is a dendrogram?\n",
    "\n",
    "**f)** What are the differences between the \"linkage\" concepts and what are they used for?\n",
    "\n",
    "**g)** can the three \"linkage\" concepts lead to different results? why?\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**h)** What is $k$-means or $c$-means clustering? How does it work? What do $k$-means and *Expectation Maximization* have to do with each other?\n",
    "\n",
    "\n",
    " **---  Your Text Here ----** \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intel MKL WARNING: Support of Intel(R) Streaming SIMD Extensions 4.2 (Intel(R) SSE4.2) enabled only processors has been deprecated. Intel oneAPI Math Kernel Library 2025.0 will require Intel(R) Advanced Vector Extensions (Intel(R) AVX) instructions.\n",
      "Intel MKL WARNING: Support of Intel(R) Streaming SIMD Extensions 4.2 (Intel(R) SSE4.2) enabled only processors has been deprecated. Intel oneAPI Math Kernel Library 2025.0 will require Intel(R) Advanced Vector Extensions (Intel(R) AVX) instructions.\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "plt.style.use('ggplot')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 2: $k$-Means (Bonus)\n",
    "\n",
    "**a)** Read the following data set `'./data/chart_data.h5'`\n",
    "\n",
    ">Plot the data considering the index `TSID` and save the labels for each Time Series Sequence in a single array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<bound method Series.unique of TSID\n",
       "1      0.0\n",
       "1      0.0\n",
       "1      0.0\n",
       "1      0.0\n",
       "1      0.0\n",
       "      ... \n",
       "823    3.0\n",
       "823    3.0\n",
       "823    3.0\n",
       "823    3.0\n",
       "823    3.0\n",
       "Name: label, Length: 273236, dtype: float64>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_hdf('chart_data.h5')\n",
    "df_1 = df.loc[df['label']==2]\n",
    "df['label'].unique"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**b)** Is there some preprocessing required? Explain/comment shortly the Pre-Processing techniques applied in python if necessary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**c)** Does it make sense to reduce the dimensionality of the data? Implement a suitable technique on python if required\n",
    "\n",
    ">Find a two dimensional representation of each time series e.g. mapping the complete sequence into a two dimensional space."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "####################\n",
    "# Your Code Here   #\n",
    "####################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(8,6))\n",
    "plt.scatter(mySeries_transformed[:,0],mySeries_transformed[:,1], s=100, edgecolor='black')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**d)** Apply $k$-means for clustering the time series data. How many Clusters do you consider to use? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">For the estimation of the quality of a clustering there are many different evaluation measures. One of the most common is the [Davies Bouldin Index](https://scikit-learn.org/stable/modules/clustering.html#davies-bouldin-index) ([wiki](https://en.wikipedia.org/wiki/Davies%E2%80%93Bouldin_index)) or the averaged [Intra-Cluster-Distance](https://scikit-learn.org/stable/modules/clustering.html#silhouette-coefficient)     ([geeksforgeeks](https://www.geeksforgeeks.org/ml-intercluster-and-intracluster-distance/)). Familiarize yourself with the two measures.\n",
    "\n",
    ">**Davies-Bouldin-Index**\n",
    "\n",
    ">\\begin{align}\n",
    "    \\mu_i = & \\frac{1}{|C_i|} \\sum_{y \\in C_i}{y} \\text{ (Clusters centers)} \\\\\n",
    "    d_i = & \\frac{1}{|C_i|}\\sum{y \\in C_i} d(y,\\mu_i) \\text{ (by distance to the cluster center)}\\\\\n",
    "    R_{ij} = & \\frac{d_i + d_j}{d (\\mu_i, \\mu_j)}\\\\\n",
    "    R_i = & \\max{R_{ij} | 1 \\leq J \\leq K , i \\neq j}\\\\\n",
    "    DB = &\\frac{1}{K}\\sum_{i=1}^{K}R_i\n",
    "\\end{align}\n",
    "\n",
    ">$R_{ij}$ : Compactness of two clusters in relation to their distance from each other (the smaller $R_{ij}$ the better $C_i$ and $C_j$ are separated from each other)\n",
    "\n",
    ">$R_i$: how well is $C_i$ separated from other clusters in the worst case?\n",
    "\n",
    ">$DB$: Average of all $R_i$ (the smaller the better)\n",
    "\n",
    ">**Average intra-cluster distance (ICD):**\n",
    "\n",
    ">The average intra-cluster distance corresponds to the average distance between the points in a cluster multiplied by the number of points minus 1. Becomes smaller as the number of clusters increases.\n",
    "\n",
    "**Hint: Plot the DB Score/ICD for multiple number of clusters and find the optimal value**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "####################\n",
    "# Your Code Here   #\n",
    "####################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "####################\n",
    "# Your Code Here   #\n",
    "####################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**f)** Do a scaling procedure at the Pre-Processing stage influence the results? Discuss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 3: DBSCAN (Bonus)\n",
    "\n",
    "**a)** Apply now DBSCAN for clustering the time series data given in **Task 2**\n",
    "\n",
    ">Repeat all the steps above and find the best parameters for DBSCAN. How many clusters do you recognize? What is the difference?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,8))\n",
    "plt.scatter(mySeries_transformed[:,0],mySeries_transformed[:,1], s=50)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "####################\n",
    "# Your Code Here   #\n",
    "####################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(8,8))\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "ax.view_init(30, 60)\n",
    "X, Y = np.meshgrid(eps_range,min_samples_range)\n",
    "ax.plot_surface(X, Y, np.vstack(DBI_row_list).transpose(), cmap=\"plasma\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(8,8))\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "ax.view_init(30, 225)\n",
    "X, Y = np.meshgrid(eps_range,min_samples_range)\n",
    "ax.plot_surface(X, Y, np.vstack(ICD_row_list).transpose(), cmap=\"plasma\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### SOLUTION ###\n",
    "\n",
    "db = DBSCAN(eps=0.2, min_samples=10).fit(mySeries_transformed)\n",
    "core_samples_mask = np.zeros_like(db.labels_, dtype=bool)\n",
    "core_samples_mask[db.core_sample_indices_] = True\n",
    "labels = db.labels_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**d)** Plot the Data with a scatter Plot and color labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "####################\n",
    "# Your Code Here   #\n",
    "####################"
   ]
  }
 ],
 "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.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}