Project-3-Final_version.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": "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",
    "import numpy as np\n",
    "from scipy import stats\n",
    "import pandas as pd\n",
    "import re\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "plt.style.use(['seaborn-whitegrid'])\n",
    "\n",
    "spark = SparkSession.builder.appName(\"SparkIntro\").getOrCreate()"
   ]
  },
  {
   "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": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/home/jovyan/work/Computational_Tools'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load listings\n",
    "df = spark.read.option('header', True).option('inferSchema', True).option('multiline', True).option('escape','\"').csv('listings.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load reviews\n",
    "df_review = spark.read.option('header', True).option('inferSchema', True).option('multiline', True).option('escape','\"').csv('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": 5,
   "metadata": {
    "scrolled": true
   },
   "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"
     ]
    }
   ],
   "source": [
    "# Print schema of listings\n",
    "df.printSchema()"
   ]
  },
  {
   "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": [
    "#### Description of data cleaning\n",
    "*In this section only columns of the data that is used in the analysis is kept. Furthermore, rows containing NA values in any of the selected columns are dropped. The new reduced dataframes are saved as csv in order to stage the data. They are forced to be partitioned into 16 parts, yielding 16 CSV files. We need to repartion because it is not automatically partitioned due to the multiline nature of the raw data. They are then loaded again, so that further processing is faster.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Drop rows with NA values in columns city, neighbourhood, property_type, price\n",
    "df = df.select('id','country','city', 'neighbourhood', 'property_type', 'price','review_scores_rating')\n",
    "df = df.dropna(how='any')\n",
    "# Write file\n",
    "df.repartition(16).write.csv('data/clean_data',header=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load reduced CSV files\n",
    "df = spark.read.option(\"header\", \"true\").csv(\"data/clean_data/*.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      " |-- listing_id: string (nullable = true)\n",
      " |-- review_id: string (nullable = true)\n",
      " |-- date: string (nullable = true)\n",
      " |-- comments: string (nullable = true)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df_review.printSchema()"
   ]
  },
  {
   "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.\n",
    "\n",
    "\n",
    "#### Description of implementation of the basics\n",
    "*We are computing the desired dataframe in Spark using a group by 'city' clause and then a count of listings and an approximate count of distinct neighbourhoods. The distinct count is done internally by using a HyperLogLog sketch, which is faster for large amount of data. The data frame is then ordered by the distinct number of neighbourhoods, so that we below show the cities with the highest number of neighbourhoods.*\n",
    "\n",
    "*Afterwards the data frame is filtered using a user defined function, so that only listings with either Copenhagen or København in the city column is still in the data. The data is grouped by property type and neighbourhood to get an overview of the city.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------+--------+--------------+\n",
      "|          city|Listings|Neighbourhoods|\n",
      "+--------------+--------+--------------+\n",
      "|Greater London|   33230|           151|\n",
      "|        London|   25734|           150|\n",
      "|       Toronto|   17876|           146|\n",
      "|    Washington|    7227|           105|\n",
      "|     San Diego|   10331|           104|\n",
      "|   Los Angeles|   22328|            99|\n",
      "|        Berlin|   19719|            93|\n",
      "|   Minneapolis|    2082|            89|\n",
      "|      Portland|    4098|            88|\n",
      "|      New York|   16163|            87|\n",
      "|       Chicago|    7642|            82|\n",
      "|        Denver|    4074|            81|\n",
      "|        Austin|    8042|            79|\n",
      "|       Seattle|    7667|            79|\n",
      "|Rio de Janeiro|    9566|            75|\n",
      "|       Oakland|    2619|            71|\n",
      "|        Sydney|     841|            71|\n",
      "|     Barcelona|   15530|            70|\n",
      "|        Madrid|   15782|            67|\n",
      "|         Paris|   48164|            65|\n",
      "+--------------+--------+--------------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Count number of listings and distinct neighbourhoods per city, using hyperloglog.\n",
    "df.groupby('city').agg(f.count('id').alias('Listings'), f.approxCountDistinct('neighbourhood').alias('Neighbourhoods')).orderBy(f.desc('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": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# User defined function to extract all listings contaning Copenhagen or København in city column\n",
    "def extract_cph(city):\n",
    "    regex_pattern = r'(.*København.*|.*Copenhagen.*)'\n",
    "    if re.match(regex_pattern, city, re.IGNORECASE):\n",
    "        return True\n",
    "    return False\n",
    "\n",
    "extract_cph_udf = f.udf(extract_cph, BooleanType())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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>property_type</th>\n",
       "      <th>neighbourhood</th>\n",
       "      <th>count(id)</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>176</th>\n",
       "      <td>Apartment</td>\n",
       "      <td>Amager</td>\n",
       "      <td>1409</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>177</th>\n",
       "      <td>Apartment</td>\n",
       "      <td>Østerbro</td>\n",
       "      <td>2086</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>178</th>\n",
       "      <td>Apartment</td>\n",
       "      <td>Indre By</td>\n",
       "      <td>2456</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>179</th>\n",
       "      <td>Apartment</td>\n",
       "      <td>Vesterbro</td>\n",
       "      <td>3162</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>180</th>\n",
       "      <td>Apartment</td>\n",
       "      <td>Nørrebro</td>\n",
       "      <td>4163</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    property_type neighbourhood  count(id)\n",
       "176     Apartment        Amager       1409\n",
       "177     Apartment      Østerbro       2086\n",
       "178     Apartment      Indre By       2456\n",
       "179     Apartment     Vesterbro       3162\n",
       "180     Apartment      Nørrebro       4163"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Filter data frame to only contain Copenhagen and group by property type\n",
    "prop_neigh_city = df.filter(extract_cph_udf(df.city)).groupby('property_type','neighbourhood').agg(f.count('id')).orderBy('count(id)').toPandas()\n",
    "prop_neigh_city.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the property type count per neighbourhood\n",
    "prop_neigh_city = prop_neigh_city[prop_neigh_city['count(id)']>10]\n",
    "prop_neigh_city.pivot(index='neighbourhood',columns='property_type',\\\n",
    "                      values='count(id)').plot(kind='bar',figsize=(16,6),stacked=True)\n",
    "plt.title('Property type by neighbourhood')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prices\n",
    "Compute the minimum, maximum and average listing price in your city. \n",
    "\n",
    "\n",
    "#### Description of Implementation of Prices-section\n",
    "*We see that 20,526 listings appears in Copenhagen. The price is cast to double, so that it is ready to use for some statistics. The minimum, maximum and average price of the Copenhagen is computed. It should be noted that we have data with a price of 0, that could indicate a need for removing price outliers. The distribution of the prices is also visualized and here it is clear that both the extremely low and high prices are outliers and only occurs very rarely.*\n",
    "\n",
    "*At the end of the section we compute a new attribute called value, that says something about the value for money, based on the average rating score and price per night. In order to show the top three value for money listings in each Copenhagen neighbourhood, we implemented a window function that orders by value and is used for filtering.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20526"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Listings in Copenhagen\n",
    "df_cph = df.filter(extract_cph_udf(df.city))\n",
    "df_cph.count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cast price into double and remove $\n",
    "df_cph = df_cph.withColumn(\"price\",f.expr(\"substring(price, 2, length(price))\"))\n",
    "df_cph = df_cph.withColumn(\"price\", f.regexp_replace(f.col(\"price\"), \",\", \"\"))\n",
    "df_cph = df_cph.withColumn(\"price\",df_cph[\"price\"].cast(DoubleType()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Basic statistics for Copenhagen\n",
      "+-----------------+---------+---------+\n",
      "|    Average price|Max price|Min price|\n",
      "+-----------------+---------+---------+\n",
      "|815.9543505797525|  59999.0|      0.0|\n",
      "+-----------------+---------+---------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Min, max and average price data frame\n",
    "print(\"Basic statistics for Copenhagen\")\n",
    "df_cph.select(f.avg('price').alias(\"Average price\"), f.max('price').alias(\"Max price\"), f.min('price').alias(\"Min price\")).show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute and visualize the distribution of listing prices in your city."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set_palette(\"cubehelix\", 4)\n",
    "plt.style.use(['seaborn-whitegrid'])\n",
    "sns.set(rc={'figure.figsize':(16,6)})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_city_p = df_cph.toPandas()\n",
    "plt.hist(df_city_p.price,bins=1500)\n",
    "plt.title('Distribution of prices in Copenhagen')\n",
    "plt.xlabel('Price')\n",
    "plt.xlim(0,10000)\n",
    "plt.ylabel('Count');"
   ]
  },
  {
   "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": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create new value column\n",
    "df_value = df_cph.withColumn(\"review_scores_rating\",df_cph[\"review_scores_rating\"].cast(DoubleType()))\n",
    "df_value = df_value.withColumn(\"value\",f.lit(f.col(\"review_scores_rating\")/f.col(\"price\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Window function to select top three\n",
    "sorted_by_value = Window.partitionBy('neighbourhood').orderBy(f.desc('value'))\n",
    "# Apply window function\n",
    "ranked_by_value = df_value.withColumn('value_rank', f.rank().over(sorted_by_value))\n",
    "# Filter top three\n",
    "ranked_df = ranked_by_value.filter(f.col('value_rank') <= 3).drop('value_rank').orderBy('neighbourhood', f.desc('value'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------+-------+-----------+--------------+-------------+-----+--------------------+-------------------+\n",
      "|      id|country|       city| neighbourhood|property_type|price|review_scores_rating|              value|\n",
      "+--------+-------+-----------+--------------+-------------+-----+--------------------+-------------------+\n",
      "| 5710617|Denmark| Copenhagen|        Amager|    Apartment|150.0|               100.0| 0.6666666666666666|\n",
      "|23337696|Denmark|  København|        Amager|    Apartment|178.0|               100.0| 0.5617977528089888|\n",
      "|22900213|Denmark|  København|        Amager|    Apartment|178.0|               100.0| 0.5617977528089888|\n",
      "|27815787|Denmark| Copenhagen|   Amager Vest|    Apartment| 75.0|               100.0| 1.3333333333333333|\n",
      "| 4831559|Denmark| Copenhagen|   Amager Vest|    Apartment| 96.0|                90.0|             0.9375|\n",
      "|37172149|Denmark|  København|   Amager Vest|    Apartment|177.0|               100.0| 0.5649717514124294|\n",
      "|13746265|Denmark|  København|    Amager Øst|    Apartment| 68.0|               100.0| 1.4705882352941178|\n",
      "|33156740|Denmark|København S|    Amager Øst|    Apartment|123.0|                95.0| 0.7723577235772358|\n",
      "|15472837|Denmark|  København|    Amager Øst|    Apartment|137.0|                96.0| 0.7007299270072993|\n",
      "|11860639|Denmark|  København|     Amagerbro|    Apartment|157.0|                98.0| 0.6242038216560509|\n",
      "|23213098|Denmark|  København|     Amagerbro|    Apartment|212.0|               100.0| 0.4716981132075472|\n",
      "|18621920|Denmark|  København|     Amagerbro|    Apartment|253.0|               100.0| 0.3952569169960474|\n",
      "|14162456|Denmark|  København|      Brønshøj|    Apartment|123.0|                87.0| 0.7073170731707317|\n",
      "|30925351|Denmark|  København|      Brønshøj|    Apartment|150.0|               100.0| 0.6666666666666666|\n",
      "|10491752|Denmark|  København|      Brønshøj|    Apartment|137.0|                90.0|  0.656934306569343|\n",
      "|14295875|Denmark|  København|   Christiania|    Apartment|751.0|                85.0|0.11318242343541944|\n",
      "|24096788|Denmark|  København|Christianshavn|    Apartment|253.0|               100.0| 0.3952569169960474|\n",
      "| 3145494|Denmark| Copenhagen|Christianshavn|    Apartment|280.0|                97.0| 0.3464285714285714|\n",
      "|12194944|Denmark|  København|Christianshavn|    Apartment|369.0|               100.0|0.27100271002710025|\n",
      "|19115574|Denmark|  København| Frederiksberg|    Townhouse|259.0|                87.0| 0.3359073359073359|\n",
      "+--------+-------+-----------+--------------+-------------+-----+--------------------+-------------------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "ranked_df.show()"
   ]
  },
  {
   "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.\n",
    "\n",
    "#### Description of Trends\n",
    "*In this section we first join (left) the Review data on the Listing data (filtered on Copenhagen) and then count the number of reviews pr. unique date using group by. The data is transformed to Pandas Dataframe and the Date column is changed to Pandas Datetime type. We then sum the number of reviews pr. month, again using groupby and plot the result. To vizualize the popularity of neighbourhoods over time we do almost the same as just described. The only difference is that we also group by \"neighbourhood\". This is done to show the number of reviews pr. neighbourhood. Lastly, to show seasonality we sum the number of reviews pr. month and plot the result.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# left-join Review-data on Listing-data on listing_id and id\n",
    "df_join = df_cph.join(df_review, (df_cph.id == df_review.listing_id), how='left')\n",
    "# Groupby date count reviews\n",
    "df_plot = df_join.groupby('date').agg(f.count('review_id')).toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To datetime and groupby date at month level\n",
    "df_plot.date = pd.to_datetime(df_plot.date)\n",
    "df_plot = df_plot.groupby(pd.Grouper(key='date',freq='M')).sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plotting number of reveis over entire time period\n",
    "df_plot.plot(figsize=(16,6))\n",
    "\n",
    "plt.title('Reviews per month over entire time period')\n",
    "plt.ylabel('Count')\n",
    "plt.show()"
   ]
  },
  {
   "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": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Group by date and neighbourhood\n",
    "df_plot = df_join.groupby('date','neighbourhood').agg(f.count('review_id')).toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To datetime and group by date at month level\n",
    "df_plot.date = pd.to_datetime(df_plot.date)\n",
    "df_plot = df_plot.groupby(['neighbourhood',pd.Grouper(key='date',freq='M')]).sum().reset_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_plot = df_plot.pivot(index='date',columns='neighbourhood',\\\n",
    "                      values='count(review_id)')\n",
    "df_plot = df_plot[df_plot.index.notnull()].reset_index()\n",
    "df_plot = df_plot.fillna(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot review count of four largest neighbourhoods\n",
    "df_plot.plot(x='date', y=['Østerbro','Nørrebro','Vesterbro','Indre By'],figsize=(16,6))\n",
    "plt.title('Number of reviews for different neighbourhoods')\n",
    "plt.show()"
   ]
  },
  {
   "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": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Group by date\n",
    "df_plot = df_join.groupby('date').agg(f.count('review_id')).toPandas()\n",
    "# To datetime and select month\n",
    "df_plot.date = pd.to_datetime(df_plot.date)\n",
    "df_plot['date'] = df_plot['date'].dt.month\n",
    "\n",
    "# Group by name of month\n",
    "df_plot = df_plot.groupby('date',as_index=False).sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot season popularity\n",
    "fig = df_plot.plot(x='date', y='count(review_id)',figsize=(16,6))\n",
    "fig.set_xticks(np.arange(1,13))\n",
    "fig.set_xticklabels(['January','February','March','April','May','June','July','August','Septmenber','Oktober','November','December'])\n",
    "plt.title('Season popularity of Copenhagen')\n",
    "plt.xlabel('Month')\n",
    "plt.ylabel('Number of reviews')\n",
    "plt.show()"
   ]
  },
  {
   "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": [
    "#### Description of Reviews\n",
    "\n",
    "*To assess the possitivity score for each word in the reviews, we are merging the listing and review dataframe, such that all reviews are getting the average score for the respective listing. Before analyzing the words, we are handling things that might tweak the correct positivity-score of a given word. This includes things like lowercasing and removal of symbols.*\n",
    "\n",
    "*The weight measure is calculated by exploding each review such that every word in the `comments` column gets its own row. This means, that every review, which initially consitis of one row, gets exploded into as many rows as the number of words in the review comment. Thereby, we will have distinct words with the score for that particular listing. We can then group by words and use an aggregate mean to get the final score for each word.*\n",
    "\n",
    "*We are ignoring all words which occurs less than 500 times in total, in order to ensure that words are actually having an impotance before they can occur as a positive word. This hinders, that a word which are mentioned very few times in a review that has been very positive, will outweigh other more relevant words.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Importing packages\n",
    "from pyspark.sql.functions import lower, regexp_replace, split\n",
    "from pyspark.ml.feature import Tokenizer, RegexTokenizer\n",
    "from pyspark.ml.feature import StopWordsRemover\n",
    "from pyspark.sql.functions import udf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Selecting the relevant columns in the two dataframes\n",
    "dfr = df_review.select('listing_id','comments')\n",
    "dfl = df.select('id','review_scores_rating') #country"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After selecting the correct columns, we have to join the two dataframes. As we do not have a rating for each of the reviews, each review will get the average rating which is contained in the listing dataset. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Joining the reviews and listings on listing ID\n",
    "df = dfr.join(dfl, (f.col('listing_id') == f.col('id')), 'left')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Cleaning text in the comments column \n",
    "#Note that this is not defined as a UDF when only using spark imported functions.\n",
    "def clean_text(c):\n",
    "    c = lower(c)\n",
    "    c = regexp_replace(c, \"[^a-zA-Z0-9\\\\s]\", \"\")\n",
    "    return c\n",
    "\n",
    "df = df.withColumn(\"text_clean\", clean_text(f.col(\"comments\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Creating a tokenizer and tokenizing all the comments, enabling us to analyze each word seperately \n",
    "tokenizer = Tokenizer(inputCol=\"text_clean\", outputCol=\"words\")\n",
    "df = tokenizer.transform(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Defining a stopwords remover\n",
    "remover = StopWordsRemover()\n",
    "stopwords = remover.getStopWords() \n",
    "\n",
    "#Defining the input column on which the stopwords remover is applied and what to call the output column\n",
    "remover.setInputCol(\"words\")\n",
    "remover.setOutputCol(\"comments_wo_stopwords\")\n",
    "\n",
    "#Apply the stopwords remover to the dataframe \n",
    "df = remover.transform(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----------+-------------------+----------+\n",
      "|       Word|Average word-review|Word count|\n",
      "+-----------+-------------------+----------+\n",
      "|    cottage|  97.21373169707154|    255399|\n",
      "|    touches|   97.1571085603631|    404079|\n",
      "| thoughtful|  97.03602483558197|    366127|\n",
      "|     snacks|  96.94667404065913|    189832|\n",
      "|beautifully|  96.93262616184424|    269993|\n",
      "|  sparkling|   96.7294242702305|    152138|\n",
      "|     beyond|   96.7025421911345|    244214|\n",
      "|   spotless|  96.65763350869335|    201897|\n",
      "|   gorgeous|  96.62795972297678|    274823|\n",
      "|  appointed|  96.58053215837083|    173446|\n",
      "|   stunning|  96.54279379616871|    173569|\n",
      "|    stocked|  96.48226261462027|    279125|\n",
      "|      truly|   96.4673495764646|    275760|\n",
      "|   gracious|  96.44744251694067|    171740|\n",
      "|   relaxing|  96.43518737716019|    305707|\n",
      "|outstanding|  96.41961028483233|    156439|\n",
      "|    special|  96.41434456021322|    217543|\n",
      "|  decorated|  96.37500308994458|    531947|\n",
      "|    stylish|  96.34675732883133|    606742|\n",
      "|       home|  96.33915903118309|   3006755|\n",
      "+-----------+-------------------+----------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Displaying results of which words are the most positive given the reviews\n",
    "df_explode = df.withColumn('Word', f.explode(f.col('comments_wo_stopwords'))).select('review_scores_rating','Word')\\\n",
    "    .groupBy('Word').agg(f.mean('review_scores_rating').alias(\"Average word-review\"), f.count('Word').alias(\"Word count\"))\\\n",
    "    .sort('Average word-review', ascending=False)\\\n",
    "    .filter(f.col('Word count') > 150000)\\\n",
    "    .show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we see above, the words are very relevant from the perspective of an AirBnB review. Words like \"stylish\", \"beautifully\", \"home\", \"relaxing\", are all words we associate with positive holiday experiences. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}