4_EDA_with_spark.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exploration Data Analysis\n",
    "Summary:   \n",
    "- Load data into spark dataframe\n",
    "- Clean data by removing abnormal records like \"song_length = 0\" and \"single day playing time more than 24 hrs\". \n",
    "- Discover the user acticity is decreasing with time as music play times, music search times and music download times shows decreasing trend.\n",
    "- Find that Android device holders are the main user for the platform.\n",
    "- Indentify two main reasons that the user quit playing certain song. First, user don't like the song. Second, the song is near end.\n",
    "- The weekly user retention rate is stable.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Load data into Spark DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark import SparkContext\n",
    "import pyspark.sql.functions as F\n",
    "# We use matplotlib for plotting\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# This statement allow to display plot without asking to\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.sql import SparkSession\n",
    "\n",
    "spark = SparkSession \\\n",
    "    .builder \\\n",
    "    .appName(\"Project\") \\\n",
    "    .config(\"Spark.some.config.option\", \"Value\") \\\n",
    "    .getOrCreate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DataFrame[uid: string, event: string, device: string, song_id: string, song_type: string, date: string, play_time: string, song_length: string, paid_flag: string]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = spark.read.csv('../data/event_ds.csv',header=True).cache()\n",
    "df "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------+-----+------+-------+---------+----------+---------+-----------+---------+\n",
      "|      uid|event|device|song_id|song_type|      date|play_time|song_length|paid_flag|\n",
      "+---------+-----+------+-------+---------+----------+---------+-----------+---------+\n",
      "|167923158|    P|    ar| 985228|        0|2017-04-01|      251|        251|        0|\n",
      "|168045107|    P|    ar|6818758|        0|2017-04-01|        0|       1683|        0|\n",
      "|167580792|    P|    ar|6989313|        0|2017-04-01|      113|        113|        0|\n",
      "|167575198|    P|    ar|9953526|        0|2017-04-01|      277|        277|        0|\n",
      "|168045107|    P|    ar|6796145|        0|2017-04-01|        0|       1799|        0|\n",
      "+---------+-----+------+-------+---------+----------+---------+-----------+---------+\n",
      "only showing top 5 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Clean and explore data set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cast numerical and date variable into corresponding data type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DataFrame[uid: string, event: string, device: string, song_id: string, song_type: string, date: date, play_time: int, song_length: int, paid_flag: string]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = df.withColumn('date',F.col('date').cast('date'))\n",
    "df = df.withColumn('play_time',F.col('play_time').cast('int'))\n",
    "df = df.withColumn('song_length',F.col('song_length').cast('int'))\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I notice that the play_time can be much longer than song_length. Does that mean this song is played by multiple times ? Or is there something wrong with play_time ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------+-----+------+--------+---------+----------+---------+-----------+---------+\n",
      "|      uid|event|device| song_id|song_type|      date|play_time|song_length|paid_flag|\n",
      "+---------+-----+------+--------+---------+----------+---------+-----------+---------+\n",
      "|168042119|    P|    ar| 4192120|        0|2017-04-01|      315|          0|        0|\n",
      "|167925146|    P|    ar|       0|        1|2017-04-01|      254|        253|        0|\n",
      "|167912036|    P|    ar| 7177686|        0|2017-04-01|      309|          0|        0|\n",
      "|167912588|    P|    ar|       0|        1|2017-04-01|      259|        258|        0|\n",
      "|167938487|    P|    ar| 3264466|        0|2017-04-01|      218|          0|        0|\n",
      "|167635528|    P|    ar|  665417|        0|2017-04-01|      232|        231|        0|\n",
      "|168056157|    P|    ar|       0|        1|2017-04-01|      123|        122|        0|\n",
      "|167653765|    P|    ar|  117422|        1|2017-04-01|   263175|        263|        0|\n",
      "|164373490|    P|    ar| 9327377|        1|2017-04-01|   243148|          0|        0|\n",
      "|168042119|    P|    ar|22799214|        0|2017-04-01|       64|          0|        0|\n",
      "|168042619|    P|    ar|  724933|        0|2017-04-01|      230|        229|        0|\n",
      "|168009457|    P|    ar|  870671|        1|2017-04-01|   264500|          0|        0|\n",
      "|167798149|    P|    ar|18748667|        0|2017-04-01|      130|          0|        0|\n",
      "|167869574|    P|    ar|23110938|        0|2017-04-01|      279|        278|        0|\n",
      "|167697498|    P|    ar| 6468891|        0|2017-04-01|      261|          0|        0|\n",
      "|167993855|    P|    ar|20876432|        0|2017-04-01|      278|          0|        0|\n",
      "|167653878|    P|    ar|  545655|        1|2017-04-01|   342819|          0|        0|\n",
      "|167796648|    P|    ar| 2528433|        0|2017-04-01|     1034|          0|        0|\n",
      "|167741989|    P|    ar|       0|        1|2017-04-01|      290|        289|        0|\n",
      "|167039322|    P|    ar|  461314|        0|2017-04-01|      276|          0|        0|\n",
      "+---------+-----+------+--------+---------+----------+---------+-----------+---------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.filter((F.col('play_time') > F.col('song_length')) & (F.col('event') == 'P')).show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of records where play time is larger than song length is 2519623.\n",
      "The number of records where play time is smaller than song length is 39063159.\n"
     ]
    }
   ],
   "source": [
    "print('The number of records where play time is larger than song length is %d.' \\\n",
    "      % (df.filter(F.col('play_time') > F.col('song_length')).count()))\n",
    "print('The number of records where play time is smaller than song length is %d.' \\\n",
    "      % (df.filter(F.col('play_time') <= F.col('song_length')).count()))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here I observe two strange cases:\n",
    "- The song length is 0 but the play time is much larger than 0. \n",
    "- The song length is normal but the play time is 100 times larger than that. For example, play time is 268330 and song length is 268. It means user play the same song for 100+ times and play it for more than 6 hours. This behavior could be background music in shopping mall "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thus, I will\n",
    "- remove records with song_length = 0\n",
    "- remove abnormal users if the total play time on a single day exceeds 24 hours. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.filter((F.col('song_length') > 0) | (F.col('event') != 'P'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let me take an example fof such abnormal users."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------+-----+------+-------+---------+----------+---------+-----------+---------+\n",
      "|      uid|event|device|song_id|song_type|      date|play_time|song_length|paid_flag|\n",
      "+---------+-----+------+-------+---------+----------+---------+-----------+---------+\n",
      "|167653765|    P|    ar| 117422|        1|2017-04-01|   263175|        263|        0|\n",
      "|167653765|    P|    ar| 312954|        1|2017-04-01|   271534|        272|        0|\n",
      "|167653765|    P|    ar| 164258|        1|2017-04-01|   228391|        228|        0|\n",
      "|167653765|    P|    ar| 117422|        1|2017-04-01|   262850|        263|        0|\n",
      "|167653765|    P|    ar| 312954|        1|2017-04-01|   271302|        272|        0|\n",
      "|167653765|    P|    ar| 164258|        1|2017-04-01|   228299|        228|        0|\n",
      "|167653765|    P|    ar| 117422|        1|2017-04-01|   262943|        263|        0|\n",
      "|167653765|    P|    ar| 312954|        1|2017-04-01|   271488|        272|        0|\n",
      "|167653765|    P|    ar| 164258|        1|2017-04-01|   228020|        228|        0|\n",
      "|167653765|    P|    ar| 117422|        1|2017-04-01|   263175|        263|        0|\n",
      "|167653765|    P|    ar| 312954|        1|2017-04-01|   271395|        272|        0|\n",
      "|167653765|    P|    ar| 164258|        1|2017-04-01|   228531|        228|        0|\n",
      "|167653765|    P|    ar| 312954|        1|2017-04-01|   271395|        272|        0|\n",
      "|167653765|    P|    ar| 164258|        1|2017-04-01|   228206|        228|        0|\n",
      "|167653765|    P|    ar| 117422|        1|2017-04-01|   263175|        263|        0|\n",
      "|167653765|    P|    ar| 312954|        1|2017-04-01|   270930|        272|        0|\n",
      "|167653765|    P|    ar| 164258|        1|2017-04-01|   228299|        228|        0|\n",
      "|167653765|    P|    ar| 117422|        1|2017-04-01|   262850|        263|        0|\n",
      "|167653765|    P|    ar| 312954|        1|2017-04-01|   271534|        272|        0|\n",
      "|167653765|    P|    ar| 164258|        1|2017-04-01|   228299|        228|        0|\n",
      "+---------+-----+------+-------+---------+----------+---------+-----------+---------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.filter(F.col('uid') == '167653765').show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df_total_play_time = df.filter(F.col('event') == 'P').groupBy('uid', 'date').agg(\n",
    "    F.sum(F.col('play_time')).alias('total_play_time')\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The total number of abnormal users is 2580.\n"
     ]
    }
   ],
   "source": [
    "print('The total number of abnormal users is %d.' \\\n",
    "     % (df_total_play_time.filter(F.col('total_play_time') > 24 * 60 * 60).select('uid').distinct().count()))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are 2580 users who play music more than 24 hours per day. Something could be wrong with these users' records. Thus, I have to remove these users."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "abnormal_id = set(df_total_play_time.filter((F.col('total_play_time') > 24 * 60 * 60)).select('uid').toPandas()['uid'])\n",
    "df_filtered = df.filter(~F.col('uid').isin(abnormal_id))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Exploration Data Analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.1 What's the user activity from 04/01 to 05/12 ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The total number of records is 41562512.\n",
      "The total number of users in sampled data set is 130531.\n"
     ]
    }
   ],
   "source": [
    "print('The total number of records is %d.' % (df_filtered.count()))\n",
    "print('The total number of users in sampled data set is %d.' % (df_filtered.select('uid').distinct().count()))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----+--------+\n",
      "|event|   count|\n",
      "+-----+--------+\n",
      "|    D| 1504548|\n",
      "|    S| 2290699|\n",
      "|    P|37767265|\n",
      "+-----+--------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# check number of records for each event\n",
    "df_filtered.groupBy('event').count().show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----+----------+-------+\n",
      "|event|      date|  count|\n",
      "+-----+----------+-------+\n",
      "|    D|2017-04-01| 149800|\n",
      "|    P|2017-04-01|2232159|\n",
      "|    S|2017-04-01| 165114|\n",
      "|    D|2017-04-02| 124107|\n",
      "|    P|2017-04-02|2032064|\n",
      "|    S|2017-04-02| 151717|\n",
      "|    D|2017-04-03|  82552|\n",
      "|    P|2017-04-03|1056463|\n",
      "|    S|2017-04-03| 111224|\n",
      "|    D|2017-04-04|  71903|\n",
      "|    P|2017-04-04|1437283|\n",
      "|    S|2017-04-04|  93136|\n",
      "|    D|2017-04-05|  56706|\n",
      "|    P|2017-04-05|1195176|\n",
      "|    S|2017-04-05|  75705|\n",
      "|    D|2017-04-06|  50547|\n",
      "|    P|2017-04-06|1204254|\n",
      "|    S|2017-04-06|  70254|\n",
      "|    D|2017-04-07|  45933|\n",
      "|    P|2017-04-07|1158715|\n",
      "+-----+----------+-------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df_event = df_filtered.groupBy('event', 'date').agg(\n",
    "    F.count(F.col('uid')).alias('count'),\n",
    ").orderBy('date','event')\n",
    "df_event.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from matplotlib.dates import date2num\n",
    "x = df_event.select('date').distinct().toPandas()\n",
    "x = list(pd.to_datetime(x['date'], format='%Y-%m-%d').sort_values())\n",
    "x = date2num(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "D = np.array(df_event.filter(F.col('event') == 'D').select('count').toPandas()['count'])/10000.0\n",
    "P = np.array(df_event.filter(F.col('event') == 'P').select('count').toPandas()['count'])/10000.0\n",
    "S = np.array(df_event.filter(F.col('event') == 'S').select('count').toPandas()['count'])/10000.0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x11db440f0>"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11dbfeef0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(15,8))\n",
    "ax = plt.subplot(111)\n",
    "ax.bar(x-0.4,D,width=0.4,color='b',align='center',alpha = 0.8)\n",
    "ax.bar(x, S,width=0.4, color='r',align='center')\n",
    "ax.xaxis_date()\n",
    "plt.title('Music download and search activities')\n",
    "plt.ylabel('Counts (unit = 10,000)')\n",
    "\n",
    "import matplotlib.patches as mpatches\n",
    "red_patch = mpatches.Patch(color='red', label='Search counts')\n",
    "blue_patch = mpatches.Patch(color='blue', label='Download counts')\n",
    "plt.legend(handles=[red_patch, blue_patch])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I can see that searching times is more than downloading times. This makes sense."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x11e2b8c18>"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11dbf8ef0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(15,8))\n",
    "ax = plt.subplot(111)\n",
    "ax.bar(x, P,width=0.5,color='g',align='center')\n",
    "ax.xaxis_date()\n",
    "plt.title('Music playing activities')\n",
    "plt.ylabel('Counts (unit = 10,000)')\n",
    "\n",
    "import matplotlib.patches as mpatches\n",
    "green_patch = mpatches.Patch(color='green', label='Play counts')\n",
    "plt.legend(handles=[green_patch])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Overall, I can see the decresing trend of music play, music search and music download activities."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2 What's the device distribution ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------+------+\n",
      "|device| count|\n",
      "+------+------+\n",
      "|    ar|110466|\n",
      "|    ip| 20074|\n",
      "+------+------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df_device = df_filtered.groupBy('device').agg(\n",
    "    F.countDistinct(F.col('uid')).alias('count'),\n",
    ")\n",
    "df_device.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11e6ccf60>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8,8))\n",
    "objects = ['Android', 'Apple Device'] \n",
    "sizes = list((110466,20074))\n",
    "colors = ['gold', 'yellowgreen']\n",
    "explode = (0.1, 0)  # explode 1st slice\n",
    "plt.pie(sizes, explode=explode, labels=objects, colors=colors,\n",
    "        autopct='%1.1f%%', shadow=True, startangle=140)\n",
    "plt.axis('equal')\n",
    "plt.title('Device Distribution')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Android device holders are more active in this platform."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.3 What's the percentage of paid songs ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------+------+\n",
      "|paid_flag| count|\n",
      "+---------+------+\n",
      "|        0|857946|\n",
      "|     null|     0|\n",
      "+---------+------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df_filtered.groupBy('paid_flag').agg(\n",
    "    F.countDistinct(F.col('song_id')).alias('count'),\n",
    ").show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It indicates that this platform is a free music play platform."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.4 Why do users stop playing songs before it ends?\n",
    "To answer this question, play_time compared to music length can be used as metric for this quiestion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_records = df_filtered.count()\n",
    "records_less_than_ten = df_filtered.filter(F.col('play_time') < F.col('song_length') * 0.1).count()\n",
    "records_less_than_twenty = df_filtered.filter(F.col('play_time') < F.col('song_length') * 0.2).count()\n",
    "records_less_than_thirty = df_filtered.filter(F.col('play_time') < F.col('song_length') * 0.3).count()\n",
    "records_less_than_fourty = df_filtered.filter(F.col('play_time') < F.col('song_length') * 0.4).count()\n",
    "records_less_than_fifty = df_filtered.filter(F.col('play_time') < F.col('song_length') * 0.5).count()\n",
    "records_less_than_sixty = df_filtered.filter(F.col('play_time') < F.col('song_length') * 0.6).count()\n",
    "records_less_than_seventy = df_filtered.filter(F.col('play_time') < F.col('song_length') * 0.7).count()\n",
    "records_less_than_eighty = df_filtered.filter(F.col('play_time') < F.col('song_length') * 0.8).count()\n",
    "records_less_than_ninty = df_filtered.filter(F.col('play_time') < F.col('song_length') * 0.9).count()\n",
    "records_less_than_hundred = df_filtered.filter(F.col('play_time') < F.col('song_length')).count()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = (np.array(range(10)) + 1)/10.0\n",
    "y = [\n",
    "    records_less_than_ten/all_records,\n",
    "    records_less_than_twenty/all_records,\n",
    "    records_less_than_thirty/all_records,\n",
    "    records_less_than_fourty/all_records,\n",
    "    records_less_than_fifty/all_records,\n",
    "    records_less_than_sixty/all_records,\n",
    "    records_less_than_seventy/all_records,\n",
    "    records_less_than_eighty/all_records,\n",
    "    records_less_than_ninty/all_records,\n",
    "    records_less_than_hundred/all_records\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'Percentage in all records')"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11ec9ae48>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8,6))\n",
    "plt.plot(x,y,\"b--\",linewidth=1)\n",
    "plt.xlabel('play_time over song_length')\n",
    "plt.ylabel('Percentage in all records')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "music play length < 10% song_length: 0.261071.\n",
      "music play length < 20% song_length: 0.292810.\n",
      "music play length < 30% song_length: 0.316070.\n",
      "music play length < 40% song_length: 0.334438.\n",
      "music play length < 50% song_length: 0.348138.\n",
      "music play length < 60% song_length: 0.369312.\n",
      "music play length < 70% song_length: 0.389147.\n",
      "music play length < 80% song_length: 0.409507.\n",
      "music play length < 90% song_length: 0.428894.\n",
      "music play length < 100% song_length: 0.487150.\n"
     ]
    }
   ],
   "source": [
    "print('music play length < 10%% song_length: %f.' % (records_less_than_ten/all_records))\n",
    "print('music play length < 20%% song_length: %f.' % (records_less_than_twenty/all_records))\n",
    "print('music play length < 30%% song_length: %f.' % (records_less_than_thirty/all_records))\n",
    "print('music play length < 40%% song_length: %f.' % (records_less_than_fourty/all_records))\n",
    "print('music play length < 50%% song_length: %f.' % (records_less_than_fifty/all_records))\n",
    "print('music play length < 60%% song_length: %f.' % (records_less_than_sixty/all_records))\n",
    "print('music play length < 70%% song_length: %f.' % (records_less_than_seventy/all_records))\n",
    "print('music play length < 80%% song_length: %f.' % (records_less_than_eighty/all_records))\n",
    "print('music play length < 90%% song_length: %f.' % (records_less_than_ninty/all_records))\n",
    "print('music play length < 100%% song_length: %f.' % (records_less_than_hundred/all_records))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = [\n",
    "    records_less_than_ten/records_less_than_hundred,\n",
    "    (records_less_than_twenty - records_less_than_ten)/records_less_than_hundred,\n",
    "    (records_less_than_thirty - records_less_than_twenty)/records_less_than_hundred,\n",
    "    (records_less_than_fourty - records_less_than_thirty)/records_less_than_hundred,\n",
    "    (records_less_than_fifty - records_less_than_fourty)/records_less_than_hundred,\n",
    "    (records_less_than_sixty - records_less_than_fifty)/records_less_than_hundred,\n",
    "    (records_less_than_seventy - records_less_than_sixty)/records_less_than_hundred,\n",
    "    (records_less_than_eighty - records_less_than_seventy)/records_less_than_hundred,\n",
    "    (records_less_than_ninty - records_less_than_eighty)/records_less_than_hundred,\n",
    "    (records_less_than_hundred - records_less_than_ninty)/records_less_than_hundred\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,1.05,'Distribution of early stopping')"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11e95bf98>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,10))\n",
    "objects = ['0-10%', '10-20%', '20-30%', '30-40%', '40-50%', '50-60%', '60-70%', '70-80%', '80-90%', '90-100%'] \n",
    "explode = (0.1, 0, 0, 0, 0,0 ,0 ,0 ,0 ,0)  # explode 1st slice\n",
    "plt.pie(y, explode=explode, labels=objects,\n",
    "        autopct='%1.1f%%', shadow=True, startangle=140)\n",
    "plt.axis('equal')\n",
    "plt.title('Distribution of early stopping', y=1.05)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "0% < play_time/song_length < 10% $\\rightarrow$ 53.6% stop playing       \n",
    "90% < play_time/song_length < 100% $\\rightarrow$ 12.0% stop playing    \n",
    "Remaining are similar.  \n",
    "\n",
    "The reason that users stop playing before it ends:\n",
    "1. User don't like the song after playing it for dozen seconds.\n",
    "2. User like to jump to next when the current one is near end."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.5 What's the weekly retention rate for users? \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "from dateutil import parser\n",
    "window_size = 7\n",
    "period_one_start = parser.parse('2017-04-01').date()\n",
    "period_one_end = period_one_start + datetime.timedelta(window_size - 1)\n",
    "period_two_start = period_one_end + datetime.timedelta(1)\n",
    "period_two_end = period_two_start + datetime.timedelta(window_size - 1)\n",
    "period_three_start = period_two_end + datetime.timedelta(1)\n",
    "period_three_end = period_three_start + datetime.timedelta(window_size - 1)\n",
    "period_four_start = period_three_end + datetime.timedelta(1)\n",
    "period_four_end = period_four_start + datetime.timedelta(window_size - 1)\n",
    "period_five_start = period_four_end + datetime.timedelta(1)\n",
    "period_five_end = period_five_start + datetime.timedelta(window_size - 1)\n",
    "period_six_start = period_five_end + datetime.timedelta(1)\n",
    "period_six_end = period_six_start + datetime.timedelta(window_size - 1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [],
   "source": [
    "period_one_id = df_filtered.filter((F.col('date')>=period_one_start) & (F.col('date')<=period_one_end))\\\n",
    "                    .select('uid').distinct()\n",
    "period_two_id = df_filtered.filter((F.col('date')>=period_two_start) & (F.col('date')<=period_two_end))\\\n",
    "                    .select('uid').distinct()\n",
    "period_three_id = df_filtered.filter((F.col('date')>=period_three_start) & (F.col('date')<=period_three_end))\\\n",
    "                    .select('uid').distinct()\n",
    "period_four_id = df_filtered.filter((F.col('date')>=period_four_start) & (F.col('date')<=period_four_end))\\\n",
    "                    .select('uid').distinct()\n",
    "period_five_id = df_filtered.filter((F.col('date')>=period_five_start) & (F.col('date')<=period_five_end))\\\n",
    "                    .select('uid').distinct()\n",
    "period_six_id = df_filtered.filter((F.col('date')>=period_six_start) & (F.col('date')<=period_six_end))\\\n",
    "                    .select('uid').distinct()\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [],
   "source": [
    "period_one_retention = period_one_id.join(period_two_id,on=['uid'],how='inner').count()\n",
    "period_two_retention = period_two_id.join(period_three_id,on=['uid'],how='inner').count()\n",
    "period_three_retention = period_three_id.join(period_four_id,on=['uid'],how='inner').count()\n",
    "period_four_retention = period_four_id.join(period_five_id,on=['uid'],how='inner').count()\n",
    "period_five_retention = period_five_id.join(period_six_id,on=['uid'],how='inner').count()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array(range(5)) + 1\n",
    "y = [\n",
    "    period_one_retention/period_one_id.count(),\n",
    "    period_two_retention/period_two_id.count(),\n",
    "    period_three_retention/period_three_id.count(),\n",
    "    period_four_retention/period_four_id.count(),\n",
    "    period_five_retention/period_five_id.count(),\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x11ff94fd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "objects = list(('Week1', 'Week2', 'Week3', 'Week4', 'Week5'))\n",
    "y_pos = np.arange(len(objects))\n",
    "plt.barh(y_pos, y, align='center', alpha = 0.5)\n",
    "plt.yticks(y_pos, objects)\n",
    "plt.xlabel('Retention rate')\n",
    "plt.title('Weekly retention rate')\n",
    "plt.gca().invert_yaxis()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I can see that the retention rate is quite stable during the six weeks. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python(conda)",
   "language": "python",
   "name": "base"
  },
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}