project.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c4d872fc",
   "metadata": {},
   "source": [
    "# Implementations of the k-means clustering using Spark\n",
    "\n",
    "### Group 12:\n",
    "- Eugenio Fella\n",
    "- Matteo Pedrazzi\n",
    "- Gaetano Ricucci \n",
    "- Carlo Sgorlon Gaiatto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c87c0f61",
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import time\n",
    "import math\n",
    "import csv\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy import sparse as sp\n",
    "import matplotlib.pyplot as plt\n",
    "import sklearn\n",
    "from sklearn.datasets import fetch_rcv1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "851de006",
   "metadata": {},
   "outputs": [],
   "source": [
    "# set this variable with one of the following values:\n",
    "\n",
    "# 'cloud-veneto-cluster' -> Spark standalone cluster\n",
    "# 'docker-cluster' -> development Spark standalone cluster\n",
    "\n",
    "CLUSTER_TYPE = 'cloud-veneto-cluster'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a3a2c006",
   "metadata": {},
   "outputs": [],
   "source": [
    "if CLUSTER_TYPE == 'cloud-veneto-cluster':\n",
    "    \n",
    "    import findspark\n",
    "    \n",
    "    # add pyspark to sys.path runtime\n",
    "    findspark.init('/usr/local/spark')\n",
    "\n",
    "    import boto3\n",
    "    import urllib3\n",
    "\n",
    "    urllib3.disable_warnings()\n",
    "    \n",
    "    # establish a connection to Cloud-Veneto's Amazon S3 buckets with Boto3\n",
    "    s3 = boto3.client('s3',\n",
    "                     endpoint_url = 'https://cloud-areapd.pd.infn.it:5210',\n",
    "                     aws_access_key_id = '1d3f4d968ec14d53bcc4b8e6f6afd9e1',\n",
    "                     aws_secret_access_key = '***insert key***',\n",
    "                     verify = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "626b92d0",
   "metadata": {},
   "source": [
    "# Load compressed [RCV1 dataset](https://scikit-learn.org/stable/datasets/real_world.html#rcv1-dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d46967d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "rcv1 = fetch_rcv1(subset = 'all')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ce71a231",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RCV1 dataset attributes:\n",
      "\n",
      "       name:                                   class:           shape: \n",
      "\n",
      "        data   <class 'scipy.sparse._csr.csr_matrix'>  (804414, 47236)\n",
      "      target   <class 'scipy.sparse._csr.csr_matrix'>    (804414, 103)\n",
      "target_names                  <class 'numpy.ndarray'>           (103,)\n",
      "   sample_id                  <class 'numpy.ndarray'>        (804414,)\n"
     ]
    }
   ],
   "source": [
    "# attributes of rcv1 (dictionary-like object):\n",
    "# data         -> scipy CSR sparse matrix\n",
    "# target       -> scipy CSR sparse matrix\n",
    "# target_names -> numpy array\n",
    "# sample_id    -> numpy array\n",
    "\n",
    "attributes_rcv1 = ['data', 'target', 'target_names', 'sample_id']\n",
    "format_spec = '{:>12} {:>40} {:>16}'\n",
    "\n",
    "print('RCV1 dataset attributes:\\n')\n",
    "print(format_spec.format('name:', 'class:', 'shape:'), '\\n')\n",
    "\n",
    "for attribute in attributes_rcv1:\n",
    "    words = [attribute, type(getattr(rcv1, attribute)), getattr(rcv1, attribute).shape]\n",
    "    words = [str(w) for w in words]\n",
    "    print(format_spec.format(words[0], words[1], words[2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f4c6084b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data CSR sparse matrix attributes:\n",
      "\n",
      "     name:                    class:       shape:     size [Mb]: \n",
      "\n",
      "      data   <class 'numpy.ndarray'>  (60915113,)       487.3209\n",
      "   indices   <class 'numpy.ndarray'>  (60915113,)       243.6605\n",
      "    indptr   <class 'numpy.ndarray'>    (804415,)         3.2177\n",
      "\n",
      "\n",
      "\n",
      "target CSR sparse matrix attributes:\n",
      "\n",
      "     name:                    class:       shape:     size [Mb]: \n",
      "\n",
      "      data   <class 'numpy.ndarray'>   (2606875,)         2.6069\n",
      "   indices   <class 'numpy.ndarray'>   (2606875,)        10.4275\n",
      "    indptr   <class 'numpy.ndarray'>    (804415,)         3.2177\n"
     ]
    }
   ],
   "source": [
    "# attributes of scipy CSR sparse matrix (CSR = Compressed Sparse Row):\n",
    "# data    -> CSR format data array of the matrix\n",
    "# indices -> CSR format index array of the matrix\n",
    "# indptr  -> CSR format index pointer array of the matrix\n",
    "\n",
    "attributes_CSR = ['data', 'indices', 'indptr']\n",
    "format_spec = '{:>10} {:>25} {:>12} {:>14}'\n",
    "    \n",
    "for i in range(2):\n",
    "    \n",
    "    csr = getattr(rcv1, attributes_rcv1[i])\n",
    "    \n",
    "    if i == 1: print('\\n\\n')\n",
    "    print('{} CSR sparse matrix attributes:\\n'.format(attributes_rcv1[i]))\n",
    "    print(format_spec.format('name:', 'class:', 'shape:', 'size [Mb]:'), '\\n')\n",
    "\n",
    "    for attribute in attributes_CSR:\n",
    "\n",
    "        x = getattr(csr, attribute)\n",
    "        words = [attribute, type(x), x.shape, round(x.nbytes/10**6, 4)]\n",
    "        words = [str(w) for w in words]\n",
    "        print(format_spec.format(words[0], words[1], words[2], words[3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65257bfe",
   "metadata": {},
   "source": [
    "# Split compressed RCV1 dataset into chunks and save them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "df193418",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of selected documents: 512000\n"
     ]
    }
   ],
   "source": [
    "# define the number of rows for each chunk\n",
    "rows_per_chunk = 16000\n",
    "# define number of chunks\n",
    "n_chunk = 32\n",
    "# compute total number of selected documents \n",
    "tot_docs = rows_per_chunk*n_chunk\n",
    "print('number of selected documents:', tot_docs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "97c73669",
   "metadata": {},
   "outputs": [],
   "source": [
    "if CLUSTER_TYPE == 'cloud-veneto-cluster':\n",
    "\n",
    "    for i in range(n_chunk):\n",
    "\n",
    "        # save data CSR sparse matrix chunk\n",
    "        sp.save_npz('rcv1_dataset/data_{}.npz'.format(i),\n",
    "                    rcv1.data[rows_per_chunk*(i):rows_per_chunk*(i+1)],\n",
    "                    compressed = True)\n",
    "\n",
    "        # save target CSR sparse matrix chunk\n",
    "        sp.save_npz('rcv1_dataset/target_{}.npz'.format(i),\n",
    "                    rcv1.target[rows_per_chunk*(i):rows_per_chunk*(i+1)],\n",
    "                    compressed = True)\n",
    "\n",
    "        # upload chunks into 'mapd-gr12' Amazon S3 bucket\n",
    "        s3.upload_file('rcv1_dataset/data_{}.npz'.format(i), 'mapd-gr12', 'data_{}.npz'.format(i))\n",
    "        s3.upload_file('rcv1_dataset/target_{}.npz'.format(i), 'mapd-gr12', 'target_{}.npz'.format(i))  \n",
    "        \n",
    "elif CLUSTER_TYPE == 'docker-cluster':\n",
    "    \n",
    "    for i in range(n_chunk):\n",
    "    \n",
    "        # save data CSR sparse matrix chunk\n",
    "        sp.save_npz('rcv1_dataset/data_{}.npz'.format(i),\n",
    "                    rcv1.data[rows_per_chunk*(i):rows_per_chunk*(i+1)],\n",
    "                    compressed = True)\n",
    "\n",
    "        # save target CSR sparse matrix chunk\n",
    "        sp.save_npz('rcv1_dataset/target_{}.npz'.format(i),\n",
    "                    rcv1.target[rows_per_chunk*(i):rows_per_chunk*(i+1)],\n",
    "                    compressed = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "6ac6dfa1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data_0 CSR sparse matrix chunk attributes:\n",
      "\n",
      "     name:                    class:       shape:     size [Mb]: \n",
      "\n",
      "      data   <class 'numpy.ndarray'>   (1203897,)         9.6312\n",
      "   indices   <class 'numpy.ndarray'>   (1203897,)         4.8156\n",
      "    indptr   <class 'numpy.ndarray'>     (16001,)          0.064\n",
      "\n",
      "\n",
      "\n",
      "target_0 CSR sparse matrix chunk attributes:\n",
      "\n",
      "     name:                    class:       shape:     size [Mb]: \n",
      "\n",
      "      data   <class 'numpy.ndarray'>     (50731,)         0.0507\n",
      "   indices   <class 'numpy.ndarray'>     (50731,)         0.2029\n",
      "    indptr   <class 'numpy.ndarray'>     (16001,)          0.064\n"
     ]
    }
   ],
   "source": [
    "# inspect a single chunk\n",
    "format_spec = '{:>10} {:>25} {:>12} {:>14}'\n",
    "\n",
    "for i in range(2):\n",
    "    \n",
    "    # loading method\n",
    "    csr = sp.load_npz('rcv1_dataset/{}_0.npz'.format(attributes_rcv1[i]))\n",
    "    \n",
    "    if i == 1: print('\\n\\n')\n",
    "    print('{}_0 CSR sparse matrix chunk attributes:\\n'.format(attributes_rcv1[i]))\n",
    "    print(format_spec.format('name:', 'class:', 'shape:', 'size [Mb]:'), '\\n')\n",
    "\n",
    "    for attribute in attributes_CSR:\n",
    "\n",
    "        x = getattr(csr, attribute)\n",
    "        words = [attribute, type(x), x.shape, round(x.nbytes/10**6, 4)]\n",
    "        words = [str(w) for w in words]\n",
    "        print(format_spec.format(words[0], words[1], words[2], words[3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c58350bb",
   "metadata": {},
   "source": [
    "# Build the Spark session"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "fb1fbed0",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.sql import SparkSession\n",
    "from pyspark.sql import functions as F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "480fa675",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Setting default log level to \"WARN\".\n",
      "To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22/07/11 19:52:34 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "            <div>\n",
       "                <p><b>SparkSession - in-memory</b></p>\n",
       "                \n",
       "        <div>\n",
       "            <p><b>SparkContext</b></p>\n",
       "\n",
       "            <p><a href=\"http://10.67.22.104:4040\">Spark UI</a></p>\n",
       "\n",
       "            <dl>\n",
       "              <dt>Version</dt>\n",
       "                <dd><code>v3.3.0</code></dd>\n",
       "              <dt>Master</dt>\n",
       "                <dd><code>spark://master:7077</code></dd>\n",
       "              <dt>AppName</dt>\n",
       "                <dd><code>k_means_application</code></dd>\n",
       "            </dl>\n",
       "        </div>\n",
       "        \n",
       "            </div>\n",
       "        "
      ],
      "text/plain": [
       "<pyspark.sql.session.SparkSession at 0x7f70ae638940>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "if CLUSTER_TYPE == 'cloud-veneto-cluster':\n",
    "\n",
    "    spark = SparkSession.builder \\\n",
    "        .master('spark://master:7077')\\\n",
    "        .appName('k_means_application')\\\n",
    "        .config('spark.driver.host','10.67.22.104')\\\n",
    "        .config('spark.executor.memory', '1g')\\\n",
    "        .config('spark.executor.cores', '1')\\\n",
    "        .config('spark.default.parallelism', '32')\\\n",
    "        .getOrCreate()\n",
    "    \n",
    "elif CLUSTER_TYPE == 'docker-cluster':\n",
    "    \n",
    "    spark = SparkSession.builder \\\n",
    "        .master('spark://spark-master:7077')\\\n",
    "        .appName('k_means_application')\\\n",
    "        .config('spark.executor.memory', '512m')\\\n",
    "        .config('spark.executor.cores', '1')\\\n",
    "        .config('spark.default.parallelism', '2')\\\n",
    "        .getOrCreate()\n",
    "\n",
    "# get the SparkSession\n",
    "spark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "6b31b4e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <div>\n",
       "            <p><b>SparkContext</b></p>\n",
       "\n",
       "            <p><a href=\"http://10.67.22.104:4040\">Spark UI</a></p>\n",
       "\n",
       "            <dl>\n",
       "              <dt>Version</dt>\n",
       "                <dd><code>v3.3.0</code></dd>\n",
       "              <dt>Master</dt>\n",
       "                <dd><code>spark://master:7077</code></dd>\n",
       "              <dt>AppName</dt>\n",
       "                <dd><code>k_means_application</code></dd>\n",
       "            </dl>\n",
       "        </div>\n",
       "        "
      ],
      "text/plain": [
       "<SparkContext master=spark://master:7077 appName=k_means_application>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get the SparkContext\n",
    "sc = spark.sparkContext\n",
    "\n",
    "sc"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c47db3b1",
   "metadata": {},
   "source": [
    "# Read the files in parallel with Spark and select only one-label documents\n",
    "\n",
    "We only select one-label documents, as k-means clustering assigns each point to a single cluster. We have considered all sub-labels and not only the macro-labels, in order to have a larger number of clusters necessary to properly test the different execution times of the k-means++ and k-means|| initialization methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "b50a5ee1",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('data_0.npz', 'target_0.npz'),\n",
       " ('data_1.npz', 'target_1.npz'),\n",
       " ('data_2.npz', 'target_2.npz'),\n",
       " ('data_3.npz', 'target_3.npz'),\n",
       " ('data_4.npz', 'target_4.npz'),\n",
       " ('data_5.npz', 'target_5.npz'),\n",
       " ('data_6.npz', 'target_6.npz'),\n",
       " ('data_7.npz', 'target_7.npz'),\n",
       " ('data_8.npz', 'target_8.npz'),\n",
       " ('data_9.npz', 'target_9.npz'),\n",
       " ('data_10.npz', 'target_10.npz'),\n",
       " ('data_11.npz', 'target_11.npz'),\n",
       " ('data_12.npz', 'target_12.npz'),\n",
       " ('data_13.npz', 'target_13.npz'),\n",
       " ('data_14.npz', 'target_14.npz'),\n",
       " ('data_15.npz', 'target_15.npz'),\n",
       " ('data_16.npz', 'target_16.npz'),\n",
       " ('data_17.npz', 'target_17.npz'),\n",
       " ('data_18.npz', 'target_18.npz'),\n",
       " ('data_19.npz', 'target_19.npz'),\n",
       " ('data_20.npz', 'target_20.npz'),\n",
       " ('data_21.npz', 'target_21.npz'),\n",
       " ('data_22.npz', 'target_22.npz'),\n",
       " ('data_23.npz', 'target_23.npz'),\n",
       " ('data_24.npz', 'target_24.npz'),\n",
       " ('data_25.npz', 'target_25.npz'),\n",
       " ('data_26.npz', 'target_26.npz'),\n",
       " ('data_27.npz', 'target_27.npz'),\n",
       " ('data_28.npz', 'target_28.npz'),\n",
       " ('data_29.npz', 'target_29.npz'),\n",
       " ('data_30.npz', 'target_30.npz'),\n",
       " ('data_31.npz', 'target_31.npz')]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# creates a list of file names\n",
    "\n",
    "if CLUSTER_TYPE == 'cloud-veneto-cluster':\n",
    "\n",
    "    file_list = [('data_{}.npz'.format(i), 'target_{}.npz'.format(i)) for i in range(n_chunk)]\n",
    "    \n",
    "elif CLUSTER_TYPE == 'docker-cluster':\n",
    "    \n",
    "    files_path = '/opt/workspace/rcv1_dataset/'\n",
    "    file_list = [(files_path + 'data_{}.npz'.format(i),\n",
    "                  files_path + 'target_{}.npz'.format(i)) for i in range(n_chunk)]\n",
    "\n",
    "# parallelize the list of file names\n",
    "files_rdd = sc.parallelize(file_list)\n",
    "files_rdd.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e622fae0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the names of all possible labels (both macro and sub)\n",
    "target_names = rcv1.target_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "001722b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to download, load and read files in parallel with Spark\n",
    "# and perform an initial filter operation selecting only one-label documents\n",
    "\n",
    "if CLUSTER_TYPE == 'cloud-veneto-cluster':\n",
    "    \n",
    "    def parse_file(file, target_names):\n",
    "\n",
    "        # list of macro-labels\n",
    "        target_names_macro = ['CCAT', 'ECAT', 'GCAT', 'MCAT']  \n",
    "\n",
    "        s3 = boto3.client('s3',\n",
    "                     endpoint_url = 'https://cloud-areapd.pd.infn.it:5210',\n",
    "                     aws_access_key_id = '1d3f4d968ec14d53bcc4b8e6f6afd9e1',\n",
    "                     aws_secret_access_key = '***insert key***',\n",
    "                     verify = False)\n",
    "\n",
    "        # download files from s3\n",
    "        s3.download_file('mapd-gr12', file[0] ,'/home/Project/rcv1_dataset/' + file[0])\n",
    "        s3.download_file('mapd-gr12', file[1] ,'/home/Project/rcv1_dataset/' + file[1])\n",
    "\n",
    "        # load sparse matricies\n",
    "        data = sp.load_npz('/home/Project/rcv1_dataset/' + file[0])\n",
    "        target = sp.load_npz('/home/Project/rcv1_dataset/' + file[1])\n",
    "\n",
    "        # list of documents\n",
    "        rows = [] \n",
    "\n",
    "        # loop over documents in the chunk\n",
    "        for i in range(data.shape[0]):\n",
    "\n",
    "            # get indices of non-zero labels of the i-th document\n",
    "            indices = target.indices[target.indptr[i]:target.indptr[i+1]]\n",
    "\n",
    "            # check if there are only two labels\n",
    "            if len(indices) == 2:\n",
    "\n",
    "                # get the 2 labels of the i-th document\n",
    "                labels = [target_names[i] for i in indices]\n",
    "\n",
    "                # check if there is at least 1 macro-label AND\n",
    "                # check if both labels belong to the same macro-label\n",
    "                if (any(c in labels for c in target_names_macro) and len(set([c[0] for c in labels])) == 1):\n",
    "\n",
    "                    # select the sub-label\n",
    "                    label = [l for l in labels if l not in target_names_macro][0]\n",
    "\n",
    "                    # build a dictionary containing the non-zero features of the i-th document\n",
    "                    keys = [str(i) for i in data.indices[data.indptr[i]:data.indptr[i+1]]]\n",
    "                    values = data.data[data.indptr[i]:data.indptr[i+1]].tolist()\n",
    "                    features = dict(zip(keys, values))\n",
    "\n",
    "                    rows.append((label,features))           \n",
    "\n",
    "        return rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "297cd69b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to load and read files in parallel with Spark\n",
    "# and perform an initial filter operation selecting only one-label documents\n",
    "\n",
    "if CLUSTER_TYPE == 'docker-cluster':\n",
    "    \n",
    "    def parse_file(file, target_names):\n",
    "    \n",
    "        # list of macro-labels\n",
    "        target_names_macro = ['CCAT', 'ECAT', 'GCAT', 'MCAT']\n",
    "\n",
    "        # load sparse matricies\n",
    "        data = sp.load_npz(file[0])\n",
    "        target = sp.load_npz(file[1])\n",
    "\n",
    "        # list of documents\n",
    "        rows = [] \n",
    "\n",
    "        # loop over documents in the chunk\n",
    "        for i in range(data.shape[0]):\n",
    "\n",
    "            # get indices of non-zero labels of the i-th document\n",
    "            indices = target.indices[target.indptr[i]:target.indptr[i+1]]\n",
    "\n",
    "            # check if there are only two labels\n",
    "            if len(indices) == 2:\n",
    "\n",
    "                # get the 2 labels of the i-th document\n",
    "                labels = [target_names[i] for i in indices]\n",
    "\n",
    "                # check if there is at least 1 macro-label AND\n",
    "                # check if both labels belong to the same macro-label\n",
    "                if (any(c in labels for c in target_names_macro) and len(set([c[0] for c in labels])) == 1):\n",
    "\n",
    "                    # select the sub-label\n",
    "                    label = [l for l in labels if l not in target_names_macro][0]\n",
    "\n",
    "                    # build a dictionary containing the non-zero features of the i-th document\n",
    "                    keys = [str(i) for i in data.indices[data.indptr[i]:data.indptr[i+1]]]\n",
    "                    values = data.data[data.indptr[i]:data.indptr[i+1]].tolist()\n",
    "                    features = dict(zip(keys, values))\n",
    "\n",
    "                    rows.append((label,features))           \n",
    "\n",
    "        return rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "9e075b2d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "size of a parse chunk: 14.98 Mb\n"
     ]
    }
   ],
   "source": [
    "# get the size of a parse chunk\n",
    "parse_chunk = parse_file(file_list[0], target_names)\n",
    "parse_chunk_size = 0\n",
    "\n",
    "for i in range(len(parse_chunk)):\n",
    "    parse_chunk_size += sys.getsizeof(parse_chunk[i][0]) + sys.getsizeof(parse_chunk[i][1])\n",
    "\n",
    "print('size of a parse chunk:', round(parse_chunk_size/10**6, 2), 'Mb')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "0c353df8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# persist tha dataset in memory\n",
    "data_rdd = files_rdd.flatMap(lambda file: parse_file(file, target_names)).persist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "2d6a26d0",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of documents in the loaded dataset: 512000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Stage 1:==============================================>          (26 + 6) / 32]\r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of one-label documents in the loaded dataset: 131844\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "[Stage 1:================================================>        (27 + 5) / 32]\r",
      "\r",
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "# trigger the caching\n",
    "print('number of documents in the loaded dataset:', rows_per_chunk*n_chunk)\n",
    "print('number of one-label documents in the loaded dataset:', data_rdd.count())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ab048b3",
   "metadata": {},
   "source": [
    "# Visualize clusters population"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "089f530e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Clusters information:\n",
      "\n",
      "  macro-label:    number of sub-labels:      population: \n",
      "\n",
      "          CCAT                       18            31774\n",
      "          ECAT                       10             8233\n",
      "          GCAT                       21            56235\n",
      "          MCAT                        4            35602\n",
      "\n",
      "                                  total:           total:\n",
      "                                     53           131844\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1526.4x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def visualize_clusters_pop(labels_dict):\n",
    "    \n",
    "    macros = ['CCAT', 'ECAT', 'GCAT', 'MCAT']    \n",
    "    colors = ['tab:blue', 'tab:red', 'tab:green', 'tab:orange']\n",
    "    \n",
    "    keys = []\n",
    "    values = []\n",
    "    color_list = []\n",
    "    \n",
    "    format_spec = '{:>14} {:>24} {:>16}'\n",
    "    \n",
    "    print('Clusters information:\\n')\n",
    "    print(format_spec.format('macro-label:', 'number of sub-labels:', 'population:'), '\\n')\n",
    "    \n",
    "    # get population of each sub-label sorted by values and grouped by macro-label\n",
    "    for i, macro in enumerate(macros):\n",
    "\n",
    "        # create a sorted dictionary of sub-labels belonging to the same macro-label\n",
    "        d = dict([(key, labels_dict[key]) for key in labels_dict.keys() if key[0] == macro[0]])\n",
    "        d = dict(sorted(d.items(), key = lambda item: -item[1]))\n",
    "\n",
    "        keys += [*d]\n",
    "        values += [*d.values()] \n",
    "        color_list += [colors[i]]*len(d)\n",
    "\n",
    "        print(format_spec.format(macro, str(len(d)), str(np.sum([*d.values()]))))\n",
    "\n",
    "    print('\\n', format_spec.format('', 'total:', 'total:'))\n",
    "    print(format_spec.format('', str(len(values)), str(np.sum(values))))\n",
    "\n",
    "    # plot\n",
    "    fig, ax = plt.subplots(figsize = (0.4*len(values),6))\n",
    "    ax.bar(keys, values, color = color_list)\n",
    "    ax.set_xlabel('cluster', fontsize = 14)\n",
    "    ax.set_ylabel('population', fontsize = 14)\n",
    "    plt.xticks(fontsize = 12, rotation = 45)\n",
    "    plt.yticks(fontsize = 12)\n",
    "    plt.show()\n",
    "        \n",
    "clusters_dict = data_rdd.countByKey()\n",
    "visualize_clusters_pop(clusters_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bee1479",
   "metadata": {},
   "source": [
    "# Clusters filter\n",
    "\n",
    "We only select clusters with nearly homogeneous populations, as k-means clustering requires clusters to be of similar size in order to work properly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "ad59908b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of selected clusters:  11 \n",
      "\n",
      "['M12', 'C31', 'GPOL', 'GVIO', 'GDIP', 'C24', 'C33', 'C11', 'GCRIM', 'C21', 'E71']\n"
     ]
    }
   ],
   "source": [
    "# sort the dictionary containing the population of each cluster\n",
    "clusters_dict = {k: clusters_dict[k] for k in sorted(clusters_dict, key = clusters_dict.get, reverse = True)}\n",
    "\n",
    "# get population of each cluster\n",
    "clusters_pop = np.array([*clusters_dict.values()]) \n",
    "\n",
    "# define thresholds to select only clusters with homogeneous populations\n",
    "threshold_high = 0.125*np.sum(clusters_pop)\n",
    "threshold_low = 0.0225*np.sum(clusters_pop)\n",
    "\n",
    "# get filtered clusters\n",
    "filter_index_high = np.max(np.where(clusters_pop > threshold_high)) + 1\n",
    "filter_index_low = np.max(np.where(clusters_pop > threshold_low)) + 1\n",
    "filtered_clusters = [*clusters_dict][filter_index_high:filter_index_low]\n",
    "\n",
    "print('Number of selected clusters: ', filter_index_low - filter_index_high, '\\n')\n",
    "print(filtered_clusters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "fe06fc8d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Clusters information:\n",
      "\n",
      "  macro-label:    number of sub-labels:      population: \n",
      "\n",
      "          CCAT                        5            25796\n",
      "          ECAT                        1             3273\n",
      "          GCAT                        4            25895\n",
      "          MCAT                        1             9017\n",
      "\n",
      "                                  total:           total:\n",
      "                                     11            63981\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 316.8x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# filter the RDD\n",
    "filtered_clusters_dict = data_rdd \\\n",
    "                    .filter(lambda el: el[0] in filtered_clusters) \\\n",
    "                    .countByKey()\n",
    "\n",
    "visualize_clusters_pop(filtered_clusters_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "8d641dcf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# fix the number of clusters\n",
    "k = len(filtered_clusters_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4885e43",
   "metadata": {},
   "source": [
    "# Features filter\n",
    "The data features are represented by cosine-normalized, log TF-IDF vectors. Therefore we can reduce the dimensionality of the points by aggregating the features using the sum operation and selecting only the most important ones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "454315ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to sum the values of two dictionaries by keys\n",
    "def sum_dictionary(el1, el2):\n",
    "    \n",
    "    dict_sum = {key: el1.get(key, 0) + el2.get(key, 0) for key in set([*el1]+[*el2])}\n",
    "    \n",
    "    # return a tuple as rdd element\n",
    "    return ('total', dict_sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "731c29f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "# create a sorted dictionary of the aggregated features\n",
    "features_dict = data_rdd \\\n",
    "            .filter(lambda el: el[0] in filtered_clusters) \\\n",
    "            .reduce(lambda el1, el2: sum_dictionary(el1[1], el2[1]))[1]\n",
    "\n",
    "features_dict = {key: features_dict[key] for key in sorted(features_dict, key = features_dict.get, reverse = True)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "0dbc23aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of selected features: 920\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# compute the cumulative sum\n",
    "cumsum_features_dict = np.cumsum([*features_dict.values()])\n",
    "\n",
    "# define a threshold to select only a fraction of the features\n",
    "threshold = 0.5*cumsum_features_dict[-1]\n",
    "\n",
    "# get filtered features\n",
    "filter_index = np.min(np.where(cumsum_features_dict > threshold))\n",
    "filtered_features = [*features_dict][:filter_index]\n",
    "print('number of selected features:', filter_index)\n",
    "\n",
    "# plot\n",
    "fig, ax = plt.subplots(figsize=(10,6))\n",
    "ax.plot(range(len(features_dict)), features_dict.values(), lw = 2, label = 'importance')\n",
    "ax.axvline(x = filter_index, color = 'tab:red', ls = '--', lw = 2, label = 'threshold')\n",
    "ax.set_xlabel('feature', fontsize = 14)\n",
    "ax.set_ylabel('feature importance', fontsize = 14)\n",
    "plt.xticks(fontsize = 12)\n",
    "plt.yticks(fontsize = 12)\n",
    "plt.legend(fontsize = 14)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "07fb68ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to remove not selected features\n",
    "def filter_features(el, filtered_keys):\n",
    "    \n",
    "    filtered_dict = {key: el[key] for key in filtered_keys if key in el}\n",
    "    \n",
    "    return filtered_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "e2b591f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "[Stage 5:============================================>            (25 + 7) / 32]\r",
      "\r",
      "                                                                                \r"
     ]
    },
    {
     "data": {
      "text/plain": [
       "63981"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# persist the dataset in memory after the clusters and features filters\n",
    "data_rdd_filtered = data_rdd \\\n",
    "                .filter(lambda el: el[0] in filtered_clusters) \\\n",
    "                .mapValues(lambda el: filter_features(el, filtered_features)) \\\n",
    "                .persist()\n",
    "\n",
    "# trigger the caching\n",
    "data_rdd_filtered.count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "cc7c75a5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PythonRDD[1] at RDD at PythonRDD.scala:53"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# free up memory\n",
    "data_rdd.unpersist()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c6d3125",
   "metadata": {},
   "source": [
    "# K-means clustering\n",
    "\n",
    "In this section, we define some UDFs that we are going to use in the implementation of the k-means clustering algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "9deae4c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to assign each point to a cluster\n",
    "def assign_cluster(el, C):\n",
    "    \n",
    "    # compute the squared distance using the first centroid\n",
    "    d2_dict = {key: (el.get(key, 0) - C[0].get(key, 0))**2 for key in set([*el]+[*C[0]])}\n",
    "    d2_min = np.sum([*d2_dict.values()])      \n",
    "    cluster_ID = str(0)\n",
    "\n",
    "    # loop over the remaining k - 1 centroids\n",
    "    for k in range(1, len(C)):\n",
    "        d2_dict = {key: (el.get(key, 0) - C[k].get(key, 0))**2 for key in set([*el]+[*C[k]])}\n",
    "        d2 = np.sum([*d2_dict.values()])\n",
    "        \n",
    "        # update the minimum squared distance \n",
    "        if d2 < d2_min:\n",
    "            d2_min = d2\n",
    "            cluster_ID = str(k)\n",
    "               \n",
    "    return (cluster_ID, el)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "fe3734c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to sum sparse dictionaries\n",
    "def sum_points(el1, el2):\n",
    "    dict_sum = {key: el1.get(key,0) + el2.get(key,0) for key in set([*el1]+[*el2])}    \n",
    "    return dict_sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "6f9f27ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to compute centroids given labelled documents \n",
    "def compute_centroids(el, pop_clusters):\n",
    "    \n",
    "    cluster_ID = el[0]\n",
    "    pop = pop_clusters[cluster_ID]\n",
    "    \n",
    "    keys = [*el[1]]\n",
    "    values = [v/pop for v in [*el[1].values()]]\n",
    "    \n",
    "    return (cluster_ID, dict(zip(keys, values)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "c27c9bdd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to calculate the squared distance to the nearest centroid\n",
    "def compute_d2(el, C):\n",
    "    \n",
    "    # compute the squared distance using the first centroid\n",
    "    d2_dict = {key: (el.get(key, 0) - C[0].get(key, 0))**2 for key in set([*el]+[*C[0]])}\n",
    "    d2_min = np.sum([*d2_dict.values()])      \n",
    "\n",
    "    # loop over the remaining k - 1 centroids\n",
    "    for k in range(1, len(C)):\n",
    "        d2_dict = {key: (el.get(key, 0) - C[k].get(key, 0))**2 for key in set([*el]+[*C[k]])}\n",
    "        d2 = np.sum([*d2_dict.values()])\n",
    "        \n",
    "        # update the minimum squared distance\n",
    "        if d2 < d2_min:\n",
    "            d2_min = d2\n",
    "            \n",
    "    return d2_min"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b0d4f15",
   "metadata": {},
   "source": [
    "# Baseline cost\n",
    "We compute the cost function using the human assigned labels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "f79c36d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_base_cost(label, el, C):\n",
    "    \n",
    "    c = [c[1] for c in C if c[0] == label][0]\n",
    "    d2_dict = {key: (el.get(key, 0) - c[key])**2 for key in [*c]}\n",
    "    d2 = np.sum([*d2_dict.values()])      \n",
    "            \n",
    "    return d2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "7cb51961",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "C_base = data_rdd_filtered \\\n",
    "        .reduceByKey(lambda el1, el2: sum_points(el1, el2)) \\\n",
    "        .map(lambda el: compute_centroids(el, filtered_clusters_dict)) \\\n",
    "        .collect()\n",
    "\n",
    "base_cost = data_rdd_filtered \\\n",
    "        .map(lambda el: compute_base_cost(el[0], el[1], C_base)) \\\n",
    "        .reduce(lambda x, y: x + y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "306bf359",
   "metadata": {},
   "source": [
    "# Naive (Forgy) initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "62fdb72d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def naive_init(k, data_rdd, seed):\n",
    "    \n",
    "    print('naive initialization started ...')\n",
    "    \n",
    "    # select k cetroids uniformly at random at once\n",
    "    C = data_rdd.takeSample(False, k, seed) # return a list with k tuples\n",
    "    C = [c[1] for c in C]\n",
    "    \n",
    "    return C"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "000afdca",
   "metadata": {},
   "source": [
    "# K-means++ initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "74c64c97",
   "metadata": {},
   "outputs": [],
   "source": [
    "def k_means_pp_init(k, data_rdd, seed, verbose = 0):\n",
    "    \n",
    "    print('k-means ++ initialization started ...')\n",
    "    if verbose == 1: print('')\n",
    "       \n",
    "    np.random.seed(seed)\n",
    "    \n",
    "    # centroids list\n",
    "    C = []\n",
    "    \n",
    "    # select first centroid uniformly at random\n",
    "    c = data_rdd.takeSample(False, 1, seed) # return a list with 1 tuple\n",
    "    C.append(c[0][1])\n",
    "    \n",
    "    # select the remaining k-1 centroids\n",
    "    for i in range(k-1):\n",
    "        \n",
    "        if verbose == 1: print('iteration:', i+1)\n",
    "          \n",
    "        # persist the dataset in memory after computing the squared distance\n",
    "        data_rdd_cached = data_rdd \\\n",
    "                        .map(lambda el: (compute_d2(el[1], C), el[1])) \\\n",
    "                        .persist()\n",
    "        \n",
    "        # compute cost and trigger the caching\n",
    "        cost = data_rdd_cached \\\n",
    "            .reduce(lambda x, y: (x[0] + y[0], ''))[0]\n",
    "        \n",
    "        # weighted sampling\n",
    "        c = data_rdd_cached \\\n",
    "            .map(lambda el: (True, el[1]) if np.random.uniform(size = 1) < el[0]/cost else (False, el[1])) \\\n",
    "            .filter(lambda el: el[0]) \\\n",
    "            .takeSample(False, 1, seed) # return a list with at most 1 tuple\n",
    "        \n",
    "        if len(c) == 0:\n",
    "            \n",
    "            if verbose == 1: print('-> failed weighted sampling: take highest probabilty')\n",
    "            \n",
    "            # get centroid with the highest probabilty (unnormalized)\n",
    "            c = data_rdd_cached \\\n",
    "                .reduce(lambda el1, el2: el1 if (el1[0] >= el2[0]) else el2) # return 1 tuple\n",
    "            \n",
    "            C.append(c[1])\n",
    "            \n",
    "        else:\n",
    "            \n",
    "            C.append(c[0][1]) \n",
    "            \n",
    "        # free up memory\n",
    "        data_rdd_cached.unpersist()\n",
    "                \n",
    "    return C"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9695fe4f",
   "metadata": {},
   "source": [
    "# K-means|| initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "67087323",
   "metadata": {},
   "outputs": [],
   "source": [
    "def k_means_ll_init(k, data_rdd, seed, l = 2, t = 5, verbose = 0):\n",
    "    \n",
    "    print('k-means || initialization started ...')\n",
    "    \n",
    "    np.random.seed(seed)\n",
    "    \n",
    "    # centroids list\n",
    "    C = []\n",
    "    \n",
    "    # select first centroid uniformly at random\n",
    "    c = data_rdd.takeSample(False, 1, seed) # return a list with 1 tuple\n",
    "    C.append(c[0][1])\n",
    "    \n",
    "    # compute cost\n",
    "    cost = data_rdd.map(lambda el: compute_d2(el[1], C)) \\\n",
    "        .reduce(lambda x, y: x + y)\n",
    "    \n",
    "    #t = math.floor(math.log(cost))\n",
    "    if verbose == 1: print('\\ntheoretical number of iterations:', math.floor(math.log(cost)), '\\n')\n",
    "      \n",
    "    for i in range(t):\n",
    "        \n",
    "        if verbose == 1: print('iteration:', i+1)\n",
    "            \n",
    "        # persist the dataset in memory after computing the squared distance\n",
    "        data_rdd_cached = data_rdd \\\n",
    "                        .map(lambda el: (compute_d2(el[1], C), el[1])) \\\n",
    "                        .persist()\n",
    "        \n",
    "        if i != 0:\n",
    "            # compute cost and trigger the caching\n",
    "            cost = data_rdd_cached \\\n",
    "                .reduce(lambda x, y: (x[0] + y[0], ''))[0]\n",
    "\n",
    "        #  compute normalize probs and multiply by the oversampling factor\n",
    "        #  weighted sampling\n",
    "        #  get new centroids       \n",
    "        rows = data_rdd_cached \\\n",
    "            .map(lambda el: (True, el[1]) if np.random.uniform(size = 1) < l*el[0]/cost else (False, el[1])) \\\n",
    "            .filter(lambda el: el[0]) \\\n",
    "            .collect() # return a list with a variable number of tuples\n",
    "        \n",
    "        c_list = [row[1] for row in rows]\n",
    "        C += c_list     \n",
    "\n",
    "        if verbose == 1: print('-> number of selected centroids:', len(c_list))\n",
    "            \n",
    "        # free up memory\n",
    "        data_rdd_cached.unpersist()\n",
    "        \n",
    "    if verbose == 1: print('\\ntotal number of centroids:', len(C))\n",
    "    \n",
    "    if len(C) > k:\n",
    "        \n",
    "        print('\\nre-clustering started ...\\n')\n",
    "        \n",
    "        # select k centroids from C using k-means ++\n",
    "        C_rdd = sc.parallelize([('', c) for c in C])\n",
    "        C = k_means_pp_init(k, C_rdd, seed, 0)\n",
    "        \n",
    "        if verbose == 1: print('\\ntotal number of centroids after re-clustering:', len(C))\n",
    "           \n",
    "    return C"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92837256",
   "metadata": {},
   "source": [
    "# Lloyd's algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "28168798",
   "metadata": {},
   "outputs": [],
   "source": [
    "def lloyd_algorithm(data_rdd, C, cost_list, t):\n",
    "    \n",
    "    print(\"Lloyd's algorithm started ...\\n\")\n",
    "    \n",
    "    # compute initialization cost\n",
    "    cost = data_rdd \\\n",
    "        .map(lambda el: compute_d2(el[1], C)) \\\n",
    "        .reduce(lambda x, y: x + y)\n",
    "    \n",
    "    cost_list.append(cost)\n",
    "    \n",
    "    print('cost (init):', np.round(cost, 2), '\\n')\n",
    "    \n",
    "    for i in range(t):\n",
    "        \n",
    "        # persist the dataset in memory after cluster assignment\n",
    "        data_rdd_cached = data_rdd \\\n",
    "                        .map(lambda el: assign_cluster(el[1], C)) \\\n",
    "                        .persist()\n",
    "\n",
    "        # compute clusters population and trigger caching \n",
    "        pop_clusters = data_rdd_cached.countByKey()\n",
    "\n",
    "        # compute new centroids\n",
    "        C = data_rdd_cached \\\n",
    "            .reduceByKey(lambda el1, el2: sum_points(el1, el2)) \\\n",
    "            .map(lambda el: compute_centroids(el, pop_clusters)) \\\n",
    "            .values() \\\n",
    "            .collect()\n",
    "        \n",
    "        # compute new cost\n",
    "        cost_best = data_rdd \\\n",
    "                .map(lambda el: compute_d2(el[1], C)) \\\n",
    "                .reduce(lambda x, y: x + y)\n",
    "        \n",
    "        cost_list.append(cost_best)\n",
    "        \n",
    "        # free up memory\n",
    "        data_rdd_cached.unpersist()\n",
    "\n",
    "        print('iteration:', i+1)\n",
    "        print('cost:', np.round(cost_best, 2))\n",
    "        print('reduction:', np.round(100*(cost - cost_best)/cost, 3), '%\\n')\n",
    "        \n",
    "        cost = cost_best\n",
    "        \n",
    "    return C, cost_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8ec7a2f",
   "metadata": {},
   "source": [
    "# Run k-means clustering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "1bd48cec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of clusters: 11\n"
     ]
    }
   ],
   "source": [
    "print('number of clusters:', k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "6364b4a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k-means || initialization started ...\n",
      "\n",
      "theoretical number of iterations: 10 \n",
      "\n",
      "iteration: 1\n",
      "-> number of selected centroids: 4\n",
      "iteration: 2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> number of selected centroids: 2\n",
      "iteration: 3\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> number of selected centroids: 4\n",
      "iteration: 4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> number of selected centroids: 6\n",
      "\n",
      "total number of centroids: 17\n",
      "\n",
      "re-clustering started ...\n",
      "\n",
      "k-means ++ initialization started ...\n",
      "\n",
      "total number of centroids after re-clustering: 11\n",
      "\n",
      "initialization time: 13.84 s\n"
     ]
    }
   ],
   "source": [
    "# set this variable with one of the following values:\n",
    "\n",
    "# 'naive'      -> naive (Forgy) initialization\n",
    "# 'k-means-pp' -> k-means++ initialization\n",
    "# 'k-means-ll' -> k-means|| initialization\n",
    "\n",
    "init_method = 'k-means-ll'\n",
    "\n",
    "# initial centroids\n",
    "C = []\n",
    "\n",
    "start_time = time.time()\n",
    "\n",
    "if init_method == 'naive':\n",
    "    C = naive_init(k, data_rdd_filtered, seed = 54321)\n",
    "    \n",
    "elif init_method == 'k-means-pp':\n",
    "    C = k_means_pp_init(k, data_rdd_filtered, seed = 54321, verbose = 1)\n",
    "    \n",
    "elif init_method == 'k-means-ll':\n",
    "    C = k_means_ll_init(k, data_rdd_filtered, seed = 54321, l = 3, t = 4, verbose = 1)\n",
    "    if len(C) != k:\n",
    "        print('ERROR: increase the oversampling factor l or the number of iterations t')\n",
    "\n",
    "end_time = time.time()\n",
    "\n",
    "t_init = end_time - start_time\n",
    "\n",
    "print('\\ninitialization time: {} s'.format(str(round(t_init, 2))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "00341f4e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cost (base): 20587.19\n"
     ]
    }
   ],
   "source": [
    "cost_list = [base_cost]\n",
    "print('cost (base):', round(cost_list[0], 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "c3607133",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lloyd's algorithm started ...\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cost (init): 34886.88 \n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 1\n",
      "cost: 20696.4\n",
      "reduction: 40.676 %\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 2\n",
      "cost: 20258.74\n",
      "reduction: 2.115 %\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 3\n",
      "cost: 20164.2\n",
      "reduction: 0.467 %\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 4\n",
      "cost: 20136.23\n",
      "reduction: 0.139 %\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 5\n",
      "cost: 20128.35\n",
      "reduction: 0.039 %\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 6\n",
      "cost: 20122.91\n",
      "reduction: 0.027 %\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 7\n",
      "cost: 20115.6\n",
      "reduction: 0.036 %\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 8\n",
      "cost: 20110.92\n",
      "reduction: 0.023 %\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 9\n",
      "cost: 20107.61\n",
      "reduction: 0.016 %\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 10\n",
      "cost: 20104.18\n",
      "reduction: 0.017 %\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 11\n",
      "cost: 20100.41\n",
      "reduction: 0.019 %\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 12\n",
      "cost: 20095.64\n",
      "reduction: 0.024 %\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 13\n",
      "cost: 20089.02\n",
      "reduction: 0.033 %\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 14\n",
      "cost: 20081.91\n",
      "reduction: 0.035 %\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 15\n",
      "cost: 20076.09\n",
      "reduction: 0.029 %\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 16\n",
      "cost: 20069.58\n",
      "reduction: 0.032 %\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 17\n",
      "cost: 20062.5\n",
      "reduction: 0.035 %\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 18\n",
      "cost: 20048.16\n",
      "reduction: 0.071 %\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 19\n",
      "cost: 20027.93\n",
      "reduction: 0.101 %\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 20\n",
      "cost: 20021.68\n",
      "reduction: 0.031 %\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 21\n",
      "cost: 20014.63\n",
      "reduction: 0.035 %\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 22\n",
      "cost: 20002.45\n",
      "reduction: 0.061 %\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 23\n",
      "cost: 19975.67\n",
      "reduction: 0.134 %\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Stage 246:=====================================================> (31 + 1) / 32]\r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 24\n",
      "cost: 19958.09\n",
      "reduction: 0.088 %\n",
      "\n",
      "Lloyd’s algorithm time: 822.8 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "                                                                                \r"
     ]
    }
   ],
   "source": [
    "start_time = time.time()\n",
    "\n",
    "C, cost_list = lloyd_algorithm(data_rdd_filtered, C, cost_list, t = 24)\n",
    "\n",
    "end_time = time.time()\n",
    "\n",
    "t_lloyd = end_time - start_time\n",
    "\n",
    "print('Lloyd’s algorithm time: {} s'.format(str(round(t_lloyd, 2))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "0fe5dd49",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total time: 836.64 s\n"
     ]
    }
   ],
   "source": [
    "print('total time: {} s'.format(str(round(t_init + t_lloyd, 2))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "6711e8fe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PythonRDD[6] at RDD at PythonRDD.scala:53"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# free up memory\n",
    "data_rdd_filtered.unpersist()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f7e5bcf",
   "metadata": {},
   "source": [
    "# Deleting files local and on cloud"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "54f7eba0",
   "metadata": {},
   "outputs": [],
   "source": [
    "if CLUSTER_TYPE == 'cloud-veneto-cluster':\n",
    "\n",
    "    import subprocess\n",
    "\n",
    "    # delete files on all nodes\n",
    "    def deleting(dummy):\n",
    "        subprocess.call('rm /home/Project/rcv1_dataset/*', shell = True)\n",
    "    \n",
    "    files_rdd.map(lambda file: deleting(file)).count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "99e37a3d",
   "metadata": {},
   "outputs": [],
   "source": [
    "if CLUSTER_TYPE == 'cloud-veneto-cluster':\n",
    "\n",
    "    # delete files on cloud\n",
    "    for i in range(n_chunk):\n",
    "        s3.delete_object(Bucket = 'mapd-gr12', Key = 'data_{}.npz'.format(i))\n",
    "        s3.delete_object(Bucket = 'mapd-gr12', Key = 'target_{}.npz'.format(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "21d2facd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# stop the running Spark context\n",
    "sc.stop()\n",
    "# stop the running Spark session\n",
    "spark.stop()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82936801",
   "metadata": {},
   "source": [
    "# Compare the perfomances with different initializations: cost function\n",
    "The dataset we used for this comparison consisted of 32 chunks of 16000 documents each, divided into 32 partitions, while the Spark cluster consisted of 16 executors, each with 1 core and 1 Gb of memory. From the graph below, it can be seen that the k-means algorithm with naive initialization requires more iterations to reach an arbitrarily set threshold of the cost function than the cases with the k-means++ and k-means|| (l = 3, t = 4) initialization methods. This trend occurred in numerous runs with similar settings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "db75bcc3",
   "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>naive</th>\n",
       "      <th>naive-sd</th>\n",
       "      <th>k-means-pp</th>\n",
       "      <th>k-means-pp-sd</th>\n",
       "      <th>k-means-ll</th>\n",
       "      <th>k-means-ll-sd</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>21621.568246</td>\n",
       "      <td>107.701496</td>\n",
       "      <td>21194.974679</td>\n",
       "      <td>189.677276</td>\n",
       "      <td>20959.947254</td>\n",
       "      <td>148.843565</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>21313.057030</td>\n",
       "      <td>169.047862</td>\n",
       "      <td>20846.444500</td>\n",
       "      <td>183.588199</td>\n",
       "      <td>20623.872912</td>\n",
       "      <td>85.181279</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>21039.884562</td>\n",
       "      <td>196.106464</td>\n",
       "      <td>20671.651555</td>\n",
       "      <td>170.821388</td>\n",
       "      <td>20509.362809</td>\n",
       "      <td>82.038404</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>20873.407304</td>\n",
       "      <td>155.979689</td>\n",
       "      <td>20527.084504</td>\n",
       "      <td>129.289452</td>\n",
       "      <td>20439.111224</td>\n",
       "      <td>85.296591</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>20713.737788</td>\n",
       "      <td>91.131274</td>\n",
       "      <td>20434.448000</td>\n",
       "      <td>98.783586</td>\n",
       "      <td>20388.429906</td>\n",
       "      <td>88.272097</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>20573.869696</td>\n",
       "      <td>42.564499</td>\n",
       "      <td>20386.801324</td>\n",
       "      <td>89.965727</td>\n",
       "      <td>20342.726350</td>\n",
       "      <td>95.222002</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>20488.955174</td>\n",
       "      <td>60.035752</td>\n",
       "      <td>20352.090197</td>\n",
       "      <td>90.486223</td>\n",
       "      <td>20312.624664</td>\n",
       "      <td>91.858481</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>20432.717001</td>\n",
       "      <td>46.411574</td>\n",
       "      <td>20333.609169</td>\n",
       "      <td>89.769043</td>\n",
       "      <td>20261.867688</td>\n",
       "      <td>74.121141</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>20380.052730</td>\n",
       "      <td>32.510651</td>\n",
       "      <td>20305.346423</td>\n",
       "      <td>71.257114</td>\n",
       "      <td>20180.452973</td>\n",
       "      <td>47.365097</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>20352.289887</td>\n",
       "      <td>33.619964</td>\n",
       "      <td>20207.505908</td>\n",
       "      <td>8.785963</td>\n",
       "      <td>20133.480763</td>\n",
       "      <td>41.489084</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>20329.740271</td>\n",
       "      <td>32.542310</td>\n",
       "      <td>20169.984125</td>\n",
       "      <td>22.904995</td>\n",
       "      <td>20104.554484</td>\n",
       "      <td>48.620923</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>20315.229490</td>\n",
       "      <td>27.135065</td>\n",
       "      <td>20155.124817</td>\n",
       "      <td>19.812111</td>\n",
       "      <td>20094.171829</td>\n",
       "      <td>52.325066</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>20309.711671</td>\n",
       "      <td>25.597925</td>\n",
       "      <td>20139.626688</td>\n",
       "      <td>21.051094</td>\n",
       "      <td>20082.122586</td>\n",
       "      <td>46.621208</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>20304.921871</td>\n",
       "      <td>24.824264</td>\n",
       "      <td>20132.773272</td>\n",
       "      <td>23.714215</td>\n",
       "      <td>20070.798255</td>\n",
       "      <td>40.580056</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>20299.635294</td>\n",
       "      <td>23.824228</td>\n",
       "      <td>20128.758584</td>\n",
       "      <td>25.691809</td>\n",
       "      <td>20050.260704</td>\n",
       "      <td>29.433343</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>20292.617018</td>\n",
       "      <td>21.036244</td>\n",
       "      <td>20128.094448</td>\n",
       "      <td>26.009985</td>\n",
       "      <td>19993.692311</td>\n",
       "      <td>16.575117</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>20282.944056</td>\n",
       "      <td>14.880087</td>\n",
       "      <td>20128.034752</td>\n",
       "      <td>26.008217</td>\n",
       "      <td>19975.951032</td>\n",
       "      <td>23.989939</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>20272.293209</td>\n",
       "      <td>9.751680</td>\n",
       "      <td>20127.998354</td>\n",
       "      <td>26.002550</td>\n",
       "      <td>19970.807770</td>\n",
       "      <td>22.578655</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>20249.977637</td>\n",
       "      <td>16.983281</td>\n",
       "      <td>20127.978002</td>\n",
       "      <td>25.998207</td>\n",
       "      <td>19966.413811</td>\n",
       "      <td>20.284228</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>20229.557888</td>\n",
       "      <td>32.159379</td>\n",
       "      <td>20127.962462</td>\n",
       "      <td>25.995101</td>\n",
       "      <td>19961.069546</td>\n",
       "      <td>18.689290</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>20225.416874</td>\n",
       "      <td>35.279180</td>\n",
       "      <td>20127.950532</td>\n",
       "      <td>25.993057</td>\n",
       "      <td>19955.994538</td>\n",
       "      <td>16.131110</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>20223.621703</td>\n",
       "      <td>36.594841</td>\n",
       "      <td>20127.942565</td>\n",
       "      <td>25.992428</td>\n",
       "      <td>19951.349793</td>\n",
       "      <td>14.165431</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>20222.300096</td>\n",
       "      <td>37.529952</td>\n",
       "      <td>20127.938776</td>\n",
       "      <td>25.992589</td>\n",
       "      <td>19947.030088</td>\n",
       "      <td>12.636293</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25</th>\n",
       "      <td>20221.389621</td>\n",
       "      <td>38.112304</td>\n",
       "      <td>20127.937234</td>\n",
       "      <td>25.992654</td>\n",
       "      <td>19941.875224</td>\n",
       "      <td>11.324545</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           naive    naive-sd    k-means-pp  k-means-pp-sd    k-means-ll  \\\n",
       "2   21621.568246  107.701496  21194.974679     189.677276  20959.947254   \n",
       "3   21313.057030  169.047862  20846.444500     183.588199  20623.872912   \n",
       "4   21039.884562  196.106464  20671.651555     170.821388  20509.362809   \n",
       "5   20873.407304  155.979689  20527.084504     129.289452  20439.111224   \n",
       "6   20713.737788   91.131274  20434.448000      98.783586  20388.429906   \n",
       "7   20573.869696   42.564499  20386.801324      89.965727  20342.726350   \n",
       "8   20488.955174   60.035752  20352.090197      90.486223  20312.624664   \n",
       "9   20432.717001   46.411574  20333.609169      89.769043  20261.867688   \n",
       "10  20380.052730   32.510651  20305.346423      71.257114  20180.452973   \n",
       "11  20352.289887   33.619964  20207.505908       8.785963  20133.480763   \n",
       "12  20329.740271   32.542310  20169.984125      22.904995  20104.554484   \n",
       "13  20315.229490   27.135065  20155.124817      19.812111  20094.171829   \n",
       "14  20309.711671   25.597925  20139.626688      21.051094  20082.122586   \n",
       "15  20304.921871   24.824264  20132.773272      23.714215  20070.798255   \n",
       "16  20299.635294   23.824228  20128.758584      25.691809  20050.260704   \n",
       "17  20292.617018   21.036244  20128.094448      26.009985  19993.692311   \n",
       "18  20282.944056   14.880087  20128.034752      26.008217  19975.951032   \n",
       "19  20272.293209    9.751680  20127.998354      26.002550  19970.807770   \n",
       "20  20249.977637   16.983281  20127.978002      25.998207  19966.413811   \n",
       "21  20229.557888   32.159379  20127.962462      25.995101  19961.069546   \n",
       "22  20225.416874   35.279180  20127.950532      25.993057  19955.994538   \n",
       "23  20223.621703   36.594841  20127.942565      25.992428  19951.349793   \n",
       "24  20222.300096   37.529952  20127.938776      25.992589  19947.030088   \n",
       "25  20221.389621   38.112304  20127.937234      25.992654  19941.875224   \n",
       "\n",
       "    k-means-ll-sd  \n",
       "2      148.843565  \n",
       "3       85.181279  \n",
       "4       82.038404  \n",
       "5       85.296591  \n",
       "6       88.272097  \n",
       "7       95.222002  \n",
       "8       91.858481  \n",
       "9       74.121141  \n",
       "10      47.365097  \n",
       "11      41.489084  \n",
       "12      48.620923  \n",
       "13      52.325066  \n",
       "14      46.621208  \n",
       "15      40.580056  \n",
       "16      29.433343  \n",
       "17      16.575117  \n",
       "18      23.989939  \n",
       "19      22.578655  \n",
       "20      20.284228  \n",
       "21      18.689290  \n",
       "22      16.131110  \n",
       "23      14.165431  \n",
       "24      12.636293  \n",
       "25      11.324545  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_cost = pd.read_csv('performances/k-means-cost.csv')\n",
    "df_cost = df_cost.iloc[2:,:]\n",
    "df_cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b785abb0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize = (14, 7))\n",
    "\n",
    "ax.errorbar(range(1, df_cost.shape[0]+1), df_cost['naive'], yerr = df_cost['naive-sd'],\n",
    "            marker = 'o', ls = '--', color = 'tab:blue', label = 'naive')\n",
    "ax.errorbar(range(1, df_cost.shape[0]+1), df_cost['k-means-pp'], yerr = df_cost['k-means-pp-sd'],\n",
    "            marker = 'o', ls = '--', color = 'tab:red', label = 'k-means++')\n",
    "ax.errorbar(range(1, df_cost.shape[0]+1), df_cost['k-means-ll'], yerr = df_cost['k-means-ll-sd'],\n",
    "            marker = 'o', ls = '--', color = 'tab:green', label = 'k-means||')\n",
    "\n",
    "\n",
    "ax.axvline(x = 6, color = 'gray', ls = '--', dashes = (3, 2))\n",
    "ax.axvline(x = 7, color = 'gray', ls = '--', dashes = (3, 2))\n",
    "ax.axvline(x = 10, color = 'gray', ls = '--', dashes = (3, 2))\n",
    "ax.axhline(y = df_cost['k-means-ll'][7], color = 'k', ls = '--', dashes = (3, 2), label = 'threshold')\n",
    "\n",
    "\n",
    "ax.set_xlabel('iteration', fontsize = 14)\n",
    "ax.set_ylabel('cost', fontsize = 14)\n",
    "ax.set_xticks(np.arange(df_cost.shape[0])+1)\n",
    "plt.xticks(fontsize = 12)\n",
    "plt.yticks(fontsize = 12)\n",
    "plt.legend(fontsize = 14)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92e19f23",
   "metadata": {},
   "source": [
    "# Compare the perfomances with different initializations: execution time\n",
    "The setting for this comparison is the same as the previous one. From the graph below it is possible to see that the k-means|| initialization time is lower than the k-means++ one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "17bb19ce",
   "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>naive</th>\n",
       "      <th>k-means-pp</th>\n",
       "      <th>k-means-ll</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.490000</td>\n",
       "      <td>22.10</td>\n",
       "      <td>16.396667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>781.493333</td>\n",
       "      <td>740.22</td>\n",
       "      <td>770.790000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        naive  k-means-pp  k-means-ll\n",
       "0    0.490000       22.10   16.396667\n",
       "1  781.493333      740.22  770.790000"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_time = pd.read_csv('performances/k-means-time.csv')\n",
    "df_time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b1673621",
   "metadata": {},
   "outputs": [],
   "source": [
    "t_init = np.array(df_time.iloc[0].tolist())\n",
    "t_Lloyd = np.multiply(np.array(df_time.iloc[1].tolist())/24, np.array([10, 7, 6]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "529ec6ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k-means clustering execution time:\n",
      "\n",
      "init method:   init time:  Lloyd time:  total time: \n",
      "\n",
      "       naive         0.49       325.62       326.11\n",
      "   k-means++         22.1        215.9        238.0\n",
      "   k-means||         16.4        192.7       209.09\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfwAAAHWCAYAAACSZTtDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAjCElEQVR4nO3de7RdZXnv8e8TEu4JF5Nws8kuFIiCRCEIHJWLQquCBwQHhUYkglzKCIIUqPUARry2ahWkAqGmEQocZDRealtqoQHRiuOklGADFEWIQEIuNZKEhBDkOX/MudOVzU5YO9lrrb3yfj9jrJG15vvOuZ6dzOzffOc1MhNJkrRlG9bpAiRJUusZ+JIkFcDAlySpAAa+JEkFMPAlSSrA8E4X0EqjR4/Onp6eTpchSVJb/Pu///vSzBzTX9sWHfg9PT3MmTOn02VIktQWETF/Q23u0pckqQAGviRJBTDwJUkqgIEvSVIBDHxJkgqwRZ+lL0nqjOXLl7N48WLWrl3b6VK2GCNGjGDs2LGMGjVqk+Y38CVJg2r58uUsWrSIvfbai+22246I6HRJXS8zWb16Nc8++yzAJoW+u/QlSYNq8eLF7LXXXmy//faG/SCJCLbffnv22msvFi9evEnLMPAlSYNq7dq1bLfddp0uY4u03XbbbfJhEgNfkjToHNm3xub8vRr4kiQVwMCXJKkAnqUvSWqL6/fcs63f98cLFgx4nilTprB06VK+//3vN9X/6KOP5sADD+S6664b8He1m4EvSVLtmmuuITOb7j9r1ixGjBix7nNPTw9Tp07l0ksvbUV5m8XAlySpttNOOw2o/6677tqiSgafx/AlSapNmTKFE044Aah2119wwQV84hOfYPTo0YwdO5ZLL72UV155ZV3/o48+mqlTp657P3/+fC677DIiYshdqWDgS5K0AbfeeivDhw/n3/7t37juuuv46le/yh133NFv31mzZvH617+eq666ioULF7Jw4cI2V7txBr4kSRvwxje+kauvvpr99tuPU089lWOOOYZ77rmn37677rorW221FSNHjmT33Xdn9913b3O1G2fgS5K0AQcddNB6n/fcc89NvrVtp3nS3gCc/pW7O11C17v9Y8d2ugRJalrjGfhQ3emu8Rh+N3GEL0nSINl666357W9/2+ky+mXgS5I0SHp6erj//vt59tlnWbp0aafLWY+79CVJbbEpd77rNldffTXnnXce++yzD2vWrBnQTXxazcCXJKk2c+bMde/vvffejbb31+fwww9n7ty5g1/YIHCXviRJBTDwJUkqgIEvSVIBDHxJkgpg4EuSVAADX5KkAhj4kiQVwMCXJKkABr4kSQXwTnuSpLZo9xNHB/vpnD09PUydOpVLL710UJfbaM6cORx66KE8+eST9PT0DOqyHeFLklSbMmUKJ5xwQqfLaAkDX5KkAhj4kiRtgl/96le8//3vZ+TIkYwcOZKTTz6ZZ555BoCnnnqKYcOGMWfOnPXmuemmmxg9ejQvvfQSAHfddRcTJkxg22235R3veAePP/54y+o18CVJGqBXXnmFE088kUWLFjF79mxmz57NggULOOmkk8hMenp6OO6445gxY8Z6882YMYMzzjiDrbfemqeffpqTTjqJ4447joceeogLL7yQyy+/vGU1G/iSJA3QPffcw8MPP8xtt93GpEmTmDRpErfddhsPPvgg99xzDwDnnHMOt99+Oy+++CIAjz76KA888ABnn302ANdffz3jxo3j2muvZcKECZx66qmcf/75LavZwJckaYAeffRR9txzz/XOpN97773Zc889eeSRRwA48cQT2XrrrZk1axZQje7f+ta3cuCBB65bxuGHH05ErFvGEUcc0bKaDXxJkgZRb4CPGDGCD33oQ8yYMYOXX36ZW265Zd3ovhMMfEmSBugNb3gDCxYs4Kmnnlo37Ze//CULFizgjW9847ppH/nIR5g9ezZf//rXWbFiBaeddtp6y/jpT39KZq6b9sADD7SsZm+8I0lSg+XLl/PQQw+tN23nnXde7/Oxxx7LQQcdxOTJk7nmmmsAuPDCCzn44IN55zvfua7f/vvvz9vf/nYuu+wyTjvtNEaNGrWu7fzzz+fLX/4yF198MRdccAE/+9nPuOGGG1r2cxn4kqS2GOw737XK/fffz1ve8pb1pp1yyinrfY4Ivvvd7/LRj36UY445Bqg2Ar72ta+td0we4Oyzz+aHP/zhq3bnjxs3jlmzZnHJJZdw4403csghh/CFL3yBD37wgy34qQx8SZLWmTlzJjNnzmyq77hx4/jOd77zmv0WLlzIvvvuy5FHHvmqtuOPP57jjz9+vWmTJ09u6vsHymP4kiS1wMqVK5k3bx7XXHMNF110UafLMfAlSWqFqVOncvDBB/O2t72N8847r9PlGPiSJLXCzJkzWbNmDXfeeSfDh3f+CLqBL0lSAdoa+BHxtxGxMCKWR8TjEfGRhrZ3RcRjEbEqImZHxPiGtm0iYkY933MRcUk765YkDUzjteUaPJvz99ruEf7ngZ7MHAX8b+AzEXFIRIwGZgFXArsCc4A7GuabBuwLjAeOAS6PiHe3s3BJUnNGjBjB6tWrO13GFmn16tWMGDFik+Zta+Bn5rzMXNP7sX7tA5wMzMvMOzPzRaqAnxgRE+q+ZwKfzsxlmfkocBMwpZ21S5KaM3bsWJ599llWrVrlSH+QZCarVq3i2WefZezYsZu0jLafRRARX6cK6+2A/wD+EfgsMLe3T2a+EBFPAAdExCJgj8b2+v1JG1j+ucC5UF0jKUlqr967yS1YsIC1a9d2uJotx4gRI9htt93Wu1vfQLQ98DPzgoi4EDgCOBpYA+wILOnT9XlgZN3W+7lvW3/Lnw5MB5g0aZKblpLUAaNGjdrkYFJrdOQs/cz8bWb+CHg98MfASqDvmjEKWFG30ae9t02SJDWh05flDac6hj8PmNg7MSJ26J2emcuAhY3t9ft5baxTkqSu1rbAj4ixEXFaROwYEVtFxB8ApwP3AN8GDoyIUyJiW+Aq4OHMfKye/WbgiojYpT6R7xxgZrtqlySp27VzhJ9Uu++fAZYBXwIuzszvZeYS4BSqk/eWAYcBpzXM+0ngCWA+cB/wxcy8q421S5LU1dp20l4d6kdtpP1uYMIG2tYAZ9UvSZI0QJ0+hi9JktrAwJckqQAGviRJBTDwJUkqgIEvSVIBDHxJkgpg4EuSVAADX5KkAhj4kiQVwMCXJKkABr4kSQUw8CVJKoCBL0lSAQx8SZIKYOBLklQAA1+SpAIY+JIkFcDAlySpAAa+JEkFMPAlSSqAgS9JUgEMfEmSCmDgS5JUAANfkqQCGPiSJBXAwJckqQAGviRJBTDwJUkqgIEvSVIBDHxJkgpg4EuSVAADX5KkAhj4kiQVwMCXJKkABr4kSQUw8CVJKoCBL0lSAQx8SZIKYOBLklQAA1+SpAIY+JIkFcDAlySpAAa+JEkFMPAlSSqAgS9JUgEMfEmSCmDgS5JUAANfkqQCGPiSJBXAwJckqQAGviRJBTDwJUkqgIEvSVIBDHxJkgrQtsCPiG0i4hsRMT8iVkTEQxHxnrqtJyIyIlY2vK7sM++MiFgeEc9FxCXtqluSpC3B8DZ/19PAUcCvgPcC34qINzX02TkzX+5n3mnAvsB4YHdgdkQ8kpl3tbZkSZK2DG0b4WfmC5k5LTOfysxXMvP7wJPAIU3Mfibw6cxclpmPAjcBU1pYriRJW5SOHcOPiN2A/YB5DZPnR8QzEfE3ETG67rcLsAcwt6HfXOCADSz33IiYExFzlixZ0qLqJUnqLh0J/IgYAdwKfDMzHwOWAodS7bI/BBhZtwPsWP/5fMMinq/7vEpmTs/MSZk5acyYMa0oX5KkrtPOY/gARMQw4BbgJWAqQGauBObUXRZFxFRgYUSMBFbW00cBLza8X9G2oiVJ6nJtHeFHRADfAHYDTsnMtRvomvWfwzJzGbAQmNjQPpH1DwVIkqSNaPcu/euBNwDvy8zVvRMj4rCI2D8ihkXE64BrgXszs3c3/s3AFRGxS0RMAM4BZra5dkmSulY7r8MfD5wHvBl4ruF6+8nA3sBdVLvp/xNYA5zeMPsngSeA+cB9wBe9JE+SpOa17Rh+Zs4HYiNdbt/IvGuAs+qXJEkaIG+tK0lSAQx8SZIKYOBLklQAA1+SpAIY+JIkFcDAlySpAAa+JEkFMPAlSSpA2x+eI2nznP6Vuztdwhbh9o8d2+kSpLZyhC9JUgEMfEmSCmDgS5JUAANfkqQCGPiSJBXAwJckqQAGviRJBTDwJUkqgIEvSVIBDHxJkgpg4EuSVAADX5KkAhj4kiQVwMCXJKkABr4kSQUw8CVJKoCBL0lSAQx8SZIKYOBLklQAA1+SpAIY+JIkFcDAlySpAAa+JEkFMPAlSSqAgS9JUgEMfEmSCmDgS5JUAANfkqQCGPiSJBXAwJckqQAGviRJBTDwJUkqgIEvSVIBDHxJkgpg4EuSVAADX5KkAgzvdAGSpO50+lfu7nQJXe/2jx3btu9yhC9JUgEMfEmSCmDgS5JUAANfkqQCGPiSJBXAwJckqQAGviRJBWhb4EfENhHxjYiYHxErIuKhiHhPQ/u7IuKxiFgVEbMjYnyfeWdExPKIeC4iLmlX3ZIkbQnaOcIfDjwNHAXsBFwBfCsieiJiNDALuBLYFZgD3NEw7zRgX2A8cAxweUS8u32lS5LU3dp2p73MfIEquHt9PyKeBA4BXgfMy8w7ASJiGrA0IiZk5mPAmcCUzFwGLIuIm4ApwF3tql+SpG7WsWP4EbEbsB8wDzgAmNvbVm8cPAEcEBG7AHs0ttfvD9jAcs+NiDkRMWfJkiWtKl+SpK7SkcCPiBHArcA36xH8jsDzfbo9D4ys2+jT3tv2Kpk5PTMnZeakMWPGDG7hkiR1qbYHfkQMA24BXgKm1pNXAqP6dB0FrKjb6NPe2yZJkprQ1sCPiAC+AewGnJKZa+umecDEhn47APtQHddfBixsbK/fz2tL0ZIkbQHaPcK/HngD8L7MXN0w/dvAgRFxSkRsC1wFPFzv7ge4GbgiInaJiAnAOcDMNtYtSVJXa+d1+OOB84A3A89FxMr6NTkzlwCnAJ8FlgGHAac1zP5JqpP45gP3AV/MTM/QlySpSe28LG8+EBtpvxuYsIG2NcBZ9UuSJA2Qt9aVJKkABr4kSQUw8CVJKoCBL0lSAQx8SZIKsMGz9CPi2k1Y3rTM/PVm1CNJklpgY5flTQV+QnUL3Ga8HfgqYOBLkjTEvNZ1+O/PzMXNLCgivLe9JElD1MaO4X+YVz/BbmPOAxZtXjmSJKkVNjjCz8xvDmRBmXnb5pcjSZJaoamz9CNiTESMafj8poj4TESc3rrSJEnSYGn2srxvAe8DiIjRwA+B9wM3RMSftKg2SZI0SJoN/IOAB+r3HwB+kZkHAB+iOnYvSZKGsGYDfztgZf3+WOB79fsHgd8Z7KIkSdLgajbwfw6cHBG/A/w+8IN6+m7Ab1pQlyRJGkTNBv6ngD8HngIeyMyf1tP/APiPFtQlSZIG0WvdeAeAzJwVEeOAPYG5DU13A3/XisIkSdLgaSrwATJzEX1urNMw0pckSUPYBnfpR8TlEbFdswuKiIsjYtTglCVJkgbTxo7hfx7YcQDLuhoYvXnlSJKkVtjYLv0A7ouIl5tcVtN7AyRJUnttLPA/tQnL89G4kiQNQRt7eM6mBL4kSRqCmr0OX5IkdTEDX5KkAhj4kiQVwMCXJKkABr4kSQVoOvAj4oKImBcRqyJi73raxyPi1NaVJ0mSBkNTgR8RFwNXANOpbsjT61lg6uCXJUmSBlOzI/zzgXMy8xqg8c57DwIHDHpVkiRpUDUb+OOB/+xn+lq8pa4kSUNes4H/S+Dgfqa/F3hk8MqRJEmtsLF76Tf6EnBdRGxPdQz/iIg4A7gcOKtVxUmSpMHRVOBn5t9ExHDgc8D2wC3AAuCjmXlHC+uTJEmDoNkRPpl5E3BTRIwGhmXm4taVJUmSBlPTgd8rM5e2ohBJktQ6TQV+ROwCTAOOAcbS52S/zBw76JVJkqRB0+wI/2aq6+2/CSwCsmUVSZKkQdds4B8NHJWZD7awFkmS1CLNXof/xAD6SpKkIabZEL8I+HxETIyIrVpZkCRJGnzN7tL/BdUtdB8EiIj1GjPTjQBJkoawZgP/dmAn4KN40p4kSV2n2cCfBLw1M/t7gI4kSRrimj2G/wgwqpWFSJKk1mk28K8A/jIijo2I3SJi18ZXKwuUJEmbr9ld+v9Y//kD1j9+H/VnT9qTJGkIazbwj2lpFZIkqaWafTzufa0uRJIktc4GAz8iDgYeysxX6vcb5C13JUka2jY2wp8D7A4srt8n1TH7vjyGL0nSELexwP9dYEnDe0mS1KU2GPiZOb/xI/B0Zr7qDnsRMa4VhUmSpMHT7HX4TwJj+k6MiNfVbU2JiKkRMSci1kTEzIbpPRGREbGy4XVlQ/s2ETEjIpZHxHMRcUmz3ylJkpq/LK/3evu+dgReHMD3LQA+A/wB1cN4+to5M1/uZ/o0YF9gPNV5BbMj4pHMvGsA3y1JUrE2GvgRcW39Nqkej7uqoXkr4K3AQ81+WWbOqpc7CXj9AOo8E5iSmcuAZRFxEzAFMPAlSWrCa43w31T/GcAbgJca2l6ielzulwaxnvkRkcC/AJdl5tKI2AXYA5jb0G8ucFJ/C4iIc4FzAcaN8/QCSZLgNQI/M48BiIi/AS7KzOUtqmMpcCjV3oLXAX8F3Eq163/Hus/zDf2fB0b2t6DMnA5MB5g0aZKP8ZUkiebvtPfhVhaRmSuprvUHWBQRU4GFETESWFlPH8X/nC8wCljRypokSdqSNHuWfrv1jsyH1cftFwITG9onAvPaXpUkSV2qrYEfEcMjYluqE/62ioht62mHRcT+ETGsvtTvWuDezOzdjX8zcEVE7BIRE4BzgJntrF2SpG7W7hH+FcBq4OPAB+v3VwB7U51xvwL4T2ANcHrDfJ8EngDmA/cBX/SSPEmSmtfsdfiDIjOnUV1T35/bNzLfGuCs+iVJkgZoqB7DlyRJg8jAlySpAAa+JEkFMPAlSSqAgS9JUgEMfEmSCmDgS5JUAANfkqQCGPiSJBXAwJckqQAGviRJBTDwJUkqgIEvSVIBDHxJkgpg4EuSVAADX5KkAhj4kiQVwMCXJKkABr4kSQUw8CVJKoCBL0lSAQx8SZIKYOBLklQAA1+SpAIY+JIkFcDAlySpAAa+JEkFMPAlSSqAgS9JUgEMfEmSCmDgS5JUAANfkqQCGPiSJBXAwJckqQAGviRJBTDwJUkqgIEvSVIBDHxJkgpg4EuSVAADX5KkAhj4kiQVwMCXJKkABr4kSQUw8CVJKoCBL0lSAQx8SZIKYOBLklQAA1+SpAIY+JIkFcDAlySpAAa+JEkFMPAlSSqAgS9JUgHaGvgRMTUi5kTEmoiY2aftXRHxWESsiojZETG+oW2biJgREcsj4rmIuKSddUuS1O3aPcJfAHwGmNE4MSJGA7OAK4FdgTnAHQ1dpgH7AuOBY4DLI+LdbahXkqQtQlsDPzNnZeZ3gP/u03QyMC8z78zMF6kCfmJETKjbzwQ+nZnLMvNR4CZgSnuqliSp+w2VY/gHAHN7P2TmC8ATwAERsQuwR2N7/f6A/hYUEefWhw3mLFmypIUlS5LUPYZK4O8IPN9n2vPAyLqNPu29ba+SmdMzc1JmThozZsygFypJUjcaKoG/EhjVZ9ooYEXdRp/23jZJktSEoRL484CJvR8iYgdgH6rj+suAhY3t9ft5ba1QkqQu1u7L8oZHxLbAVsBWEbFtRAwHvg0cGBGn1O1XAQ9n5mP1rDcDV0TELvWJfOcAM9tZuyRJ3azdI/wrgNXAx4EP1u+vyMwlwCnAZ4FlwGHAaQ3zfZLqJL75wH3AFzPzrjbWLUlSVxvezi/LzGlUl9z113Y3MGEDbWuAs+qXJEkaoKFyDF+SJLWQgS9JUgEMfEmSCmDgS5JUAANfkqQCGPiSJBXAwJckqQAGviRJBTDwJUkqgIEvSVIBDHxJkgpg4EuSVAADX5KkAhj4kiQVwMCXJKkABr4kSQUw8CVJKoCBL0lSAQx8SZIKYOBLklQAA1+SpAIY+JIkFcDAlySpAAa+JEkFMPAlSSqAgS9JUgEMfEmSCmDgS5JUAANfkqQCGPiSJBXAwJckqQAGviRJBTDwJUkqgIEvSVIBDHxJkgpg4EuSVAADX5KkAhj4kiQVwMCXJKkABr4kSQUw8CVJKoCBL0lSAQx8SZIKYOBLklQAA1+SpAIY+JIkFcDAlySpAAa+JEkFMPAlSSqAgS9JUgEMfEmSCmDgS5JUAANfkqQCGPiSJBVgSAV+RNwbES9GxMr69V8NbX8UEfMj4oWI+E5E7NrJWiVJ6iZDKvBrUzNzx/q1P0BEHADcCJwB7AasAr7ewRolSeoqwztdQJMmA3+fmT8EiIgrgUcjYmRmruhsaZIkDX1DcYT/+YhYGhE/joij62kHAHN7O2TmE8BLwH59Z46IcyNiTkTMWbJkSTvqlSRpyBtqgf+nwN7AXsB04O8jYh9gR+D5Pn2fB0b2XUBmTs/MSZk5acyYMa2uV5KkrjCkAj8zf5qZKzJzTWZ+E/gx8F5gJTCqT/dRgLvzJUlqwpAK/H4kEMA8YGLvxIjYG9gGeLxDdUmS1FWGzEl7EbEzcBhwH/Ay8IfAkcBFwAjgJxHxDuBB4GpglifsSZLUnCET+FSh/hlgAvBb4DHgpMx8HCAizgduBV4H3A18uEN1SpLUdYZM4GfmEuDQjbTfBtzWvookSdpyDPVj+JIkaRAY+JIkFcDAlySpAAa+JEkFMPAlSSqAgS9JUgEMfEmSCmDgS5JUAANfkqQCGPiSJBXAwJckqQAGviRJBTDwJUkqgIEvSVIBDHxJkgpg4EuSVAADX5KkAhj4kiQVwMCXJKkABr4kSQUw8CVJKoCBL0lSAQx8SZIKYOBLklQAA1+SpAIY+JIkFcDAlySpAAa+JEkFGN7pAiQNzJFf/FCnS9gyfGxBpyuQ2soRviRJBTDwJUkqgIEvSVIBDHxJkgpg4EuSVAADX5KkAnhZniRpk3iJ6CBo4+WhjvAlSSqAgS9JUgEMfEmSCmDgS5JUAANfkqQCGPiSJBXAwJckqQAGviRJBTDwJUkqgIEvSVIBDHxJkgpg4EuSVAADX5KkAhj4kiQVwMCXJKkABr4kSQUw8CVJKkDXBH5E7BoR346IFyJifkT8UadrkiSpWwzvdAED8FfAS8BuwJuBf4iIuZk5r6NVSZLUBbpihB8ROwCnAFdm5srM/BHwPeCMzlYmSVJ3iMzsdA2vKSLeAvw4M7dvmHYpcFRmvq9P33OBc+uP+wP/1bZCh4bRwNJOF6HiuR5qKChxPRyfmWP6a+iWXfo7Asv7THseGNm3Y2ZOB6a3o6ihKCLmZOakTtehsrkeaihwPVxfV+zSB1YCo/pMGwWs6EAtkiR1nW4J/MeB4RGxb8O0iYAn7EmS1ISuCPzMfAGYBVwdETtExNuAE4FbOlvZkFTs4QwNKa6HGgpcDxt0xUl7UF2HD8wAjgP+G/h4Zt7W2aokSeoOXRP4kiRp03XFLn1JkrR5DPwtRET0RERGhJegbOEi4t6IuK7TdUjqLgb+luNpYA/goQ7XIUlFbZj2Drj6TJsWETM7VFK/DPwtRGb+NjOfy8yXO12L1CoD/SVah86U1lUkdQ8Df4iofzF9PSI+FxFLI2JxRHwpIobV7R+MiP8XESvqtjsjYq+G+dft0o+IYRHxdERc2Oc79qv7HFx/3ikiptfLWxER93lIoPtExLsi4jcRcf4G2u+NiOsj4ssR8euIWBIRF0XENhHxV/W8v4qIM/rMt1dE/N+IWFa//qHxXhgRsU9EfDcinqufYvlgRJzQZxlPRcQVEXFjRCyPiGci4rI+fc6LiMcj4sV63f/niOiWu4BKXcPAH1omAy8D/wuYClwM/GHdtjXwSaobDp1AdY/o2/tbSGa+UrdN7mf5j2bmgxERwD8Ae9XLewvwQ+BfI2KPwfuR1EoR8QHg28C5mXnDRrpOproz5WHAF4CvAt+huqnVJOCbwF/3/ttHxPbAbOBF4CjgCGAhcHfdBtUtr/+J6lLZicDfAbMiYkKf7/4Y8DPgYODPgb+IiCPq75lE9STMT1E9++JdwF0D/5vQUOeG6RCQmb6GwAu4F/hJn2n/Avz1BvpPABJ4ff25p/48qf58UP15n4Z5fg58on7/TqpbFm/XZ7kPAZd3+u/D12uuK9dRPSTqeeD3B7JuAQEsAb7XMG0E1eOnP1B/PqteX6Khz1ZU98A4dSPf9QBwRcPnp4Db+/T5eW8f4OT6ZxjZ5M8+DZg5wL+rKZ3+Nyvx1bue1u8/QPU8lI2tO/fWfaYB+wJ/Uv8O+yfgIuD3gE8Da4A96nm2p9ponVn/zpsA/DUwH9i+7jMROB94U72M/1Ov6xP6rKf/TTXQ+j3gwvq7j6jbJ1ENxiYD4+tlfgwYXrf3ALk562o7Xo7wh5aH+3xeAIwFiIiD663U+RGxAphT9xnX34Iy82GqUdXkev7DgH2AW+suh1D9Z1kSESt7X8CBdT8NbSdRjYzfnZk/AIiIdzT+W0ZE4x6edetWVr+NFlOtH73T1gLLqNc3qvXjd4EVDevG88Au1OtHVHe9/IuIeKQeWa2k+sXYd53c4HpNtVE7H3gyIm6NiDMjYt1DsSJicp/18xPA5A39nBFxQ5/+7wBu6NO/3/8zao2onmD6DaqNyW+9Rvd5mTktM38O/CXVk+7WZuY1mfkL4GqqDda31f1Pqz9/ODMfzszHgPOo9j6dAJCZczPzhsz8WWb+IjM/CzxItRHS6AeZeV3d52vAL6j2OEG1Tr9AtZE8v17mV7LLzpnqrt0RW761fT4nMCwidgD+GbgbOIPql/Vo4H6qXf0b8rfA2VT/SSYDP8rM+XXbMGAR1S/Evvo+mVBDz1yqEcvZEfFAHeJzgDc39FnU8L6/davf9a1+P4xqb89p/Xz3r+s/vwS8G7iUatS+CriZV6+TG/yezFwR1TklR1IdGvgz4HMRcWhmLgC+B/y0Yd6PUh2G+tMN/JxX1XX1upX6UEPDtAX9/ExqjZOoAvjIzPwJVBumVKP2XudlZu9AZL0N04h41YZpRGxow7Txe7enYcOU6nDoCVRXMo0AtuXVG6LNbpj+M/ADYFZmdtUD3Az87jCBKuA/kZlPAkTEyU3Mdxvw+Yg4nOpcgCsb2h4EdgNeycxfDnK9ar0nqXY73gtMj4hzM3M11ahkMDwInA4szczfbKDP24GbM/PvACJiW6pfso8P5IvqUdK/Up0/8kmqDdoTgOn1L9R1v1Qj4tfAqHq019+yFtfz9/ZfDSzeUH+1XCkbpl3BXfrd4VdUx62mRsTeEXE81bGsjcrMZ4D7gBuAnYA7G5rvBn4MfDci3hMRvxsRR0TEp+otcA1x9YbaMVS/zG6MPkOczXQr1S/i70bEUfX6cWR9QlXvCVGPA++vDze9iWqP0rYD+ZKIOKE+MestETEe+CNgJPDoIP4s6pwngaOB36faMI3MXF3vNu99bc4o+UGqY+5L+yzzF5nZG/jrNkzrQ53PsAmHLTPz5cz818z8M6rzBXagPmzQLQz8LpCZS4AzqXaPPUK1e+qSJmf/W6oTTP4xM5c1LDOB91KNrG4C/gv4FtWZ0l2zxVq6zHyC6hfqexjE0M/MVVSjmV9SbSg+RnUm/y5Ux/qhWgcXUx1a+ieqE/buH+BX/YZqvb67/o5LgY9k5kCXoyHKDdOhw136Q0RmHt3PtCkN7+8A7ujTJRran2r83DB9BtVTBvv7zhVUZ79etAklq0P6rit16P9Os/3raQf2M233Pp8XAR/eyHLnA8f2mfylPn16NlZPZv6IKgyakpnTmu3b97vUOZn5REQcTXUI6saIOK8edGzucldFxJFUl5reSbUncwHVJaWNG6bfoNoYXUZ1SeqAAp//2TC9iur8gCfowg1Tn5YnSdJmiIge4MnMjIZp04CexoFbp7lLX5KkAhj4kiQVwGP4kiRtnt9Q3R660b3Azu0uZGM8hi9JUgHcpS9JUgEMfEmSCmDgS5JUAANfkqQC/H/HS4MPCBpRMgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print('k-means clustering execution time:\\n')\n",
    "format_spec = '{:>12} {:>12} {:>12} {:>12}'\n",
    "\n",
    "print(format_spec.format('init method:', 'init time:', 'Lloyd time:', 'total time:'), '\\n')\n",
    "\n",
    "names = ['naive', 'k-means++', 'k-means||']\n",
    "for i, name in enumerate(names):\n",
    "    times = [t_init[i], t_Lloyd[i], t_init[i] + t_Lloyd[i]]\n",
    "    words = [str(round(t, 2)) for t in times]\n",
    "    print(format_spec.format(name, words[0], words[1], words[2]))\n",
    "    \n",
    "fig, ax = plt.subplots(figsize = (8, 8))\n",
    "\n",
    "ax.bar(names, t_init, width = 0.5, color = 'darkred', alpha = 0.9, label = 'init')\n",
    "ax.bar(names, t_Lloyd, width = 0.5, bottom = t_init, color = 'steelblue', alpha = 0.9, label = 'Lloyd')\n",
    "ax.set_ylabel('time [s]', fontsize = 14)\n",
    "plt.xticks(fontsize = 14)\n",
    "plt.yticks(fontsize = 12)\n",
    "ax.legend(fontsize = 14)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58a80b71",
   "metadata": {},
   "source": [
    "# Study the perfomances of different Spark configurations\n",
    "The dataset used for this comparison consisted of a total of 128000 documents (varying the number of chunks/partitions and the number of documents per chunk) tested using k-means|| initialization (l = 3, t = 5) and running the Lloyd's algorithm for 5 iterations. The small number of documents was necessary to run 5 executions in order to obtain the average execution time values. We considered two Spark configurations: the first consisted of 16 executors, each with 1 core and 1536 Mb of memory, while the second consisted of 8 executors, each with 2 cores and 3072 Mb of memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "20c6b5ee",
   "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>t-init-mean</th>\n",
       "      <th>t-init-sd</th>\n",
       "      <th>t-Lloyd-mean</th>\n",
       "      <th>t-Lloyd-sd</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>27.770</td>\n",
       "      <td>1.538417</td>\n",
       "      <td>120.598</td>\n",
       "      <td>3.691748</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>15.728</td>\n",
       "      <td>0.616042</td>\n",
       "      <td>62.226</td>\n",
       "      <td>1.253927</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>10.962</td>\n",
       "      <td>0.380183</td>\n",
       "      <td>36.820</td>\n",
       "      <td>1.677288</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>13.926</td>\n",
       "      <td>0.183010</td>\n",
       "      <td>34.652</td>\n",
       "      <td>1.937556</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>19.786</td>\n",
       "      <td>0.126320</td>\n",
       "      <td>43.762</td>\n",
       "      <td>1.722100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>30.504</td>\n",
       "      <td>0.801631</td>\n",
       "      <td>47.488</td>\n",
       "      <td>2.613698</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   t-init-mean  t-init-sd  t-Lloyd-mean  t-Lloyd-sd\n",
       "0       27.770   1.538417       120.598    3.691748\n",
       "1       15.728   0.616042        62.226    1.253927\n",
       "2       10.962   0.380183        36.820    1.677288\n",
       "3       13.926   0.183010        34.652    1.937556\n",
       "4       19.786   0.126320        43.762    1.722100\n",
       "5       30.504   0.801631        47.488    2.613698"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_16exec = pd.read_csv('performances/spark-config-16exec.csv')\n",
    "df_16exec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "dd20053b",
   "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>t-init-mean</th>\n",
       "      <th>t-init-sd</th>\n",
       "      <th>t-Lloyd-mean</th>\n",
       "      <th>t-Lloyd-sd</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>20.272</td>\n",
       "      <td>0.552372</td>\n",
       "      <td>116.854</td>\n",
       "      <td>4.344921</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>12.788</td>\n",
       "      <td>0.146490</td>\n",
       "      <td>64.690</td>\n",
       "      <td>1.289955</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>10.492</td>\n",
       "      <td>0.140610</td>\n",
       "      <td>34.662</td>\n",
       "      <td>1.210654</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>13.622</td>\n",
       "      <td>0.216968</td>\n",
       "      <td>39.012</td>\n",
       "      <td>0.915547</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>18.258</td>\n",
       "      <td>0.357249</td>\n",
       "      <td>38.456</td>\n",
       "      <td>1.719401</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>29.956</td>\n",
       "      <td>0.613942</td>\n",
       "      <td>44.704</td>\n",
       "      <td>1.181533</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   t-init-mean  t-init-sd  t-Lloyd-mean  t-Lloyd-sd\n",
       "0       20.272   0.552372       116.854    4.344921\n",
       "1       12.788   0.146490        64.690    1.289955\n",
       "2       10.492   0.140610        34.662    1.210654\n",
       "3       13.622   0.216968        39.012    0.915547\n",
       "4       18.258   0.357249        38.456    1.719401\n",
       "5       29.956   0.613942        44.704    1.181533"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_8exec = pd.read_csv('performances/spark-config-8exec.csv')\n",
    "df_8exec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "97616f27",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(nrows = 1, ncols = 2, figsize = (16, 8))\n",
    "\n",
    "# 16 executors\n",
    "ax[0].errorbar(range(df_16exec.shape[0]), df_16exec['t-init-mean'], yerr = df_16exec['t-init-sd'],\n",
    "            marker = 'o', ls = '--', color = 'darkred', alpha = 0.9, label = 'k-means||')\n",
    "ax[0].errorbar(range(df_16exec.shape[0]), df_16exec['t-Lloyd-mean'], yerr = df_16exec['t-Lloyd-sd'],\n",
    "            marker = 'o', ls = '--', color = 'steelblue', alpha = 0.9, label = 'Lloyd')\n",
    "\n",
    "ax[0].set_xlabel('number of partitions', fontsize = 14)\n",
    "ax[0].set_ylabel('time [s]', fontsize = 14)\n",
    "ax[0].set_title('16 executors, 1 core, 1536 Mb', fontsize = 16)\n",
    "ax[0].set_xticks(range(df_16exec.shape[0]), labels = ['4', '8', '16', '32', '64', '128'])\n",
    "ax[0].tick_params(labelsize = 12)\n",
    "ax[0].legend(fontsize = 14)\n",
    "\n",
    "# 8 executors\n",
    "ax[1].errorbar(range(df_8exec.shape[0]), df_8exec['t-init-mean'], yerr = df_8exec['t-init-sd'],\n",
    "            marker = 'o', ls = '--', color = 'darkred', alpha = 0.9, label = 'k-means||')\n",
    "ax[1].errorbar(range(df_8exec.shape[0]), df_8exec['t-Lloyd-mean'], yerr = df_8exec['t-Lloyd-sd'],\n",
    "            marker = 'o', ls = '--', color = 'steelblue', alpha = 0.9, label = 'Lloyd')\n",
    "\n",
    "ax[1].set_xlabel('number of partitions', fontsize = 14)\n",
    "ax[1].set_ylabel('time [s]', fontsize = 14)\n",
    "ax[1].set_title('8 executors, 2 cores, 3072 Mb', fontsize = 16)\n",
    "ax[1].set_xticks(range(df_8exec.shape[0]), labels = ['4', '8', '16', '32', '64', '128'])\n",
    "ax[1].tick_params(labelsize = 12)\n",
    "ax[1].legend(fontsize = 14)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbfbd44e",
   "metadata": {},
   "source": [
    "# References\n",
    "\n",
    "[Scalable K-means++](https://arxiv.org/abs/1203.6402)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}