Sparkify.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sparkify Project Workspace\n",
    "This workspace contains a tiny subset (128MB) of the full dataset available (12GB). Feel free to use this workspace to build your project, or to explore a smaller subset with Spark before deploying your cluster on the cloud. Instructions for setting up your Spark cluster is included in the last lesson of the Extracurricular Spark Course content.\n",
    "\n",
    "You can follow the steps below to guide your data analysis and model building portion of this project."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import libraries\n",
    "from pyspark.sql import SparkSession, Window\n",
    "from pyspark.sql.functions import avg, stddev, split, udf, isnull, first, col, format_number, rand\n",
    "from pyspark.sql.functions import min as fmin\n",
    "from pyspark.sql.functions import max as fmax\n",
    "from pyspark.sql.types import IntegerType, FloatType\n",
    "\n",
    "from pyspark.ml import Pipeline\n",
    "from pyspark.ml.classification import LogisticRegression, DecisionTreeClassifier,RandomForestClassifier, LinearSVC\n",
    "from pyspark.ml.feature import StandardScaler, VectorAssembler\n",
    "from pyspark.ml.evaluation import MulticlassClassificationEvaluator\n",
    "from pyspark.mllib.evaluation import MulticlassMetrics\n",
    "from pyspark.ml.tuning import CrossValidator, ParamGridBuilder\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import copy\n",
    "import time\n",
    "import datetime\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "from statsmodels.stats.proportion import proportions_ztest\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a Spark session\n",
    "spark = SparkSession.builder.appName('Sparkify_customer_churn').getOrCreate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load and Clean Dataset\n",
    "In this workspace, the mini-dataset file is `mini_sparkify_event_data.json`. Load and clean the dataset, checking for invalid or missing data - for example, records without userids or sessionids. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------+---------+---------+------+-------------+--------+---------+-----+---------------+------+--------+-------------+---------+---------+------+-------------+--------------------+------+\n",
      "|        artist|     auth|firstName|gender|itemInSession|lastName|   length|level|       location|method|    page| registration|sessionId|     song|status|           ts|           userAgent|userId|\n",
      "+--------------+---------+---------+------+-------------+--------+---------+-----+---------------+------+--------+-------------+---------+---------+------+-------------+--------------------+------+\n",
      "|Martha Tilston|Logged In|    Colin|     M|           50| Freeman|277.89016| paid|Bakersfield, CA|   PUT|NextSong|1538173362000|       29|Rockpools|   200|1538352117000|Mozilla/5.0 (Wind...|    30|\n",
      "+--------------+---------+---------+------+-------------+--------+---------+-----+---------------+------+--------+-------------+---------+---------+------+-------------+--------------------+------+\n",
      "only showing top 1 row\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df = spark.read.json('mini_sparkify_event_data.json')\n",
    "df.show(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      " |-- artist: string (nullable = true)\n",
      " |-- auth: string (nullable = true)\n",
      " |-- firstName: string (nullable = true)\n",
      " |-- gender: string (nullable = true)\n",
      " |-- itemInSession: long (nullable = true)\n",
      " |-- lastName: string (nullable = true)\n",
      " |-- length: double (nullable = true)\n",
      " |-- level: string (nullable = true)\n",
      " |-- location: string (nullable = true)\n",
      " |-- method: string (nullable = true)\n",
      " |-- page: string (nullable = true)\n",
      " |-- registration: long (nullable = true)\n",
      " |-- sessionId: long (nullable = true)\n",
      " |-- song: string (nullable = true)\n",
      " |-- status: long (nullable = true)\n",
      " |-- ts: long (nullable = true)\n",
      " |-- userAgent: string (nullable = true)\n",
      " |-- userId: string (nullable = true)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.printSchema()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+-----------------+\n",
      "|summary|           userId|\n",
      "+-------+-----------------+\n",
      "|  count|           286500|\n",
      "|   mean|59682.02278593872|\n",
      "| stddev|109091.9499991047|\n",
      "|    min|                 |\n",
      "|    max|               99|\n",
      "+-------+-----------------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.describe('userId').show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+-----------------+\n",
      "|summary|        sessionId|\n",
      "+-------+-----------------+\n",
      "|  count|           286500|\n",
      "|   mean|1041.526554973822|\n",
      "| stddev|726.7762634630741|\n",
      "|    min|                1|\n",
      "|    max|             2474|\n",
      "+-------+-----------------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.describe('sessionId').show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "286500"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.count()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Clean Data\n",
    "\n",
    "Remove NAN or '' values from userId & sessionId columns\n",
    "Also convert time column into format '%Y-%m-%d %H:%M:%S'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.filter(isnull(df['userId'])).count()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.filter(isnull(df['sessionId'])).count()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8346"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.filter(df['userId']=='').count()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.filter(df['sessionId']=='').count()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_cleaned = df.filter(df['userId']!='')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a user defined function for formating the timestamp\n",
    "get_time = udf(lambda x: datetime.datetime.fromtimestamp(x / 1000.0).strftime(\"%Y-%m-%d %H:%M:%S\"))\n",
    "\n",
    "#Apply the udf on the ts column\n",
    "df_cleaned = df_cleaned.withColumn(\"time\", get_time(df_cleaned.ts))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Row(artist='Martha Tilston', auth='Logged In', firstName='Colin', gender='M', itemInSession=50, lastName='Freeman', length=277.89016, level='paid', location='Bakersfield, CA', method='PUT', page='NextSong', registration=1538173362000, sessionId=29, song='Rockpools', status=200, ts=1538352117000, userAgent='Mozilla/5.0 (Windows NT 6.1; WOW64; rv:31.0) Gecko/20100101 Firefox/31.0', userId='30', time='2018-10-01 00:01:57')]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_cleaned.take(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exploratory Data Analysis\n",
    "When you're working with the full dataset, perform EDA by loading a small subset of the data and doing basic manipulations within Spark. In this workspace, you are already provided a small subset of data you can explore.\n",
    "\n",
    "\n",
    "\n",
    "### Explore Data\n",
    "Once you've defined churn, perform some exploratory data analysis to observe the behavior for users who stayed vs users who churned. You can start by exploring aggregates on these two groups of users, observing how much of a specific action they experienced per a certain time unit or number of songs played."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create a temporary view to perform SQL operations\n",
    "df_cleaned.createOrReplaceTempView(\"sparkify_cleaned\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## User Auth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------+\n",
      "|     auth|\n",
      "+---------+\n",
      "|Cancelled|\n",
      "|Logged In|\n",
      "+---------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "spark.sql('''\n",
    "        SELECT DISTINCT(auth)\n",
    "        FROM sparkify_cleaned\n",
    "''').show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------+-----------+\n",
      "|     auth|user_counts|\n",
      "+---------+-----------+\n",
      "|Logged In|        225|\n",
      "|Cancelled|         52|\n",
      "+---------+-----------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\n",
    "spark.sql('''\n",
    "        SELECT auth,COUNT(DISTINCT userId) AS user_counts\n",
    "        FROM sparkify_cleaned\n",
    "        GROUP BY auth\n",
    "        ORDER BY user_counts DESC\n",
    "''').show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 52 users cancelled the subscription .\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## User Gender"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------+-----------+\n",
      "|gender|user_counts|\n",
      "+------+-----------+\n",
      "|     M|        121|\n",
      "|     F|        104|\n",
      "+------+-----------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "gender_count = spark.sql('''\n",
    "        SELECT gender,COUNT(DISTINCT userId) AS user_counts\n",
    "        FROM sparkify_cleaned\n",
    "        GROUP BY gender\n",
    "        ORDER BY user_counts DESC\n",
    "''')\n",
    "gender_count.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa9569c4358>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.barplot(x='gender',y='user_counts',data=gender_count.toPandas());\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### There are 124 males and 104 females"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Items played in a session"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----------+\n",
      "|item_counts|\n",
      "+-----------+\n",
      "|       1311|\n",
      "+-----------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "spark.sql('''\n",
    "        SELECT COUNT(DISTINCT(itemInSession)) AS item_counts\n",
    "        FROM sparkify_cleaned\n",
    "''').show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "length_data = spark.sql('''\n",
    "        SELECT length\n",
    "        FROM sparkify_cleaned\n",
    "''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAD8CAYAAAB3u9PLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAIABJREFUeJzt3X2QXNV95vHv093zqpeREAKDJIIwso1wYsAq7MRZe9fYRngTa3cLysLrXSpLFakENvFuthLYVLEOVWwtW0mc7C4kxQYSQowFxnaiJIqxE3Cyjm0JYTAgEdljxMtYvAhLmtHLvPTLb//o26NWq2fm9kzPTF94PmVZ3afvvX3O9NCPzjn3nquIwMzMLLfYFTAzs87gQDAzM8CBYGZmCQeCmZkBDgQzM0s4EMzMDEgZCJI2S9onaVDSzU1e75H0YPL6Tknn1712S1K+T9KVdeX/SdIeSc9K+oKk3nY0yMzMZmfGQJCUB+4ErgI2AtdK2tiw2fXA4Yi4EPgccEey70ZgK3AxsBm4S1Je0hrgV4BNEfFuIJ9sZ2ZmiyRND+FyYDAino+ICWAbsKVhmy3Afcnjh4ErJCkp3xYR4xGxHxhMjgdQAPokFYB+4MDcmmJmZnNRSLHNGuDluudDwPum2iYiSpKGgVVJ+Xca9l0TEd+W9NvAS8Ao8LWI+FqzN5d0A3ADwJIlS977rne9K0WVzcwM4IknnngjIlan2TZNIKhJWeN6F1Nt07Rc0kqqvYf1wBHgi5I+HRF/dtrGEXcDdwNs2rQpdu/enaLKZmYGIOnFtNumGTIaAtbVPV/L6cM7k9skQ0ADwKFp9v0IsD8iDkZEEfgy8DNpK21mZu2XJhAeBzZIWi+pm+rk7/aGbbYD1yWPrwYejeqqeduBrclZSOuBDcAuqkNF75fUn8w1XAE8N/fmmJnZbM04ZJTMCdwEPEL1bKB7I2KPpNuA3RGxHbgHuF/SINWewdZk3z2SHgL2AiXgxogoAzslPQx8Nyl/kmRYyMzMFoeytPy15xDMzFoj6YmI2JRmW1+pbGZmgAPBzMwSDgQzMwMcCGZmlnAgzFFEsPn3/oEvPTG02FUxM5sTB8IcjRbL/NOrR3n2wPBiV8XMbE4cCHM0MloCYHi0uMg1MTObGwfCHB0dqwbBiAPBzDLOgTBHI0kguIdgZlnnQJgjDxmZ2ZuFA2GO3EMwszcLB8Ic1eYOHAhmlnUOhDkaGasOGY0VK4yXyotcGzOz2XMgzFFtyAhOzieYmWWRA2GO6kPAw0ZmlmUOhDmq7yE4EMwsyxwIczQyWiSf0+RjM7OsciDM0dGxEucM9ALuIZhZtqUKBEmbJe2TNCjp5iav90h6MHl9p6Tz6167JSnfJ+nKpOydkp6q+zMi6TPtatRCGhkrsnZlH+BAMLNsmzEQJOWBO4GrgI3AtZI2Nmx2PXA4Ii4EPgfckey7EdgKXAxsBu6SlI+IfRFxSURcArwXOAF8pU1tWlAjoyXWrewHHAhmlm1pegiXA4MR8XxETADbgC0N22wB7ksePwxcIUlJ+baIGI+I/cBgcrx6VwA/jIgXZ9uIxTQyVuSMpd30d+cdCGaWaWkCYQ3wct3zoaSs6TYRUQKGgVUp990KfGGqN5d0g6TdknYfPHgwRXUXzlixzESpwvLeLgb6uhwIZpZpaQJBTcoi5TbT7iupG/gE8MWp3jwi7o6ITRGxafXq1Smqu3COJlcpL+8tOBDMLPPSBMIQsK7u+VrgwFTbSCoAA8ChFPteBXw3Il5rrdqdoXYNwvK+Lpb3dfm0UzPLtDSB8DiwQdL65F/0W4HtDdtsB65LHl8NPBoRkZRvTc5CWg9sAHbV7Xct0wwXdbpaACzv7WJ5r3sIZpZthZk2iIiSpJuAR4A8cG9E7JF0G7A7IrYD9wD3Sxqk2jPYmuy7R9JDwF6gBNwYEWUASf3AR4FfnId2LYjawnbL+6pDRnsPOBDMLLtmDASAiNgB7Ggou7Xu8RhwzRT73g7c3qT8BNWJ58yq7yF4DsHMss5XKs9BbVJ5WRIIxyfKFMuVRa6VmdnsOBDm4OSkcoGBvmpnyxPLZpZVDoQ5GBktUsiJvq48A/1dgK9WNrPsciDMwchYkeV9XUhioM+BYGbZlmpS2U71wM6XAHh6aBglz1/88XHAgWBm2eUewhyMFyv0duUB6Ev+diCYWVY5EOZgtFimt6v6I+ztrgaCJ5XNLKscCHMwViyf1kOoXaxmZpY1DoQ5GCuWJ4OgK5+jp5DzkJGZZZYDYQ5G63oIQPVq5RMOBDPLJgfCLJUrQbEck3MIgJevMLNMcyDM0lixDHB6D8GBYGYZ5UCYpVog9DkQzOxNwoEwS6PuIZjZm4wDYZbGitVVTesDYWlvgWPjPu3UzLLJgTBLJ+cQTv4I+7rzjE6UF6tKZmZz4kCYpWaTyv1dBSbKFUq+J4KZZZADYZYmki/97vzJH2F/snzFiaJ7CWaWPQ6EWSqVA6heoVzT31MNBA8bmVkWpQoESZsl7ZM0KOnmJq/3SHoweX2npPPrXrslKd8n6cq68hWSHpb0T5Kek/TT7WjQQqn1EAp5TZZN9hAcCGaWQTMGgqQ8cCdwFbARuFbSxobNrgcOR8SFwOeAO5J9NwJbgYuBzcBdyfEAfh/4akS8C3gP8Nzcm7NwSuUKhZzI6WQg9HVVby9x3GcamVkGpekhXA4MRsTzETEBbAO2NGyzBbgvefwwcIUkJeXbImI8IvYDg8DlkpYDHwTuAYiIiYg4MvfmLJxiOU7pHcDJHsKo5xDMLIPSBMIa4OW650NJWdNtIqIEDAOrptn3AuAg8MeSnpT0R5KWNHtzSTdI2i1p98GDB1NUd2EUy5VT5g/AQ0Zmlm1pAkFNyiLlNlOVF4DLgD+IiEuB48BpcxMAEXF3RGyKiE2rV69OUd2F0SwQ+mo9hAkPGZlZ9qQJhCFgXd3ztcCBqbaRVAAGgEPT7DsEDEXEzqT8YaoBkRnFctB12pBRdQ7BPQQzy6I0gfA4sEHSekndVCeJtzdssx24Lnl8NfBoRERSvjU5C2k9sAHYFRGvAi9LemeyzxXA3jm2ZUE16yEs8ZCRmWVYYaYNIqIk6SbgESAP3BsReyTdBuyOiO1UJ4fvlzRItWewNdl3j6SHqH7Zl4AbI6L2bfkfgc8nIfM88Attbtu8qvYQphoyciCYWfbMGAgAEbED2NFQdmvd4zHgmin2vR24vUn5U8CmVirbSUqVyuQkco2HjMwsy3yl8ixNlCoUcqf++PI50V3IcaLoSWUzyx4HwiyVKkF34fQfX393nhPj7iGYWfY4EGapmFyp3Ki/K+8hIzPLJAfCLDU7ywiSeyJ4yMjMMsiBMEvNzjKC6sSyewhmlkUOhFmoRFCunH5hGiRzCA4EM8sgB8IsFJOlr5v3EHwbTTPLJgfCLBQnb47TrIdQ4ITXMjKzDHIgzEJpmh5Cn3sIZpZRDoRZOHm3tCmuQ/D9EMwsgxwIs1C7n3J3kyGjPl+YZmYZ5UCYheJ0PYSuAhPlyuSwkplZVjgQZuHkpPLpP74lPckS2B42MrOMcSDMwsnTTpsPGYGXwDaz7HEgzMJM1yGAl8A2s+xxIMzCdENGfV21eyL4WgQzyxYHwixMN2TU7yEjM8soB8IsTHdhmoeMzCyrUgWCpM2S9kkalHRzk9d7JD2YvL5T0vl1r92SlO+TdGVd+QuSnpH0lKTd7WjMQpmYbshoMhA8ZGRm2TLjPZUl5YE7gY8CQ8DjkrZHxN66za4HDkfEhZK2AncAn5S0EdgKXAycC/ytpHdERO2fz/8iIt5oY3sWRKlcIafqLTMbLfF9lc0so9L0EC4HBiPi+YiYALYBWxq22QLclzx+GLhCkpLybRExHhH7gcHkeJlWLFeaXpQGHjIys+xKEwhrgJfrng8lZU23iYgSMAysmmHfAL4m6QlJN0z15pJukLRb0u6DBw+mqO78m+rmOODrEMwsu9IEwunjItUv8zTbTLfvByLiMuAq4EZJH2z25hFxd0RsiohNq1evTlHd+Ve9fWazplWXvwb3EMwse9IEwhCwru75WuDAVNtIKgADwKHp9o2I2t+vA18hQ0NJxXKFrlzzH10+J7oLOU74vspmljFpAuFxYIOk9ZK6qU4Sb2/YZjtwXfL4auDRiIikfGtyFtJ6YAOwS9ISScsAJC0BPgY8O/fmLIxiOegqNO8hgO+aZmbZNONZRhFRknQT8AiQB+6NiD2SbgN2R8R24B7gfkmDVHsGW5N990h6CNgLlIAbI6Is6WzgK9V5ZwrAAxHx1Xlo37woVqbuIQD0d/m+ymaWPTMGAkBE7AB2NJTdWvd4DLhmin1vB25vKHseeE+rle0UxVKFnkJ+ytd91zQzyyJfqTwLpUpMOakMsKSnwHFfmGZmGeNAmIXprkMA6POQkZllkANhFqa7DgE8qWxm2eRAmIXprkOA6rUIXsvIzLLGgTAL1UCYZsjIPQQzyyAHQosiIhkymv46BN9T2cyyxoHQovHS1PdCqOnr9qSymWWPA6FF48WZA2FJd4GJUoVypXHJJzOzzuVAaNFoMhRUmGHICHyTHDPLFgdCi8aSQOieYcgIvOKpmWWLA6FFY6VaD2H66xDAgWBm2ZJqLSM7qXY6abOzjB7Y+RIAew4MA/ClJ4Y4d0Ufn3rfeQtXQTOzWXIPoUVjKSaVa8NJxXJlQepkZtYODoQW1YaMpg2EQvW1iZIDwcyyw4HQorFphoxqaoEw7kAwswxxILQoTQ+ht6s6qTzmq5XNLEMcCC1KM4fQm9w8Z8w9BDPLEAdCiybPMspNPWTU01X9sbqHYGZZkioQJG2WtE/SoKSbm7zeI+nB5PWdks6ve+2WpHyfpCsb9stLelLSX821IQtlcsioMPWPLifRU8gx7kAwswyZMRAk5YE7gauAjcC1kjY2bHY9cDgiLgQ+B9yR7LsR2ApcDGwG7kqOV/OrwHNzbcRCqg0ZFabpIUB1HqG2rZlZFqTpIVwODEbE8xExAWwDtjRsswW4L3n8MHCFJCXl2yJiPCL2A4PJ8ZC0FviXwB/NvRkLZ6xYppAT1eZNraeQm+xNmJllQZpAWAO8XPd8KClruk1ElIBhYNUM+/4e8OvAtP+MlnSDpN2Sdh88eDBFdefXWLE87YRyTbWH4EAws+xIEwjN/incuK7zVNs0LZf0c8DrEfHETG8eEXdHxKaI2LR69eqZazvPqoEwfe8AoLcr5yEjM8uUNIEwBKyre74WODDVNpIKwABwaJp9PwB8QtILVIegPizpz2ZR/wU3Wpz+9pk1PQX3EMwsW9IEwuPABknrJXVTnSTe3rDNduC65PHVwKMREUn51uQspPXABmBXRNwSEWsj4vzkeI9GxKfb0J5519KQka9DMLMMmXG104goSboJeATIA/dGxB5JtwG7I2I7cA9wv6RBqj2Drcm+eyQ9BOwFSsCNEZHpfza3MmTk007NLEtSLX8dETuAHQ1lt9Y9HgOumWLf24Hbpzn2N4BvpKlHJxgrlqe9F0JNb1eeUiUoecVTM8sIX6ncotFiedq7pdX0JheuedjIzLLCgdCi4+PlyaUppuMF7swsaxwILTo6VqJnmmUrahwIZpY1DoQWHR8v0VPIz7jdyQXuPGRkZtngQGhBuRKMFsvpeggF9xDMLFscCC04Nl4CaGnIaNzrGZlZRjgQWnB8MhBmHjLq9ZCRmWWMA6EFk4GQ4iyjnsm7prmHYGbZ4EBoQStDRvmc6M7nGHcPwcwywoHQglogdKcYMoLaiqfuIZhZNjgQWlAbMupNMWQE0ON7IphZhjgQWnBsvPrlnmZSGarLV3jpCjPLCgdCC46NFQHoTjGHAL5rmplliwOhBccnql/uvS0FgnsIZpYNDoQWHBsv0ZVXquWvwfdEMLNscSC04NhYiSU9qW4hAVSXr/B1CGaWFQ6EFhwfL7G0hUDo6cpTLAdF3yTHzDLAgdCCYy0GQu301KNjpfmqkplZ26QKBEmbJe2TNCjp5iav90h6MHl9p6Tz6167JSnfJ+nKpKxX0i5J35O0R9JvtatB8+nYeItDRskCd0eTs5PMzDrZjIEgKQ/cCVwFbASulbSxYbPrgcMRcSHwOeCOZN+NwFbgYmAzcFdyvHHgwxHxHuASYLOk97enSfPneKuBUKgFgnsIZtb50vQQLgcGI+L5iJgAtgFbGrbZAtyXPH4YuEKSkvJtETEeEfuBQeDyqDqWbN+V/Ik5tmXeHRsvsWwWQ0Yj7iGYWQakCYQ1wMt1z4eSsqbbREQJGAZWTbevpLykp4DXga9HxM5mby7pBkm7Je0+ePBgiurOn+qQUbqrlKF+yMg9BDPrfGkCQU3KGv81P9U2U+4bEeWIuARYC1wu6d3N3jwi7o6ITRGxafXq1SmqO3+Oj5dnOYfgQDCzzpcmEIaAdXXP1wIHptpGUgEYAA6l2TcijgDfoDrH0LEiguMTLQ4ZFWpnGXnIyMw6X5pAeBzYIGm9pG6qk8TbG7bZDlyXPL4aeDQiIinfmpyFtB7YAOyStFrSCgBJfcBHgH+ae3Pmz4mJMhG01EPocQ/BzDJkxm+3iChJugl4BMgD90bEHkm3AbsjYjtwD3C/pEGqPYOtyb57JD0E7AVKwI0RUZZ0DnBfcsZRDngoIv5qPhrYLrV7IbQSCPmc6MrLPQQzy4RU324RsQPY0VB2a93jMeCaKfa9Hbi9oexp4NJWK7uYaoGwrLfA8fH0y1H0duXdQzCzTPCVyinVbo6zpDt9DwGq1yI4EMwsCxwIKR0ba33ICKCvO8+R0Yn5qJKZWVs5EFKqHzJqRX93nsPHPYdgZp3PgZDS8YnZ9RD6uwscPuEegpl1PgdCSieHjNJfqQywpDvvQDCzTHAgpHQsObNoWU9XS/v19xQYK1YYnfCNcsysszkQUjo+XiKnkwvWpdXfXe1RHHIvwcw6nAMhpdq9EKqLuKa3JAmEw8cdCGbW2RwIKbW69HVNf3LdgucRzKzTORBSavXmODWTQ0buIZhZh3MgpNTq7TNr+pN9jpzwtQhm1tkcCCkdGy+xdBaB0NeVR3IPwcw6nwMhpeOzDIR8Tizv7fIcgpl1PAdCSq3eLa3eGUu6OewhIzPrcA6ElI6OFVna4lXKNSv7u3zaqZl1vNn9k/ct4oGdLwHV22ceGy/x4o9PTJa1YmV/N68Mj7W7emZmbeUeQgqlSlAJ6CnM7se1ckk3RzyHYGYdzoGQwlixug5Rd9fshozOWNLtpSvMrOOlCgRJmyXtkzQo6eYmr/dIejB5faek8+teuyUp3yfpyqRsnaTHJD0naY+kX21Xg+bDRKkCQO8sewgr+ru8wJ2ZdbwZv+Ek5YE7gauAjcC1kjY2bHY9cDgiLgQ+B9yR7LsR2ApcDGwG7kqOVwJ+LSIuAt4P3NjkmB1jNOkh9M62h9DfDXj5CjPrbGn+yXs5MBgRz0fEBLAN2NKwzRbgvuTxw8AVqq4CtwXYFhHjEbEfGAQuj4hXIuK7ABFxFHgOWDP35syPkdHqKaPLe1tb+rpm5ZJqIPjiNDPrZGkCYQ3wct3zIU7/8p7cJiJKwDCwKs2+yfDSpcDOZm8u6QZJuyXtPnjwYIrqtt+RJBAG+mcZCO4hmFkGpAmEZus9R8ptpt1X0lLgS8BnImKk2ZtHxN0RsSkiNq1evTpFddtvZLRIPqfJhepadcaSapC4h2BmnSxNIAwB6+qerwUOTLWNpAIwAByabl9JXVTD4PMR8eXZVH6hDI8WGejrItfivRBqaj0EL3BnZp0sTSA8DmyQtF5SN9VJ4u0N22wHrkseXw08GhGRlG9NzkJaD2wAdiXzC/cAz0XE77ajIfNpeLQ46/kDgIE+9xDMrPPNeKVyRJQk3QQ8AuSBeyNij6TbgN0RsZ3ql/v9kgap9gy2JvvukfQQsJfqmUU3RkRZ0s8C/w54RtJTyVv914jY0e4GtsPwaJHzzuif9f6FfI6BPi9wZ2adLdXSFckX9Y6GslvrHo8B10yx7+3A7Q1l36T5/ELHqUQwMlpioK97TsfxAndm1ul8pfIMjo+XKEcw0De3ZZ9WeIE7M+twDoQZjIyWgJPzALN1Rn+35xDMrKM5EGYwPFr9Ep/rkJEXuDOzTudAmMFw7SrlOQ4Zrezv8gJ3ZtbRHAgzGB4tkZdmfbe0mpVLur3AnZl1NAfCDIZHJ1jeV5j1RWk1a1b0AbD3leF2VMvMrO0cCDMYHi3NeUIZ4MPvOoueQo4/f7LxIm8zs87gW2jOYGSsyLqVfXM6Ru22m+84exlf+u4Q7zh7Gfmc+NT7zmtHFc3M2sI9hGlUIibXMWqHS9at4MREmR+8frQtxzMzaycHwjROTJQpV4LlbQqEDWcvpa8rz1MvH2nL8czM2smBMI3hZKmJFW0KhEIux0+uHeC5V0YYL/lsIzPrLA6EaZy8BqE9gQBwydoVFMvBc680vf2DmdmicSBMY3gsuVNaGwPhvFX99BRyvHRotG3HNDNrBwfCNIZPFNtyUVq9nMSZS3v48bHxth3TzKwdHAjTGBkrsqwNF6U1WrW0mzccCGbWYRwI0xiZ453SpnLm0h6OnCh6YtnMOooDYRojY8W2TijXnLm0mwBePnSi7cc2M5stB8IUonantN72X8y9akkPAM8fPN72Y5uZzZYDYQpHx0tMlCvz1EOoBsILP3YgmFnnSBUIkjZL2idpUNLNTV7vkfRg8vpOSefXvXZLUr5P0pV15fdKel3Ss+1oSLu9NjwGMC9zCH3defq78+x/w4FgZp1jxkCQlAfuBK4CNgLXStrYsNn1wOGIuBD4HHBHsu9GYCtwMbAZuCs5HsCfJGUd6dWRJBDmoYcA1V6Ch4zMrJOk6SFcDgxGxPMRMQFsA7Y0bLMFuC95/DBwhSQl5dsiYjwi9gODyfGIiH8ADrWhDfPi1ckewvwsCHvm0h4PGZlZR0kTCGuAl+ueDyVlTbeJiBIwDKxKue+0JN0gabek3QcPHmxl1zl5bd57CN28NjLO8fHSvBzfzKxVaQKh2VVZkXKbNPtOKyLujohNEbFp9erVrew6J6+NjNPXlacrPz/z7qs8sWxmHSbNt90QsK7u+Vqg8bZfk9tIKgADVIeD0uzbkV4dGWN53/zdP+jMpd0Anlg2s46RJhAeBzZIWi+pm+ok8faGbbYD1yWPrwYejYhIyrcmZyGtBzYAu9pT9fn12sjYvJxhVFO7FmG/J5bNrEPMGAjJnMBNwCPAc8BDEbFH0m2SPpFsdg+wStIg8J+Bm5N99wAPAXuBrwI3RkQZQNIXgG8D75Q0JOn69jZtbl4dHpu3+QOA7kKOcwZ62e8hIzPrEKnGRCJiB7CjoezWusdjwDVT7Hs7cHuT8mtbqukCKpUrvHFsnIvPHZjX9zl/1RIPGZlZx/CVyk0cPDZOJZjXOQSAn1w7wDNDw+w94JvlmNnicyA0UbsGYWAe5xAAfulDb2egr4ubv/w0pXJlXt/LzGwmDoQmatcgLJvHOQSAlUu6+ewnLubpoWH+5FsvzOt7mZnNxIHQxGsj1ZvXzNdVyvV+7qfO4SMXncVvf20fQ4e9HLaZLR4HQhOvjozRlW/vrTOnIonPfuJiJkoVHnr85Zl3MDObJ/P/jZdBrw2Pcday3rbfOrPRAztfmnx8weql3P+dFzlrefV9P/W+8+b1vc3MGrmH0MSrI2OcvbxnQd/z0nUrOHyiyIs/9rCRmS0OB0ITr46M8baB3gV9z4vPHaA7n+PJlw4v6PuamdU4EBqMFcu8cmSMs5cvbCB0F3JcfO5ynvnRMEWfgmpmi8CB0OCP//EFRotlPrbxbQv+3peet5LxUoXnXvGFama28BwIdQ4dn+Cuxwa54l1n8dNvX7Xg73/B6iUM9HWx45lX+OYP3ljw9zeztzYHAtWzfR7Y+RI3PfBdjo2XePeagVPOAFooOYlPv/8n6Cnk+fQ9O/lvf/EsR8eKC14PM3trciAk3jg2zs7nD7Hp/DMWfP6g3poVfdz04Qv5hQ+cz59+50U+/Dt/z5eeGPLSFmY27xwIwESpwhd2vURXQVxx0VmLXR268jk2nLWMX/rQ2+kt5Pi1L36Pi279Kh/6n4/xu1//Pq8nS2uYmbXTWz4QIoI/f+pHvDo8xic3nTevN8Vp1dqV/fzih97Opy4/j03nn0EA//vRH/CzdzzGbzz8NMdmcT/mvQdGOHBktP2VNbPMe8tfqfwn33qBp14+wkcuOot3vm3ZYlfnNDmJd68Z4N1rqvdm+Jm3r+Keb+7n8ztfBOCOq38q9bGOjhX55N3fZsNZS/nyL39gXuprZtn1lg6EHc+8wm1/tZeLzlnOP3/n4g8VpfGtH/6Yi85Zzj/bsJoHd79Mb1eOd75teaqlLrbtepmjYyW++9IRnnzpMJeet3IBamxmWfGWHTL6x8E3+My2p7jsvJV8ctO6eV+3qN2ueNdZnLWsh688+SN+dGSUbbte4s7HBieX7m40Uapwzzf3c9l5K1jWW+Ceb+5f4BqbWadL1UOQtBn4fSAP/FFE/I+G13uAPwXeC/wY+GREvJC8dgtwPVAGfiUiHklzzPlQO5X0+68d5YFdL7FySRcff/c5dBeyl4uFfI5r3ruOP/j7Qe58bHCy/Pf/7gd8ctM6zl3Rx+tHx3jlyBg//fZVPDM0zKsjY1x58dvo7y7wN8++yo+OjHLO8l52vXCIC89ayplLF3b9JjPrLDMGgqQ8cCfwUWAIeFzS9ojYW7fZ9cDhiLhQ0lbgDuCTkjYCW4GLgXOBv5X0jmSfmY7ZNnsODDPQ10WpXGHn/kPseOYVzl7ey3U/cz593fn5eMsFsWZlH//2fT/ByFiRC85cSk7w998/yOd3vkglqsthTJQq7HrhEBHB2ct7eMfZSzlreQ/f+uEb/Pe/fo6hwyf43tAwy3oL/NpH38HPv+dcnh4aZvD1Y2w4eymXnreSYrnCMz8a5o2j47zzbct4x9nVuZYjJ4pUIljR30VfV55yJTg+UaaQE/3deZT0usqV4MfHxnlleIxSpcJZy3o5c2kPvV25yW0iglIlKJYrlCpBTqKQE135HPlcdZtKJRgrlcnnRHf+1H1V18MrV4KJUoWuvCjkWw/7clLQaiL1AAAG4ElEQVSPSgSFXI6uvE45fqUSTJQrSFDI5ciJU143m0pEEFF9nMud/P0tlquFtd+1sWKZkbEiPfk8y3oLk9vOtzQ9hMuBwYh4HkDSNmALUP/lvQX4bPL4YeD/qPpfyBZgW0SMA/slDSbHI8Ux2+aaP/w2JybKk883nrOcazatpaeQ3TCoueic5ac8/zeXreXjP3kOOYnuQo4fHjzG9qcOcPD4BNe8dy2SWNnfzcXnDvDXz7zCsp4CP/+ec3nuwAif/cu9fPYvZ/4IJCZ/qWsKOVGqnCzMqRpIpXKcUt6oK1/9Ra/9BzHV++V16vHzOU2+Z7kS5FQ9XTcCJuqu2SjkdMpwYHDq+0RAkPyHyuntqn+/rryoVE49fn1788l75XOaPE4QdY+r/1erQ+29meL9pepJBTmB0OTzxuxprHNjG5tt00zjcYWmfX2q4zf7GZ98rTXTfQ1OV5/GuqfdD2qfy+mfUeNnV388IZL/TX5OEVBJAqASQbkuDKD6u1nIi4lShdqvdj5X/f2ZKFVOOf7alX38v1//8PQVb4M0gbAGqL9zyxDwvqm2iYiSpGFgVVL+nYZ91ySPZzomAJJuAG5Inh6TtC9FnadyJvDGi8DfzOEgHeBMoOW1LX57ivJn51aXuZhVOzqQ29E53gxtgIZ2vADoN2Z9rJ9Iu2GaQGiWp41BP9U2U5U368c3/cdDRNwN3D1dBdOStDsiNrXjWIvJ7egsbkfneDO0ARavHWkGWIeAdXXP1wIHptpGUgEYAA5Ns2+aY5qZ2QJKEwiPAxskrZfUTXWSeHvDNtuB65LHVwOPRkQk5Vsl9UhaD2wAdqU8ppmZLaAZh4ySOYGbgEeoniJ6b0TskXQbsDsitgP3APcnk8aHqH7Bk2z3ENXJ4hJwY0SUAZods/3NO01bhp46gNvRWdyOzvFmaAMsUjsUaU4/MDOzN73sXZFlZmbzwoFgZmbAWygQJG2WtE/SoKSbF7s+05H0gqRnJD0laXdSdoakr0v6QfL3yqRckv5X0q6nJV22iPW+V9Lrkp6tK2u53pKuS7b/gaTrmr3XIrTjs5J+lHwmT0n6eN1rtyTt2CfpyrryRf2dk7RO0mOSnpO0R9KvJuWZ+UymaUOmPg9JvZJ2Sfpe0o7fSsrXS9qZ/FwfTE6yITkR58GkrjslnT9T+9qiein1m/sP1YnrHwIXAN3A94CNi12vaer7AnBmQ9n/BG5OHt8M3JE8/jjV6+wEvB/YuYj1/iBwGfDsbOsNnAE8n/y9Mnm8sgPa8VngvzTZdmPy+9QDrE9+z/Kd8DsHnANcljxeBnw/qW9mPpNp2pCpzyP5mS5NHncBO5Of8UPA1qT8D4FfSh7/MvCHyeOtwIPTta9d9Xyr9BAml9+IiAmgtlRGlmwB7kse3wf8q7ryP42q7wArJJ2zGBWMiH+gepZZvVbrfSXw9Yg4FBGHga8Dm+e/9idN0Y6pTC7PEhH7gdryLIv+OxcRr0TEd5PHR4HnqK4UkJnPZJo2TKUjP4/kZ3osedqV/Angw1SX+4HTP4vaZ/QwcIV06nJADe1ri7dKIDRbfmO6X6rFFsDXJD2h6tIdAGdHxCtQ/Y8EqN3AodPb1mq9O7k9NyVDKffWhlnISDuSIYdLqf7LNJOfSUMbIGOfh6S8pKeA16mG6g+BIxFRu/VhfZ1OWQ4IqF8OaN7a8VYJhDTLb3SSD0TEZcBVwI2SPjjNtllrW02ry50stj8A3g5cArwC/E5S3vHtkLQU+BLwmYgYmW7TJmUd0ZYmbcjc5xER5Yi4hOrKDJcDF01Tp0Vpx1slEDK1VEZEHEj+fh34CtVfntdqQ0HJ368nm3d621qtd0e2JyJeS/6DrgD/l5Pd9I5uh6Quql+kn4+ILyfFmfpMmrUhq58HQEQcAb5BdQ5hharL/TTWqdXlgNrirRIImVkqQ9ISSctqj4GPUV2QtH55kOuAv0gebwf+fXKGyPuB4dpwQIdotd6PAB+TtDIZBvhYUraoGuZl/jUnF4nt2OVZkjHne4DnIuJ3617KzGcyVRuy9nlIWi1pRfK4D/gI1fmQx6gu9wOnfxatLAfUHgs1y77Yf6ieQfF9quN2v7nY9ZmmnhdQPYvge8CeWl2pjh/+HfCD5O8z4uTZC3cm7XoG2LSIdf8C1e57keq/ZK6fTb2B/0B1smwQ+IUOacf9ST2fpvof5Tl12/9m0o59wFWd8jsH/CzV4YSngaeSPx/P0mcyTRsy9XkAPwU8mdT3WeDWpPwCql/og8AXgZ6kvDd5Ppi8fsFM7WvHHy9dYWZmwFtnyMjMzGbgQDAzM8CBYGZmCQeCmZkBDgQzM0s4EMzMDHAgmJlZ4v8DPTK0EzuGaF0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa9569c4e48>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.distplot(length_data.toPandas().dropna());\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Most of the songs length are from 0 to 500"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## User Level"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----+-----------+\n",
      "|level|user_counts|\n",
      "+-----+-----------+\n",
      "| free|        195|\n",
      "| paid|        165|\n",
      "+-----+-----------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "spark.sql('''\n",
    "        SELECT level,COUNT(DISTINCT userId) AS user_counts\n",
    "        FROM sparkify_cleaned\n",
    "        GROUP BY level\n",
    "        ORDER BY user_counts DESC\n",
    "''').show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### There  are 195 free users and 165 paid , which means 135 people upgraded their level"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## User Location"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "location_count = spark.sql('''\n",
    "        SELECT location,COUNT(DISTINCT userId) AS user_counts\n",
    "        FROM sparkify_cleaned\n",
    "        GROUP BY location\n",
    "        ORDER BY user_counts DESC\n",
    "''').toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "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>location</th>\n",
       "      <th>user_counts</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Los Angeles-Long Beach-Anaheim, CA</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>New York-Newark-Jersey City, NY-NJ-PA</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Phoenix-Mesa-Scottsdale, AZ</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Dallas-Fort Worth-Arlington, TX</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>St. Louis, MO-IL</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                location  user_counts\n",
       "0     Los Angeles-Long Beach-Anaheim, CA           16\n",
       "1  New York-Newark-Jersey City, NY-NJ-PA           15\n",
       "2            Phoenix-Mesa-Scottsdale, AZ            7\n",
       "3        Dallas-Fort Worth-Arlington, TX            7\n",
       "4                       St. Louis, MO-IL            6"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "location_count.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "#split city and state\n",
    "location_count = location_count.join(location_count['location'].str.split(',',expand=True).rename(columns={0:'city',1:'state'})).drop('location',axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa95403e6a0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "location_count.groupby('city')['user_counts'].sum().sort_values(ascending=False).plot(kind='bar',figsize=(17,5));\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa94fdd30f0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "location_count.groupby('state')['user_counts'].sum().sort_values(ascending=False).plot(kind='bar',figsize=(17,5));\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Los Angeles and New York are top cities which have the largest user count, and California is the top state has the largest user count.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Page Wise User Count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------------+-----------+\n",
      "|                page|user_counts|\n",
      "+--------------------+-----------+\n",
      "|            NextSong|     228108|\n",
      "|           Thumbs Up|      12551|\n",
      "|                Home|      10082|\n",
      "|     Add to Playlist|       6526|\n",
      "|          Add Friend|       4277|\n",
      "|         Roll Advert|       3933|\n",
      "|              Logout|       3226|\n",
      "|         Thumbs Down|       2546|\n",
      "|           Downgrade|       2055|\n",
      "|            Settings|       1514|\n",
      "|                Help|       1454|\n",
      "|             Upgrade|        499|\n",
      "|               About|        495|\n",
      "|       Save Settings|        310|\n",
      "|               Error|        252|\n",
      "|      Submit Upgrade|        159|\n",
      "|    Submit Downgrade|         63|\n",
      "|              Cancel|         52|\n",
      "|Cancellation Conf...|         52|\n",
      "+--------------------+-----------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "spark.sql('''\n",
    "        SELECT page,COUNT(userId) AS user_counts\n",
    "        FROM sparkify_cleaned\n",
    "        GROUP BY page\n",
    "        ORDER BY user_counts DESC\n",
    "''').show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### User Agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "userAgent_count = spark.sql('''\n",
    "        SELECT userAgent,COUNT(DISTINCT userId) AS user_counts\n",
    "        FROM sparkify_cleaned\n",
    "        GROUP BY userAgent\n",
    "        ORDER BY user_counts DESC\n",
    "''').toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_browser(x):\n",
    "    if 'Firefox' in x:\n",
    "        return 'Firefox'\n",
    "    elif 'Safari' in x:\n",
    "        if 'Chrome' in x:\n",
    "            return 'Chrome'\n",
    "        else:\n",
    "            return 'Safari'\n",
    "    elif 'Trident' in x:\n",
    "        return 'IE'\n",
    "    else:\n",
    "        return np.NaN\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "userAgent_count['browser'] = userAgent_count['userAgent'].apply(get_browser)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "platform_dict = {'compatible': 'Windows',  'iPad': 'iPad',  'iPhone': 'iPhone',  \n",
    "          'Macintosh': 'Mac',  'Windows NT 5.1': 'Windows','Windows NT 6.0': 'Windows', 'Windows NT 6.1': 'Windows',  \n",
    "          'Windows NT 6.2': 'Windows',  'Windows NT 6.3': 'Windows', 'X11': 'Linux'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "userAgent_count['platform'] = userAgent_count['userAgent'].str.extract(r'\\(([^\\)]*)\\)')[0].str.split(';').str[0].map(platform_dict)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa94e4a8f98>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "userAgent_count.groupby('browser')['user_counts'].sum().sort_values().plot(kind='bar');\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa94e4036d8>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "userAgent_count.groupby('platform')['user_counts'].sum().sort_values().plot(kind='bar');\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Time of day "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "time_data = spark.sql('''\n",
    "        SELECT time,userId\n",
    "        FROM sparkify_cleaned\n",
    "''').toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "time_data['time'] = pd.to_datetime(time_data['time'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "weekday_dict = {0:'Mon.',1:'Tues.',2:'Wed.',3:'Thur.',4:'Fri.',5:'Sat.',6:'Sun.'}\n",
    "time_data['weekday'] = time_data['time'].dt.weekday.map(weekday_dict)\n",
    "time_data['day'] = time_data['time'].dt.day\n",
    "time_data['hour'] = time_data['time'].dt.hour"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa94e35c358>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "time_data.groupby('weekday')['userId'].count().loc[list(weekday_dict.values())].plot(kind='bar',color='#318ce7');\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa94e327198>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "time_data.groupby('day')['userId'].count().plot(kind='bar',color='#318ce7');\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAENCAYAAADkNanAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAGP1JREFUeJzt3Xu0nXWd3/H310QQZDQBwsUkmFSjFHBUPA14mZGCA8Gxhq6BtcBZEiltVmcYoNZZAnW60iK00LGiLpVplEhilYioQzrlYuQydjoECBfDJdCcASVHQGID0Rk7aphv/3h+B7fnt/c+5+x9knNO8n6t9azz7N/z+z77t6+f/Vz2PpGZSJLU6mWTPQBJ0tRjOEiSKoaDJKliOEiSKoaDJKliOEiSKoaDJKliOEiSKoaDJKliOEiSKjMnewC9Ovjgg3PBggWTPQxJmlbuu+++H2fmnNH6TdtwWLBgARs3bpzsYUjStBIRPxhLP3crSZIqhoMkqWI4SJIqhoMkqWI4SJIqhoMkqWI4SJIqhoMkqTLql+AiYhXwPuC5zDxmxLI/Bv4UmJOZP46IAD4NvBf4GfChzLy/9F0G/EkpvSwzV5f2twHXAvsBNwEXZmZOwG2TtIsd+1+f7bjs/o8cthtHook2li2Ha4ElIxsjYj7wO8BTLc2nAovKtBy4uvQ9EFgBHAcsBlZExOxSc3XpO1xXXZckafcaNRwy87vA9jaLrgI+CrR+yl8KrMnGBmBWRBwOnAKsz8ztmfk8sB5YUpa9KjPvKlsLa4DT+rtJkqR+9fTbShHxfuCHmfm9Zk/SS+YCW1suD5W2bu1Dbdol7cHcHTX1jTscImJ/4GPAye0Wt2nLHto7Xfdyml1QHHHEEaOOVZLUm162HF4HLASGtxrmAfdHxGKaT/7zW/rOA54u7SeMaL+ztM9r07+tzFwJrAQYGBjwoLU0Qfwkr5HGfSprZj6UmYdk5oLMXEDzBn9sZj4LrAPOjsbxwI7MfAa4FTg5ImaXA9EnA7eWZT+NiOPLmU5nAzdO0G2TJPVo1HCIiOuAu4A3RsRQRJzbpftNwBPAIPAF4A8BMnM78HHg3jJdWtoA/gD4Yqn5G+Dm3m6KJGmijLpbKTPPGmX5gpb5BM7r0G8VsKpN+0bgmLpCkjRZ/Ia0JKkybf9NqKS9jwfOdx+3HCRJFcNBklRxt5KkPZ67o8bPLQdJUsVwkCRV3K0kSR3szbuj3HKQJFUMB0lSxXCQJFUMB0lSxQPS0h5kbz6AqonlloMkqeKWgyRNsD1hC84tB0lSxXCQJFUMB0lSxXCQJFUMB0lSZdRwiIhVEfFcRDzc0vanEfFYRGyKiG9FxKyWZZdExGBEPB4Rp7S0LyltgxFxcUv7woi4OyK2RMTXImKfibyBkqTxG8uprNcCnwXWtLStBy7JzJ0RcSVwCXBRRBwFnAkcDbwG+E5EvKHUfA74HWAIuDci1mXmo8CVwFWZuTYi/gw4F7i6/5smSdPLVDoFdtQth8z8LrB9RNu3M3NnubgBmFfmlwJrM/PnmfkkMAgsLtNgZj6Rmb8A1gJLIyKAE4EbSv1q4LQ+b5MkqU8TcczhXwA3l/m5wNaWZUOlrVP7QcALLUEz3C5JmkR9hUNEfAzYCXxluKlNt+yhvdP1LY+IjRGxcdu2beMdriRpjHoOh4hYBrwP+P3MHH5DHwLmt3SbBzzdpf3HwKyImDmiva3MXJmZA5k5MGfOnF6HLkkaRU+/rRQRS4CLgHdn5s9aFq0DvhoRn6Q5IL0IuIdmC2FRRCwEfkhz0PoDmZkRcQdwOs1xiGXAjb3eGGlPMpUOTmrvM2o4RMR1wAnAwRExBKygOTtpX2B9c0yZDZn5rzPzkYi4HniUZnfTeZn5YlnPHwG3AjOAVZn5SLmKi4C1EXEZ8ABwzQTePkna4+2KDxKjhkNmntWmueMbeGZeDlzepv0m4KY27U/QnM0kSZoi/Ia0JKliOEiSKoaDJKnif4KTdjHPOtJ05JaDJKliOEiSKoaDJKliOEiSKoaDJKmyR5yt5NkgkjSx3HKQJFUMB0lSxXCQJFX2iGMO0nj0eozKY1vam7jlIEmqGA6SpIrhIEmqGA6SpIrhIEmqGA6SpMqo4RARqyLiuYh4uKXtwIhYHxFbyt/ZpT0i4jMRMRgRmyLi2JaaZaX/lohY1tL+toh4qNR8JiJiom+kJGl8xvI9h2uBzwJrWtouBm7LzCsi4uJy+SLgVGBRmY4DrgaOi4gDgRXAAJDAfRGxLjOfL32WAxuAm4AlwM393zTt6fzegbTrjBoOmfndiFgwonkpcEKZXw3cSRMOS4E1mZnAhoiYFRGHl77rM3M7QESsB5ZExJ3AqzLzrtK+BjiN3RQOu/vNxTczSdNFr9+QPjQznwHIzGci4pDSPhfY2tJvqLR1ax9q0z6l+SYvaU830T+f0e54QfbQ3n7lEctpdkFxxBFH9DK+vcp0CbHpMk5pb9JrOPwoIg4vWw2HA8+V9iFgfku/ecDTpf2EEe13lvZ5bfq3lZkrgZUAAwMDHUNkT+Obp6TdrddTWdcBw2ccLQNubGk/u5y1dDywo+x+uhU4OSJmlzObTgZuLct+GhHHl7OUzm5ZlyRpkoy65RAR19F86j84IoZozjq6Arg+Is4FngLOKN1vAt4LDAI/A84ByMztEfFx4N7S79Lhg9PAH9CcEbUfzYFoz1SaZP5qqaSxnK10VodFJ7Xpm8B5HdazCljVpn0jcMxo45Ak7T5+Q1qSVDEcJEkVw0GSVDEcJEkVw0GSVDEcJEkVw0GSVDEcJEkVw0GSVDEcJEkVw0GSVDEcJEkVw0GSVDEcJEkVw0GSVDEcJEkVw0GSVDEcJEkVw0GSVDEcJEmVvsIhIj4cEY9ExMMRcV1EvCIiFkbE3RGxJSK+FhH7lL77lsuDZfmClvVcUtofj4hT+rtJkqR+9RwOETEXuAAYyMxjgBnAmcCVwFWZuQh4Hji3lJwLPJ+ZrweuKv2IiKNK3dHAEuDzETGj13FJkvrX726lmcB+ETET2B94BjgRuKEsXw2cVuaXlsuU5SdFRJT2tZn588x8EhgEFvc5LklSH3oOh8z8IfAJ4CmaUNgB3Ae8kJk7S7chYG6ZnwtsLbU7S/+DWtvb1EiSJkE/u5Vm03zqXwi8BnglcGqbrjlc0mFZp/Z217k8IjZGxMZt27aNf9CSpDHpZ7fSe4AnM3NbZv4S+CbwDmBW2c0EMA94uswPAfMByvJXA9tb29vU/JrMXJmZA5k5MGfOnD6GLknqpp9weAo4PiL2L8cOTgIeBe4ATi99lgE3lvl15TJl+e2ZmaX9zHI200JgEXBPH+OSJPVp5uhd2svMuyPiBuB+YCfwALAS+J/A2oi4rLRdU0quAb4cEYM0WwxnlvU8EhHX0wTLTuC8zHyx13FJkvrXczgAZOYKYMWI5idoc7ZRZv49cEaH9VwOXN7PWCRJE8dvSEuSKoaDJKliOEiSKoaDJKliOEiSKoaDJKliOEiSKoaDJKliOEiSKoaDJKliOEiSKoaDJKliOEiSKoaDJKliOEiSKoaDJKliOEiSKoaDJKliOEiSKoaDJKnSVzhExKyIuCEiHouIzRHx9og4MCLWR8SW8nd26RsR8ZmIGIyITRFxbMt6lpX+WyJiWb83SpLUn363HD4N3JKZRwJvBjYDFwO3ZeYi4LZyGeBUYFGZlgNXA0TEgcAK4DhgMbBiOFAkSZOj53CIiFcBvw1cA5CZv8jMF4ClwOrSbTVwWplfCqzJxgZgVkQcDpwCrM/M7Zn5PLAeWNLruCRJ/etny+EfAduAL0XEAxHxxYh4JXBoZj4DUP4eUvrPBba21A+Vtk7tkqRJ0k84zASOBa7OzLcCf8evdiG1E23askt7vYKI5RGxMSI2btu2bbzjlSSNUT/hMAQMZebd5fINNGHxo7K7iPL3uZb+81vq5wFPd2mvZObKzBzIzIE5c+b0MXRJUjc9h0NmPgtsjYg3lqaTgEeBdcDwGUfLgBvL/Drg7HLW0vHAjrLb6Vbg5IiYXQ5En1zaJEmTZGaf9ecDX4mIfYAngHNoAuf6iDgXeAo4o/S9CXgvMAj8rPQlM7dHxMeBe0u/SzNze5/jkiT1oa9wyMwHgYE2i05q0zeB8zqsZxWwqp+xSJImjt+QliRVDAdJUsVwkCRVDAdJUsVwkCRVDAdJUsVwkCRVDAdJUsVwkCRVDAdJUsVwkCRVDAdJUsVwkCRVDAdJUsVwkCRVDAdJUsVwkCRVDAdJUsVwkCRVDAdJUqXvcIiIGRHxQET8Rbm8MCLujogtEfG1iNintO9bLg+W5Qta1nFJaX88Ik7pd0ySpP5MxJbDhcDmlstXAldl5iLgeeDc0n4u8Hxmvh64qvQjIo4CzgSOBpYAn4+IGRMwLklSj/oKh4iYB/wu8MVyOYATgRtKl9XAaWV+ablMWX5S6b8UWJuZP8/MJ4FBYHE/45Ik9affLYdPAR8F/qFcPgh4ITN3lstDwNwyPxfYClCW7yj9X2pvUyNJmgQ9h0NEvA94LjPva21u0zVHWdatZuR1Lo+IjRGxcdu2beMaryRp7PrZcngn8P6I+D6wlmZ30qeAWRExs/SZBzxd5oeA+QBl+auB7a3tbWp+TWauzMyBzByYM2dOH0OXJHXTczhk5iWZOS8zF9AcUL49M38fuAM4vXRbBtxY5teVy5Tlt2dmlvYzy9lMC4FFwD29jkuS1L+Zo3cZt4uAtRFxGfAAcE1pvwb4ckQM0mwxnAmQmY9ExPXAo8BO4LzMfHEXjEuSNEYTEg6ZeSdwZ5l/gjZnG2Xm3wNndKi/HLh8IsYiSeqf35CWJFUMB0lSxXCQJFUMB0lSxXCQJFUMB0lSxXCQJFUMB0lSxXCQJFUMB0lSxXCQJFUMB0lSxXCQJFUMB0lSxXCQJFUMB0lSxXCQJFUMB0lSxXCQJFUMB0lSpedwiIj5EXFHRGyOiEci4sLSfmBErI+ILeXv7NIeEfGZiBiMiE0RcWzLupaV/lsiYln/N0uS1I9+thx2Ah/JzH8MHA+cFxFHARcDt2XmIuC2chngVGBRmZYDV0MTJsAK4DhgMbBiOFAkSZOj53DIzGcy8/4y/1NgMzAXWAqsLt1WA6eV+aXAmmxsAGZFxOHAKcD6zNyemc8D64ElvY5LktS/CTnmEBELgLcCdwOHZuYz0AQIcEjpNhfY2lI2VNo6tUuSJknf4RARBwDfAP5NZv6kW9c2bdmlvd11LY+IjRGxcdu2beMfrCRpTPoKh4h4OU0wfCUzv1maf1R2F1H+Plfah4D5LeXzgKe7tFcyc2VmDmTmwJw5c/oZuiSpi37OVgrgGmBzZn6yZdE6YPiMo2XAjS3tZ5ezlo4HdpTdTrcCJ0fE7HIg+uTSJkmaJDP7qH0n8EHgoYh4sLT9O+AK4PqIOBd4CjijLLsJeC8wCPwMOAcgM7dHxMeBe0u/SzNzex/jkiT1qedwyMy/ov3xAoCT2vRP4LwO61oFrOp1LJKkieU3pCVJFcNBklQxHCRJFcNBklQxHCRJFcNBklQxHCRJFcNBklQxHCRJFcNBklQxHCRJFcNBklQxHCRJFcNBklQxHCRJFcNBklQxHCRJFcNBklQxHCRJFcNBklSZMuEQEUsi4vGIGIyIiyd7PJK0N5sS4RARM4DPAacCRwFnRcRRkzsqSdp7TYlwABYDg5n5RGb+AlgLLJ3kMUnSXmuqhMNcYGvL5aHSJkmaBJGZkz0GIuIM4JTM/Jfl8geBxZl5/oh+y4Hl5eIbgcc7rPJg4Mc9DGU61E2HMVpnnXVTt+61mTln1DVk5qRPwNuBW1suXwJc0sf6Nu6pddNhjNZZZ930rGudpspupXuBRRGxMCL2Ac4E1k3ymCRprzVzsgcAkJk7I+KPgFuBGcCqzHxkkoclSXutKREOAJl5E3DTBK1u5R5cNx3GaJ111k3PupdMiQPSkqSpZaocc5AkTSGGgySpMmWOOfQqIo6k+Tb1XCCBp4F1mbl5Ugc2QkQsBjIz7y0/DbIEeKwcaxnPetZk5tm7ZJC7WcuZaU9n5nci4gPAO4DNwMrM/OWkDlDai03rYw4RcRFwFs3PbQyV5nk0bzhrM/OKXXCdR9IE0d2Z+bct7Usy85YONStofjdqJrAeOA64E3gPzfc7Lu9QN/J03gD+KXA7QGa+f4xjfhfNT5Q8nJnf7tLvOGBzZv4kIvYDLgaOBR4F/lNm7uhQdwHwrczc2m55l+v7Cs19sj/wAnAA8E3gJJrn5rIuta8D/jkwH9gJbAGu6zRGSePU7xclJnMC/g/w8jbt+wBb+ljvOR3aL6D5VvafA98HlrYsu7/L+h6iOUV3f+AnwKtK+37Api519wP/HTgBeHf5+0yZf3eXunta5v8V8CCwAvjfwMVd6h4BZpb5lcCngHeV2m92qdtBs8X2v4A/BOaM8X7eVP7OBH4EzCiXY5T75QKakP0T4K+BzwOX04TYCZP9vJxKE3DIbr6+gyb7Nk/Q7Xg1cAXwGPB/y7S5tM3qcZ03d1n2KuA/A18GPjBi2ee71B0GXE3zw6UHAf+hvN9cDxze130w2Q9Cnw/gYzRfBR/Z/lrg8T7W+1SH9oeAA8r8AmAjcGG5/ECX9T3Qbr5cfrBL3cuAD5c3wreUtifGMP7W67t3+M0aeCXwUJe6zS3z949jnA+UsZ4MXANsA24BlgG/0aXuYZognw38FDiwtL+idSwdHofhINkfuLPMHzHK47BHv+CBA0dMB9F8iJk9fN92qFsy4j66BtgEfBU4tEvdFcDBZX4AeAIYBH5A9w8v99ME++vGeV8PAHfQfGCaX14XO8pz/K1d6g4ALqX58LOjPD83AB/qUnMrcBFw2IjH5SJgfZe6YztMbwOe6VL3jXJ/nkbzBeBvAPu2ey2OqLsFOJ9mK39TGd8Rpe3GXp7TL627n+LJnmj22w8CN9N80l1Z7qzB1id8h9pNHaaHgJ93qHm0zZPuFuCTdH/zvBvYv8y/rKX91d0e+JZ+84CvA5+lQ3CN6P+98oZwECO+Rk/3N8+vU7aagC8BA2X+DcC9XepGBsnLgfcD1wHbutR9uLyh/IBma+A24AvlMVjRpe6hlhfObOC+lmUPd6nbo1/wwD8AT46Yfln+dvxQ0ToW4IvAZTQfsD4M/Hm3x6Fl/g7gn7Q8Xzr+fEMZzyeAp4B7yvW8ZgzP63tods+eRfNDnaeX9pOAu7rU3Qh8qLyO/i3w74FFwGqa3aXtajp+uBxl2Ys0u33vaDP9vy51D464/DGaLf2DRnmutH4QfKrbOsc79Vw4VSaaT6zHA78HnF7mZ4yh7kfAW8qLoHVaQHOAtF3N7ZRP8C1tM4E1wItdrmvfDu0HA28ax2393U5P5hH9vk/zpvtk+XtYaT+g2xOGJqyuBf6GJtB+Wer/EnjzWJ6gbZbtN8pYXzP8xgDMKo/h4lFqLqR501xJsxUwHGhzgO92qdujX/DAH9MEy5ta2p4cw/Pl/k7rH+X6HuNXuyE3jFjWbQu19fp+i2a34LPl/lze4/3S7Tn4vRGX7y1/X0ZzUki7mm8DH6Vlywk4lCaov9Pluh4GFnVYtrVL3WZaPjiWtmU0Wzs/GMttAy4b62Mwlqnnwuk+0Ww6v6vDsq92aJ9Hy6fOEcveOdm3aQy3eX9g4Rj6/QbwZppPxh13K7T0f8Mk3JajS5AcOY6aPf4Fz6+2Mj9ZHsex7IYcovlE/RGaDwPRsqzbsZ/zy316Is2ur08Bvw38R+DLXeqqYKQ5JrcE+FKXurtodl2eQbO1eVppfzfdt1T+evi1Dvwzfv1HPtt+KKDZIr2SJgCfB7aXx/NKuu+iOx14Y4dlp3Wp+y/Ae9q0L6HL8VOa3WUHtGl/PXDDWF4XHdfdT7GT03SaRrzgt494wc/uUjftXvDlTXAD8OwY+q4YMQ0fozoMWDNK7QnA12iOOz1E8xM4yylbFB1q1vb4+L2ZZtfgzcCRwKdpznJ7BHhHl7rfpNkl9QLwV5QPMzRbmhd0qTuS5ozCA0a0j7bL+kiaXV0TVXfqrri+Ue/vfoqdnPaUiQ5nqE3nOpqz4Y6Z6uOcinX0fmZir3Xn7866Md03/RQ7Oe0pE2M40G/d3lNH72cmTou6sUzT/hvS0lhFxKZOi2iOPVhn3bAZWb7kmpnfj4gTgBsi4rWlrpPpUjcqw0F7k0OBU2gOMLYKmoOW1lk37NmIeEtmPgiQmX8bEe8DVgFv6nJd06VuVIaD9iZ/QbMJ/uDIBRFxp3XWtTib5mdZXpKZO4GzI+K/dbmu6VI3qmn920qSpF3Dn+yWJFUMB0lSxXCQxigiFkTEw5M9Dml3MBykSRQRnhSiKclwkMZnRkR8ISIeiYhvR8R+EfGWiNgQEZsi4lsRMRuaM2EiYqDMHxwR3y/zH4qIr0fE/6D5bSJpyjEcpPFZBHwuM4+m+a2e36P5Vd6LMvM3KT83Pob1vB1Ylpkn7rKRSn0wHKTxebLlfPn7gNfR/KOgvyxtq2l+mXQ06zNz+64YoDQRDAdpfH7eMv8izf+g6GQnv3qNvWLEsr+byEFJE81wkPqzA3g+In6rXP4gzT9HguZXMt9W5k/fzeOS+uKZElL/lgF/FhH70/yznHNK+yeA6yPigzT/SU6aNvz5DElSxd1KkqSK4SBJqhgOkqSK4SBJqhgOkqSK4SBJqhgOkqSK4SBJqvx/AhhOA/Qmgd0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa94d97b080>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "time_data.groupby('hour')['userId'].count().plot(kind='bar',color='#318ce7');\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Users behaviors are periodic, they use Sparkify more often in weekdays than weekend; In one single day, they use Sparkify more often after 14 o'clock.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define Churn\n",
    "\n",
    "Once you've done some preliminary analysis, create a column `Churn` to use as the label for your model. I suggest using the `Cancellation Confirmation` events to define your churn, which happen for both paid and free users. As a bonus task, you can also look into the `Downgrade` events."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Row(page='Cancel'),\n",
       " Row(page='Submit Downgrade'),\n",
       " Row(page='Thumbs Down'),\n",
       " Row(page='Home'),\n",
       " Row(page='Downgrade'),\n",
       " Row(page='Roll Advert'),\n",
       " Row(page='Logout'),\n",
       " Row(page='Save Settings'),\n",
       " Row(page='Cancellation Confirmation'),\n",
       " Row(page='About'),\n",
       " Row(page='Settings'),\n",
       " Row(page='Add to Playlist'),\n",
       " Row(page='Add Friend'),\n",
       " Row(page='NextSong'),\n",
       " Row(page='Thumbs Up'),\n",
       " Row(page='Help'),\n",
       " Row(page='Upgrade'),\n",
       " Row(page='Error'),\n",
       " Row(page='Submit Upgrade')]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#first we should define a column named Churn as dataset's label for predict\n",
    "#find the flag event\n",
    "df_cleaned.select('page').dropDuplicates().collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "#define the flag event udf to transform event to 0 or 1\n",
    "flag_event = udf(lambda x : 1 if x=='Cancellation Confirmation' else 0, IntegerType())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "#define the current churn or not state\n",
    "df_cleaned_cancel = df_cleaned.withColumn('Churn_state',flag_event('page'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "#mark the user who have churned event\n",
    "userwindow = Window.partitionBy('userId').rangeBetween(Window.unboundedPreceding,Window.unboundedFollowing)\n",
    "df_cleaned_cancel = df_cleaned_cancel.withColumn('Churn',fmax('Churn_state').over(userwindow))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Row(artist='Sleeping With Sirens', auth='Logged In', firstName='Darianna', gender='F', itemInSession=0, lastName='Carpenter', length=202.97098, level='free', location='Bridgeport-Stamford-Norwalk, CT', method='PUT', page='NextSong', registration=1538016340000, sessionId=31, song='Captain Tyin Knots VS Mr Walkway (No Way)', status=200, ts=1539003534000, userAgent='\"Mozilla/5.0 (iPhone; CPU iPhone OS 7_1_2 like Mac OS X) AppleWebKit/537.51.2 (KHTML, like Gecko) Version/7.0 Mobile/11D257 Safari/9537.53\"', userId='100010', time='2018-10-08 12:58:54', Churn_state=0, Churn=0)]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_cleaned_cancel.take(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Row(Churn=1, count=52), Row(Churn=0, count=173)]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_cleaned_cancel.dropDuplicates(['userId']).select('Churn').groupby('Churn').count().collect()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### So, there are 52 users have churned events in the dataset, it's about 23.1% churned rate. The rate of churn and not churn is roughly 1:3\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalize_data(groupby_data):\n",
    "    groupby_series = groupby_data.set_index(list(groupby_data.columns[:2]))\n",
    "    temp = groupby_series.unstack('Churn').fillna(0)\n",
    "    df = pd.DataFrame(((temp - temp.min()) / (temp.max() - temp.min())).stack()).reset_index()\n",
    "    df = df.rename(columns={df.columns[-1]:'result'})\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "get_hour = udf(lambda x: datetime.datetime.fromtimestamp(x / 1000.0).hour)\n",
    "get_day = udf(lambda x: datetime.datetime.fromtimestamp(x / 1000.0).day)\n",
    "get_weekday = udf(lambda x: datetime.datetime.fromtimestamp(x / 1000.0).strftime('%w'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_cleaned_cancel = df_cleaned_cancel.withColumn('hour', get_hour(df_cleaned_cancel.ts))\n",
    "df_cleaned_cancel = df_cleaned_cancel.withColumn('day', get_day(df_cleaned_cancel.ts))\n",
    "df_cleaned_cancel = df_cleaned_cancel.withColumn('dayofweek', get_weekday(df_cleaned_cancel.ts))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "hour_data = df_cleaned_cancel.select([\"Churn\", \"hour\"]).groupby([\"Churn\", \"hour\"]).count().sort(\"hour\").toPandas()\n",
    "day_data = df_cleaned_cancel.select([\"Churn\", \"day\"]).groupby([\"Churn\", \"day\"]).count().sort(\"day\").toPandas()\n",
    "dayofweek_data = df_cleaned_cancel.select([\"Churn\", \"dayofweek\"]).groupby([\"Churn\", \"dayofweek\"]).count().sort(\"dayofweek\").toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "hour_data = normalize_data(hour_data)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa96adedda0>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(10,5))\n",
    "sns.barplot( x=\"hour\",y=\"result\", hue=\"Churn\", data=hour_data,ax=ax,order=list(map(lambda x: str(x),range(23))));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "day_data = normalize_data(day_data)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa94571e278>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(10,5))\n",
    "sns.barplot( x=\"day\",y=\"result\", hue=\"Churn\", data=day_data,ax=ax,order=list(map(lambda x: str(x),range(1,32))));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "dayofweek_data = normalize_data(dayofweek_data)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa94620cc18>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(10,5))\n",
    "sns.barplot( x=\"dayofweek\",y=\"result\", hue=\"Churn\", data=dayofweek_data,ax=ax);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "browser = udf(lambda x : get_browser(x))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "#get browsers\n",
    "df_cleaned_cancel = df_cleaned_cancel.withColumn('browser',browser(df_cleaned_cancel.userAgent))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "get_platform = udf(lambda x: platform_dict[re.findall(r'\\(([^\\)]*)\\)',x)[0].split(';')[0]])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "#get platform\n",
    "df_cleaned_cancel = df_cleaned_cancel.withColumn('platform',get_platform(df_cleaned_cancel.userAgent))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "browser_data = df_cleaned_cancel.select([\"browser\",\"Churn\"]).groupby([ \"browser\",\"Churn\"]).count().sort(\"browser\").toPandas()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "browser_data = normalize_data(browser_data)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fa946cbca90>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(8,8))\n",
    "sns.barplot( x=\"result\",y=\"browser\", hue=\"Churn\", data=browser_data,ax=ax);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Feature Engineering\n",
    "Once you've familiarized yourself with the data, build out the features you find promising to train your model on. To work with the full dataset, you can follow the following steps.\n",
    "- Write a script to extract the necessary features from the smaller subset of data\n",
    "- Ensure that your script is scalable, using the best practices discussed in Lesson 3\n",
    "- Try your script on the full data set, debugging your script if necessary\n",
    "\n",
    "If you are working in the classroom workspace, you can just extract features based on the small subset of data contained here. Be sure to transfer over this work to the larger dataset when you work on your Spark cluster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      " |-- artist: string (nullable = true)\n",
      " |-- auth: string (nullable = true)\n",
      " |-- firstName: string (nullable = true)\n",
      " |-- gender: string (nullable = true)\n",
      " |-- itemInSession: long (nullable = true)\n",
      " |-- lastName: string (nullable = true)\n",
      " |-- length: double (nullable = true)\n",
      " |-- level: string (nullable = true)\n",
      " |-- location: string (nullable = true)\n",
      " |-- method: string (nullable = true)\n",
      " |-- page: string (nullable = true)\n",
      " |-- registration: long (nullable = true)\n",
      " |-- sessionId: long (nullable = true)\n",
      " |-- song: string (nullable = true)\n",
      " |-- status: long (nullable = true)\n",
      " |-- ts: long (nullable = true)\n",
      " |-- userAgent: string (nullable = true)\n",
      " |-- userId: string (nullable = true)\n",
      " |-- time: string (nullable = true)\n",
      " |-- Churn_state: integer (nullable = true)\n",
      " |-- Churn: integer (nullable = true)\n",
      " |-- hour: string (nullable = true)\n",
      " |-- day: string (nullable = true)\n",
      " |-- dayofweek: string (nullable = true)\n",
      " |-- browser: string (nullable = true)\n",
      " |-- platform: string (nullable = true)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df_cleaned_cancel.printSchema()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### On the basis of the above EDA, we can create features as follows:\n",
    "\n",
    "##### Categorical Features \n",
    "* gender\n",
    "* level\n",
    "* browser\n",
    "* platform\n",
    "##### Numerical Features\n",
    "* mean,max,min,std of length of users\n",
    "* numbers of these item in page (NextSong,ThumbsUp, ThumbsDown, AddtoPlaylist, AddFriend, RollAdvert)\n",
    "* number of unique songs and total songs of users\n",
    "* number of unique artists of users\n",
    "* percentage of operations after 15th in a month\n",
    "* percentage of operations in workday"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "def label_encoding(col_name):\n",
    "    '''\n",
    "    transform categorical items to number\n",
    "    '''\n",
    "    temp = df_cleaned_cancel.select([col_name]).dropDuplicates().toPandas()\n",
    "    label_dict = {val:str(idx) for idx,val in enumerate(temp[col_name].tolist())}\n",
    "    result = df_cleaned_cancel.dropDuplicates(['userId']).select(['userId',col_name]).replace(label_dict,subset=col_name)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_categorical_features():\n",
    "    '''\n",
    "    join all categorical features together\n",
    "    '''\n",
    "    feature_gender = label_encoding('gender')\n",
    "    feature_level = label_encoding('level')\n",
    "    feature_browser = label_encoding('browser')\n",
    "    feature_platform = label_encoding('platform')\n",
    "    \n",
    "    result = feature_gender.join(feature_level,on='userId',how='inner').\\\n",
    "                            join(feature_browser,on='userId',how='inner').\\\n",
    "                            join(feature_platform,on='userId',how='inner')\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "categorical_feature = get_categorical_features()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------+------+-----+-------+--------+\n",
      "|userId|gender|level|browser|platform|\n",
      "+------+------+-----+-------+--------+\n",
      "|100010|     0|    0|      1|       1|\n",
      "|200002|     1|    0|      1|       1|\n",
      "+------+------+-----+-------+--------+\n",
      "only showing top 2 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "categorical_feature.show(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_numerical_features():\n",
    "    '''\n",
    "    join all numerical features together and implement Standscaler\n",
    "    '''\n",
    "    #length\n",
    "    feature_length = df_cleaned_cancel.select([\"userId\", \"length\"]).groupby([\"userId\"]).agg(avg('length').alias('mean_length'), \n",
    "                                                                     stddev('length').alias('stdev_length'),\n",
    "                                                                    fmax('length').alias('max_length'),\n",
    "                                                                    fmin('length').alias('min_length'))\n",
    "    \n",
    "    #page, reference url:https://stackoverflow.com/questions/56051438/pivot-table-in-pyspark\n",
    "    page_count = df_cleaned_cancel.select([\"userId\",\"page\"]).groupby([\"userId\",\"page\"]).count()\n",
    "    # create the pivot table\n",
    "    temp1 = page_count.groupby('userId').pivot('page').agg(first('count')).fillna(0)\n",
    "    # filter columns\n",
    "    temp1 = temp1.select(['userId','NextSong','Thumbs Up', 'Thumbs Down', 'Add to Playlist', 'Add Friend', 'Roll Advert'])\n",
    "    # column names used to sum up for total\n",
    "    cols = temp1.columns[1:]\n",
    "    # calculate the total \n",
    "    feature_page = temp1.withColumn('total', sum([col(c) for c in cols]))    \n",
    "    \n",
    "    \n",
    "    #unique songs number\n",
    "    feature_nunique_song = df_cleaned_cancel.filter(df_cleaned_cancel.page=='NextSong').select([\"userId\",\"song\"]).\\\n",
    "                                             dropDuplicates([\"userId\",\"song\"]).groupby([\"userId\"]).count()\n",
    "    feature_nunique_song = feature_nunique_song.selectExpr(\"userId as userId\",\"count as nunique_song\")\n",
    "    \n",
    "    #total songs number\n",
    "    feature_ntotal_song = df_cleaned_cancel.filter(df_cleaned_cancel.page=='NextSong').select([\"userId\",\"song\"]).\\\n",
    "                                             groupby([\"userId\"]).count()\n",
    "    #source:https://exceptionshub.com/how-to-change-dataframe-column-names-in-pyspark.html\n",
    "    feature_ntotal_song = feature_ntotal_song.selectExpr(\"userId as userId\",\"count as ntotal_song\")\n",
    "    \n",
    "    #unique artists artist\n",
    "    feature_nunique_artist = df_cleaned_cancel.filter(df_cleaned_cancel.page=='NextSong').select([\"userId\",\"artist\"]).\\\n",
    "                                               dropDuplicates([\"userId\",\"artist\"]).groupby([\"userId\"]).count()\n",
    "    feature_nunique_artist = feature_nunique_artist.selectExpr(\"userId as userId\",\"count as nunique_artist\")\n",
    "    \n",
    "    #percentage of opretions\n",
    "    day_count = df_cleaned_cancel.filter(df_cleaned_cancel.day>=15).select(['userId']).groupby([\"userId\"]).count()\n",
    "    day_count = day_count.selectExpr(\"userId as userId\",\"count as day_count\")\n",
    "    \n",
    "    total_count = df_cleaned_cancel.select(['userId']).groupby([\"userId\"]).count()\n",
    "    total_count = total_count.selectExpr(\"userId as userId\",\"count as total_count\")\n",
    "    \n",
    "    dayofweek_count = df_cleaned_cancel.filter(df_cleaned_cancel.dayofweek<5).select(['userId']).groupby([\"userId\"]).count()\n",
    "    dayofweek_count = dayofweek_count.selectExpr(\"userId as userId\",\"count as dayofweek_count\")\n",
    "    \n",
    "    feature_percentage_month = (total_count.alias(\"total\").join(day_count.alias(\"day\"), [\"userId\"]).\\\n",
    "                              select(col(\"userId\"), (col(\"day.day_count\") / col(\"total.total_count\")).alias(\"month_percentage\")))\n",
    "    \n",
    "    feature_percentage_week = (total_count.alias(\"total\").join(dayofweek_count.alias(\"day\"), [\"userId\"]).\\\n",
    "                          select(col(\"userId\"), (col(\"day.dayofweek_count\") / col(\"total.total_count\")).alias(\"week_percentage\")))\n",
    "    \n",
    "    #merge together\n",
    "    result = feature_length.join(feature_page,on='userId',how='inner').\\\n",
    "                        join(feature_nunique_song,on='userId',how='inner').\\\n",
    "                        join(feature_ntotal_song,on='userId',how='inner').\\\n",
    "                        join(feature_nunique_artist,on='userId',how='inner').\\\n",
    "                        join(feature_percentage_month,on='userId',how='inner').\\\n",
    "                        join(feature_percentage_week,on='userId',how='inner')\n",
    "    \n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "label = df_cleaned_cancel.select(['userId','Churn']).dropDuplicates()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_data_for_train():\n",
    "    '''\n",
    "    merge features and label together\n",
    "    '''\n",
    "    categorical_feature = get_categorical_features()\n",
    "    numerical_feature = get_numerical_features()\n",
    "    label = df_cleaned_cancel.select(['userId','Churn']).dropDuplicates()\n",
    "    result = categorical_feature.join(numerical_feature,on='userId',how='inner').join(label,on='userId',how='inner')\n",
    "    \n",
    "    #correct datatype\n",
    "    for col_name in result.columns[1:5]:\n",
    "        result = result.withColumn(col_name, result[col_name].cast(IntegerType()))\n",
    "    for col_name in result.columns[5:-1]:\n",
    "        result = result.withColumn(col_name, result[col_name].cast(FloatType()))\n",
    "    \n",
    "    #fill NaN\n",
    "    result = result.na.fill(0)\n",
    "    \n",
    "  \n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_data = get_data_for_train()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "#backup final_data \n",
    "final_data.write.save('final_data_new3.json',format='json',header=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_data = spark.read.json('final_data_new2.json')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_data_columns = final_data.columns\n",
    "final_data_columns.remove('Churn')\n",
    "final_data_columns.remove('userId')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "categorical_features = ['gender','level','browser','platform']\n",
    "numerical_features = [col_name for col_name in final_data_columns if col_name not in categorical_features]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "check_df = final_data.toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(204, 22)"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check_df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "#implement standscaler\n",
    "vector = VectorAssembler(inputCols=numerical_features, outputCol='numerical_features')\n",
    "temp = vector.transform(final_data)\n",
    "scaler = StandardScaler(withMean=True, withStd=True, inputCol='numerical_features', outputCol='features_scaled')\n",
    "scaler_fit = scaler.fit(temp)\n",
    "result_scaled = scaler_fit.transform(temp)\n",
    "\n",
    "#add categorical features to feature vector\n",
    "\n",
    "vector = VectorAssembler(inputCols=categorical_features+['features_scaled'], outputCol='all_features')\n",
    "result_scaled = vector.transform(result_scaled)\n",
    "final_result = result_scaled.select(result_scaled.Churn.alias('label'), result_scaled.all_features.alias('features'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modeling\n",
    "Split the full dataset into train, test, and validation sets. Test out several of the machine learning methods you learned. Evaluate the accuracy of the various models, tuning parameters as necessary. Determine your winning model based on test accuracy and report results on the validation set. Since the churned users are a fairly small subset, I suggest using F1 score as the metric to optimize."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "def undersample(df): \n",
    "    '''\n",
    "    Implement undersample on dataset, return a balanced dataset.\n",
    "    '''    \n",
    "    # size of minority class(0)\n",
    "    minoritySize = df.where(df.label == '1').count()\n",
    "    \n",
    "    # two classes with the same size\n",
    "    df_minority = df.where(df.label == '1')\n",
    "    df_majority = df.where(df.label == '0').sample(1.0, seed=7).limit(minoritySize)\n",
    "    \n",
    "    # concatenate them together\n",
    "    result = df_minority.union(df_majority)\n",
    "    \n",
    "    #shuffle data\n",
    "    result = result.orderBy(rand())\n",
    "    return result\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "balanced_data = undersample(final_result)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "check_balanced_df = balanced_data.toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----+-----+\n",
      "|label|count|\n",
      "+-----+-----+\n",
      "|    0|   38|\n",
      "|    1|   38|\n",
      "+-----+-----+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "balanced_data.groupby(balanced_data.label).count().show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "train, test = balanced_data.randomSplit([0.7, 0.3], seed=7)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize four models\n",
    "clf_LR = LogisticRegression(maxIter=50)\n",
    "clf_DT = DecisionTreeClassifier(seed=7)\n",
    "clf_RF = RandomForestClassifier(seed=7)\n",
    "clf_SVM = LinearSVC()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "evaluator= MulticlassClassificationEvaluator(predictionCol=\"prediction\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LogisticRegression is training...\n",
      "LogisticRegression is predicting...\n",
      "LogisticRegression is evaluating...\n",
      "Test F1-score:  0.6085858585858586\n",
      "DecisionTreeClassifier is training...\n",
      "DecisionTreeClassifier is predicting...\n",
      "DecisionTreeClassifier is evaluating...\n",
      "Test F1-score:  0.5198467432950191\n",
      "RandomForestClassifier is training...\n",
      "RandomForestClassifier is predicting...\n",
      "RandomForestClassifier is evaluating...\n",
      "Test F1-score:  0.46851851851851856\n",
      "LinearSVC is training...\n",
      "LinearSVC is predicting...\n",
      "LinearSVC is evaluating...\n",
      "Test F1-score:  0.702075702075702\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# collect results on the learners\n",
    "all_results = {}\n",
    "for clf in [clf_LR, clf_DT, clf_RF, clf_SVM]:\n",
    "    model_results = {}\n",
    "    # get the classifier name\n",
    "    clf_name = clf.__class__.__name__\n",
    "    \n",
    "    \n",
    "    # fit the dataset\n",
    "    print(f'{clf_name} is training...')\n",
    "    start = time.time() \n",
    "    model = clf.fit(train)\n",
    "    end = time.time() \n",
    "    model_results['train_time'] = round(end-start,6)\n",
    "    \n",
    "    # predict\n",
    "    print(f'{clf_name} is predicting...')\n",
    "    start = time.time() \n",
    "    pred_test = model.transform(test)\n",
    "    end = time.time()\n",
    "    model_results['pred_time'] = round(end-start,6)\n",
    "    \n",
    "    #metrics\n",
    "    print(f'{clf_name} is evaluating...')    \n",
    "    model_results['f1_test'] = evaluator.evaluate(pred_test.select('label','prediction'),{evaluator.metricName: 'f1'})\n",
    "    print('Test F1-score: ',model_results['f1_test'])\n",
    "    all_results[clf_name] = model_results\n",
    "    \n",
    "all_results_df = pd.DataFrame(all_results)\n",
    "all_results_df.to_csv('baseline.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "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>LogisticRegression</th>\n",
       "      <th>DecisionTreeClassifier</th>\n",
       "      <th>RandomForestClassifier</th>\n",
       "      <th>LinearSVC</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>f1_test</th>\n",
       "      <td>0.608586</td>\n",
       "      <td>0.519847</td>\n",
       "      <td>0.468519</td>\n",
       "      <td>0.702076</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>pred_time</th>\n",
       "      <td>0.116291</td>\n",
       "      <td>0.134142</td>\n",
       "      <td>0.134124</td>\n",
       "      <td>0.121613</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>train_time</th>\n",
       "      <td>9.993120</td>\n",
       "      <td>4.092183</td>\n",
       "      <td>3.508062</td>\n",
       "      <td>51.391608</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            LogisticRegression  DecisionTreeClassifier  \\\n",
       "f1_test               0.608586                0.519847   \n",
       "pred_time             0.116291                0.134142   \n",
       "train_time            9.993120                4.092183   \n",
       "\n",
       "            RandomForestClassifier  LinearSVC  \n",
       "f1_test                   0.468519   0.702076  \n",
       "pred_time                 0.134124   0.121613  \n",
       "train_time                3.508062  51.391608  "
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_results_df\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Though the LinearSVC spent more training time, but it can get the highest f1 score 0.702. And the LogisticRegression has a medium trainning time and f1 score, so will try to tune the LogisticRegression model \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "paramGrid = ParamGridBuilder().\\\n",
    "            addGrid(clf_SVM.maxIter, [10, 100, 1000]).\\\n",
    "            addGrid(clf_SVM.regParam, [0.01,0.1,10.0,100.0]).\\\n",
    "            build()\n",
    "crossval = CrossValidator(estimator=clf_SVM,\n",
    "                      estimatorParamMaps=paramGrid,\n",
    "                      evaluator=MulticlassClassificationEvaluator(metricName=\"f1\"),\n",
    "                      numFolds=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model tuning is done, spent 1096.886549949646s.\n"
     ]
    }
   ],
   "source": [
    "start = time.time()\n",
    "cvModel_SVM = crossval.fit(train)\n",
    "end = time.time()\n",
    "print(f'Model tuning is done, spent {end-start}s.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.503775962599492,\n",
       " 0.4822725150666327,\n",
       " 0.13759833435289825,\n",
       " 0.13759833435289825,\n",
       " 0.5593338760005427,\n",
       " 0.4871794871794871,\n",
       " 0.13759833435289825,\n",
       " 0.13759833435289825,\n",
       " 0.5593338760005427,\n",
       " 0.4871794871794871,\n",
       " 0.13759833435289825,\n",
       " 0.13759833435289825]"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cvModel_SVM.avgMetrics\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.7407407407407407\n",
      "F-1 Score:0.7371647509578544\n"
     ]
    }
   ],
   "source": [
    "pred = cvModel_SVM.transform(test)\n",
    "\n",
    "print('Accuracy: {}'.format(evaluator.evaluate(pred.select('label','prediction'), {evaluator.metricName: \"accuracy\"})))\n",
    "print('F-1 Score:{}'.format(evaluator.evaluate(pred.select('label','prediction'), {evaluator.metricName: \"f1\"})))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "cvModel_SVM.save('svm_model')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "paramGrid = ParamGridBuilder().\\\n",
    "            addGrid(clf_LR.elasticNetParam,[0.1, 0.5, 1]).\\\n",
    "            addGrid(clf_LR.regParam,[0.01, 0.05, 0.1]).\\\n",
    "            build()\n",
    "\n",
    "crossval = CrossValidator(estimator=clf_LR,\n",
    "                          estimatorParamMaps=paramGrid,\n",
    "                          evaluator=MulticlassClassificationEvaluator(metricName=\"f1\"),\n",
    "                          numFolds=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model tuning is done, spent 196.16279363632202s.\n"
     ]
    }
   ],
   "source": [
    "start = time.time()\n",
    "cvModel_LR = crossval.fit(train)\n",
    "end = time.time()\n",
    "print(f'Model tuning is done, spent {end-start}s.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.5138888888888888,\n",
       " 0.4623778998778998,\n",
       " 0.4958876000542667,\n",
       " 0.5216931216931217,\n",
       " 0.44659523180765015,\n",
       " 0.3587962962962963,\n",
       " 0.5291296005581719,\n",
       " 0.42723856209150324,\n",
       " 0.2336914517557942]"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cvModel_LR.avgMetrics\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.7037037037037037\n",
      "F-1 Score:0.702075702075702\n"
     ]
    }
   ],
   "source": [
    "pred = cvModel_LR.transform(test)\n",
    "\n",
    "print('Accuracy: {}'.format(evaluator.evaluate(pred.select('label','prediction'), {evaluator.metricName: \"accuracy\"})))\n",
    "print('F-1 Score:{}'.format(evaluator.evaluate(pred.select('label','prediction'), {evaluator.metricName: \"f1\"})))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "cvModel_LR.save('lr_model')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8204193254329991"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1097-197)/1097"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "As we can see in above, the logistic regression can get a nearly f1 score and save 82% time spending than the linear svc. So, the logistic regression is the best model from now on in this project.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Final Steps\n",
    "Clean up your code, adding comments and renaming variables to make the code easier to read and maintain. Refer to the Spark Project Overview page and Data Scientist Capstone Project Rubric to make sure you are including all components of the capstone project and meet all expectations. Remember, this includes thorough documentation in a README file in a Github repository, as well as a web app or blog post."
   ]
  },
  {
   "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}