Algorithm.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> \n",
    "A SparkContext gets created\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyspark\n",
    "from pyspark import Row\n",
    "from pyspark.sql import SQLContext\n",
    "from pyspark.sql.types import *\n",
    "from numpy import array\n",
    "from math import sqrt\n",
    "import sys\n",
    "\n",
    "from pyspark.mllib.clustering import KMeans, KMeansModel\n",
    "\n",
    "sc = pyspark.SparkContext('local[*]')\n",
    "sc._conf.set(\"spark.executor.memory\", \"12g\")\n",
    "sc._conf.set(\"spark.driver.memory\", \"12g\")\n",
    "sqlContext = pyspark.SQLContext(sc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p> \n",
    "Data gets loaded from a parquet file named \"stackoverflow.parquet\", which is later turned into dataframes.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = sqlContext.read.parquet(\"stackoverflow.parquet\")\n",
    "\n",
    "Posting = Row('question_answer', 'id', 'accepted_answer', 'parentId', 'score', 'language')\n",
    "\n",
    "posting = df.rdd.map(lambda r: Posting(*r))\n",
    "\n",
    "df = sqlContext.createDataFrame(posting, samplingRatio=0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Languages\n",
    "languages = [\"JavaScript\", \"Java\", \"PHP\", \"Python\", \"C#\", \"C++\", \"Ruby\", \"CSS\",\n",
    "      \"Objective-C\", \"Perl\", \"Scala\", \"Haskell\", \"MATLAB\", \"Clojure\", \"Groovy\"]\n",
    "\n",
    "# How spread apart should the languages be for the K-Clustering algorithm\n",
    "langSpread = 50000\n",
    "\n",
    "# Number of clusters \n",
    "kmeansKernels = 45\n",
    "\n",
    "# Convergence Criterion\n",
    "kmeansEta = 20.0\n",
    "\n",
    "# Max number of iterations\n",
    "kmeansMaxIterations = 120"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "questions = df.filter(df['question_answer'] == 1).rdd.map(lambda q: (q.id, q))\n",
    "answers = df.filter(df['question_answer'] == 2).rdd.map(lambda a: (a.parentId, a))\n",
    "\n",
    "group_questions_and_answers = questions.join(answers).groupByKey()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Row(question_answer='1', id='21167403', accepted_answer=None, parentId=None, score='0', language='PHP'), '0')\n"
     ]
    }
   ],
   "source": [
    "def max_score(v):\n",
    "    return max(map(lambda r: r.score, list(v)))\n",
    "\n",
    "score_by_question = group_questions_and_answers.flatMap(lambda v: v[1]).groupByKey().mapValues(max_score)\n",
    "\n",
    "print(score_by_question.take(1)[0])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PythonRDD[35] at RDD at PythonRDD.scala:53"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def getindexdefault(self, elem):\n",
    "        try:\n",
    "            idx = self.index(elem)\n",
    "            return idx\n",
    "        except ValueError:\n",
    "            return -1\n",
    "\n",
    "def first_language_in_languages(tag):\n",
    "    idx = getindexdefault(languages, tag)\n",
    "    if idx >= 0:\n",
    "        return idx\n",
    "    else:\n",
    "        return -1\n",
    "\n",
    "        \n",
    "\n",
    "vectors = score_by_question.filter(lambda x:  x[0].language is not u'').map(lambda x: ((first_language_in_languages(x[0].language)+1) * langSpread , x[1]))\n",
    "\n",
    "vectors.persist()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(150000, '0'), (150000, '-1'), (150000, '1'), (150000, '0'), (150000, '0'), (200000, '0'), (150000, '0'), (300000, '0'), (100000, '911'), (150000, '2'), (150000, '1'), (400000, '3'), (300000, '0'), (300000, '0'), (200000, '9'), (150000, '0'), (300000, '0'), (200000, '6'), (300000, '0'), (150000, '0'), (150000, '0'), (200000, '2'), (150000, '0'), (150000, '0'), (150000, '1'), (150000, '-2'), (300000, '1'), (150000, '0'), (300000, '2'), (150000, '2'), (150000, '1'), (300000, '7'), (150000, '0'), (150000, '0'), (300000, '2'), (150000, '1'), (300000, '4'), (150000, '0'), (400000, '4'), (300000, '1'), (300000, '2'), (150000, '0'), (150000, '0'), (150000, '1'), (300000, '3'), (150000, '0'), (150000, '0'), (150000, '1'), (250000, '20'), (150000, '2')]\n"
     ]
    }
   ],
   "source": [
    "print(vectors.take(50))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "by_language = kmeansKernels / len(languages)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train model\n",
    "\n",
    "clusters = KMeans.train(vectors, kmeansKernels, maxIterations=kmeansMaxIterations, initializationMode=\"random\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------+-----+\n",
      "|language|score|\n",
      "+--------+-----+\n",
      "|  150000|    0|\n",
      "|  150000|   -1|\n",
      "|  150000|    1|\n",
      "|  150000|    0|\n",
      "|  150000|    0|\n",
      "|  200000|    0|\n",
      "|  150000|    0|\n",
      "|  300000|    0|\n",
      "|  100000|  911|\n",
      "|  150000|    2|\n",
      "|  150000|    1|\n",
      "|  400000|    3|\n",
      "|  300000|    0|\n",
      "|  300000|    0|\n",
      "|  200000|    9|\n",
      "|  150000|    0|\n",
      "|  300000|    0|\n",
      "|  200000|    6|\n",
      "|  300000|    0|\n",
      "|  150000|    0|\n",
      "+--------+-----+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "NewPosting = Row('language', 'score')\n",
    "\n",
    "posting = vectors.map(lambda r: NewPosting(*r))\n",
    "\n",
    "new_df = sqlContext.createDataFrame(posting, samplingRatio=0.1)\n",
    "\n",
    "new_df.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------+-----+----------------+\n",
      "|language|score|        features|\n",
      "+--------+-----+----------------+\n",
      "|  150000|    0|  [150000.0,0.0]|\n",
      "|  150000|   -1| [150000.0,-1.0]|\n",
      "|  150000|    1|  [150000.0,1.0]|\n",
      "|  150000|    0|  [150000.0,0.0]|\n",
      "|  150000|    0|  [150000.0,0.0]|\n",
      "|  200000|    0|  [200000.0,0.0]|\n",
      "|  150000|    0|  [150000.0,0.0]|\n",
      "|  300000|    0|  [300000.0,0.0]|\n",
      "|  100000|  911|[100000.0,911.0]|\n",
      "|  150000|    2|  [150000.0,2.0]|\n",
      "|  150000|    1|  [150000.0,1.0]|\n",
      "|  400000|    3|  [400000.0,3.0]|\n",
      "|  300000|    0|  [300000.0,0.0]|\n",
      "|  300000|    0|  [300000.0,0.0]|\n",
      "|  200000|    9|  [200000.0,9.0]|\n",
      "|  150000|    0|  [150000.0,0.0]|\n",
      "|  300000|    0|  [300000.0,0.0]|\n",
      "|  200000|    6|  [200000.0,6.0]|\n",
      "|  300000|    0|  [300000.0,0.0]|\n",
      "|  150000|    0|  [150000.0,0.0]|\n",
      "+--------+-----+----------------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'cost')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from pyspark.ml.feature import VectorAssembler\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "from pyspark.ml.clustering import KMeans\n",
    "\n",
    "\n",
    "FEATURES_COL = ['language', 'score']\n",
    "\n",
    "for col in df.columns:\n",
    "    if col in FEATURES_COL:\n",
    "        new_df = new_df.withColumn(col,new_df[col].cast('int'))\n",
    "\n",
    "new_df = new_df.na.drop()\n",
    "new_df.schema\n",
    "\n",
    "vecAssembler = VectorAssembler(inputCols=FEATURES_COL, outputCol=\"features\")\n",
    "df_kmeans = vecAssembler.transform(new_df).select('language', 'score', 'features')\n",
    "df_kmeans.show()\n",
    "\n",
    "cost = np.zeros(20)\n",
    "for k in range(2,20):\n",
    "    kmeans = KMeans().setK(k).setSeed(1).setFeaturesCol(\"features\")\n",
    "    model = kmeans.fit(df_kmeans.sample(False,0.1, seed=42))\n",
    "    cost[k] = model.computeCost(df_kmeans) # requires Spark 2.0 or later\n",
    "    \n",
    "fig, ax = plt.subplots(1,1, figsize =(8,6))\n",
    "ax.plot(range(2,20),cost[2:20])\n",
    "ax.set_xlabel('k')\n",
    "ax.set_ylabel('cost')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cluster Centers: \n",
      "[2.50000000e+05 1.10453231e+00]\n",
      "[4.00000000e+05 2.11342948e+00]\n",
      "[1.00000000e+05 4.47869599e-01]\n",
      "[1.50000000e+05 4.18475448e-01]\n",
      "[7.00000000e+05 4.43146836e+00]\n",
      "[5.00000000e+04 4.90311486e+00]\n",
      "[6.00000000e+05 5.27862957e+00]\n",
      "[2.00000000e+05 7.32137067e+00]\n",
      "[3.00000000e+05 2.67391943e+00]\n",
      "[5.00000000e+05 3.15579167e+00]\n",
      "[4.50000000e+05 1.53871322e+00]\n",
      "[5.50000000e+05 4.27435975e+00]\n",
      "[6.50000000e+05 2.20327167e+00]\n",
      "[7.50000000e+05 2.56927612e+00]\n",
      "[3.50000000e+05 3.25160207e+00]\n",
      "[250000.            640.33333333]\n",
      "[1.00000000e+05 6.20447691e+01]\n",
      "[100000.       728.375]\n",
      "[1.5000000e+05 1.0623815e+01]\n",
      "[2.00000000e+05 8.41061693e+01]\n",
      "[50000.           366.47368421]\n",
      "[300000.            592.90909091]\n",
      "[50000.            78.92704918]\n",
      "[2.50000000e+05 6.54045293e+01]\n",
      "[400000.        696.9375]\n",
      "[350000.            598.16666667]\n",
      "[4.50000000e+05 7.83899557e+01]\n",
      "[100000.            247.35897436]\n",
      "[1.00000000e+05 9.02687995e+00]\n",
      "[5.00000000e+04 7.43837808e-01]\n",
      "[200000.            644.33333333]\n",
      "[1.50000000e+05 6.42691892e+01]\n",
      "[4.00000000e+05 2.22177778e+02]\n",
      "[3.00000000e+05 5.68719212e+01]\n",
      "[450000.            615.19047619]\n",
      "[2.00000000e+05 1.39939073e+00]\n",
      "[1.50000000e+05 2.98477338e+00]\n",
      "[150000.            551.86666667]\n",
      "[5.00000000e+04 3.16643134e+01]\n",
      "[2.00000000e+05 3.55248843e+01]\n",
      "[500000.    836.]\n",
      "[50000.           817.69230769]\n",
      "[2.50000000e+05 6.75690423e+00]\n",
      "[4.50000000e+05 1.43748674e+01]\n",
      "[1.00000000e+05 2.91827497e+00]\n"
     ]
    }
   ],
   "source": [
    "kmeans = KMeans().setK(kmeansKernels).setSeed(1).setFeaturesCol(\"features\")\n",
    "model = kmeans.fit(df_kmeans)\n",
    "centers = model.clusterCenters()\n",
    "\n",
    "print(\"Cluster Centers: \")\n",
    "for center in centers:\n",
    "    print(center)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Row(language=150000, prediction=3), Row(language=150000, prediction=3), Row(language=150000, prediction=3)]\n"
     ]
    }
   ],
   "source": [
    "transformed = model.transform(df_kmeans).select('language', 'prediction')\n",
    "rows = transformed.collect()\n",
    "print(rows[:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------+----------+\n",
      "|language|prediction|\n",
      "+--------+----------+\n",
      "|  150000|         3|\n",
      "|  150000|         3|\n",
      "|  150000|         3|\n",
      "|  150000|         3|\n",
      "|  150000|         3|\n",
      "|  200000|        35|\n",
      "|  150000|         3|\n",
      "|  300000|         8|\n",
      "|  100000|        17|\n",
      "|  150000|        36|\n",
      "|  150000|         3|\n",
      "|  400000|         1|\n",
      "|  300000|         8|\n",
      "|  300000|         8|\n",
      "|  200000|         7|\n",
      "|  150000|         3|\n",
      "|  300000|         8|\n",
      "|  200000|         7|\n",
      "|  300000|         8|\n",
      "|  150000|         3|\n",
      "+--------+----------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df_pred = sqlContext.createDataFrame(rows)\n",
    "df_pred.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------+----------+-----+\n",
      "|language|prediction|score|\n",
      "+--------+----------+-----+\n",
      "|  350000|        14|   12|\n",
      "|  350000|        14|    5|\n",
      "|  350000|        14|    9|\n",
      "|  350000|        14|    6|\n",
      "|  350000|        14|    6|\n",
      "|  350000|        14|    6|\n",
      "|  350000|        14|   14|\n",
      "|  350000|        14|    4|\n",
      "|  350000|        14|    0|\n",
      "|  350000|        14|    7|\n",
      "|  350000|        14|    3|\n",
      "|  350000|        14|    5|\n",
      "|  350000|        14|    1|\n",
      "|  350000|        14|    9|\n",
      "|  350000|        14|    9|\n",
      "|  350000|        14|    3|\n",
      "|  350000|        14|    6|\n",
      "|  350000|        14|   16|\n",
      "|  350000|        14|    4|\n",
      "|  350000|        14|    2|\n",
      "+--------+----------+-----+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df_pred = df_pred.join(new_df, 'language')\n",
    "df_pred.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Row(language=350000, prediction=14, score=12), Row(language=350000, prediction=14, score=5), Row(language=350000, prediction=14, score=9)]\n"
     ]
    }
   ],
   "source": [
    "print(df_pred.take(3))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "pddf_pred = df_pred.sample(False, 0.00001).toPandas()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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>language</th>\n",
       "      <th>prediction</th>\n",
       "      <th>score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>350000</td>\n",
       "      <td>14</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>350000</td>\n",
       "      <td>14</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>350000</td>\n",
       "      <td>14</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>350000</td>\n",
       "      <td>14</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>350000</td>\n",
       "      <td>14</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   language  prediction  score\n",
       "0    350000          14      0\n",
       "1    350000          14      1\n",
       "2    350000          14      1\n",
       "3    350000          14      0\n",
       "4    350000          14      8"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pddf_pred.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(6043377, 3)\n"
     ]
    }
   ],
   "source": [
    "\n",
    "print(pddf_pred.shape) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "pddf_pred.to_csv('pandas_csv.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "threedee = plt.figure(figsize=(12,10)).gca(projection='3d')\n",
    "threedee.scatter(pddf_pred.language, pddf_pred.prediction, c=pddf_pred.score)\n",
    "threedee.set_xlabel('language')\n",
    "threedee.set_ylabel('prediction')\n",
    "threedee.set_zlabel('score')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}