Lab_ex_1_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ex 1.2: A simple parallel MapReduce framework in Python\n",
    "Now we use the [*multiprocessing*](https://docs.python.org/3/library/multiprocessing.html) lib to actually do things in parallel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import collections\n",
    "import itertools\n",
    "import multiprocessing\n",
    "\n",
    "\n",
    "class SimpleMapReduce:\n",
    "\n",
    "    def __init__(self, map_func, reduce_func, num_workers=None):\n",
    "        \"\"\"\n",
    "        map_func\n",
    "\n",
    "          Function to map inputs to intermediate data. Takes as\n",
    "          argument one input value and returns a tuple with the\n",
    "          key and a value to be reduced.\n",
    "\n",
    "        reduce_func\n",
    "\n",
    "          Function to reduce partitioned version of intermediate\n",
    "          data to final output. Takes as argument a key as\n",
    "          produced by map_func and a sequence of the values\n",
    "          associated with that key.\n",
    "\n",
    "        num_workers\n",
    "\n",
    "          The number of workers to create in the pool. Defaults\n",
    "          to the number of CPUs available on the current host.\n",
    "        \"\"\"\n",
    "        self.map_func = map_func\n",
    "        self.reduce_func = reduce_func\n",
    "        self.pool = multiprocessing.Pool(num_workers)\n",
    "\n",
    "    def partition(self, mapped_values):\n",
    "        \"\"\"Organize the mapped values by their key.\n",
    "        Returns an unsorted sequence of tuples with a key\n",
    "        and a sequence of values.\n",
    "        \"\"\"\n",
    "        partitioned_data = collections.defaultdict(list)\n",
    "        for key, value in mapped_values:\n",
    "            partitioned_data[key].append(value)\n",
    "        return partitioned_data.items()\n",
    "\n",
    "    def __call__(self, inputs, chunksize=1):\n",
    "        \"\"\"Process the inputs through the map and reduce functions\n",
    "        given.\n",
    "\n",
    "        inputs\n",
    "          An iterable containing the input data to be processed.\n",
    "\n",
    "        chunksize=1\n",
    "          The portion of the input data to hand to each worker.\n",
    "          This can be used to tune performance during the mapping\n",
    "          phase.\n",
    "        \"\"\"\n",
    "        map_responses = self.pool.map(\n",
    "            self.map_func,\n",
    "            inputs,\n",
    "            chunksize=chunksize,\n",
    "        )\n",
    "        partitioned_data = self.partition(\n",
    "            itertools.chain(*map_responses)\n",
    "        )\n",
    "        reduced_values = self.pool.map(\n",
    "            self.reduce_func,\n",
    "            partitioned_data,\n",
    "        )\n",
    "        return reduced_values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A Word Count example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import string\n",
    "\n",
    "# map - read file and count words\n",
    "def file_to_words(filename):\n",
    "    \"\"\"Read a file and return a sequence of\n",
    "    (word, occurences) values.\n",
    "    \"\"\"\n",
    "    STOP_WORDS = set([\n",
    "        'a', 'an', 'and', 'are', 'as', 'be', 'by', 'for', 'if',\n",
    "        'in', 'is', 'it', 'of', 'or', 'py', 'rst', 'that', 'the',\n",
    "        'to', 'with',\n",
    "    ])\n",
    "    TR = str.maketrans({\n",
    "        p: ' '\n",
    "        for p in string.punctuation\n",
    "    })\n",
    "\n",
    "    print('{} reading {}'.format(\n",
    "        multiprocessing.current_process().name, filename))\n",
    "    output = []\n",
    "\n",
    "    with open(filename, 'rt') as f:\n",
    "        for line in f:\n",
    "            # Skip comment lines.\n",
    "            if line.lstrip().startswith('..'):\n",
    "                continue\n",
    "            line = line.translate(TR)  # Strip punctuation\n",
    "            for word in line.split():\n",
    "                word = word.lower()\n",
    "                if word.isalpha() and word not in STOP_WORDS:\n",
    "                    output.append((word, 1))\n",
    "    return output\n",
    "\n",
    "# reduce\n",
    "def count_words(item):\n",
    "    \"\"\"Convert the partitioned data for a word to a\n",
    "    tuple containing the word and the number of occurences.\n",
    "    \"\"\"\n",
    "    word, occurences = item\n",
    "    return (word, sum(occurences))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ForkPoolWorker-12 reading text1.rst\n",
      "ForkPoolWorker-9 reading text3.rst\n",
      "ForkPoolWorker-11 reading text2.rst\n",
      "ForkPoolWorker-10 reading text4.rst\n",
      "\n",
      "TOP 20 WORDS BY FREQUENCY\n",
      "\n",
      "my    :    67\n",
      "i     :    60\n",
      "her   :    43\n",
      "he    :    41\n",
      "quiz  :    33\n",
      "was   :    28\n",
      "quick :    28\n",
      "his   :    23\n",
      "fox   :    22\n",
      "she   :    21\n",
      "from  :    20\n",
      "when  :    20\n",
      "blind :    19\n",
      "would :    18\n",
      "so    :    18\n",
      "but   :    18\n",
      "have  :    18\n",
      "vex   :    18\n",
      "on    :    17\n",
      "which :    16\n"
     ]
    }
   ],
   "source": [
    "import operator\n",
    "import glob #easy file access\n",
    "\n",
    "input_files = glob.glob('*.rst')#get all text files names \n",
    "\n",
    "mapper = SimpleMapReduce(file_to_words, count_words)#get mapreduce instance with custom map and reduce functions\n",
    "word_counts = mapper(input_files)#call parallel mapreduce on files\n",
    "\n",
    "word_counts.sort(key=operator.itemgetter(1))#sort results\n",
    "word_counts.reverse()\n",
    "\n",
    "print('\\nTOP 20 WORDS BY FREQUENCY\\n')\n",
    "top20 = word_counts[:20]\n",
    "longest = max(len(word) for word, count in top20)\n",
    "for word, count in top20:\n",
    "    print('{word:<{len}}: {count:5}'.format(\n",
    "            len=longest + 1,\n",
    "            word=word,\n",
    "            count=count)\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## K-Means implementation\n",
    "Use the simple frame work to implement K-Means"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.cluster import KMeans\n",
    "from sklearn.datasets import make_blobs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7f0cd8581ed0>"
      ]
     },
     "execution_count": 15,
     "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": [
    "#generate data with K=4\n",
    "X, y = make_blobs(n_samples=1500, centers=4)\n",
    "plt.scatter(X[:, 0], X[:, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7f0cd81f35d0>"
      ]
     },
     "execution_count": 22,
     "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": [
    "#K-Means ref implementation\n",
    "k = KMeans(n_clusters=4, random_state=random_state)\n",
    "y_pred = k.fit_predict(X)\n",
    "\n",
    "plt.scatter(X[:, 0], X[:, 1], c=y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 4.42960056,  9.91112785],\n",
       "       [-6.09429836, -7.91072107],\n",
       "       [ 1.00288082, -8.81953563],\n",
       "       [-9.11679611, -2.11217534]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k.cluster_centers_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "#implement map -> assign data to center \n",
    "def kMap( ... ): \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "#implement reduce -> compute new centers\n",
    "def kReduce( ... ):\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "init center [[-7.43559786 -2.53818871]\n",
      " [-9.68259007 -2.75656783]\n",
      " [-9.92905839 -2.02917772]\n",
      " [ 5.88128798  8.58245137]]\n"
     ]
    }
   ],
   "source": [
    "#init centers\n",
    "center = X[np.random.randint(X.shape[0], size=4), :]#get 4 random datapoints\n",
    "print('init center', center)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'kMap' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-31-2df835bb7630>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#use framework\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mmapper\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mSimpleMapReduce\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkMap\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkReduce\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;31m#get mapreduce instance with custom map and reduce functions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0mcenter\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;31m#call parallel mapreduce oo data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'kMap' is not defined"
     ]
    }
   ],
   "source": [
    "#use framework\n",
    "mapper = SimpleMapReduce(kMap, kReduce)#get mapreduce instance with custom map and reduce functions\n",
    "center = mapper(X)#call parallel mapreduce oo data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}