COMPSs_Manuals/source/Sections/09_PyCOMPSs_Notebooks/syntax/9_Dislib.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dislib tutorial\n",
    "\n",
    "This tutorial will show the basics of using [dislib](https://dislib.bsc.es).\n",
    "\n",
    "\n",
    "## Setup\n",
    "\n",
    "\n",
    "First, we need to start an interactive PyCOMPSs session:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "******************************************************\n",
      "*************** PyCOMPSs Interactive *****************\n",
      "******************************************************\n",
      "*          .-~~-.--.           _____       _______   *\n",
      "*         :         )         |____ \\     /  ___  \\  *\n",
      "*   .~ ~ -.\\       /.- ~~ .     ___) |    | (___) |  *\n",
      "*   >       `.   .'       <    / ___/     \\____   /  *\n",
      "*  (         .- -.         )  | |___   _      /  /   *\n",
      "*   `- -.-~  `- -'  ~-.- -'   |_____| |_|    /__/    *\n",
      "*     (        :        )           _ _ .-:          *\n",
      "*      ~--.    :    .--~        .-~  .-~  }          *\n",
      "*          ~-.-^-.-~ \\_      .~  .-~   .~            *\n",
      "*                   \\ \\ '     \\ '_ _ -~              *\n",
      "*                    \\`.\\`.    //                    *\n",
      "*           . - ~ ~-.__\\`.\\`-.//                     *\n",
      "*       .-~   . - ~  }~ ~ ~-.~-.                     *\n",
      "*     .' .-~      .-~       :/~-.~-./:               *\n",
      "*    /_~_ _ . - ~                 ~-.~-._            *\n",
      "*                                     ~-.<           *\n",
      "******************************************************\n",
      "* - Starting COMPSs runtime...                       *\n",
      "* - Log path : /home/javier/.COMPSs/InteractiveMode_13/\n",
      "* - PyCOMPSs Runtime started... Have fun!            *\n",
      "******************************************************\n"
     ]
    }
   ],
   "source": [
    "import pycompss.interactive as ipycompss\n",
    "import os\n",
    "if 'BINDER_SERVICE_HOST' in os.environ:\n",
    "    ipycompss.start(graph=True,\n",
    "                    project_xml='../xml/project.xml',\n",
    "                    resources_xml='../xml/resources.xml')\n",
    "else:\n",
    "    ipycompss.start(graph=True, monitor=1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we import dislib and we are all set to start working!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import dislib as ds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Distributed arrays\n",
    "\n",
    "The main data structure in dislib is the distributed array (or ds-array). These arrays are a distributed representation of a 2-dimensional array that can be operated as a regular Python object. Usually, rows in the array represent samples, while columns represent features.\n",
    "\n",
    "To create a random array we can run the following NumPy-like command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(500, 500)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "ds-array(blocks=(...), top_left_shape=(100, 100), reg_shape=(100, 100), shape=(500, 500), sparse=False)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = ds.random_array(shape=(500, 500), block_size=(100, 100))\n",
    "print(x.shape)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now `x` is a 500x500 ds-array of random numbers stored in blocks of 100x100 elements. Note that `x` is not stored in memory. Instead, `random_array` generates the contents of the array in tasks that are usually executed remotely. This allows the creation of really big arrays.\n",
    "\n",
    "The content of `x` is a list of `Futures` that represent the actual data (wherever it is stored).\n",
    "\n",
    "To see this, we can access the `_blocks` field of `x`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<pycompss.runtime.management.classes.Future at 0x7fb7a58ca8b0>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x._blocks[0][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`block_size` is useful to control the granularity of dislib algorithms.\n",
    "\n",
    "To retrieve the actual contents of `x`, we use `collect`, which synchronizes the data and returns the equivalent NumPy array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.48604732, 0.68571232, 0.98557605, ..., 0.51530027, 0.39511585,\n",
       "        0.42942001],\n",
       "       [0.03398195, 0.40964073, 0.5437061 , ..., 0.16162333, 0.79046618,\n",
       "        0.71677277],\n",
       "       [0.82399233, 0.80869154, 0.16965568, ..., 0.79380114, 0.31004525,\n",
       "        0.51511589],\n",
       "       ...,\n",
       "       [0.57630698, 0.72028925, 0.11842501, ..., 0.92236462, 0.5837854 ,\n",
       "        0.92114111],\n",
       "       [0.84521256, 0.17909749, 0.42140394, ..., 0.95331429, 0.01587735,\n",
       "        0.58532187],\n",
       "       [0.81065273, 0.5666422 , 0.65635218, ..., 0.58820423, 0.42493203,\n",
       "        0.84351429]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.collect()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way of creating ds-arrays is using array-like structures like NumPy arrays or lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ds-array(blocks=(...), top_left_shape=(1, 3), reg_shape=(1, 3), shape=(2, 3), sparse=False)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1 = ds.array([[1, 2, 3], [4, 5, 6]], block_size=(1, 3))\n",
    "x1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Distributed arrays can also store sparse data in CSR format:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ds-array(blocks=(...), top_left_shape=(1, 3), reg_shape=(1, 3), shape=(2, 3), sparse=True)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from scipy.sparse import csr_matrix\n",
    "\n",
    "sp = csr_matrix([[0, 0, 1], [1, 0, 1]])\n",
    "x_sp = ds.array(sp, block_size=(1, 3))\n",
    "x_sp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, `collect` returns a CSR matrix as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<2x3 sparse matrix of type '<class 'numpy.int64'>'\n",
       "\twith 3 stored elements in Compressed Sparse Row format>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_sp.collect()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading data\n",
    "\n",
    "A typical way of creating ds-arrays is to load data from disk. Dislib currently supports reading data in CSV and SVMLight formats like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ds-array(blocks=(...), top_left_shape=(20, 100), reg_shape=(20, 100), shape=(61, 780), sparse=True)\n",
      "ds-array(blocks=(...), top_left_shape=(500, 122), reg_shape=(500, 122), shape=(4235, 122), sparse=False)\n"
     ]
    }
   ],
   "source": [
    "x, y = ds.load_svmlight_file(\"./files/libsvm/1\", block_size=(20, 100), n_features=780, store_sparse=True)\n",
    "\n",
    "print(x)\n",
    "\n",
    "csv = ds.load_txt_file(\"./files/csv/1\", block_size=(500, 122))\n",
    "\n",
    "print(csv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing\n",
    "\n",
    "Similar to NumPy, ds-arrays support the following types of slicing:\n",
    "\n",
    "(Note that slicing a ds-array creates a new ds-array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = ds.random_array((50, 50), (10, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get a single row:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ds-array(blocks=(...), top_left_shape=(1, 10), reg_shape=(10, 10), shape=(1, 50), sparse=False)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get a single element:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ds-array(blocks=(...), top_left_shape=(1, 1), reg_shape=(1, 1), shape=(1, 1), sparse=False)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[2, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get a set of rows or a set of columns:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ds-array(blocks=(...), top_left_shape=(10, 10), reg_shape=(10, 10), shape=(10, 50), sparse=False)\n",
      "ds-array(blocks=(...), top_left_shape=(10, 10), reg_shape=(10, 10), shape=(50, 10), sparse=False)\n",
      "ds-array(blocks=(...), top_left_shape=(3, 10), reg_shape=(10, 10), shape=(3, 50), sparse=False)\n",
      "ds-array(blocks=(...), top_left_shape=(10, 3), reg_shape=(10, 10), shape=(50, 3), sparse=False)\n"
     ]
    }
   ],
   "source": [
    "# Consecutive rows\n",
    "print(x[10:20])\n",
    "\n",
    "# Consecutive columns\n",
    "print(x[:, 10:20])\n",
    "\n",
    "# Non consecutive rows\n",
    "print(x[[3, 7, 22]])\n",
    "\n",
    "# Non consecutive columns\n",
    "print(x[:, [5, 9, 48]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get any set of elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ds-array(blocks=(...), top_left_shape=(5, 5), reg_shape=(10, 10), shape=(5, 5), sparse=False)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[0:5, 40:45]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other functions\n",
    "\n",
    "Apart from this, ds-arrays also provide other useful operations like `transpose` and `mean`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.51352356, 0.49396794, 0.4661033 , 0.48026991, 0.50136143,\n",
       "       0.49323405, 0.51248831, 0.51658519, 0.4904544 , 0.47166468,\n",
       "       0.50245676, 0.49936659, 0.47499634, 0.52566765, 0.53676456,\n",
       "       0.59127036, 0.50947458, 0.47320677, 0.42695456, 0.54335201,\n",
       "       0.51780756, 0.49855486, 0.53845333, 0.37299501, 0.51229418,\n",
       "       0.43110043, 0.47262688, 0.41698864, 0.54994596, 0.46676007,\n",
       "       0.46070067, 0.48861301, 0.45868291, 0.53380687, 0.50555055,\n",
       "       0.53453463, 0.43711111, 0.52115681, 0.48152436, 0.49215593,\n",
       "       0.41552034, 0.47669533, 0.5610678 , 0.43511911, 0.49611885,\n",
       "       0.44116871, 0.42241364, 0.48626255, 0.51636529, 0.44251849])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.mean(axis=0).collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.02733543, 0.65891797, 0.36654465, ..., 0.52109164, 0.86395718,\n",
       "        0.93593907],\n",
       "       [0.41462264, 0.97419918, 0.14124931, ..., 0.15893453, 0.49486474,\n",
       "        0.14138483],\n",
       "       [0.91312707, 0.53860404, 0.96686988, ..., 0.78763956, 0.18268972,\n",
       "        0.20551984],\n",
       "       ...,\n",
       "       [0.19468602, 0.62184611, 0.81007025, ..., 0.88719987, 0.55132466,\n",
       "        0.32694948],\n",
       "       [0.19221646, 0.64678511, 0.98416872, ..., 0.18736269, 0.51392039,\n",
       "        0.59614856],\n",
       "       [0.49591758, 0.17913008, 0.11419029, ..., 0.02701779, 0.22316829,\n",
       "        0.78426262]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.transpose().collect()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Machine learning with dislib\n",
    "\n",
    "Dislib provides an estimator-based API very similar to [scikit-learn](https://scikit-learn.org/stable/). To run an algorithm, we first create an estimator. For example, a K-means estimator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dislib.cluster import KMeans\n",
    "\n",
    "km = KMeans(n_clusters=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we create a ds-array with some blob data, and fit the estimator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KMeans(n_clusters=3, random_state=RandomState(MT19937) at 0x7FB7D4FFB240)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.datasets import make_blobs\n",
    "\n",
    "# create ds-array\n",
    "x, y = make_blobs(n_samples=1500)\n",
    "x_ds = ds.array(x, block_size=(500, 2))\n",
    "\n",
    "km.fit(x_ds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can make predictions on new (or the same) data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ds-array(blocks=(...), top_left_shape=(500, 1), reg_shape=(500, 1), shape=(1500, 1), sparse=False)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_pred = km.predict(x_ds)\n",
    "y_pred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`y_pred` is a ds-array of predicted labels for `x_ds`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's plot the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7fb7a137d640>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "centers = km.centers\n",
    "\n",
    "# set the color of each sample to the predicted label\n",
    "plt.scatter(x[:, 0], x[:, 1], c=y_pred.collect())\n",
    "\n",
    "# plot the computed centers in red\n",
    "plt.scatter(centers[:, 0], centers[:, 1], c='red')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that we need to call `y_pred.collect()` to retrieve the actual labels and plot them. The rest is the same as if we were using scikit-learn."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's try a more complex example that uses some preprocessing tools.\n",
    "\n",
    "First, we load a classification data set from scikit-learn into ds-arrays. \n",
    "\n",
    "Note that this step is only necessary for demonstration purposes. Ideally, your data should be already loaded in ds-arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_breast_cancer\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "x, y = load_breast_cancer(return_X_y=True)\n",
    "\n",
    "x_train, x_test, y_train, y_test = train_test_split(x, y)\n",
    "\n",
    "x_train = ds.array(x_train, block_size=(100, 10))\n",
    "y_train = ds.array(y_train.reshape(-1, 1), block_size=(100, 1))\n",
    "\n",
    "x_test = ds.array(x_test, block_size=(100, 10))\n",
    "y_test = ds.array(y_test.reshape(-1, 1), block_size=(100, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we can see how support vector machines perform in classifying the data. We first fit the model (ignore any warnings in this step):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/javier/.local/lib/python3.8/site-packages/dislib/classification/csvm/base.py:374: RuntimeWarning: overflow encountered in exp\n",
      "  k = np.exp(k)\n",
      "/home/javier/.local/lib/python3.8/site-packages/dislib/classification/csvm/base.py:342: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  delta = np.abs((w - self._last_w) / self._last_w)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "CascadeSVM()"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from dislib.classification import CascadeSVM\n",
    "\n",
    "csvm = CascadeSVM()\n",
    "\n",
    "csvm.fit(x_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and now we can make predictions on new data using `csvm.predict()`, or we can get the model accuracy on the test set with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "score = csvm.score(x_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`score` represents the classifier accuracy, however, it is returned as a `Future`. We need to synchronize to get the actual value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6503496503496503\n"
     ]
    }
   ],
   "source": [
    "from pycompss.api.api import compss_wait_on\n",
    "\n",
    "print(compss_wait_on(score))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The accuracy should be around 0.6, which is not very good. We can scale the data before classification to improve accuracy. This can be achieved using dislib's `StandardScaler`.\n",
    "\n",
    "The `StandardScaler` provides the same API as other estimators. In this case, however, instead of making predictions on new data, we transform it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dislib.preprocessing import StandardScaler\n",
    "\n",
    "sc = StandardScaler()\n",
    "\n",
    "# fit the scaler with train data and transform it\n",
    "scaled_train = sc.fit_transform(x_train)\n",
    "\n",
    "# transform test data\n",
    "scaled_test = sc.transform(x_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now `scaled_train` and `scaled_test` are the scaled samples. Let's see how SVM perfroms now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.972027972027972\n"
     ]
    }
   ],
   "source": [
    "csvm.fit(scaled_train, y_train)\n",
    "score = csvm.score(scaled_test, y_test)\n",
    "print(compss_wait_on(score))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The new accuracy should be around 0.9, which is a great improvement!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Close the session\n",
    "\n",
    "To finish the session, we need to stop PyCOMPSs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "******************************************************\n",
      "*************** STOPPING PyCOMPSs ******************\n",
      "******************************************************\n",
      "Checking if any issue happened.\n",
      "Warning: some of the variables used with PyCOMPSs may\n",
      "         have not been brought to the master.\n",
      "******************************************************\n"
     ]
    }
   ],
   "source": [
    "ipycompss.stop()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}