Project 3 - Airbnb_final2.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": 64,
   "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": 53,
   "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": 66,
   "metadata": {
    "scrolled": true
   },
   "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": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load reduced CSV files\n",
    "df = spark.read.option(\"header\", \"true\").csv(\"data/clean_data/*.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------+--------------+--------------+-------------------+------------------+-------+--------------------+\n",
      "|      id|       country|          city|      neighbourhood|     property_type|  price|review_scores_rating|\n",
      "+--------+--------------+--------------+-------------------+------------------+-------+--------------------+\n",
      "|33585119|   Netherlands|     Amsterdam|    Oosterparkbuurt|         Apartment|$100.00|                  98|\n",
      "| 7418083|         Italy|        Milano|        Città Studi| Bed and breakfast| $59.00|                  89|\n",
      "|24660198|     Singapore|     Singapore|       Central Area|Serviced apartment|$230.00|                  96|\n",
      "|34200105| United States|         Kihei|               Maui|       Condominium|$184.00|                  99|\n",
      "|19624554|        Sweden|     Södermalm|          Södermalm|         Apartment|$450.00|                  91|\n",
      "| 8687518| United States|Marina del Rey|     Marina Del Rey|             House|$174.00|                  93|\n",
      "|34725563| United States|      Honolulu|           Honolulu|       Guest suite|$150.00|                 100|\n",
      "|33556124|       Austria|          Wien|         Josefstadt|         Apartment|$129.00|                  93|\n",
      "|14685276| United States|      Brooklyn|       Clinton Hill|              Loft|$132.00|                  94|\n",
      "|22733547|        Canada|       Toronto|            Bendale|             House| $30.00|                  99|\n",
      "|25873639|        Canada|       Toronto|  Trinity-Bellwoods|         Townhouse|$139.00|                  93|\n",
      "|29321561|         Italy|          Roma|        Roma Centro|         Apartment|$230.00|                  99|\n",
      "|26581851|         Spain|     Barcelona|           Eixample|         Apartment| $50.00|                  90|\n",
      "|17219192|         Italy|       Firenze|       San Giovanni|         Apartment| $60.00|                  99|\n",
      "|11578960|        France|         Paris| XIX Arrondissement|         Apartment| $70.00|                  80|\n",
      "|27859799|     Australia|   South Yarra|        South Yarra|         Apartment|$121.00|                 100|\n",
      "|19575337|     Australia| Carlton North|      Carlton North|         Apartment| $97.00|                 100|\n",
      "| 5151960|         Italy|          Roma|              Celio|         Apartment|$120.00|                  97|\n",
      "|21783732| United States|     San Diego|          Hillcrest|         Apartment|$105.00|                  94|\n",
      "|24768184|United Kingdom|Greater London|LB of Tower Hamlets|         Apartment| $70.00|                  99|\n",
      "+--------+--------------+--------------+-------------------+------------------+-------+--------------------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Subset of Review data and change column name \n",
    "df_review = df_review.select('listing_id', f.col('id').alias('review_id'),\\\n",
    "                             'date','comments')\n",
    "\n",
    "# Write CSV\n",
    "df_review = df_review.dropna(how='any')\n",
    "#df_review.write.csv('data/clean_review_data',header=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load CSV\n",
    "#df_review = spark.read.option(\"header\", \"true\").csv(\"data/clean_review_data/*.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----------+---------+----------+--------------------+\n",
      "|listing_id|review_id|      date|            comments|\n",
      "+----------+---------+----------+--------------------+\n",
      "|    145320|156423122|2017-05-30|Prima plek om Sto...|\n",
      "|    145320|170211906|2017-07-15|Cosy and clean fl...|\n",
      "|    145320|172169175|2017-07-20|The host canceled...|\n",
      "|    145320|176647581|2017-07-31|Kim's place was o...|\n",
      "|    145320|185676021|2017-08-22|great spacious ap...|\n",
      "|    145320|189668224|2017-09-02|Kim is a very fri...|\n",
      "|    145320|191894030|2017-09-09|The apartment is ...|\n",
      "|    145320|193316070|2017-09-13|Nicely appointed,...|\n",
      "|    145320|196760607|2017-09-24|It was a pleasure...|\n",
      "|    145320|201885633|2017-10-09|Kim's place is si...|\n",
      "|    145320|203410181|2017-10-15|We absolutely lov...|\n",
      "|    145320|210619953|2017-11-10|Amazing place to ...|\n",
      "|    145320|211523951|2017-11-13|Very pleasant sta...|\n",
      "|    145320|212932349|2017-11-19|We had a wonderfu...|\n",
      "|    145320|214018139|2017-11-24|Great location! C...|\n",
      "|    145320|216533345|2017-12-04|Lovely flat in a ...|\n",
      "|    145320|219021131|2017-12-16|Kim’s flat is in ...|\n",
      "|    145320|231273225|2018-01-31|I would definitel...|\n",
      "|    145320|233159940|2018-02-08|Kim's place is pe...|\n",
      "|    145320|234271335|2018-02-12|The flat is so co...|\n",
      "+----------+---------+----------+--------------------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df_review.show()"
   ]
  },
  {
   "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": 69,
   "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",
      "|       Seattle|    7667|            79|\n",
      "|        Austin|    8042|            79|\n",
      "|Rio de Janeiro|    9566|            75|\n",
      "|        Sydney|     841|            71|\n",
      "|       Oakland|    2619|            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": 15,
   "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": 16,
   "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": 16,
     "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": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "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": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20526"
      ]
     },
     "execution_count": 18,
     "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": 19,
   "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": 20,
   "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": 21,
   "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": 22,
   "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": 23,
   "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": 24,
   "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": 25,
   "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": 26,
   "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": 27,
   "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": 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": [
    "# 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": 29,
   "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": 30,
   "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": 31,
   "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": 32,
   "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": 33,
   "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": 34,
   "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": 84,
   "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": 85,
   "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')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------+--------------+--------------+-------------------+------------------+-------+--------------------+\n",
      "|      id|       country|          city|      neighbourhood|     property_type|  price|review_scores_rating|\n",
      "+--------+--------------+--------------+-------------------+------------------+-------+--------------------+\n",
      "|33585119|   Netherlands|     Amsterdam|    Oosterparkbuurt|         Apartment|$100.00|                  98|\n",
      "| 7418083|         Italy|        Milano|        Città Studi| Bed and breakfast| $59.00|                  89|\n",
      "|24660198|     Singapore|     Singapore|       Central Area|Serviced apartment|$230.00|                  96|\n",
      "|34200105| United States|         Kihei|               Maui|       Condominium|$184.00|                  99|\n",
      "|19624554|        Sweden|     Södermalm|          Södermalm|         Apartment|$450.00|                  91|\n",
      "| 8687518| United States|Marina del Rey|     Marina Del Rey|             House|$174.00|                  93|\n",
      "|34725563| United States|      Honolulu|           Honolulu|       Guest suite|$150.00|                 100|\n",
      "|33556124|       Austria|          Wien|         Josefstadt|         Apartment|$129.00|                  93|\n",
      "|14685276| United States|      Brooklyn|       Clinton Hill|              Loft|$132.00|                  94|\n",
      "|22733547|        Canada|       Toronto|            Bendale|             House| $30.00|                  99|\n",
      "|25873639|        Canada|       Toronto|  Trinity-Bellwoods|         Townhouse|$139.00|                  93|\n",
      "|29321561|         Italy|          Roma|        Roma Centro|         Apartment|$230.00|                  99|\n",
      "|26581851|         Spain|     Barcelona|           Eixample|         Apartment| $50.00|                  90|\n",
      "|17219192|         Italy|       Firenze|       San Giovanni|         Apartment| $60.00|                  99|\n",
      "|11578960|        France|         Paris| XIX Arrondissement|         Apartment| $70.00|                  80|\n",
      "|27859799|     Australia|   South Yarra|        South Yarra|         Apartment|$121.00|                 100|\n",
      "|19575337|     Australia| Carlton North|      Carlton North|         Apartment| $97.00|                 100|\n",
      "| 5151960|         Italy|          Roma|              Celio|         Apartment|$120.00|                  97|\n",
      "|21783732| United States|     San Diego|          Hillcrest|         Apartment|$105.00|                  94|\n",
      "|24768184|United Kingdom|Greater London|LB of Tower Hamlets|         Apartment| $70.00|                  99|\n",
      "+--------+--------------+--------------+-------------------+------------------+-------+--------------------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "df.show()"
   ]
  },
  {
   "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": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Joining the reviews and listings on listing ID\n",
    "df_join = dfr.join(dfl, (f.col('listing_id') == f.col('id')), 'left')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Cleaning text in the comments column \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_clean = df_join.withColumn(\"text_clean\", clean_text(f.col(\"comments\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "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_clean = tokenizer.transform(df_clean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "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_clean = remover.transform(df_clean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "ename": "Py4JJavaError",
     "evalue": "An error occurred while calling o1574.showString.\n: org.apache.spark.SparkException: Job aborted due to stage failure: Task 0 in stage 110.0 failed 1 times, most recent failure: Lost task 0.0 in stage 110.0 (TID 3403, localhost, executor driver): java.io.IOException: No space left on device\n\tat java.io.FileOutputStream.writeBytes(Native Method)\n\tat java.io.FileOutputStream.write(FileOutputStream.java:326)\n\tat org.apache.spark.storage.TimeTrackingOutputStream.write(TimeTrackingOutputStream.java:58)\n\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n\tat java.io.BufferedOutputStream.write(BufferedOutputStream.java:126)\n\tat net.jpountz.lz4.LZ4BlockOutputStream.flushBufferedData(LZ4BlockOutputStream.java:220)\n\tat net.jpountz.lz4.LZ4BlockOutputStream.write(LZ4BlockOutputStream.java:173)\n\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n\tat java.io.BufferedOutputStream.write(BufferedOutputStream.java:126)\n\tat java.io.DataOutputStream.write(DataOutputStream.java:107)\n\tat org.apache.spark.sql.catalyst.expressions.UnsafeRow.writeToStream(UnsafeRow.java:554)\n\tat org.apache.spark.sql.execution.UnsafeRowSerializerInstance$$anon$1.writeValue(UnsafeRowSerializer.scala:69)\n\tat org.apache.spark.storage.DiskBlockObjectWriter.write(DiskBlockObjectWriter.scala:241)\n\tat org.apache.spark.shuffle.sort.BypassMergeSortShuffleWriter.write(BypassMergeSortShuffleWriter.java:151)\n\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:55)\n\tat org.apache.spark.scheduler.Task.run(Task.scala:121)\n\tat org.apache.spark.executor.Executor$TaskRunner$$anonfun$10.apply(Executor.scala:408)\n\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1360)\n\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:414)\n\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n\tat java.lang.Thread.run(Thread.java:748)\n\nDriver stacktrace:\n\tat org.apache.spark.scheduler.DAGScheduler.org$apache$spark$scheduler$DAGScheduler$$failJobAndIndependentStages(DAGScheduler.scala:1889)\n\tat org.apache.spark.scheduler.DAGScheduler$$anonfun$abortStage$1.apply(DAGScheduler.scala:1877)\n\tat org.apache.spark.scheduler.DAGScheduler$$anonfun$abortStage$1.apply(DAGScheduler.scala:1876)\n\tat scala.collection.mutable.ResizableArray$class.foreach(ResizableArray.scala:59)\n\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:48)\n\tat org.apache.spark.scheduler.DAGScheduler.abortStage(DAGScheduler.scala:1876)\n\tat org.apache.spark.scheduler.DAGScheduler$$anonfun$handleTaskSetFailed$1.apply(DAGScheduler.scala:926)\n\tat org.apache.spark.scheduler.DAGScheduler$$anonfun$handleTaskSetFailed$1.apply(DAGScheduler.scala:926)\n\tat scala.Option.foreach(Option.scala:257)\n\tat org.apache.spark.scheduler.DAGScheduler.handleTaskSetFailed(DAGScheduler.scala:926)\n\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2110)\n\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2059)\n\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2048)\n\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n\tat org.apache.spark.scheduler.DAGScheduler.runJob(DAGScheduler.scala:737)\n\tat org.apache.spark.SparkContext.runJob(SparkContext.scala:2061)\n\tat org.apache.spark.SparkContext.runJob(SparkContext.scala:2158)\n\tat org.apache.spark.rdd.RDD$$anonfun$reduce$1.apply(RDD.scala:1035)\n\tat org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:151)\n\tat org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:112)\n\tat org.apache.spark.rdd.RDD.withScope(RDD.scala:363)\n\tat org.apache.spark.rdd.RDD.reduce(RDD.scala:1017)\n\tat org.apache.spark.rdd.RDD$$anonfun$takeOrdered$1.apply(RDD.scala:1439)\n\tat org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:151)\n\tat org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:112)\n\tat org.apache.spark.rdd.RDD.withScope(RDD.scala:363)\n\tat org.apache.spark.rdd.RDD.takeOrdered(RDD.scala:1426)\n\tat org.apache.spark.sql.execution.TakeOrderedAndProjectExec.executeCollect(limit.scala:136)\n\tat org.apache.spark.sql.Dataset.org$apache$spark$sql$Dataset$$collectFromPlan(Dataset.scala:3383)\n\tat org.apache.spark.sql.Dataset$$anonfun$head$1.apply(Dataset.scala:2544)\n\tat org.apache.spark.sql.Dataset$$anonfun$head$1.apply(Dataset.scala:2544)\n\tat org.apache.spark.sql.Dataset$$anonfun$53.apply(Dataset.scala:3364)\n\tat org.apache.spark.sql.execution.SQLExecution$$anonfun$withNewExecutionId$1.apply(SQLExecution.scala:78)\n\tat org.apache.spark.sql.execution.SQLExecution$.withSQLConfPropagated(SQLExecution.scala:125)\n\tat org.apache.spark.sql.execution.SQLExecution$.withNewExecutionId(SQLExecution.scala:73)\n\tat org.apache.spark.sql.Dataset.withAction(Dataset.scala:3363)\n\tat org.apache.spark.sql.Dataset.head(Dataset.scala:2544)\n\tat org.apache.spark.sql.Dataset.take(Dataset.scala:2758)\n\tat org.apache.spark.sql.Dataset.getRows(Dataset.scala:254)\n\tat org.apache.spark.sql.Dataset.showString(Dataset.scala:291)\n\tat sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n\tat sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)\n\tat sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\n\tat java.lang.reflect.Method.invoke(Method.java:498)\n\tat py4j.reflection.MethodInvoker.invoke(MethodInvoker.java:244)\n\tat py4j.reflection.ReflectionEngine.invoke(ReflectionEngine.java:357)\n\tat py4j.Gateway.invoke(Gateway.java:282)\n\tat py4j.commands.AbstractCommand.invokeMethod(AbstractCommand.java:132)\n\tat py4j.commands.CallCommand.execute(CallCommand.java:79)\n\tat py4j.GatewayConnection.run(GatewayConnection.java:238)\n\tat java.lang.Thread.run(Thread.java:748)\nCaused by: java.io.IOException: No space left on device\n\tat java.io.FileOutputStream.writeBytes(Native Method)\n\tat java.io.FileOutputStream.write(FileOutputStream.java:326)\n\tat org.apache.spark.storage.TimeTrackingOutputStream.write(TimeTrackingOutputStream.java:58)\n\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n\tat java.io.BufferedOutputStream.write(BufferedOutputStream.java:126)\n\tat net.jpountz.lz4.LZ4BlockOutputStream.flushBufferedData(LZ4BlockOutputStream.java:220)\n\tat net.jpountz.lz4.LZ4BlockOutputStream.write(LZ4BlockOutputStream.java:173)\n\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n\tat java.io.BufferedOutputStream.write(BufferedOutputStream.java:126)\n\tat java.io.DataOutputStream.write(DataOutputStream.java:107)\n\tat org.apache.spark.sql.catalyst.expressions.UnsafeRow.writeToStream(UnsafeRow.java:554)\n\tat org.apache.spark.sql.execution.UnsafeRowSerializerInstance$$anon$1.writeValue(UnsafeRowSerializer.scala:69)\n\tat org.apache.spark.storage.DiskBlockObjectWriter.write(DiskBlockObjectWriter.scala:241)\n\tat org.apache.spark.shuffle.sort.BypassMergeSortShuffleWriter.write(BypassMergeSortShuffleWriter.java:151)\n\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:55)\n\tat org.apache.spark.scheduler.Task.run(Task.scala:121)\n\tat org.apache.spark.executor.Executor$TaskRunner$$anonfun$10.apply(Executor.scala:408)\n\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1360)\n\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:414)\n\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n\t... 1 more\n",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mPy4JJavaError\u001b[0m                             Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-91-62fbe5f6aa90>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0;34m.\u001b[0m\u001b[0mgroupBy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Word'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0magg\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'review_scores_rating'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0malias\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Average word-review\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcount\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Word'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0malias\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Word count\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;31m\\\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0;34m.\u001b[0m\u001b[0msort\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Average word-review'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mascending\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;31m\\\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m     \u001b[0;34m.\u001b[0m\u001b[0mfilter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcol\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Word count'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m150000\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;31m\\\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m     \u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/spark/python/pyspark/sql/dataframe.py\u001b[0m in \u001b[0;36mshow\u001b[0;34m(self, n, truncate, vertical)\u001b[0m\n\u001b[1;32m    376\u001b[0m         \"\"\"\n\u001b[1;32m    377\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtruncate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbool\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mtruncate\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 378\u001b[0;31m             \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_jdf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshowString\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m20\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvertical\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    379\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    380\u001b[0m             \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_jdf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshowString\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtruncate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvertical\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/spark/python/lib/py4j-0.10.7-src.zip/py4j/java_gateway.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args)\u001b[0m\n\u001b[1;32m   1255\u001b[0m         \u001b[0manswer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgateway_client\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msend_command\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcommand\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1256\u001b[0m         return_value = get_return_value(\n\u001b[0;32m-> 1257\u001b[0;31m             answer, self.gateway_client, self.target_id, self.name)\n\u001b[0m\u001b[1;32m   1258\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1259\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mtemp_arg\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mtemp_args\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/spark/python/pyspark/sql/utils.py\u001b[0m in \u001b[0;36mdeco\u001b[0;34m(*a, **kw)\u001b[0m\n\u001b[1;32m     61\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mdeco\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     62\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 63\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     64\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0mpy4j\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprotocol\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mPy4JJavaError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     65\u001b[0m             \u001b[0ms\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjava_exception\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtoString\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/usr/local/spark/python/lib/py4j-0.10.7-src.zip/py4j/protocol.py\u001b[0m in \u001b[0;36mget_return_value\u001b[0;34m(answer, gateway_client, target_id, name)\u001b[0m\n\u001b[1;32m    326\u001b[0m                 raise Py4JJavaError(\n\u001b[1;32m    327\u001b[0m                     \u001b[0;34m\"An error occurred while calling {0}{1}{2}.\\n\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 328\u001b[0;31m                     format(target_id, \".\", name), value)\n\u001b[0m\u001b[1;32m    329\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    330\u001b[0m                 raise Py4JError(\n",
      "\u001b[0;31mPy4JJavaError\u001b[0m: An error occurred while calling o1574.showString.\n: org.apache.spark.SparkException: Job aborted due to stage failure: Task 0 in stage 110.0 failed 1 times, most recent failure: Lost task 0.0 in stage 110.0 (TID 3403, localhost, executor driver): java.io.IOException: No space left on device\n\tat java.io.FileOutputStream.writeBytes(Native Method)\n\tat java.io.FileOutputStream.write(FileOutputStream.java:326)\n\tat org.apache.spark.storage.TimeTrackingOutputStream.write(TimeTrackingOutputStream.java:58)\n\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n\tat java.io.BufferedOutputStream.write(BufferedOutputStream.java:126)\n\tat net.jpountz.lz4.LZ4BlockOutputStream.flushBufferedData(LZ4BlockOutputStream.java:220)\n\tat net.jpountz.lz4.LZ4BlockOutputStream.write(LZ4BlockOutputStream.java:173)\n\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n\tat java.io.BufferedOutputStream.write(BufferedOutputStream.java:126)\n\tat java.io.DataOutputStream.write(DataOutputStream.java:107)\n\tat org.apache.spark.sql.catalyst.expressions.UnsafeRow.writeToStream(UnsafeRow.java:554)\n\tat org.apache.spark.sql.execution.UnsafeRowSerializerInstance$$anon$1.writeValue(UnsafeRowSerializer.scala:69)\n\tat org.apache.spark.storage.DiskBlockObjectWriter.write(DiskBlockObjectWriter.scala:241)\n\tat org.apache.spark.shuffle.sort.BypassMergeSortShuffleWriter.write(BypassMergeSortShuffleWriter.java:151)\n\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:55)\n\tat org.apache.spark.scheduler.Task.run(Task.scala:121)\n\tat org.apache.spark.executor.Executor$TaskRunner$$anonfun$10.apply(Executor.scala:408)\n\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1360)\n\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:414)\n\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n\tat java.lang.Thread.run(Thread.java:748)\n\nDriver stacktrace:\n\tat org.apache.spark.scheduler.DAGScheduler.org$apache$spark$scheduler$DAGScheduler$$failJobAndIndependentStages(DAGScheduler.scala:1889)\n\tat org.apache.spark.scheduler.DAGScheduler$$anonfun$abortStage$1.apply(DAGScheduler.scala:1877)\n\tat org.apache.spark.scheduler.DAGScheduler$$anonfun$abortStage$1.apply(DAGScheduler.scala:1876)\n\tat scala.collection.mutable.ResizableArray$class.foreach(ResizableArray.scala:59)\n\tat scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:48)\n\tat org.apache.spark.scheduler.DAGScheduler.abortStage(DAGScheduler.scala:1876)\n\tat org.apache.spark.scheduler.DAGScheduler$$anonfun$handleTaskSetFailed$1.apply(DAGScheduler.scala:926)\n\tat org.apache.spark.scheduler.DAGScheduler$$anonfun$handleTaskSetFailed$1.apply(DAGScheduler.scala:926)\n\tat scala.Option.foreach(Option.scala:257)\n\tat org.apache.spark.scheduler.DAGScheduler.handleTaskSetFailed(DAGScheduler.scala:926)\n\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.doOnReceive(DAGScheduler.scala:2110)\n\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2059)\n\tat org.apache.spark.scheduler.DAGSchedulerEventProcessLoop.onReceive(DAGScheduler.scala:2048)\n\tat org.apache.spark.util.EventLoop$$anon$1.run(EventLoop.scala:49)\n\tat org.apache.spark.scheduler.DAGScheduler.runJob(DAGScheduler.scala:737)\n\tat org.apache.spark.SparkContext.runJob(SparkContext.scala:2061)\n\tat org.apache.spark.SparkContext.runJob(SparkContext.scala:2158)\n\tat org.apache.spark.rdd.RDD$$anonfun$reduce$1.apply(RDD.scala:1035)\n\tat org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:151)\n\tat org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:112)\n\tat org.apache.spark.rdd.RDD.withScope(RDD.scala:363)\n\tat org.apache.spark.rdd.RDD.reduce(RDD.scala:1017)\n\tat org.apache.spark.rdd.RDD$$anonfun$takeOrdered$1.apply(RDD.scala:1439)\n\tat org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:151)\n\tat org.apache.spark.rdd.RDDOperationScope$.withScope(RDDOperationScope.scala:112)\n\tat org.apache.spark.rdd.RDD.withScope(RDD.scala:363)\n\tat org.apache.spark.rdd.RDD.takeOrdered(RDD.scala:1426)\n\tat org.apache.spark.sql.execution.TakeOrderedAndProjectExec.executeCollect(limit.scala:136)\n\tat org.apache.spark.sql.Dataset.org$apache$spark$sql$Dataset$$collectFromPlan(Dataset.scala:3383)\n\tat org.apache.spark.sql.Dataset$$anonfun$head$1.apply(Dataset.scala:2544)\n\tat org.apache.spark.sql.Dataset$$anonfun$head$1.apply(Dataset.scala:2544)\n\tat org.apache.spark.sql.Dataset$$anonfun$53.apply(Dataset.scala:3364)\n\tat org.apache.spark.sql.execution.SQLExecution$$anonfun$withNewExecutionId$1.apply(SQLExecution.scala:78)\n\tat org.apache.spark.sql.execution.SQLExecution$.withSQLConfPropagated(SQLExecution.scala:125)\n\tat org.apache.spark.sql.execution.SQLExecution$.withNewExecutionId(SQLExecution.scala:73)\n\tat org.apache.spark.sql.Dataset.withAction(Dataset.scala:3363)\n\tat org.apache.spark.sql.Dataset.head(Dataset.scala:2544)\n\tat org.apache.spark.sql.Dataset.take(Dataset.scala:2758)\n\tat org.apache.spark.sql.Dataset.getRows(Dataset.scala:254)\n\tat org.apache.spark.sql.Dataset.showString(Dataset.scala:291)\n\tat sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n\tat sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)\n\tat sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\n\tat java.lang.reflect.Method.invoke(Method.java:498)\n\tat py4j.reflection.MethodInvoker.invoke(MethodInvoker.java:244)\n\tat py4j.reflection.ReflectionEngine.invoke(ReflectionEngine.java:357)\n\tat py4j.Gateway.invoke(Gateway.java:282)\n\tat py4j.commands.AbstractCommand.invokeMethod(AbstractCommand.java:132)\n\tat py4j.commands.CallCommand.execute(CallCommand.java:79)\n\tat py4j.GatewayConnection.run(GatewayConnection.java:238)\n\tat java.lang.Thread.run(Thread.java:748)\nCaused by: java.io.IOException: No space left on device\n\tat java.io.FileOutputStream.writeBytes(Native Method)\n\tat java.io.FileOutputStream.write(FileOutputStream.java:326)\n\tat org.apache.spark.storage.TimeTrackingOutputStream.write(TimeTrackingOutputStream.java:58)\n\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n\tat java.io.BufferedOutputStream.write(BufferedOutputStream.java:126)\n\tat net.jpountz.lz4.LZ4BlockOutputStream.flushBufferedData(LZ4BlockOutputStream.java:220)\n\tat net.jpountz.lz4.LZ4BlockOutputStream.write(LZ4BlockOutputStream.java:173)\n\tat java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)\n\tat java.io.BufferedOutputStream.write(BufferedOutputStream.java:126)\n\tat java.io.DataOutputStream.write(DataOutputStream.java:107)\n\tat org.apache.spark.sql.catalyst.expressions.UnsafeRow.writeToStream(UnsafeRow.java:554)\n\tat org.apache.spark.sql.execution.UnsafeRowSerializerInstance$$anon$1.writeValue(UnsafeRowSerializer.scala:69)\n\tat org.apache.spark.storage.DiskBlockObjectWriter.write(DiskBlockObjectWriter.scala:241)\n\tat org.apache.spark.shuffle.sort.BypassMergeSortShuffleWriter.write(BypassMergeSortShuffleWriter.java:151)\n\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:99)\n\tat org.apache.spark.scheduler.ShuffleMapTask.runTask(ShuffleMapTask.scala:55)\n\tat org.apache.spark.scheduler.Task.run(Task.scala:121)\n\tat org.apache.spark.executor.Executor$TaskRunner$$anonfun$10.apply(Executor.scala:408)\n\tat org.apache.spark.util.Utils$.tryWithSafeFinally(Utils.scala:1360)\n\tat org.apache.spark.executor.Executor$TaskRunner.run(Executor.scala:414)\n\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\n\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\n\t... 1 more\n"
     ]
    }
   ],
   "source": [
    "#Displaying results of which words are the most positive given the reviews\n",
    "df_clean.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 \"home\", \"beautiful\", \"quiet\", \"restaurants\", 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
}