Project 3 - Airbnb.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Project 3: Airbnb\n",
    "**This is the third of three mandatory projects to be handed in as part of the assessment for the course 02807 Computational Tools for Data Science at Technical University of Denmark, autumn 2019.**\n",
    "\n",
    "#### Practical info\n",
    "- **The project is to be done in groups of at most 3 students**\n",
    "- **Each group has to hand in _one_ Jupyter notebook (this notebook) with their solution**\n",
    "- **The hand-in of the notebook is due 2019-12-05, 23:59 on DTU Inside**\n",
    "\n",
    "#### Your solution\n",
    "- **Your solution should be in Python/PySpark**\n",
    "- **For each question you may use as many cells for your solution as you like**\n",
    "- **You should not remove the problem statements**\n",
    "- **Your notebook should be runnable, i.e., clicking [>>] in Jupyter should generate the result that you want to be assessed**\n",
    "- **You are not expected to use machine learning to solve any of the exercises**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "[Airbnb](http://airbnb.com) is an online marketplace for arranging or offering lodgings. In this project you will use Spark to analyze data obtained from the Airbnb website. The purpose of the analysis is to extract information about trends and patterns from the data.\n",
    "\n",
    "The project has two parts.\n",
    "\n",
    "### Part 1: Loading, describing and preparing the data\n",
    "There's quite a lot of data. Make sure that you can load and correctly parse the data, and that you understand what the dataset contains. You should also prepare the data for the analysis in part two. This means cleaning it and staging it so that subsequent queries are fast.\n",
    "\n",
    "### Par 2: Analysis\n",
    "In this part your goal is to learn about trends and usage patterns from the data. You should give solutions to the tasks defined in this notebook, and you should use Spark to do the data processing. You may use other libraries like for instance Pandas and matplotlib for visualisation.\n",
    "\n",
    "## Guidelines\n",
    "- Processing data should be done using Spark. Once data has been reduced to aggregate form, you may use collect to extract it into Python for visualisation.\n",
    "- Your solutions will be evaluated by correctness, code quality and interpretability of the output. This means that you have to write clean and efficient Spark code that will generate sensible execution plans, and that the tables and visualisations that you produce are meaningful and easy to read.\n",
    "- You may add more cells for your solutions, but you should not modify the notebook otherwise."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create Spark session and define imports"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No need to manipulate data - simply remove odd rows.\n",
    "Focus is on using spark.\n",
    "\n",
    "Reviews is open, the rest should be considered as excersises. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.sql import *\n",
    "from pyspark.sql import functions as f\n",
    "from pyspark.sql.types import *\n",
    "\n",
    "spark = SparkSession.builder.appName(\"SparkIntro\").getOrCreate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 1: Loading, describing and preparing the data\n",
    "The data comes in two files. Start by downloading the files and putting them in your `data/` folder.\n",
    "\n",
    "- [Listings](https://files.dtu.dk/u/siPzAasj8w2gI_ME/listings.csv?l) (5 GB)\n",
    "- [Reviews](https://files.dtu.dk/u/k3oaPYp6GjKBeho4/reviews.csv?l) (9.5 GB)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load the data\n",
    "The data has multiline rows (rows that span multiple lines in the file). To correctly parse these you should use the `multiline` option and set the `escape` character to be `\"`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_listings = spark.read.option('header', True)\\\n",
    "                   .option('inferSchema', True)\\\n",
    "                   .option(\"multiLine\", True)\\\n",
    "                   .option('escape', '\"').csv('data/listings.csv')\n",
    "df_reviews = spark.read.option('header', True)\\\n",
    "                   .option('inferSchema', True)\\\n",
    "                   .option(\"multiLine\", True)\\\n",
    "                   .option('escape', '\"').csv('data/reviews.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Describe the data\n",
    "List the features (schema) and sizes of the datasets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      " |-- id: string (nullable = true)\n",
      " |-- listing_url: string (nullable = true)\n",
      " |-- scrape_id: string (nullable = true)\n",
      " |-- last_scraped: string (nullable = true)\n",
      " |-- name: string (nullable = true)\n",
      " |-- summary: string (nullable = true)\n",
      " |-- space: string (nullable = true)\n",
      " |-- description: string (nullable = true)\n",
      " |-- experiences_offered: string (nullable = true)\n",
      " |-- neighborhood_overview: string (nullable = true)\n",
      " |-- notes: string (nullable = true)\n",
      " |-- transit: string (nullable = true)\n",
      " |-- access: string (nullable = true)\n",
      " |-- interaction: string (nullable = true)\n",
      " |-- house_rules: string (nullable = true)\n",
      " |-- thumbnail_url: string (nullable = true)\n",
      " |-- medium_url: string (nullable = true)\n",
      " |-- picture_url: string (nullable = true)\n",
      " |-- xl_picture_url: string (nullable = true)\n",
      " |-- host_id: string (nullable = true)\n",
      " |-- host_url: string (nullable = true)\n",
      " |-- host_name: string (nullable = true)\n",
      " |-- host_since: string (nullable = true)\n",
      " |-- host_location: string (nullable = true)\n",
      " |-- host_about: string (nullable = true)\n",
      " |-- host_response_time: string (nullable = true)\n",
      " |-- host_response_rate: string (nullable = true)\n",
      " |-- host_acceptance_rate: string (nullable = true)\n",
      " |-- host_is_superhost: string (nullable = true)\n",
      " |-- host_thumbnail_url: string (nullable = true)\n",
      " |-- host_picture_url: string (nullable = true)\n",
      " |-- host_neighbourhood: string (nullable = true)\n",
      " |-- host_listings_count: string (nullable = true)\n",
      " |-- host_total_listings_count: string (nullable = true)\n",
      " |-- host_verifications: string (nullable = true)\n",
      " |-- host_has_profile_pic: string (nullable = true)\n",
      " |-- host_identity_verified: string (nullable = true)\n",
      " |-- street: string (nullable = true)\n",
      " |-- neighbourhood: string (nullable = true)\n",
      " |-- neighbourhood_cleansed: string (nullable = true)\n",
      " |-- neighbourhood_group_cleansed: string (nullable = true)\n",
      " |-- city: string (nullable = true)\n",
      " |-- state: string (nullable = true)\n",
      " |-- zipcode: string (nullable = true)\n",
      " |-- market: string (nullable = true)\n",
      " |-- smart_location: string (nullable = true)\n",
      " |-- country_code: string (nullable = true)\n",
      " |-- country: string (nullable = true)\n",
      " |-- latitude: string (nullable = true)\n",
      " |-- longitude: string (nullable = true)\n",
      " |-- is_location_exact: string (nullable = true)\n",
      " |-- property_type: string (nullable = true)\n",
      " |-- room_type: string (nullable = true)\n",
      " |-- accommodates: string (nullable = true)\n",
      " |-- bathrooms: string (nullable = true)\n",
      " |-- bedrooms: string (nullable = true)\n",
      " |-- beds: string (nullable = true)\n",
      " |-- bed_type: string (nullable = true)\n",
      " |-- amenities: string (nullable = true)\n",
      " |-- square_feet: string (nullable = true)\n",
      " |-- price: string (nullable = true)\n",
      " |-- weekly_price: string (nullable = true)\n",
      " |-- monthly_price: string (nullable = true)\n",
      " |-- security_deposit: string (nullable = true)\n",
      " |-- cleaning_fee: string (nullable = true)\n",
      " |-- guests_included: string (nullable = true)\n",
      " |-- extra_people: string (nullable = true)\n",
      " |-- minimum_nights: string (nullable = true)\n",
      " |-- maximum_nights: string (nullable = true)\n",
      " |-- minimum_minimum_nights: string (nullable = true)\n",
      " |-- maximum_minimum_nights: string (nullable = true)\n",
      " |-- minimum_maximum_nights: string (nullable = true)\n",
      " |-- maximum_maximum_nights: string (nullable = true)\n",
      " |-- minimum_nights_avg_ntm: string (nullable = true)\n",
      " |-- maximum_nights_avg_ntm: string (nullable = true)\n",
      " |-- calendar_updated: string (nullable = true)\n",
      " |-- has_availability: string (nullable = true)\n",
      " |-- availability_30: string (nullable = true)\n",
      " |-- availability_60: string (nullable = true)\n",
      " |-- availability_90: string (nullable = true)\n",
      " |-- availability_365: string (nullable = true)\n",
      " |-- calendar_last_scraped: string (nullable = true)\n",
      " |-- number_of_reviews: string (nullable = true)\n",
      " |-- number_of_reviews_ltm: string (nullable = true)\n",
      " |-- first_review: string (nullable = true)\n",
      " |-- last_review: string (nullable = true)\n",
      " |-- review_scores_rating: string (nullable = true)\n",
      " |-- review_scores_accuracy: string (nullable = true)\n",
      " |-- review_scores_cleanliness: string (nullable = true)\n",
      " |-- review_scores_checkin: string (nullable = true)\n",
      " |-- review_scores_communication: string (nullable = true)\n",
      " |-- review_scores_location: string (nullable = true)\n",
      " |-- review_scores_value: string (nullable = true)\n",
      " |-- requires_license: string (nullable = true)\n",
      " |-- license: string (nullable = true)\n",
      " |-- jurisdiction_names: string (nullable = true)\n",
      " |-- instant_bookable: string (nullable = true)\n",
      " |-- is_business_travel_ready: string (nullable = true)\n",
      " |-- cancellation_policy: string (nullable = true)\n",
      " |-- require_guest_profile_picture: string (nullable = true)\n",
      " |-- require_guest_phone_verification: string (nullable = true)\n",
      " |-- calculated_host_listings_count: string (nullable = true)\n",
      " |-- calculated_host_listings_count_entire_homes: string (nullable = true)\n",
      " |-- calculated_host_listings_count_private_rooms: string (nullable = true)\n",
      " |-- calculated_host_listings_count_shared_rooms: string (nullable = true)\n",
      " |-- reviews_per_month: string (nullable = true)\n",
      "\n",
      "root\n",
      " |-- listing_id: string (nullable = true)\n",
      " |-- id: string (nullable = true)\n",
      " |-- date: string (nullable = true)\n",
      " |-- reviewer_id: string (nullable = true)\n",
      " |-- reviewer_name: string (nullable = true)\n",
      " |-- comments: string (nullable = true)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# The Schemas are printed for both datasets.\n",
    "df_listings.printSchema()\n",
    "df_reviews.printSchema()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The listings.csv dataset is a collection of listings from AirBnB and all associated data stored in a csv-format.\n",
    "The reviews.csv dataset are reviews of the various listings in AirBnb. In this dataset the column 'listing_id' can be used to link to the listing in listings.csv."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Listings count: 1330480\n",
      "Reviews count: 32297300\n"
     ]
    }
   ],
   "source": [
    "# We run a count function to determine the length of both datasets:\n",
    "print('Listings count:', df_listings.count())\n",
    "print('Reviews count:',df_reviews.count())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prepare the data for analysis\n",
    "You should prepare two dataframes to be used in the analysis part of the project. You should not be concerned with cleaning the data. There's a lot of it, so it will be sufficient to drop rows that have bad values. You may want to go back and refine this step at a later point when doing the analysis.\n",
    "\n",
    "You may also want to consider if you can stage your data so that subsequent processing is more efficient (this is not strictly necessary for Spark to run, but you may be able to decrease the time you sit around waiting for Spark to finish things)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "It was noted that NULLs occur differently in between the columns (example below), meaning that simply removing all rows with NULLs will remove more or less all data.\n",
    "\n",
    "To illustrate this, we have shows the three different neighbour columns for the city 'Agia Galini':"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------------+----------------------+----------------------------+\n",
      "|neighbourhood|neighbourhood_cleansed|neighbourhood_group_cleansed|\n",
      "+-------------+----------------------+----------------------------+\n",
      "|         null|       Αγίου Βασιλείου|                        null|\n",
      "|         null|       Αγίου Βασιλείου|                        null|\n",
      "|         null|       Αγίου Βασιλείου|                        null|\n",
      "|         null|       Αγίου Βασιλείου|                        null|\n",
      "|         null|       Αγίου Βασιλείου|                        null|\n",
      "|         null|       Αγίου Βασιλείου|                        null|\n",
      "|         null|       Αγίου Βασιλείου|                        null|\n",
      "|         null|       Αγίου Βασιλείου|                        null|\n",
      "|         null|       Αγίου Βασιλείου|                        null|\n",
      "|         null|       Αγίου Βασιλείου|                        null|\n",
      "|         null|       Αγίου Βασιλείου|                        null|\n",
      "|         null|       Αγίου Βασιλείου|                        null|\n",
      "|         null|       Αγίου Βασιλείου|                        null|\n",
      "|         null|       Αγίου Βασιλείου|                        null|\n",
      "|         null|       Αγίου Βασιλείου|                        null|\n",
      "|         null|       Αγίου Βασιλείου|                        null|\n",
      "|         null|       Αγίου Βασιλείου|                        null|\n",
      "|         null|       Αγίου Βασιλείου|                        null|\n",
      "|         null|       Αγίου Βασιλείου|                        null|\n",
      "|         null|       Αγίου Βασιλείου|                        null|\n",
      "+-------------+----------------------+----------------------------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df_listings.select('neighbourhood','neighbourhood_cleansed','neighbourhood_group_cleansed')\\\n",
    "        .filter(f.col('city')=='Agia Galini').show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead, it was found that a lot of entries contained nothing but the column titles. These were removed by filtering out all IDs with a values of 'id'.\n",
    "A count was performed to get a feeling of how much smaller the dataset has become."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1330385"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#filtered_listings = df_listings\n",
    "filtered_listings = df_listings.filter(f.col('id') != 'id')\n",
    "filtered_listings.count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apparently, this was only the case for ~100 entries, but the filtering was kept, as it solved some issues for us."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Depending on the specific questions, further data preparation steps may be done."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 2: Analysis\n",
    "Use Spark and your favorite tool for data visualization to solve the following tasks.\n",
    "\n",
    "## The basics\n",
    "Compute and show a dataframe with the number of listings and neighbourhoods per city."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "We group by the city column and compute the aggregate functions count and count destinct on the 'neighbourhood_cleansed' column. To show the most interesting cities, we order by the column with the count of distinct neighbourhoods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------+-----+-----------------------+\n",
      "|          city|Count|Distinct neighbourhoods|\n",
      "+--------------+-----+-----------------------+\n",
      "|Rio de Janeiro|19321|                    145|\n",
      "|   Los Angeles|27763|                    145|\n",
      "|       Toronto|21760|                    140|\n",
      "|        Berlin|24271|                    138|\n",
      "|        Madrid|20642|                    128|\n",
      "|       Oakland| 3122|                    124|\n",
      "|      New York|21457|                    120|\n",
      "|     Edinburgh|13339|                    111|\n",
      "|       Sevilla| 5532|                    103|\n",
      "|           Rio| 2180|                     94|\n",
      "|      Portland| 4548|                     94|\n",
      "|     Cape Town|21895|                     93|\n",
      "|       Seattle| 9017|                     89|\n",
      "|        Milano|17837|                     86|\n",
      "|     San Diego|12408|                     85|\n",
      "|        Girona|  759|                     82|\n",
      "|      València| 5466|                     81|\n",
      "|      Valencia| 1331|                     79|\n",
      "|         Milan| 2398|                     78|\n",
      "|        Denver| 4532|                     78|\n",
      "+--------------+-----+-----------------------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "filtered_listings.filter(f.col('city').isNotNull()).groupBy('city')\\\n",
    "         .agg(f.count('neighbourhood_cleansed').alias('Count'),\\\n",
    "         f.countDistinct('neighbourhood_cleansed').alias('Distinct neighbourhoods'))\\\n",
    "         .orderBy(f.desc('Distinct neighbourhoods')).show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Based on the table above, you should choose a city that you want to continue your analysis for. The city should have mulitple neighbourhoods with listings in them.\n",
    "\n",
    "Compute and visualize the number of listings of different property types per neighbourhood in your city."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "We chose to work with Oakland, as it had relatively many distinct neighbourhoods and number of listings.\n",
    "In order to save time and processing power in the following computations, we persisted the newly created dataset 'Oakland'.\n",
    "To compute the number of listings with different property types per neighbourhood, we group by the neighbourhood and use the count distinct aggregate function. Finally, we order by the count."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------------+-----------------------+\n",
      "|       neighbourhood|Distinct Property Types|\n",
      "+--------------------+-----------------------+\n",
      "|             Oakland|                     22|\n",
      "|       North Oakland|                     12|\n",
      "|        East Oakland|                     12|\n",
      "|       Oakland Hills|                     10|\n",
      "|        West Oakland|                      9|\n",
      "|         Lower Hills|                      8|\n",
      "|     Northwest Hills|                      7|\n",
      "|            Elmhurst|                      7|\n",
      "|Southeast Oakland...|                      7|\n",
      "|             Bushrod|                      7|\n",
      "|Central East Oakland|                      7|\n",
      "|            Prescott|                      7|\n",
      "|    Downtown Oakland|                      6|\n",
      "|         Adams Point|                      5|\n",
      "|           Fruitvale|                      5|\n",
      "|            Temescal|                      5|\n",
      "|           Montclair|                      5|\n",
      "|             Shafter|                      5|\n",
      "|     Redwood Heights|                      5|\n",
      "|        Upper Dimond|                      5|\n",
      "+--------------------+-----------------------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# We filter for the city and remove NULLs\n",
    "Oakland = filtered_listings.filter(f.col('city') == 'Oakland').filter(f.col('price').isNotNull()).persist()\n",
    "oakland_count = Oakland.groupBy('neighbourhood')\\\n",
    "        .agg(f.countDistinct('property_type').alias('Distinct Property Types'))\\\n",
    "        .orderBy(f.desc('Distinct Property Types'))\n",
    "oakland_count.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The visiualize the counts we use pandas and matplotlib to make a simple bar chart."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0, 0.5, 'Count'), Text(0.5, 0, 'Neighbourhoods')]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "disPropType = oakland_count.toPandas()\n",
    "disPropType.plot.bar('neighbourhood','Distinct Property Types', figsize = (15,5))\\\n",
    "        .set(ylabel = 'Count', xlabel = 'Neighbourhoods')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that the neighbourhood 'Oakland' has the highest number of listings, which is sensible as often the majority of the listings lie around the center of a city."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prices\n",
    "Compute the minimum, maximum and average listing price in your city. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We list the first 100 entries, to see the format of the values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------+\n",
      "|    Price|\n",
      "+---------+\n",
      "|  $164.00|\n",
      "|   $52.00|\n",
      "|   $65.00|\n",
      "|  $100.00|\n",
      "|  $141.00|\n",
      "|   $70.00|\n",
      "|  $110.00|\n",
      "|  $141.00|\n",
      "|  $150.00|\n",
      "|  $200.00|\n",
      "|  $110.00|\n",
      "|  $245.00|\n",
      "|  $148.00|\n",
      "|   $90.00|\n",
      "|   $65.00|\n",
      "|   $68.00|\n",
      "|  $119.00|\n",
      "|  $148.00|\n",
      "|  $129.00|\n",
      "|  $225.00|\n",
      "|   $89.00|\n",
      "|   $89.00|\n",
      "|  $108.00|\n",
      "|  $230.00|\n",
      "|  $150.00|\n",
      "|   $75.00|\n",
      "|  $105.00|\n",
      "|  $300.00|\n",
      "|   $55.00|\n",
      "|   $83.00|\n",
      "|   $69.00|\n",
      "|  $195.00|\n",
      "|   $89.00|\n",
      "|   $79.00|\n",
      "|  $102.00|\n",
      "|   $99.00|\n",
      "|  $120.00|\n",
      "|   $72.00|\n",
      "|  $160.00|\n",
      "|  $165.00|\n",
      "|   $89.00|\n",
      "|  $110.00|\n",
      "|   $88.00|\n",
      "|  $200.00|\n",
      "|  $375.00|\n",
      "|  $135.00|\n",
      "|  $150.00|\n",
      "|  $105.00|\n",
      "|   $99.00|\n",
      "|   $85.00|\n",
      "|   $69.00|\n",
      "|   $99.00|\n",
      "|  $200.00|\n",
      "|   $40.00|\n",
      "|$2,500.00|\n",
      "|  $125.00|\n",
      "|  $225.00|\n",
      "|  $145.00|\n",
      "|   $75.00|\n",
      "|   $52.00|\n",
      "|  $193.00|\n",
      "|   $40.00|\n",
      "|  $349.00|\n",
      "|  $350.00|\n",
      "|   $80.00|\n",
      "|  $115.00|\n",
      "|  $130.00|\n",
      "|$2,400.00|\n",
      "|  $269.00|\n",
      "|   $96.00|\n",
      "|  $280.00|\n",
      "|   $89.00|\n",
      "|   $76.00|\n",
      "|  $800.00|\n",
      "|   $95.00|\n",
      "|   $76.00|\n",
      "|   $79.00|\n",
      "|  $105.00|\n",
      "|   $90.00|\n",
      "|  $220.00|\n",
      "|   $45.00|\n",
      "|   $90.00|\n",
      "|  $318.00|\n",
      "|  $100.00|\n",
      "|  $135.00|\n",
      "|   $55.00|\n",
      "|   $73.00|\n",
      "|   $90.00|\n",
      "|  $195.00|\n",
      "|  $160.00|\n",
      "|   $70.00|\n",
      "|  $130.00|\n",
      "|   $49.00|\n",
      "|   $99.00|\n",
      "|  $135.00|\n",
      "|   $67.00|\n",
      "|   $75.00|\n",
      "|   $80.00|\n",
      "|   $89.00|\n",
      "|   $80.00|\n",
      "+---------+\n",
      "only showing top 100 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "Oakland.select('Price').show(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We notice that the '$' sign is consistently present, and that both , and . appears. This will be needed to be delt with in order for us to handle them as numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----------+-----------+------------------+\n",
      "|Minimum ($)|Maximum ($)|      Averiage ($)|\n",
      "+-----------+-----------+------------------+\n",
      "|       16.0|     3150.0|129.84748478051907|\n",
      "+-----------+-----------+------------------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# First, we make a new column that removes '$' and ',' from a value.\n",
    "# Then we cast the values to the float type, drop the old price and rename the newly created.\n",
    "Oakland = Oakland.withColumn('Price_', f.translate(f.col('price'),'$,','')\\\n",
    "        .cast('float')).drop('price').withColumnRenamed('Price_','Price')\n",
    "\n",
    "# We filtered out NULLs and decided to only include listings with a price above 0,\n",
    "# as it was concluded that these must be typos. Then, the aggregate functions min, max, and avg were computed:\n",
    "Oakland.filter(f.col('Price').isNotNull()).filter(f.col('Price') > 0)\\\n",
    "        .select(f.min(f.col('Price')).alias('Minimum ($)'),\\\n",
    "        f.max(f.col('Price')).alias('Maximum ($)')\\\n",
    "        ,f.avg(f.col('Price')).alias('Averiage ($)')).show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now conclude that the cheapest listing costs \\$16 per night, while the most expensive costs \\$3150. The average cost lies around \\$130.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute and visualize the distribution of listing prices in your city."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "We convert the Oakland prices to a pandas dataframe to plot a histogram over it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0, 0.5, 'Number of listings'), Text(0.5, 0, 'Price')]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "oak_prices = Oakland.select('Price').toPandas()\n",
    "oak_prices.plot.hist(figsize = (15, 5))\\\n",
    "        .set(ylabel='Number of listings', xlabel='Price')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that the vast majority of AirBnB listings for our site are in the price range of the average listing price.\n",
    "Vary few are \\> \\$1000, therefore, to get a feeling of the distribution below this price, we filtered the prices above \\$500 out:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0, 0.5, 'Number of listings'), Text(0.5, 0, 'Price')]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "oak_prices = pd.DataFrame(Oakland.filter(f.col('Price') < 500).select('Price').toPandas())\n",
    "oak_prices.plot.hist(figsize = (15, 5))\\\n",
    "        .set(ylabel='Number of listings', xlabel='Price')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This gives a much nicer view of the distribution in the lower end of the price range.\n",
    "We can conclude that the majority of listings have prices near \\$50-150 per night, so just around the average listing price.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The value of a listing is its rating divided by its price.\n",
    "\n",
    "Compute and show a dataframe with the 3 highest valued listings in each neighbourhood."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To do this, we first create a new column with the value, calculated as descibred above. We then make a window partitioned by the neighbourhood, which is ordered by the value.\n",
    "\n",
    "We then compute the value ranks with the rank function over the created window. The result is printed by filtering ranks \\< 3 and selecting the appropriate columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------+--------------------+------------------+---------+\n",
      "|      id|       Neighbourhood|             Value|ValueRank|\n",
      "+--------+--------------------+------------------+---------+\n",
      "|14770441|         Adams Point|3.4642857142857144|        1|\n",
      "|17078348|         Adams Point|             2.325|        2|\n",
      "|17929214|         Adams Point|1.8181818181818181|        3|\n",
      "|  743479|         Bella Vista|             1.225|        1|\n",
      "| 6259818|         Bella Vista|0.5344827586206896|        2|\n",
      "| 2739753|             Bushrod|2.3846153846153846|        1|\n",
      "| 1280992|             Bushrod|               2.0|        2|\n",
      "| 8149763|             Bushrod|1.8148148148148149|        3|\n",
      "|26570073|       Caballo Hills|               2.0|        1|\n",
      "|26688387|       Caballo Hills|1.7636363636363637|        2|\n",
      "|27903925|       Caballo Hills|1.5833333333333333|        3|\n",
      "|34120346|Central East Oakland| 4.318181818181818|        1|\n",
      "|26690740|Central East Oakland| 4.086956521739131|        2|\n",
      "|26690535|Central East Oakland|3.9565217391304346|        3|\n",
      "| 3695319|         Chabot Park|1.7636363636363637|        1|\n",
      "|34156946|           Chinatown|3.3333333333333335|        1|\n",
      "|31145170|           Chinatown|3.0344827586206895|        2|\n",
      "|34156617|           Chinatown| 2.962962962962963|        3|\n",
      "|15534867|             Clawson|1.7454545454545454|        1|\n",
      "|  597895|             Clawson|1.2763157894736843|        2|\n",
      "| 1484607|             Clawson|              0.99|        3|\n",
      "|22433029|   Cleveland Heights|2.6315789473684212|        1|\n",
      "|33618956|   Cleveland Heights|2.6315789473684212|        1|\n",
      "|26282060|   Cleveland Heights|1.8888888888888888|        3|\n",
      "|36757331|             Clinton|2.7027027027027026|        1|\n",
      "|24267960|             Clinton|1.0777777777777777|        2|\n",
      "|31909938|             Clinton|0.8434782608695652|        3|\n",
      "|21802229|             Dogtown|           2.96875|        1|\n",
      "|21802273|             Dogtown|            2.9375|        2|\n",
      "|21802117|             Dogtown|           2.90625|        3|\n",
      "|30111263|    Downtown Oakland| 3.111111111111111|        1|\n",
      "|31145653|    Downtown Oakland|3.0344827586206895|        2|\n",
      "|31243489|    Downtown Oakland|2.9310344827586206|        3|\n",
      "|31831256|        East Oakland| 4.260869565217392|        1|\n",
      "|31831020|        East Oakland| 4.217391304347826|        2|\n",
      "|26690688|        East Oakland| 4.130434782608695|        3|\n",
      "| 3803423|        East Peralta|1.7037037037037037|        1|\n",
      "|15314952|            Elmhurst| 2.962962962962963|        1|\n",
      "|26253043|            Elmhurst|2.7142857142857144|        2|\n",
      "|29104781|            Elmhurst|2.5833333333333335|        3|\n",
      "|  637155|       Fairview Park|1.1973684210526316|        1|\n",
      "| 5893465|       Fairview Park|1.1518987341772151|        2|\n",
      "|16271642|       Fairview Park|1.0421052631578946|        3|\n",
      "| 5182887|          Forestland|1.6166666666666667|        1|\n",
      "|32020494|          Forestland|1.1428571428571428|        2|\n",
      "|23668996|          Forestland|1.0526315789473684|        3|\n",
      "|20995485|           Fruitvale|             3.125|        1|\n",
      "|16795081|           Fruitvale| 2.857142857142857|        2|\n",
      "|20882680|           Fruitvale|2.6315789473684212|        3|\n",
      "|23005803|             Gaskill|1.5806451612903225|        1|\n",
      "|16858622|             Gaskill|1.3285714285714285|        2|\n",
      "|13298478|             Gaskill|1.0309278350515463|        3|\n",
      "|31677146|      Glen Highlands| 1.523076923076923|        1|\n",
      "|21549143|      Glen Highlands|             1.125|        2|\n",
      "|  302629|      Glen Highlands|1.1136363636363635|        3|\n",
      "|11257153|            Glenview|1.1585365853658536|        1|\n",
      "|21884600|            Glenview|           0.59375|        2|\n",
      "|14035741|            Glenview|0.5555555555555556|        3|\n",
      "|27406560|         Golden Gate| 2.111111111111111|        1|\n",
      "| 9617309|         Golden Gate|2.0833333333333335|        2|\n",
      "|20782003|         Golden Gate|1.3333333333333333|        3|\n",
      "|20075153|          Grand Lake| 5.052631578947368|        1|\n",
      "|17793909|          Grand Lake|3.3214285714285716|        2|\n",
      "|16557646|          Grand Lake|3.1724137931034484|        3|\n",
      "| 9077674|Harrison Street/O...|           1.53125|        1|\n",
      "|  253308|Harrison Street/O...|1.3194444444444444|        2|\n",
      "| 6678331|Harrison Street/O...|1.2181818181818183|        3|\n",
      "|29319383|       Highland Park| 1.403225806451613|        1|\n",
      "|33621318|       Highland Park|               1.4|        2|\n",
      "| 6186641|       Highland Park|1.1647058823529413|        3|\n",
      "|34420790|    Highland Terrace|              2.45|        1|\n",
      "|19182373|    Highland Terrace|             0.736|        2|\n",
      "|11049950|            Ivy Hill|1.4307692307692308|        1|\n",
      "|22121224|            Ivy Hill|               1.4|        2|\n",
      "| 8087754|            Ivy Hill|1.3333333333333333|        3|\n",
      "|15254224| Joaquin Miller Park|0.9797979797979798|        1|\n",
      "|14725670|        Lake Merritt|1.2933333333333332|        1|\n",
      "|   55255|        Lake Merritt|1.0888888888888888|        2|\n",
      "|23731165|        Lake Merritt|  0.98989898989899|        3|\n",
      "|11533499|           Lakeshore|0.9339622641509434|        1|\n",
      "|31382416|            Lakeside|1.3846153846153846|        1|\n",
      "|10022803|            Lakeside|1.1764705882352942|        2|\n",
      "|15274930|            Lakeside|1.0909090909090908|        3|\n",
      "|21967839|       Leona Heights|1.8181818181818181|        1|\n",
      "|27723009|       Leona Heights|1.3333333333333333|        2|\n",
      "| 4365392|       Leona Heights|0.6666666666666666|        3|\n",
      "|23153301|   Lincoln Highlands| 1.123456790123457|        1|\n",
      "|36727780|   Lincoln Highlands|1.0101010101010102|        2|\n",
      "|26365215|   Lincoln Highlands|0.4682926829268293|        3|\n",
      "|19345280|          Longfellow| 2.127659574468085|        1|\n",
      "| 8965978|          Longfellow| 2.088888888888889|        2|\n",
      "|12189833|          Longfellow| 2.088888888888889|        2|\n",
      "| 8354354|       Lower Bottoms|1.3846153846153846|        1|\n",
      "|13636373|       Lower Bottoms| 0.868421052631579|        2|\n",
      "|34682017|       Lower Bottoms|0.4714285714285714|        3|\n",
      "|29493595|         Lower Hills|3.3793103448275863|        1|\n",
      "|16579928|         Lower Hills|3.1724137931034484|        2|\n",
      "|17607684|         Lower Hills| 3.107142857142857|        3|\n",
      "|33368583|                Lynn|               2.4|        1|\n",
      "|22213414|                Lynn|1.0333333333333334|        2|\n",
      "|33365421|                Lynn|0.4271356783919598|        3|\n",
      "|25552303|        Meadow Brook|2.6857142857142855|        1|\n",
      "|22562467|        Meadow Brook|2.5428571428571427|        2|\n",
      "|30513744|        Meadow Brook| 1.694915254237288|        3|\n",
      "|12365568|             Merritt|              1.96|        1|\n",
      "| 4099934|             Merritt|              1.84|        2|\n",
      "| 9590876|             Merritt|              1.84|        2|\n",
      "| 2599217|           Merriwood| 1.476923076923077|        1|\n",
      "| 6951658|           Merriwood|               1.0|        2|\n",
      "| 4925496|           Merriwood|              0.99|        3|\n",
      "|14298525|           Montclair|              1.96|        1|\n",
      "| 8830405|           Montclair|1.3066666666666666|        2|\n",
      "|10902785|           Montclair|1.2531645569620253|        3|\n",
      "|31295709|            Mosswood|1.8181818181818181|        1|\n",
      "| 1876416|            Mosswood|              1.65|        2|\n",
      "|   56273|            Mosswood|1.5384615384615385|        3|\n",
      "|22466746|       North Oakland| 3.225806451612903|        1|\n",
      "|25015473|       North Oakland|           3.03125|        2|\n",
      "|38386300|       North Oakland| 2.857142857142857|        3|\n",
      "| 7594969|     Northwest Hills|               2.0|        1|\n",
      "| 1747411|     Northwest Hills|1.8181818181818181|        2|\n",
      "|32018844|     Northwest Hills|1.7142857142857142|        3|\n",
      "|33451748|          Oak Center|1.8518518518518519|        1|\n",
      "|24138006|          Oak Center|1.6065573770491803|        2|\n",
      "| 8324744|          Oak Center|1.3285714285714285|        3|\n",
      "|21975683|            Oak Tree|0.9894736842105263|        1|\n",
      "|22716007|             Oakland| 5.052631578947368|        1|\n",
      "|15290825|             Oakland| 4.578947368421052|        2|\n",
      "|21207200|             Oakland|               4.0|        3|\n",
      "| 8860519|       Oakland Hills|               2.8|        1|\n",
      "|30822892|       Oakland Hills|2.6666666666666665|        2|\n",
      "|31313760|       Oakland Hills|               2.5|        3|\n",
      "|21462206|       Oakland Hills|               2.5|        3|\n",
      "|11553790|             Oakmore|1.8461538461538463|        1|\n",
      "| 1315776|             Oakmore|1.8181818181818181|        2|\n",
      "| 6000201|             Oakmore|1.5806451612903225|        3|\n",
      "|32518126|            Old City|               2.0|        1|\n",
      "|13381058|            Old City| 0.979381443298969|        2|\n",
      "|11419858|       Paradise Park|               2.4|        1|\n",
      "|  235160|       Paradise Park| 1.240506329113924|        2|\n",
      "|26783805|       Paradise Park|0.8319327731092437|        3|\n",
      "|10923716|            Piedmont|               1.1|        1|\n",
      "|24087242|            Piedmont| 1.098901098901099|        2|\n",
      "|17806379|            Piedmont|1.0421052631578946|        3|\n",
      "|19781908|     Piedmont Avenue| 1.719298245614035|        1|\n",
      "|20567425|     Piedmont Avenue| 1.639344262295082|        2|\n",
      "|   62214|     Piedmont Avenue|1.4264705882352942|        3|\n",
      "|21566701|      Piedmont Pines|0.8928571428571429|        1|\n",
      "| 7579214|      Piedmont Pines|0.6711409395973155|        2|\n",
      "|31256864|      Piedmont Pines|0.6573426573426573|        3|\n",
      "|22232914|           Pill Hill|               5.0|        1|\n",
      "|14928199|           Pill Hill|               2.0|        2|\n",
      "| 4378325|           Pill Hill|0.9693877551020408|        3|\n",
      "|28817706|            Prescott|              3.68|        1|\n",
      "|29185822|            Prescott|3.6296296296296298|        2|\n",
      "|27196492|            Prescott|3.3793103448275863|        3|\n",
      "|23045702|Produce and Water...|1.3333333333333333|        1|\n",
      "| 8336147|Produce and Water...|               0.8|        2|\n",
      "|22066737|Produce and Water...|0.5128205128205128|        3|\n",
      "|32693542|Ralph Bunche/McCl...|2.0408163265306123|        1|\n",
      "|34816637|Ralph Bunche/McCl...|               2.0|        2|\n",
      "|31237294|Ralph Bunche/McCl...|              1.82|        3|\n",
      "|24227657|  Rancho San Antonio|               2.5|        1|\n",
      "|29032822|  Rancho San Antonio|0.6666666666666666|        2|\n",
      "|33426612|     Redwood Heights|               2.5|        1|\n",
      "|19663257|     Redwood Heights|1.7454545454545454|        2|\n",
      "|21013375|     Redwood Heights| 1.690909090909091|        3|\n",
      "|24651692|      Reservoir Hill|              3.76|        1|\n",
      "|23418449|      Reservoir Hill|              3.64|        2|\n",
      "|22214553|      Reservoir Hill|  2.41025641025641|        3|\n",
      "| 4180140|           Rockridge|1.6363636363636365|        1|\n",
      "| 7131456|           Rockridge|1.3692307692307693|        2|\n",
      "|18549983|           Rockridge|1.3333333333333333|        3|\n",
      "|30339219|   San Pablo Gateway| 2.735294117647059|        1|\n",
      "| 2479459|   San Pablo Gateway|              1.25|        2|\n",
      "| 6808306|   San Pablo Gateway|0.8173913043478261|        3|\n",
      "|32866320|            Santa Fe|1.4285714285714286|        1|\n",
      "| 8213527|            Santa Fe| 1.318840579710145|        2|\n",
      "|12736724|            Santa Fe| 1.303030303030303|        3|\n",
      "|31208257|            Sequoyah|1.4558823529411764|        1|\n",
      "| 1641978|            Sequoyah|1.1529411764705881|        2|\n",
      "|35017399|            Sequoyah|              0.62|        3|\n",
      "|33667839|             Shafter|1.0434782608695652|        1|\n",
      "|24948341|             Shafter|1.0217391304347827|        2|\n",
      "| 2653223|             Shafter|1.0105263157894737|        3|\n",
      "|24208199|      Shepard Canyon|1.4328358208955223|        1|\n",
      "|30763785|      Shepard Canyon|0.7461538461538462|        2|\n",
      "|22714514|      South Prescott|            5.6875|        1|\n",
      "|22659458|      South Prescott|3.6538461538461537|        2|\n",
      "|22988235|      South Prescott|2.0444444444444443|        3|\n",
      "|15633675|Southeast Oakland...|2.4390243902439024|        1|\n",
      "|10771661|Southeast Oakland...|2.1777777777777776|        2|\n",
      "| 2261596|Southeast Oakland...|               2.0|        3|\n",
      "|31363715|            Temescal|2.7777777777777777|        1|\n",
      "|20138955|            Temescal|             2.425|        2|\n",
      "|15821300|            Temescal|1.5384615384615385|        3|\n",
      "|  752568|        Trestle Glen| 1.101123595505618|        1|\n",
      "| 4385104|        Trestle Glen|               1.0|        2|\n",
      "| 2008590|        Trestle Glen|             0.784|        3|\n",
      "| 5927928|              Tuxedo|1.5666666666666667|        1|\n",
      "|13158957|              Tuxedo|1.3333333333333333|        2|\n",
      "|37916038|              Tuxedo|0.5555555555555556|        3|\n",
      "|23056765|        Upper Dimond|               2.0|        1|\n",
      "| 9113293|        Upper Dimond|               2.0|        1|\n",
      "|22775765|        Upper Dimond|1.8846153846153846|        3|\n",
      "| 5925787|     Upper Rockridge|             1.225|        1|\n",
      "|27638594|     Upper Rockridge|         0.7578125|        2|\n",
      "|  155368|     Upper Rockridge|              0.66|        3|\n",
      "|28817968|        West Oakland|               4.0|        1|\n",
      "|29185737|        West Oakland|3.6296296296296298|        2|\n",
      "|28813797|        West Oakland|              3.52|        3|\n",
      "+--------+--------------------+------------------+---------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Calculate value:\n",
    "Oakland_score = Oakland.filter(f.col('review_scores_rating').isNotNull())\\\n",
    "        .withColumn('Value', f.col('review_scores_rating').cast('float')/f.col('price'))\n",
    "# Create window:\n",
    "sorted_by_hood_window = Window.partitionBy('neighbourhood').orderBy(f.desc('Value'))\n",
    "# Make rank and filter results:\n",
    "ranked_oakland = Oakland_score.withColumn('ValueRank', f.rank().over(sorted_by_hood_window))\n",
    "ranked_oakland = ranked_oakland.filter(f.col('ValueRank') <= 3).orderBy('Neighbourhood', f.desc('Value'))\\\n",
    "        .select('id','Neighbourhood','Value','ValueRank')\n",
    "ranked_oakland.show(10000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that it is not all neighbourhoods that have more than 1 or 2 listings, so a top 3 of those cannot be shown.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Trends\n",
    "Now we want to analyze the \"popularity\" of your city. The data does not contain the number of bookings per listing, but we have a large number of reviews, and we will assume that this is a good indicator of activity on listings."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute and visualize the popularity (i.e., number of reviews) of your city over time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "For this the reviews.csv dataset is needed. In order to associate the relevant reviews with their appropriate listing, we did a broadcast inner join of the listing\\_id in df\\_reviews and id (renamed to id\\_) from Oakland.\n",
    "The new dataset was persisted to make future computations faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----------+--------+----------+-----------+-------------+--------------------+-------------+\n",
      "|listing_id|      id|      date|reviewer_id|reviewer_name|            comments|neighbourhood|\n",
      "+----------+--------+----------+-----------+-------------+--------------------+-------------+\n",
      "|      3083|16797662|2014-08-02|   18272366| Carlos Kenji|B- love guest hou...| West Oakland|\n",
      "|      3083|19980893|2014-09-21|    4400249|        Jason|The description w...| West Oakland|\n",
      "|      3083|21720882|2014-10-22|    4268642|       Carmen|B-Love makes me f...| West Oakland|\n",
      "|      3083|27107155|2015-02-25|   23674350|      Matthew|Simple but effect...| West Oakland|\n",
      "|      3083|33318077|2015-05-26|    1252519|        Pavel|I enjoyed staying...| West Oakland|\n",
      "+----------+--------+----------+-----------+-------------+--------------------+-------------+\n",
      "only showing top 5 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "Oakland_ids = Oakland.select('id','neighbourhood').withColumnRenamed('id','id_')\n",
    "Oakland_reviews = df_reviews.join(f.broadcast(Oakland_ids),\\\n",
    "        (f.col('listing_id') == f.col('id_')), 'inner').drop('id_').persist()\n",
    "Oakland_reviews.show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The reviews were grouped by the date, counted and then ordered.\n",
    "The result was plotted to show the popularity over time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0, 0.5, 'Count')]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "review_time = Oakland_reviews.groupBy('Date').count()\\\n",
    "        .orderBy(f.col('Date'))\n",
    "\n",
    "review_time.toPandas().plot('Date','count', figsize=(15,5)).set(ylabel='Count')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see thath the city was not very popular in the early days of AirBnB, which makes sense. Interestingly, we see huge deviations in popularity, probably caused by the seasons.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute and visualize the popularity of neighbourhoods over time. If there are many neighbourhoods in your city, you should select a few interesting ones for comparison."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "We selected 5 neighbourhoods, and plotted their individual popularity over time.\n",
    "We chose to only look at months, as it gave a nicer overview and made the seasons more clear."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3UAAAFsCAYAAABrSJBaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3de7wcdX3/8deHJBAhXEMMaISDRVQUQQn4K6AiCLUFFS3ipVW0WkqVKrVesLa1/uoFrBXq7WcjKngDvEBR8Y5ctFaExHANNzFoUG4BBFSQhM/vj5ngujmX3XMyu/M95/V8POZxdmfeO/vZ2Tm789nZmY3MRJIkSZJUpo2GXYAkSZIkafJs6iRJkiSpYDZ1kiRJklQwmzpJkiRJKphNnSRJkiQVzKZOkiRJkgpmUydJ0hgi4pSIeGeD8//XiPhMU/OXJM0MNnWSpGkhIlZGxG8j4t6IuDMizomIRw27LkmSmmZTJ0maTp6TmfOA7YFbgA8O6o4jYvag7kuSpE42dZKkaScz7wO+COwKEBHnR8Sr102PiFdExPfryxERJ0bErRFxd0RcHhFP7Jjd1vVev3si4qKI+KOO+WREvDYirgOuq8ftExEXR8Sv6r/7dOR3iogL6nl9G9i20QUhSZoRbOokSdNORGwKvAj4YQ/xg4GnA7sAWwJHAKs7pr8YeAewNXA98K6u2x8GPBXYNSK2Ac4BPgDMB94PnBMR8+vs54ClVM3cvwFH9vvYJEnqZlMnSZpO/jsi7gJ+BRwE/HsPt3kA2Bx4HBCZuSIzf9kx/azM/FFmrgE+C+zRdfv3ZOYdmflb4BDgusz8dGauyczTgKuB50TEDsBewD9n5v2ZeSHwlak8WEmSwKZOkjS9HJaZWwFzgWOACyJiu/FukJnfBT4EfBi4NSKWRMQWHZGbOy7/BpjXNYufd1x+BHBj1/QbgUfW0+7MzF93TZMkaUps6iRJ005mrs3MM4G1wH7Ar4FNOyLbdeU/kJl7Uh2Dtwvwpn7uruPyL4Adu6bvANwE/JLq+LzNuqZJkjQlNnWSpGmnPvnJ86iOg1sBLAdeEBGbRsTOwKs6sntFxFMjYg5V83cf8OAk7/prwC4R8dKImB0RL6JqFL+amTcClwDviIiNI2I/4DmTfpCSJNVs6iRJ08lXIuJe4G6qE5ocmZlXAicCv6P6mYNTqY6NW2cL4GPAnVRfh1xNb8firSczVwOHAv9Qz+fNwKGZeXsdeSnVSVXuAN4OfGoy9yNJUqfIzIlTkiRJkqRWck+dJEmSJBXMpk6SJEmSCmZTJ0mSJEkFs6mTJEmSpILNHnYBvdh2221zZGRk2GVIkiRJ0lAsXbr09sxcMNq0Ipq6kZERLrnkkmGXIUmSJElDERE3jjXNr19KkiRJUsFs6iRJkiSpYDZ1kiRJklSwIo6pkyRJkjT9PfDAA6xatYr77rtv2KUMzdy5c1m0aBFz5szp+TY2dZIkSZJaYdWqVWy++eaMjIwQEcMuZ+Ayk9WrV7Nq1Sp22mmnnm/n1y8lSZIktcJ9993H/PnzZ2RDBxARzJ8/v+89lTZ1kiRJklpjpjZ060zm8dvUSZIkSVLBPKZOkiRJUiuNHHfOBp3fyuMP6Sl38803c+yxx3LxxRez1VZbsXDhQk466SR22WWXDVLH+eefz8Ybb8w+++yzQebnnjpJkiRJqmUmz3/+89l///35yU9+wtKlS3nPe97DLbfcssHu4/zzz+cHP/jBBpufTZ0kSZIk1c477zzmzJnD0Ucf/dC43Xffnf322483velNPPGJT2S33XbjjDPOAKoG7dBDD30oe8wxx3DKKacAMDIywtvf/nae8pSnsNtuu3H11VezcuVKPvrRj3LiiSeyxx578L3vfW/KNfv1S0mSJGnAxvpaYa9fD1RzrrjiCvbcc8/1xp955pksX76cSy+9lNtvv5299tqLpz/96RPOb9ttt2XZsmV85CMf4X3vex8nn3wyRx99NPPmzeONb3zjBqnZPXWSJEmSNIHvf//7vOQlL2HWrFksXLiQZzzjGVx88cUT3u4FL3gBAHvuuScrV65spDabOkmSJEmqPeEJT2Dp0qU952fPns2DDz740PXu35jbZJNNAJg1axZr1qzZMEV2samTJEmSpNoBBxzA/fffz5IlSx4ad9lll7HVVltxxhlnsHbtWm677TYuvPBC9t57b3bccUeuuuoq7r//fu666y7OPffcCe9j880355577tlgNXtMnSRJkqRWGsYxhhHBWWedxbHHHssJJ5zA3LlzGRkZ4aSTTuLee+9l9913JyJ473vfy3bbbQfAEUccwROf+ER22mknnvzkJ094H895znM4/PDDOfvss/ngBz/I0572tKnVnJlTmsEgLF68OC+55JJhlyFJkiRtEJ4oZXQrVqzg8Y9//LDLGLrRlkNELM3MxaPl/fqlJEmSJBXMpk6SJEmSCmZTJ0mSJKk1Sjg8rEmTefw2dZIkSZJaYe7cuaxevXrGNnaZyerVq5k7d25ft/Psl5IkSZJaYdGiRaxatYrbbrtt2KUMzdy5c1m0aFFft7GpkyRJktQKc+bMYaeddhp2GcXx65eSJEmSVDCbOkmSJEkqmE2dJEmSJBXMpk6SJEmSCtboiVIiYiVwD7AWWJOZiyNiG+AMYARYCRyRmXc2WYckSZIkTVeD2FP3zMzcIzMX19ePA87NzMcA59bXJUmSJEmTMIyvXz4POLW+fCpw2BBqkCRJkqRpoemmLoFvRcTSiDiqHrcwM39ZX74ZWDjaDSPiqIi4JCIumck/PihJkiRJ42n6x8f3y8ybIuLhwLcj4urOiZmZEZGj3TAzlwBLABYvXjxqRpIkSZJmukb31GXmTfXfW4GzgL2BWyJie4D6761N1iBJkiRJ01ljTV1EbBYRm6+7DBwMXAF8GTiyjh0JnN1UDZIkSZI03TX59cuFwFkRse5+PpeZ34iIi4HPR8SrgBuBIxqsQZIkSZKmtcaausy8Adh9lPGrgQObul9JkiRJmkmG8ZMGkiRJkqQNxKZOkiRJkgpmUydJkiRJBbOpkyRJkqSC2dRJkiRJUsFs6iRJkiSpYDZ1kiRJklQwmzpJkiRJKphNnSRJkiQVbPawC5AkSZKkYRo57pz1xq08/pAhVDI57qmTJEmSpILZ1EmSJElSwWzqJEmSJKlgNnWSJEmSVDCbOkmSJEkqmE2dJEmSJBXMpk6SJEmSCmZTJ0mSJEkF88fHJUmSJE07bfhB8UHV4J46SZIkSSqYTZ0kSZIkFcymTpIkSZIKZlMnSZIkSQWzqZMkSZKkgtnUSZIkSVLBbOokSZIkqWA2dZIkSZJUMJs6SZIkSSrY7GEXIEmSJE3VyHHnjDp+5fGHzKgaNDO5p06SJEmSCmZTJ0mSJEkFs6mTJEmSpILZ1EmSJElSwWzqJEmSJKlgNnWSJEmSVDCbOkmSJEkqmE2dJEmSJBXMpk6SJEmSCmZTJ0mSJEkFa7ypi4hZEfHjiPhqfX2niLgoIq6PiDMiYuOma5AkSZKk6WoQe+peD6zouH4CcGJm7gzcCbxqADVIkiRJ0rTUaFMXEYuAQ4CT6+sBHAB8sY6cChzWZA2SJEmSNJ3Nbnj+JwFvBjavr88H7srMNfX1VcAjR7thRBwFHAWwww47NFymJEmSJE1s5Lhz1hu38vhDhlDJ7zW2py4iDgVuzcylk7l9Zi7JzMWZuXjBggUbuDpJkiRJmh6a3FO3L/DciPgzYC6wBfCfwFYRMbveW7cIuKnBGiRJkiRpWmtsT11mvjUzF2XmCPBi4LuZ+RfAecDhdexI4OymapAkSZKk6W4Yv1P3FuANEXE91TF2Hx9CDZIkSZI0LTR9ohQAMvN84Pz68g3A3oO4X0mSJEma7oaxp06SJEmStIHY1EmSJElSwWzqJEmSJKlgNnWSJEmSVDCbOkmSJEkqmE2dJEmSJBXMpk6SJEmSCmZTJ0mSJEkFs6mTJEmSpILZ1EmSJElSwWzqJEmSJKlgNnWSJEmSVDCbOkmSJEkq2OxhFyBJkiS11chx54w6fuXxhwy4Emls7qmTJEmSpILZ1EmSJElSwWzqJEmSJKlgNnWSJEmSVDBPlCJJkiS1mCdr0UTcUydJkiRJBbOpkyRJkqSC2dRJkiRJUsFs6iRJkiSpYJ4oRZIkSTOKJx7RdOOeOkmSJEkqmE2dJEmSJBXMpk6SJEmSCmZTJ0mSJEkF80QpkiRJkoain5PWeIKbsbmnTpIkSZIKZlMnSZIkSQWzqZMkSZKkgtnUSZIkSVLBbOokSZIkqWA2dZIkSZJUMJs6SZIkSSqYTZ0kSZIkFcymTpIkSZIK1lNTFxH79jJOkiRJkjRYve6p+2CP4x4SEXMj4kcRcWlEXBkR76jH7xQRF0XE9RFxRkRs3G/RkiRJkqTK7PEmRsQfA/sACyLiDR2TtgBmTTDv+4EDMvPeiJgDfD8ivg68ATgxM0+PiI8CrwL+36QfgSRJkiTNYBPtqdsYmEfV/G3eMdwNHD7eDbNyb311Tj0kcADwxXr8qcBhk6pckiRJkjT+nrrMvAC4ICJOycwb+515RMwClgI7Ax8GfgLclZlr6sgq4JFj3PYo4CiAHXbYod+7liRJkqQZYdymrsMmEbEEGOm8TWYeMN6NMnMtsEdEbAWcBTyu18IycwmwBGDx4sXZ6+0kSZIkaSbptan7AvBR4GRgbb93kpl3RcR5wB8DW0XE7Hpv3SLgpn7nJ0mSJEmq9NrUrcnMvk5mEhELgAfqhu5hwEHACcB5VMfjnQ4cCZzdz3wlSZIkSb/Xa1P3lYh4DdVXKO9fNzIz7xjnNtsDp9bH1W0EfD4zvxoRVwGnR8Q7gR8DH59c6ZIkSZKkXpu6I+u/b+oYl8Cjx7pBZl4GPHmU8TcAe/daoCRJkiRpbD01dZm5U9OFSJIkSZL611NTFxEvH218Zn5qw5YjSZIkSepHr1+/3Kvj8lzgQGAZYFMnSZIkSUPU69cv/67zev27c6c3UpEkSZIkqWe97qnr9mvA4+wkSZKkFhk57pxRx688/pABV6JB6vWYuq9Qne0SYBbweODzTRUlSZIkSepNr3vq3tdxeQ1wY2auaqAeSZIkSVIfNuollJkXAFcDmwNbA79rsihJkiRJUm96auoi4gjgR8ALgSOAiyLi8CYLkyRJkiRNrNevX74N2CszbwWIiAXAd4AvNlWYJEmShscTbmiyXHcGr6c9dcBG6xq62uo+bitJkiRJakive+q+ERHfBE6rr78I+FozJUmSJEmSejVuUxcROwMLM/NNEfECYL960v8Cn226OEmSJEnS+CbaU3cS8FaAzDwTOBMgInarpz2n0eokaRob7ZgDjzeQJEn9mui4uIWZeXn3yHrcSCMVSZIkSZJ6NlFTt9U40x62IQuRJEmSJPVvoqbukoj46+6REfFqYGkzJUmSJEmSejXRMXXHAmdFxF/w+yZuMbAx8PwmC5MkSZIkTWzcpi4zbwH2iYhnAk+sR5+Tmd9tvDJJkiRJjfFHwqePnn6nLjPPA85ruBZJkiRJUp8mOqZOkiRJktRiNnWSJEmSVDCbOkmSJEkqmE2dJEmSJBXMpk6SJEmSCmZTJ0mSJEkFs6mTJEmSpILZ1EmSJElSwXr68XFJkiRpLCPHnTPq+JXHHzKlrDSTjPa/0ev/hXvqJEmSJKlgNnWSJEmSVDCbOkmSJEkqmE2dJEmSJBXME6VIkiQNgCcIUclcf9vNPXWSJEmSVDCbOkmSJEkqmE2dJEmSJBXMY+okSZI6eOyQpNK4p06SJEmSCtZYUxcRj4qI8yLiqoi4MiJeX4/fJiK+HRHX1X+3bqoGSZIkSZrumtxTtwb4h8zcFfg/wGsjYlfgOODczHwMcG59XZIkSZI0CY01dZn5y8xcVl++B1gBPBJ4HnBqHTsVOKypGiRJkiRpuhvIMXURMQI8GbgIWJiZv6wn3QwsHOM2R0XEJRFxyW233TaIMiVJkiSpOI03dRExD/gScGxm3t05LTMTyNFul5lLMnNxZi5esGBB02VKkiRJUpEabeoiYg5VQ/fZzDyzHn1LRGxfT98euLXJGiRJkiRpOmvy7JcBfBxYkZnv75j0ZeDI+vKRwNlN1SBJkiRJ012TPz6+L/Ay4PKIWF6P+0fgeODzEfEq4EbgiAZrkCRJkqRprbGmLjO/D8QYkw9s6n4lSZJKN3LcOaOOX3n8IQOuRFIJBnL2S0mSJElSM2zqJEmSJKlgNnWSJEmSVDCbOkmSJEkqWJNnv5QkSZrWPKFJs1y+Um/cUydJkiRJBbOpkyRJkqSC2dRJkiRJUsFs6iRJkiSpYDZ1kiRJklQwmzpJkiRJKphNnSRJkiQVzKZOkiRJkgrmj49LkqRpzx+xrrgcpOnJPXWSJEmSVDCbOkmSJEkqmE2dJEmSJBXMpk6SJEmSCmZTJ0mSJEkFs6mTJEmSpILZ1EmSJElSwWzqJEmSJKlgNnWSJEmSVLDZwy5AaqOR485Zb9zK4w9p7XzVrH6eN59jSZI0aO6pkyRJkqSC2dRJkiRJUsFs6iRJkiSpYDZ1kiRJklQwT5QiaUye9KM9fC7aY7TnAnw+JEnD4546SZIkSSqYTZ0kSZIkFcymTpIkSZIKZlMnSZIkSQXzRCnSNNCGk2i0oQZNf56kRFqf/xeS3FMnSZIkSQWzqZMkSZKkgtnUSZIkSVLBPKZOkqQW8LgoSdJkuadOkiRJkgrWWFMXEZ+IiFsj4oqOcdtExLcj4rr679ZN3b8kSZIkzQRN7qk7BXh217jjgHMz8zHAufV1SZIkSdIkNdbUZeaFwB1do58HnFpfPhU4rKn7lyRJkqSZYNAnSlmYmb+sL98MLBwrGBFHAUcB7LDDDgMoTW3hj1irk+uDNLN4whhJ6t/QTpSSmQnkONOXZObizFy8YMGCAVYmSZIkSeUYdFN3S0RsD1D/vXXA9y9JkiRJ08qgm7ovA0fWl48Ezh7w/UuSJEnStNLkTxqcBvwv8NiIWBURrwKOBw6KiOuAZ9XXJUmSJEmT1NiJUjLzJWNMOrCp+9TM089JNDzhhjq5PmgQPOmHJGkQhnaiFEmSJEnS1NnUSZIkSVLBbOokSZIkqWA2dZIkSZJUsMZOlCJJar+mThjjCUI0CK5nklRxT50kSZIkFcymTpIkSZIKZlMnSZIkSQXzmDppikr7EevS6lX/PE5OkqSZxT11kiRJklQwmzpJkiRJKphNnSRJkiQVzKZOkiRJkgrmiVKklvKEJv1zmWmyPAmMJKlk7qmTJEmSpILZ1EmSJElSwWzqJEmSJKlgNnWSJEmSVDBPlDIJnoxBmhr/h9SpqZOUePKTZrl8Jak93FMnSZIkSQWzqZMkSZKkgtnUSZIkSVLBbOokSZIkqWCeKEWSpMKUdpKS0uqVpNK4p06SJEmSCmZTJ0mSJEkFs6mTJEmSpILZ1EmSJElSwTxRiv7AaAezj3Uge1NZSZIkSb1zT50kSZIkFcymTpIkSZIKZlMnSZIkSQXzmLoZwOPZJGnm6ueHv/2RcEkqk3vqJEmSJKlgNnWSJEmSVDCbOkmSJEkqmE2dJEmSJBWsuBOllPbj2KXVK0mSJKks7qmTJEmSpIINpamLiGdHxDURcX1EHDeMGiRJkiRpOhh4UxcRs4APA38K7Aq8JCJ2HXQdkiRJkjQdDGNP3d7A9Zl5Q2b+DjgdeN4Q6pAkSZKk4kVmDvYOIw4Hnp2Zr66vvwx4amYe05U7CjiqvvpY4JquWW0L3N7j3Zo128Y6zJo1a9asWbNmzZrtNbtjZi4Y9RaZOdABOBw4ueP6y4APTWI+l5g1O5lsW+owa9asWbNmzZo1a3Yq2XXDML5+eRPwqI7ri+pxkiRJkqQ+DaOpuxh4TETsFBEbAy8GvjyEOiRJkiSpeAP/8fHMXBMRxwDfBGYBn8jMKycxqyVmzU4y25Y6zJo1a9asWbNmzZqdShYYwolSJEmSJEkbzlB+fFySJEmStGHY1EmSJElSwWzqJEmSJKlgNnWSJEmSVLBim7qI+O6A72+biPiXiHh1VN4WEV+NiH+PiK0HWcsw1Y/9iIh4YX35wIj4QES8JiImXJ8G/bz1w+dYkqTmuA0hNaeIpi4iLusaLgf2XXe9K7tt1/W/rF8wjoqI6Jr2/ojYt8cyPgNsBuwJnAdsB5wA/BY4ZZSanxkRH4qIsyPizIg4PiJ27vUx1/NY0nV9VkT8TUT8W3fdEfFPfcz3X0YZ9ycR8aqIGOka/1dd0Q8DRwAvAz4NHE3124NPB07sum1Tz9vzI2Kb+vKCiPhURFweEWdExKKu7NCf44iYXT9v3+hYFl+PiKMjYk6PtTW5Pkx6vhGxaUS8OSLeFBFzI+IVEfHliHhvRMzr4b6vHWP8kzouz4mIf6rn++6I2LQre8y69Scido6ICyPiroi4KCJ268qeWa9bvdT26Ij4RES8MyLmRcTHIuKKiPjCKP8nG0XEX0XEORFxaUQsi4jTI2L/Uea7Zb2uXB0Rd0TE6ohYUY/baqK6Oubz9a7rW0TEeyLi0xHx0q5pH+ljvuudRtl14qGs6wSuDx3Zmbo+uA0xOrch+pyvrw8PZXt+fRj3Pkv4SYOI+DJwN/BOqn+OAL4H7AeQmTd2ZJdl5lPqy/8EPA34HHAosCoz/74jextwI7AAOAM4LTN/PEYNyzNzj/rFYVVmPrJ7Wsf191D9M58LHAb8FLgWeA3w7sz8Qkd2m7EeNnBpZi7qyJ4MbAr8iOoF8YLMfEP3455IRPwsM3fouP5uqmW5DHgOcFJmfnC0+UbE5Zm5W/1CcjOwfWb+LiJmA8sys/Mfqann7arM3LW+fAbwQ+ALwLOAv8jMgzqybXiOTwPuAk4FVtWjFwFHAttk5os6so2sDw3O9/PAz4GHAY8FVlAt5+cC22Xmyzqy9wDrXnDWvcluCvwGyMzcoiPbuT78BzAf+CTVsp6fmS/vyF6ZmU+oL58DnJyZZ9Uvhu/KzH07sjcB/wscAHwHOA04JzN/t96Cibiwnr4l8Jf1/X8eOJhqPTugI/tJqvXsO8DhVOv994C3AGev+3+qs98Evgucmpk31+O2o1ofDszMgzuyY/1PB/DVzNy+I/sl4Dqq/4e/Ah4AXpqZ909lfajzrhO4TnRkXR+Y3uvDeNyGcBtiA87X1wf6e30YV2YWMQDPBy4Enltfv2GM3I87Li8DNqsvzwEuHy0L7AL8M3AlcDXwdmCXruxlwNbADsCvgJF6/Hzgqq7s5R2XZwP/U1/eGriiK7sWuIHqH3rdsO7677pr6JrvEuBMYJPOx11Pv3uM4R5gTXe9wOz68lbA14ATu5fnKMv3G13Tlg/oebum4/LS8WpoyXN87Tjr9bVd15taH5qa7/L6b1C9QUfH9cu6sh8APgUs7Bj30x7Wh+XAnHHm27k+XDzWY+laH7agerP5GnAb1YvtwePU8LOxpo1xPz+s/24CrBir3lEe9zVd19dSbdydN8rw2wnW/bcB/1Ovv8smuz64TrhOdK8Trg8zYn1wG+IP1we3IXx96Fwfhvb6MN7QU6gtA9Vu7fcDZ1N9CjJa5mrgyVS7vy8dbeXpuL5slNs/CXgPcH3X+JcAt9TDn1N1098BbgKO6speSvXpCVT/3D/smHZlV/Y6YIcxHsvPux/bKJl/oXpRvq5r/M86V/wJ5tv9hjIL+DjVJ1fd9X4dmDfKPLcDfjSg5+2/gP9L9cnOfwDPr8c/k+oTobY9xz8EXghs1DFuI+BFwEUDWh+amu/yjsuf6F5Go8xnT6oNkNfVy2CsN+gbqN7M/3yU9bN7/XgX1VdbHg38I3AssCPwSqpPqidaH+ZTfQXou13jl1K9ke8F3A4srsfvzPovwEuBP6ovPwW4sGNa95v5t4A384dvTAupPpH7Tlf2CuAxPT5vKzrXsXrcK6g2Qm6c7PrgOuE6Mcp8XR+m//rgNsTY64PbEBtuvr4+/D7b0+vDeENPobYNwO7A0WNMO69r2L5joV/Slf1xn/c7i99/GjUbWLxu/l25F1HtRv021QvjIfX4BcDnurKvBXYf4/7+ruv6Z4Bnj5J7NfBA17h3AnuPMd8Tuq5/FXjGKLl3Ag/2uGw2Ax4+oOdtDvCv9bL9GfAg1aeHn6PrRaclz/EI1dcJbqP6esW1wK31uJ0GtD40Nd+TGf0N+o+A749xfxtRvSB/D/jFGJlPdg0L6/HbAeeOkn8FcBHVC+c9wFXAu4Etu3IXjnZ/Y9RwIHAN1YbQfsCXgOvr5+55XdkD6vXgeqpPLp/asT68tyu7NdVxFlcDd9TDinrcNl3Zw4HHjlHfYV3X3ws8a5Tcs1n/jbTn9cF1wnWie51wfZgR64PbEOk2xADm6+tD9vf6MN5QxDF1ABGxJdULz7rvKN8EfDMz7+rx9rOATTLzNx3j5mXmvU3UUH//+NFUn+T0VOOwRMTDADLzt6NMe2Rm3tQ1rp/lsMGft1HmPzszV48xvVXPcUTMBxir3ukkIiLHeYGJiO2BJ2fm1wZY1pREdTD1nZm5dpRpQfVd/dsHX1kZXCfUyfVhenAbYnL1ug0xPl8fJjH/Epq6iHg51feXv0X1DwLVQaIHAe/IzE915Tf4C0aTNYzzuA/KzG9PNjvs5dCG562px9ZvDWOZ6nPcTzYiHgc8r6veL2fmilFub3bs7NmZefVU5juWiHhlZn5yENl+623x89GG7IxbJ8yOm50u64PbEA09tn5rGIvbEEVmG3t9KOInDagO5t0zM/82M99ZD0dT7dbuPj3qy6kOkt2f6qw4m1J9T3ppPW1S2aZqmMDHJ5ttw3LoJ9tUvdP5Oe4nGxFvAU4HguqMVD+qL58WEceZ7St7+lTmO4F3DCLbb70tfz7akJ1R64TZCbPTYX0Y+vtsP1m3IZrNtvz/rbRsY68PpeypuxbYKzN/1TV+S6rvSj+mY9w1VN9F7f4EZWuqA0p3mWS2qRq+PNbDBg7IzM0mmW3DcmjD8zadn+N+stcCT8jMB7rq3ZjqoOzu581sc9k/+H2lzjjV2dQ2GUC253on8fjM9p8tap0w23i2DetDG95n3YbAbQiz678nj2V2L6EWeBewLCK+RfV7FlCdLegg4N+6ssHvf2Nm8AgAAAzDSURBVMei04P1tMlmm6rhaVS/X9H9ne0A9p5Ctg3LoQ3P23R+jvvJPgg8gurA7E7b19PMDi67EPgT4M6u8QH8YEDZfurtN2+2/2xp64TZZrNtWB/a8D7rNkTFbQizPSmiqcvMU+tPFP6E33/X9HzgrZnZ/eLUyAtGgzX8EPhNZl7Q/bjrT3Immx36cmjD89bUY+uzhqae436yxwLnRsR1XfXuDBxjdqDZr1Kd7Wt513gi4vwBZfupt9+82f6zpa0TZpvNtmF9GPr7rNsQD3EbwmxPivj65Wgi4tDM/OoY07bmD/+p1h182v1P1Ve2qRqa0obl0E+2qXqn83Pcj4jYiOrTt856L87Rz8JktsFsG/RbbxuW23TOtkEbloPZ9mjD+2w/WbchmtWG/wuzE8g+fn+jTQOj/ADgONlDG8q2oYY2ZPtZDqUts9Lq7Sd7lFmzk8m2pQ6zZs0ONNuG99nS3pNLq9dtiAKzD92m3xu0ZaCPH4Rs8AWjDTW0IdvPcihtmZVWr1mzjWfbUodZs2anRdZtiPbUa7bA7LqhlJ80GM3f9JHtPuh0Q2XbUEMbsv0sh9KWWWn1mjU7iGxb6jBr1mz5Wbchmq3B7PTPVvrtAoc1UH3PdK/68q7AG4A/6/W2/dxPm2toafZTDWVLe2xtqLef7CKzZieTbUsdZs2aHWh2yu9FwMbAy4Fn1ddfCnwIeC0wZ7LZpupt6rG1od4NkG3DOmm2YyjiRCkR8XbgT6nO1vlt4KnAeVRnCfpmZr6rK783kJl5cUTsCjwbuDozvzbKvHvKtqGGfrOj3PZTmfnyiXLjZWP93zUJqh/M/C5VYc+dTLapevvJllbvVLIRsR/VhxRXZOa3zM6sbEQ8FViRmXdHxMOA44CnAFcB7871f2ep57zZYrOvA87KzHVnXhuT2RmR3Rh4MfCLzPxORLwU2AdYASzJjt/T6jP7WartqE2Bu4B5wJnAgUBk5pGTzDZVb1OPrQ319pyt848GXgA8ClgLXAt8LjPvpovZZrNjKaWpuxzYA9gEuJmqe133JnVRZj6pI9tz89Vntg019JNtpPmKiGVUGwQnU/3GSgCnUb0wkB2nxu0z21S9TT22NtTbT/ZHmbl3ffmvqT45PAs4GPhKZh5vdkZlrwR2z8w1EbEE+A3wRaqNj90z8wV06Cdvttjsr4BfAz+het37QmbexijMzohsU83XZZn5pIiYTXV2v0dk5tqICODSrm2pfrJN1dvUY2tDvf1kXwccClwI/Bnw4/o2zwdek5nnmx1MdlzZ5669YQx0HGhK10GnwPKu65cDs6hW0ruBLerxDwMum0K2DTX0k10GfAbYH3hG/feX9eVnTCG7EfD3VE3lHvW4G8Z43vrJNlVvU4+tDfX2k+1cfy8GFtSXNwMuNzvjsis616OuaX/wetZv3myx2R9TvQYeDHwcuA34BnAksLnZGZe9rP47G7gFmFVfD9bf3ugnewXV1xS3Bu4BtqnHz6VjfZ1Etql6m3psbai3n+zlHdM3Bc6vL+/A+tvEZhvMjjeUcqKU30XEpvXlPdeNjIgtWf+X1tdk5trM/A3wk6x3W2bmb6eYbUMN/WQXA0uBtwG/yqrL/21mXpDr/9Bkz9nMfDAzTwReCbwtIj7EGD9i30+2qXqbemxtqLfP7EYRsXVEzKf6BO62+jH/GlhjdsZlr4iIV9aXL42IxQARsQvwAOvrJ2+2zGzWr4HfysxXAY8APkL1Ff8bzM647EZRfT1vc6qNzC3r8ZsAc6aQ/ThwNbCc6r3rCxHxMaoPok6fQrapept6bG2ot58s/H57aBOqvXpk5s/MDiU7uuyx+xvmAGwyxvhtgd26xl0EbFpf3qhj/Jas/0llP9k21NBztmPaIuALVAfr/myC5dxztuM2h1Adm7FBsk3V29Rja0O9vWSBlVRv2j+t/25fj5/H+p/Ym53+2S2BU6i+hnUR1Qb+DcAFVF/L615/es6bLTY75qfB1O87ZmdU9u/rdeVG4HXAucDHqPYovH2y2Tr/CKqvJgJsBRzO2Ccf6SnbVL1NPbY21Ntn9vXAZfX0q4FX1uMXABeaHVx2vKGIY+rGExHzMvPejuubZOb9o+S2pdrIuXwy2TbUMJV6I+IQYN/M/MceHk/P2a7b/cFymEq2qXqbemxtqHcyj63e+7wwM39qduZlI2ILYCeqTwhXZeYtE8yr57zZsrIRsUtmXjvWPMzOrGydfwRAZv4iIrYCnkX1weGPppId5/6mtA3RVL1NPbY21Ntn9gnA46lOvnX1BI/XbIPZMecxDZq6n2XmDj1mN1jT0cIa2pDtZzmUtsxKq9es2cazbanDrFmz0yLrNkSzNZid5tmxjhdqlYh4w1iTqL932qOrqA467DvbhhrakO1nOZS2zEqr16zZFmTbUodZs2YLyLoN0WwNZmd2toimDng38O+sf7A/8Icne2nwBWPoNbQhSx/LoZ9saY+tDfWaNTuIbFvqMGvWbPlZ3IZoTb1my8yOp5Smbhnw35m5tHtCRLy6a1QjLxgtqaEN2X6WQ2nLrLR6zZodRLYtdZg1a7b8rNsQ7anXbJnZsWWPZ1QZ5gA8lvo3l0aZtrDr+g+APcfI/nwK2TbU0IZsP8uhtGVWWr1mzTaebUsdZs2anRZZtyHaU6/ZArPjDT2FShqaesFoQw1tyJb2vPkcmzU79f+LNtRh1qzZ8rNNDaU9tjbUa7bM7HhDEWe/jOoHvt8KHAY8HEjgVuBs4PjMvGsm1NAG/SyH0pZZafVKklQStyGkBvXa/Q1zAL4JvAXYrmPcdvW4b3VltwSOp/rxvjuA1cCKetxWU8i2oYY2ZPtZDqUts9LqNWu28Wxb6jBr1uy0yLoN0Z56zRaYHW/o/eC74RrJzBMy8+Z1IzLz5sw8AdixK/t54E5g/8zcJjPnA8+sx31+Ctk21NCGbD/LobRlVlq9Zs0OItuWOsyaNVt+1m2I9tRrtszs2LLH7m+YA/At4M10fK8UWEj16cd3urLXjDOfa6aQbUMNbcj2sxxKW2al1WvWbOPZttRh1qzZaZF1G6I99ZotMDveUMqeuhcB84ELIuLOiLgDOB/YBjiiK3tjRLw5IhauGxERCyPiLcDPp5BtQw1tyPazHEpbZqXVa9bsILJtqcOsWbPlZ92GaE+9ZsvMjq3X7m/YA/A44FnAvK7xz+66vjVwAtX3Uu+k+m7qinrcNpPNtqGGNmT7WQ6lLbPS6jVrdoD/F0Ovw6xZs+Vn67zbEC2o12yZ2fGGnkLDHoDXAdcA/w2sBJ7XMW3ZgF4whl5DG7L9LIfSlllp9Zo1O6hsW+owa9Zs2VnchmhNvWbLzY419BQa9gBcvu5BAiPAJcDr6+s/7so28oLRkhrakO1nOZS2zEqr16zZxrNtqcOsWbPTIus2RHvqNVtgdryhp9CwB+DKruvzgG8A7weWT+Gfqp9sG2poQ7af5VDaMiutXrNmG8+2pQ6zZs1Oi6zbEO2p12yB2fGG2ZThlojYIzOXA2TmvRFxKPAJYLeu7EaZeW+dWxkR+wNfjIgdgZhCtg01tCHbz3IobZmVVq9Zs4PItqUOs2bNlp91G6I99ZotMzu27LH7G+YALKLjxxy7pu3bdf27wB5d42YDnwLWTiHbhhrakO1nOZS2zEqr16zZxrNtqcOsWbPTIus2RHvqNVtgdryhp1BJQ1MvGG2ooQ3Z0p43n2OzZqf+f9GGOsyaNVt+tqmhtMfWhnrNlpkdb4j6BpIkSZKkApXy4+OSJEmSpFHY1EmSJElSwWzqJEkzUkSsjYjlEXFlRFwaEf8QEeO+L0bESES8dFA1SpLUC5s6SdJM9dvM3CMznwAcBPwp8PYJbjMC2NRJklrFE6VIkmakiLg3M+d1XH80cDGwLbAj8Glgs3ryMZn5g4j4IfB44KfAqcAHgOOB/YFNgA9n5n8N7EFIkoRNnSRphupu6upxdwGPBe4BHszM+yLiMcBpmbm4/lHYN2bmoXX+KODhmfnOiNgE+B/ghZn504E+GEnSjDZ72AVIktRCc4APRcQewFpglzFyBwNPiojD6+tbAo+h2pMnSdJA2NRJksRDX79cC9xKdWzdLcDuVMef3zfWzYC/y8xvDqRISZJG4YlSJEkzXkQsAD4KfCir4xK2BH6ZmQ8CLwNm1dF7gM07bvpN4G8jYk49n10iYjMkSRog99RJkmaqh0XEcqqvWq6hOjHK++tpHwG+FBEvB74B/LoefxmwNiIuBU4B/pPqjJjLIiKA24DDBvUAJEkCT5QiSZIkSUXz65eSJEmSVDCbOkmSJEkqmE2dJEmSJBXMpk6SJEmSCmZTJ0mSJEkFs6mTJEmSpILZ1EmSJElSwf4/+66gpbHEd3oAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cool_hoods = ['Central East Oakland', 'Oakland Hills', 'Lower Hills', 'Bushrod', 'Grand Lake']\n",
    "\n",
    "for hood in cool_hoods:\n",
    "    Oakland_reviews.filter(f.col('neighbourhood') == hood)\\\n",
    "        .withColumn('date_mth', f.col('date').substr(0, 7))\\\n",
    "        .groupBy('date_mth').count().orderBy(f.col('date_mth'))\\\n",
    "        .withColumnRenamed('count','Count').toPandas()\\\n",
    "        .plot.bar('date_mth','Count', figsize = (15,5), title = hood).set(ylabel='Count', xlabel='Date')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute and visualize the popularity of your city by season. For example, visualize the popularity of your city per month."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "To make this more clear, we chose to only look at the year 2018."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0, 0.5, 'Count'), Text(0.5, 0, '(Year-Month)')]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "seasons = Oakland_reviews.select('date')\\\n",
    "        .filter(f.split(f.col('date'),'-')[0] == '2018')\\\n",
    "        .withColumn('date_mth', f.col('date').substr(0, 7))\\\n",
    "        .groupBy('date_mth').count().orderBy(f.col('date_mth'))\\\n",
    "        .select('Date_mth','Count').toPandas()\n",
    "\n",
    "seasons.plot.bar('Date_mth','Count',figsize=(15,5)).set(ylabel = 'Count', xlabel = '(Year-Month)')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see a trend that Oakland is most popular during the mid-late summer months (July, August, September, and October)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reviews\n",
    "In this part you should determine which words used in reviews that are the most positive. \n",
    "\n",
    "The individual reviews do not have a rating of the listing, so we will assume that each review gave the average rating to the listing, i.e., the one on the listing.\n",
    "\n",
    "You should assign a positivity weight to each word seen in reviews and list the words with the highest weight. It is up to you to decide what the weight should be. For example, it can be a function of the rating on the listing on which it occurs, the number of reviews it occurs in, and the number of unique listings for which it was used to review.\n",
    "\n",
    "Depending on your choice of weight function, you may also want to do some filtering of words. For example, remove words that only occur in a few reviews."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to answer this question, we broadcasted the Oakland rating scores into the reviews dataset using an inner join. Thus excluding reviews not related to Oakland. The resulting dataset was persisted to make the following computations run faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----------+--------+----------+-----------+-------------+--------------------+------+\n",
      "|listing_id|      id|      date|reviewer_id|reviewer_name|            comments|Rating|\n",
      "+----------+--------+----------+-----------+-------------+--------------------+------+\n",
      "|      3083|16797662|2014-08-02|   18272366| Carlos Kenji|B- love guest hou...|  91.0|\n",
      "|      3083|19980893|2014-09-21|    4400249|        Jason|The description w...|  91.0|\n",
      "|      3083|21720882|2014-10-22|    4268642|       Carmen|B-Love makes me f...|  91.0|\n",
      "|      3083|27107155|2015-02-25|   23674350|      Matthew|Simple but effect...|  91.0|\n",
      "|      3083|33318077|2015-05-26|    1252519|        Pavel|I enjoyed staying...|  91.0|\n",
      "+----------+--------+----------+-----------+-------------+--------------------+------+\n",
      "only showing top 5 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "Oakland_rating = Oakland.filter(f.col('review_scores_rating').isNotNull())\\\n",
    "        .withColumn('Rating', f.col('review_scores_rating').cast('float'))\\\n",
    "        .drop('review_scores_rating').select('id','Rating').withColumnRenamed('id','id_')\n",
    "\n",
    "Oakland_reviews = df_reviews.join(f.broadcast(Oakland_rating),\\\n",
    "        (f.col('listing_id') == f.col('id_')), 'inner').drop('id_').persist()\n",
    "Oakland_reviews.show(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We write a few helper functions and register them with spark UDF:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper functions for Spark operations\n",
    "\n",
    "def remove_punct(text):\n",
    "    # This function removes non-word characters from the comments.\n",
    "    return text.lower().translate(str.maketrans('', '', '0123456789\\n\\t\\r'+string.punctuation))\n",
    "    \n",
    "\n",
    "\n",
    "def update_word_dict(rating, wordlists):\n",
    "    # This function the words are counted and their ratings are summed.\n",
    "    word_dict = dict()\n",
    "    for wordlist in wordlists:\n",
    "        for word in wordlist:\n",
    "            if word == '': continue\n",
    "            if word not in word_dict:\n",
    "                word_dict[word] = [int(rating), 1]\n",
    "            else:\n",
    "                word_dict[word][0] += int(rating)   # Update sum of rating\n",
    "                word_dict[word][1] += 1             # Update count\n",
    "    return word_dict\n",
    "\n",
    "spark.udf.register(\"wordScorer\", update_word_dict)\n",
    "wordScorer = f.udf(update_word_dict, StringType())\n",
    "spark.udf.register(\"removePunct\", remove_punct)\n",
    "removePunct = f.udf(remove_punct, StringType())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This next step we were not able to solve using only Spark. Instead we created a dictionary for every review and combined them based on their rating score. Thus we would maximally have 100 dictionaries of words. This was expected to be possible to handle in memory, even if a much larger dataset was used.\n",
    "This was then converted to a pandas dataframe, allowing us to iterate through the rows and combine the created word dictionaries.\n",
    "The Spark execution works by creating a list of words based on the comments. These were grouped by rating and the word scores (the function 'update_word_dict') was used to generate a dictionary from each list of words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "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>Rating</th>\n",
       "      <th>longdict</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>82.0</td>\n",
       "      <td>{cancel=[82, 1], nicely=[82, 1], half=[164, 2]...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>90.0</td>\n",
       "      <td>{cancel=[450, 5], nicely=[1890, 21], half=[144...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>86.0</td>\n",
       "      <td>{nicely=[258, 3], prepare=[86, 1], half=[172, ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>91.0</td>\n",
       "      <td>{busses=[364, 4], cancel=[182, 2], nicely=[336...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>99.0</td>\n",
       "      <td>{cca=[99, 1], busses=[594, 6], cancel=[495, 5]...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>89.0</td>\n",
       "      <td>{cca=[89, 1], busses=[89, 1], cancel=[89, 1], ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>100.0</td>\n",
       "      <td>{cancel=[300, 3], busses=[200, 2], nicely=[880...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>97.0</td>\n",
       "      <td>{cancel=[291, 3], busses=[485, 5], cca=[97, 1]...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>67.0</td>\n",
       "      <td>{parking=[201, 3], very=[335, 5], gotten=[67, ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>70.0</td>\n",
       "      <td>{studio=[70, 1], rientrare=[70, 1], nicely=[70...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>10</td>\n",
       "      <td>72.0</td>\n",
       "      <td>{shouldn’t=[72, 1], been=[72, 1], moderna=[72,...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>11</td>\n",
       "      <td>85.0</td>\n",
       "      <td>{cancel=[170, 2], nicely=[255, 3], prepare=[85...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>12</td>\n",
       "      <td>87.0</td>\n",
       "      <td>{cancel=[783, 9], cca=[174, 2], busses=[87, 1]...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>13</td>\n",
       "      <td>40.0</td>\n",
       "      <td>{reason=[40, 1], bad=[40, 1], staying=[40, 1],...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>14</td>\n",
       "      <td>94.0</td>\n",
       "      <td>{cancel=[376, 4], busses=[94, 1], nicely=[6204...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>15</td>\n",
       "      <td>77.0</td>\n",
       "      <td>{temporary=[77, 1], hands=[77, 1], allowed=[77...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>16</td>\n",
       "      <td>20.0</td>\n",
       "      <td>{voice=[20, 1], parking=[20, 1], but=[20, 1], ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>17</td>\n",
       "      <td>96.0</td>\n",
       "      <td>{busses=[288, 3], cca=[96, 1], cancel=[864, 9]...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>18</td>\n",
       "      <td>83.0</td>\n",
       "      <td>{nicely=[166, 2], half=[332, 4], chips=[83, 1]...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>19</td>\n",
       "      <td>78.0</td>\n",
       "      <td>{certaine=[78, 1], temporary=[78, 1], prepare=...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>20</td>\n",
       "      <td>80.0</td>\n",
       "      <td>{allison=[80, 1], nicely=[240, 3], numerous=[8...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>21</td>\n",
       "      <td>88.0</td>\n",
       "      <td>{cancel=[88, 1], encased=[88, 1], nicely=[1056...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>22</td>\n",
       "      <td>69.0</td>\n",
       "      <td>{mostly=[138, 2], inform=[69, 1], half=[207, 3...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>23</td>\n",
       "      <td>93.0</td>\n",
       "      <td>{cancel=[465, 5], busses=[93, 1], nicely=[3627...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>24</td>\n",
       "      <td>95.0</td>\n",
       "      <td>{busses=[285, 3], cancel=[855, 9], nicely=[997...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>25</td>\n",
       "      <td>81.0</td>\n",
       "      <td>{cancel=[162, 2], cassandras=[81, 1], nicely=[...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>26</td>\n",
       "      <td>98.0</td>\n",
       "      <td>{busses=[784, 8], unavailable=[392, 4], descri...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>27</td>\n",
       "      <td>84.0</td>\n",
       "      <td>{cancel=[84, 1], lightfilled=[84, 1], nicely=[...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>28</td>\n",
       "      <td>79.0</td>\n",
       "      <td>{nicely=[79, 1], half=[632, 8], allowed=[79, 1...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>29</td>\n",
       "      <td>92.0</td>\n",
       "      <td>{busses=[92, 1], cancel=[368, 4], nicely=[2576...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>30</td>\n",
       "      <td>73.0</td>\n",
       "      <td>{tub=[73, 1], been=[73, 1], about=[73, 1], cou...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>31</td>\n",
       "      <td>63.0</td>\n",
       "      <td>{parking=[63, 1], slightly=[63, 1], very=[252,...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>32</td>\n",
       "      <td>60.0</td>\n",
       "      <td>{year=[60, 1], allowed=[120, 2], staying=[180,...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>33</td>\n",
       "      <td>75.0</td>\n",
       "      <td>{been=[150, 2], half=[75, 1], bad=[75, 1], chi...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>34</td>\n",
       "      <td>74.0</td>\n",
       "      <td>{cancel=[222, 3], desperate=[74, 1], allowed=[...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    Rating                                           longdict\n",
       "0     82.0  {cancel=[82, 1], nicely=[82, 1], half=[164, 2]...\n",
       "1     90.0  {cancel=[450, 5], nicely=[1890, 21], half=[144...\n",
       "2     86.0  {nicely=[258, 3], prepare=[86, 1], half=[172, ...\n",
       "3     91.0  {busses=[364, 4], cancel=[182, 2], nicely=[336...\n",
       "4     99.0  {cca=[99, 1], busses=[594, 6], cancel=[495, 5]...\n",
       "5     89.0  {cca=[89, 1], busses=[89, 1], cancel=[89, 1], ...\n",
       "6    100.0  {cancel=[300, 3], busses=[200, 2], nicely=[880...\n",
       "7     97.0  {cancel=[291, 3], busses=[485, 5], cca=[97, 1]...\n",
       "8     67.0  {parking=[201, 3], very=[335, 5], gotten=[67, ...\n",
       "9     70.0  {studio=[70, 1], rientrare=[70, 1], nicely=[70...\n",
       "10    72.0  {shouldn’t=[72, 1], been=[72, 1], moderna=[72,...\n",
       "11    85.0  {cancel=[170, 2], nicely=[255, 3], prepare=[85...\n",
       "12    87.0  {cancel=[783, 9], cca=[174, 2], busses=[87, 1]...\n",
       "13    40.0  {reason=[40, 1], bad=[40, 1], staying=[40, 1],...\n",
       "14    94.0  {cancel=[376, 4], busses=[94, 1], nicely=[6204...\n",
       "15    77.0  {temporary=[77, 1], hands=[77, 1], allowed=[77...\n",
       "16    20.0  {voice=[20, 1], parking=[20, 1], but=[20, 1], ...\n",
       "17    96.0  {busses=[288, 3], cca=[96, 1], cancel=[864, 9]...\n",
       "18    83.0  {nicely=[166, 2], half=[332, 4], chips=[83, 1]...\n",
       "19    78.0  {certaine=[78, 1], temporary=[78, 1], prepare=...\n",
       "20    80.0  {allison=[80, 1], nicely=[240, 3], numerous=[8...\n",
       "21    88.0  {cancel=[88, 1], encased=[88, 1], nicely=[1056...\n",
       "22    69.0  {mostly=[138, 2], inform=[69, 1], half=[207, 3...\n",
       "23    93.0  {cancel=[465, 5], busses=[93, 1], nicely=[3627...\n",
       "24    95.0  {busses=[285, 3], cancel=[855, 9], nicely=[997...\n",
       "25    81.0  {cancel=[162, 2], cassandras=[81, 1], nicely=[...\n",
       "26    98.0  {busses=[784, 8], unavailable=[392, 4], descri...\n",
       "27    84.0  {cancel=[84, 1], lightfilled=[84, 1], nicely=[...\n",
       "28    79.0  {nicely=[79, 1], half=[632, 8], allowed=[79, 1...\n",
       "29    92.0  {busses=[92, 1], cancel=[368, 4], nicely=[2576...\n",
       "30    73.0  {tub=[73, 1], been=[73, 1], about=[73, 1], cou...\n",
       "31    63.0  {parking=[63, 1], slightly=[63, 1], very=[252,...\n",
       "32    60.0  {year=[60, 1], allowed=[120, 2], staying=[180,...\n",
       "33    75.0  {been=[150, 2], half=[75, 1], bad=[75, 1], chi...\n",
       "34    74.0  {cancel=[222, 3], desperate=[74, 1], allowed=[..."
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summed_df = Oakland_reviews.select('comments','Rating').filter(f.col('comments').isNotNull()).withColumn('Word_list',\\\n",
    "        f.split(removePunct(f.col('comments')),' ')).drop('comments')\\\n",
    "        .groupBy('Rating').agg(f.collect_list('Word_list').alias('longlist'))\\\n",
    "        .withColumn('longdict', wordScorer(f.col('Rating'), f.col('longlist'))).drop('longlist').toPandas()\n",
    "\n",
    "summed_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_dict(d):\n",
    "    # This function is used to combine the developed dictionaries.\n",
    "    for key in d.keys():\n",
    "        if key not in full_dict:\n",
    "            full_dict[key] = [int(val) for val in d[key]]\n",
    "        else:\n",
    "            full_dict[key] = [int(full_dict[key][0])+int(d[key][0]), int(full_dict[key][1])+int(d[key][1])]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The column 'longdict' was iterated though and the string representation of the dictionaries were converted to an actually functioning dictionary in python and then inputted in the function 'update_dict' which updates 'full_dict'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "full_dict = dict()\n",
    "\n",
    "for d in summed_df['longdict']:\n",
    "    # Remove {} and split dictionary elements.\n",
    "    d = d[1:-1].replace('], ', ']!!!')\n",
    "    d = d.split('!!!')\n",
    "    new_d = dict()\n",
    "    for element in d:\n",
    "        # Split each element into key and value pairs and add to temporary dictionary.\n",
    "        element = element.split('=')\n",
    "        element[1] = element[1][1:-1].split(', ')\n",
    "        new_d[element[0]] = list(element[1])\n",
    "    # Update the full_dict\n",
    "    update_dict(new_d)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that a dictionary containing the summed ratings and counts for each word, we can convert the dictionary back into a sparks dataframe.\n",
    "For us the easiest way was to first convert to a pandas dataframe, which may not be incredibly efficient, but the syntax was way simpler."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = spark.createDataFrame(pd.DataFrame.from_dict(full_dict, orient='index').reset_index())\\\n",
    "     .withColumnRenamed('index', 'word').withColumnRenamed('0','sum').withColumnRenamed('1','count')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----------+-------+-----+\n",
      "|       word|    sum|count|\n",
      "+-----------+-------+-----+\n",
      "|     cancel|   6718|   73|\n",
      "|     nicely| 117205| 1216|\n",
      "|       half|  53715|  564|\n",
      "|unavailable|   1097|   12|\n",
      "|   spacious| 628813| 6544|\n",
      "|   shooting|   1406|   15|\n",
      "| undergoing|   2051|   22|\n",
      "|       hall|  20707|  216|\n",
      "|     owners|  40817|  426|\n",
      "|       your| 606366| 6333|\n",
      "|   bearable|    825|    9|\n",
      "|    without| 138407| 1446|\n",
      "|        tea| 115267| 1193|\n",
      "|      would|2292306|23866|\n",
      "| culturally|    558|    6|\n",
      "|       legs|   2464|   26|\n",
      "| essentials|  32282|  337|\n",
      "|        ten|  17499|  182|\n",
      "|       pics|  10699|  112|\n",
      "|      solid|  15875|  167|\n",
      "+-----------+-------+-----+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The final step is to compute a positivity score based on the rating sum and counts.\n",
    "We saw that only removing words with counts less than 100 still show mainly host names. A funny observation is that reviews containing the name Heidi have exclusively given ratings of 100 out of 125 reviews:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------+-----+-----+-----------------+\n",
      "|    word|  sum|count|       positivity|\n",
      "+--------+-----+-----+-----------------+\n",
      "|   heidi|12500|  125|            100.0|\n",
      "|  deanna|11196|  112|99.96428571428571|\n",
      "|   jesus|27416|  275|99.69454545454545|\n",
      "|  dorian|19481|  196|99.39285714285714|\n",
      "|   marie|38930|  392|99.31122448979592|\n",
      "|   shawn|11021|  111|99.28828828828829|\n",
      "| colette|13489|  136|99.18382352941177|\n",
      "|  gyorgy|13761|  139|             99.0|\n",
      "|     kay|15444|  156|             99.0|\n",
      "|   ralph|18414|  186|             99.0|\n",
      "| colleen|27913|  282|98.98226950354609|\n",
      "|  jordie|21182|  214|98.98130841121495|\n",
      "|  joelle|20187|  204|98.95588235294117|\n",
      "|danielle|11864|  120|98.86666666666666|\n",
      "|   diane|13737|  139| 98.8273381294964|\n",
      "|    beth|10276|  104| 98.8076923076923|\n",
      "|  dennis|29832|  302|98.78145695364239|\n",
      "|   allen|10547|  107|98.57009345794393|\n",
      "|    marc|11915|  121|98.47107438016529|\n",
      "|   johns|16149|  164|98.46951219512195|\n",
      "+--------+-----+-----+-----------------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.filter(f.col('count') > 100).withColumn('positivity', f.col('sum')/f.col('count')).orderBy(f.desc('positivity')).show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To remove this type of rare words with high scores, we removed all words occuring less times than 4000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------+-------+-----+-----------------+\n",
      "|     word|    sum|count|       positivity|\n",
      "+---------+-------+-----+-----------------+\n",
      "|  cottage| 413235| 4248|97.27754237288136|\n",
      "|    hosts| 905175| 9338|96.93456843007068|\n",
      "|beautiful|1255108|12949|96.92702139161325|\n",
      "|    their| 627829| 6483|96.84235693351843|\n",
      "|   highly| 834860| 8622|96.82904198561819|\n",
      "|wonderful|1013394|10467|96.81799942676984|\n",
      "|  amazing| 787272| 8140|96.71646191646191|\n",
      "|   lovely|1005531|10397|96.71357122246802|\n",
      "|    loved| 761676| 7876| 96.7084814626714|\n",
      "|welcoming| 553084| 5729|96.54110665037528|\n",
      "|    visit| 431417| 4469|96.53546654732602|\n",
      "|     home|2004513|20768|96.51930855161787|\n",
      "|     best| 450273| 4668|96.45951156812339|\n",
      "|  perfect|1308138|13562|96.45612741483556|\n",
      "|  private| 583790| 6054|96.43045920052857|\n",
      "|amenities| 436241| 4524|96.42816091954023|\n",
      "|   studio| 411954| 4273|96.40861221624152|\n",
      "|      bay| 792427| 8220|96.40231143552312|\n",
      "|   coffee| 573447| 5949|96.39384770549673|\n",
      "|    thank| 498803| 5175|96.38705314009661|\n",
      "+---------+-------+-----+-----------------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.filter(f.col('count') > 4000).withColumn('positivity',f.col('sum')/f.col('count')).orderBy(f.desc('positivity')).show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We found that the 20 words with the highest positivity score were all quite suitable words for a happy reviewer. We therefore conclude that the positivity score function works satisfactorily.\n",
    "\n",
    "Out of curiosity, we also looked at the 20 words with the lowest positivity score.\n",
    "These words did include some words one could see as slightly positive (e.g. 'good'), but we expect this might be that good somettimes is used to describe mediocre things. Also, many 'neutral' words (e.g. 'be','get','that') are listed, but such words are not trivial to remove without defining a set list of words not to include.\n",
    "A final note is that the positivity score in this case only ranges from 94-97, which is not a particularly large span. But we found that it was not extremely necessary, as we did achieve quite sensible results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------+-------+-----+-----------------+\n",
      "|    word|    sum|count|       positivity|\n",
      "+--------+-------+-----+-----------------+\n",
      "|      no| 570698| 6052| 94.2990746860542|\n",
      "|     not|1328487|14058| 94.5004268032437|\n",
      "|   other| 423669| 4476|94.65348525469169|\n",
      "|  people| 465092| 4913|94.66558111133727|\n",
      "|    good|1230955|12981|94.82744010476851|\n",
      "|     but|2071489|21828| 94.9005405900678|\n",
      "|   night| 630026| 6637|94.92632213349405|\n",
      "|    room|1600798|16820|95.17229488703924|\n",
      "|    only| 639343| 6706|95.33895019385625|\n",
      "|    that|2058699|21593|95.34103644699671|\n",
      "|   there|1978844|20752|95.35678488820355|\n",
      "|   check| 512847| 5376|95.39564732142857|\n",
      "|bathroom| 622477| 6525|95.39877394636015|\n",
      "|      be|1353847|14190|95.40852713178295|\n",
      "|     get| 880376| 9227|95.41302698601929|\n",
      "| parking| 750127| 7861|95.42386464826357|\n",
      "|  street| 561846| 5887| 95.4384236453202|\n",
      "|     one| 786397| 8231|95.54088203134492|\n",
      "|      on|1910242|19991| 95.5550997949077|\n",
      "|   which| 902898| 9448|95.56498729889924|\n",
      "+--------+-------+-----+-----------------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.filter(f.col('count') > 4000).withColumn('positivity',f.col('sum')/f.col('count')).orderBy('positivity').show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}