PySpark syntax notes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Study to do\n",
    "\n",
    "[0] incorporate notes from email\n",
    "\n",
    "[1] Incorporate examples of how functions are used in map, filter, etc: http://researchcomputing.github.io/meetup_spring_2014/python/spark.html\n",
    "\n",
    "[2] !!! Operating & munging on DataFrames: https://databricks.com/blog/2015/08/12/from-pandas-to-apache-sparks-dataframe.html   -- selection, adding, filtering, aggregating\n",
    "\n",
    "[3] Statistical & Mathematical functions in 1.4: https://databricks.com/blog/2015/06/02/statistical-and-mathematical-functions-with-dataframes-in-spark.html\n",
    "\n",
    "\n",
    "__Learning Spark__\n",
    "Read: chapters 1-3, 9\n",
    "Do: 4,5,6,7,8. \n",
    "\n",
    "__Introduction to Apache Spark__ videos: up to SPARK ESSENTIALS at 5m50s\n",
    "\n",
    "-----\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Notes about Spark, Hadoop, etc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](http://spark.apache.org/images/spark-stack.png)\n",
    "\n",
    "__Spark Core__\n",
    "Spark Core contains the basic functionality of Spark, including components for task scheduling, memory management, fault recovery, interacting with storage systems, and more. Spark Core is also home to the API that defines resilient distributed datasets (RDDs), which are Spark’s main programming abstraction. RDDs represent a collection of items distributed across many compute nodes that can be manipulated in parallel. Spark Core provides many APIs for building and manipulating these collections.\n",
    "\n",
    "__Spark SQL__\n",
    "Spark SQL is Spark’s package for working with structured data. It allows querying data via SQL as well as the Apache Hive variant of SQL—called the Hive Query Language (HQL)—and it supports many sources of data, including Hive tables, Parquet, and JSON. Beyond providing a SQL interface to Spark, Spark SQL allows developers to intermix SQL queries with the programmatic data manipulations supported by RDDs in Python, Java, and Scala, all within a single application, thus combining SQL with complex analytics. This tight integration with the rich computing environment provided by Spark makes Spark SQL unlike any other open source data warehouse tool. \n",
    "\n",
    "\n",
    "__Spark optimisations__\n",
    "\n",
    "Vs. batch:\n",
    "* Ceasing actions as soon as they are completed: eg first() stops once it has got first line\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Notes for brown bag__\n",
    "\n",
    "Spark 1.0 was released in May 2014\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Typical Spark workflow\n",
    "\n",
    "1. Create some input RDDs from external data.\n",
    "2. Transform them to define new RDDs using transformations like filter().\n",
    "3. Ask Spark to persist() any intermediate RDDs that will need to be reused.\n",
    "4. Launch actions such as count() and first() to kick off a parallel computation, which is then optimized and executed by Spark.\n",
    "\n",
    "Remember: Spark RDDs don't exist. They are pointers to an original data source (eg. textfile) along with a pipeline of transformations. When an _action_ is called, then the whole pipeline is run to return the requested result.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Contexts & config\n",
    "\n",
    "At a high level, every Spark application consists of a driver program that launches various parallel operations on a cluster. --> Accessed via SparkContext. We use the sparkContext to build RDDs.\n",
    "\n",
    "Much of what Spark does is pass functions to worker nodes\n",
    "\n",
    "#### SQLContexts vs. HiveContext - ONLY necessary to access SchemaRDD/Dataframe functionality\n",
    "\n",
    "HiveContext is a superset of the SQLContext. Adding Hive functionality allows you to access Hive tables, UDFs (user-defined functions), SerDes (serialization and deserialization formats), and the Hive query language (HiveQL). \n",
    "\n",
    "So we have two entry points, depending on what functionality we want.\n",
    "\n",
    "You can see below that when you run spark-shell, which is your interactive driver application, it automatically creates a SparkContext defined as `sc` and a HiveContext defined as `sqlContext`. The HiveContext allows you to execute SQL queries _as well as_ Hive commands. (also allow access to Hive Metadata Store?)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<pyspark.context.SparkContext object at 0x1039b4fd0>\n",
      "<pyspark.sql.context.HiveContext object at 0x104fb6e50>\n"
     ]
    }
   ],
   "source": [
    "print sc\n",
    "\n",
    "print sqlContext # note default SQLContext is actually a Hive context"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<pyspark.sql.context.SQLContext object at 0x105c54850>\n",
      "<pyspark.sql.context.HiveContext object at 0x105c54790>\n"
     ]
    }
   ],
   "source": [
    "## We could also define with\n",
    "# Import Spark SQL\n",
    "from pyspark.sql import HiveContext, Row\n",
    "# Or if you can't include the hive requirements\n",
    "from pyspark.sql import SQLContext, Row\n",
    "\n",
    "sqlContext = SQLContext(sc)\n",
    "print sqlContext\n",
    "\n",
    "hiveCtx = HiveContext(sc)\n",
    "print hiveCtx \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "## Initialising sparkcontext with parameters\n",
    "\n",
    "from pyspark import SparkConf, SparkContext\n",
    "\n",
    "conf = SparkConf().setMaster(\"local\").setAppName(\"My App\") #setMaster sets address of cluster. AppName so you can find in GUI\n",
    "sc = SparkContext(conf = conf)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### basic RDDs\n",
    "\n",
    "In Spark, we express our computation through operations on distributed collections that are automatically parallelized across the cluster. These collections are called resilient distributed datasets, or RDDs. RDDs are Spark’s fundamental abstraction for distributed data and computation.\n",
    "\n",
    "In Spark all work is expressed as either creating new RDDs, transforming existing RDDs, or calling operations on RDDs to compute a result. Under the hood, Spark automatically distributes the data contained in RDDs across your cluster and parallelizes the operations you perform on them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Creating RDDs__\n",
    "\n",
    "The simplest way to create RDDs is to take an existing collection in your program and pass it to SparkContext’s parallelize()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ParallelCollectionRDD[10] at parallelize at PythonRDD.scala:391"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data =[1,2,3,4,5]\n",
    "rDD= sc.parallelize(data,4)\n",
    "rDD"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From textfile:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "98\n",
      "# Apache Spark\n"
     ]
    }
   ],
   "source": [
    "lines = sc.textFile(\"README.md\") # Create an RDD called lines\n",
    "print lines.count() # Count the number of items in this RDD\n",
    "print lines.first() # First item in this RDD, i.e. first line of README.md"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__RDD operations: transformations__\n",
    "\n",
    "lazily evaluated\n",
    "\n",
    "\n",
    "__filter()__\t return a new dataset formed by selecting those elements of the source on which func returns true\n",
    "\n",
    "__map()__\t return a new distributed dataset formed by passing each element of the source through a function func. We can use map() to do any number of things, from fetching the website associated with each URL in our collection to just squaring the numbers. \n",
    "\n",
    "__flatMap()__\tsimilar to map, but each input item can be mapped to 0 or more output items (so func should return a list rather than a single item). Note that the list is FLATTENED before being returned, so all the lists of words will be combined into a single list\n",
    "\n",
    "\n",
    "__distinct()__\t return a new dataset that contains the distinct elements of the source dataset\n",
    "\n",
    "__sample()__   sample with or without replacement\n",
    "\n",
    "\n",
    "\n",
    "_Transformations that apply to multiple RDDs_\n",
    "\n",
    "__union()__\n",
    "\n",
    "__subtract()__ remove contents of one from another - eg remove training sample\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Filter()\n",
    "pythonLines = lines.filter(lambda line: \"Python\" in line)\n",
    "\n",
    "# Union = like SQL union for RDDs\n",
    "badLinesRDD = errorsRDD.union(warningsRDD)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 \n",
      "4 \n",
      "9 \n",
      "16 \n"
     ]
    }
   ],
   "source": [
    "## map() - squaring everything\n",
    "nums = sc.parallelize([1, 2, 3, 4])\n",
    "squared = nums.map(lambda x: x * x).collect()\n",
    "for num in squared:\n",
    "    print \"%i \" % (num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# more map examples\n",
    "\n",
    "print pandaFriends.map(lambda row: row.name).collect()  # print list of row names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# flatmap()\n",
    "lines = sc.parallelize([\"hello world\", \"hi\"])\n",
    "words = lines.flatMap(lambda line: line.split(\" \"))\n",
    "words.first()  # returns \"hello\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['hello', 'world'], ['object', 'face'], ['never', 'run', 'away']]\n",
      "['hello', 'world', 'object', 'face', 'never', 'run', 'away']\n"
     ]
    }
   ],
   "source": [
    "# map vs. flatmap\n",
    "lines = sc.parallelize([\"hello world\", \"object face\", \"never run away\"])\n",
    "words = lines.map(lambda line: line.split(\" \"))\n",
    "print words.collect()\n",
    "\n",
    "words = lines.flatMap(lambda line: line.split(\" \"))\n",
    "print words.collect()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__RDD Operations: Actions__\n",
    "\n",
    "\n",
    "__reduce()__ aggregate RDD given a function\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "nums = sc.parallelize([1, 2, 3, 4])\n",
    "nums.reduce(lambda x,y: x+y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'count' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-15-00970181501f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mpythonLines\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfirst\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mcount\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      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mfirst\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'count' is not defined"
     ]
    }
   ],
   "source": [
    "## SELECTION\n",
    "collect()  # return ALL ELEMENTS\n",
    "first()\n",
    "take(n)\n",
    "\n",
    "takeOrdered()\n",
    "\n",
    "## Aggregation\n",
    "count()\n",
    "sum = rdd.reduce(lambda x, y: x + y)\n",
    "aggregate()\n",
    "\n",
    "countByValue()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Creating functions and passing to Spark__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "lines = sc.textFile(\"README.md\") # Create an RDD called lines\n",
    "\n",
    "def hasPython(line):\n",
    "    return \"Python\" in line\n",
    "\n",
    "pythonLines = lines.filter(hasPython)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## Lambda functions\n",
    "word = rdd.filter(lambda s: \"error\" in s)\n",
    "# This is the same as:\n",
    "def containsError(s):\n",
    "    return \"error\" in s\n",
    "word = rdd.filter(containsError)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__RDD operations: persisting in memory__\n",
    "\n",
    "you will often use persist() to load a subset of your data into memory and query it repeatedly. \n",
    "\n",
    "You can set storage location within persist(): `result.persist(StorageLevel.DISK_ONLY)`\n",
    "\n",
    "MEMORY_ONLY, MEMORY_AND_DISK, DISK_ONLY...\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "pythonLines.persist   # cache() works the same \n",
    "pythonLines.count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Spark SQL = Dataframes (\"SchemaRDDs\") and other schema-enhanced data\n",
    "\n",
    "(IF you have structured or semi-structured data including, for example, out of Hive, then this is much more powerful.(\n",
    "\n",
    "\n",
    "\n",
    "Spark’s interface for working with structured and semistructured data. Structured data is any data that has a schema—that is, a known set of fields for each record. When you have this type of data, Spark SQL makes it both easier and more efficient to load and query. In particular, Spark SQL provides three main capabilities:\n",
    "\n",
    "1. It can load data from a variety of structured sources (e.g., JSON, Hive, and Parquet).\n",
    "2. It lets you query the data using SQL, both inside a Spark program and from external tools that connect to Spark SQL through standard database connectors (JDBC/ODBC), such as business intelligence tools like Tableau.\n",
    "3. When used within a Spark program, Spark SQL provides rich integration between SQL and regular Python/Java/Scala code, including the ability to join RDDs and SQL tables, expose custom functions in SQL, and more. Many jobs are easier to write using this combination.\n",
    "\n",
    "To implement these capabilities, Spark SQL provides a special type of RDD called SchemaRDD. A SchemaRDD is an RDD of Row objects, each representing a record. A SchemaRDD also knows the schema (i.e., data fields) of its rows. While SchemaRDDs look like regular RDDs, internally they store data in a more efficient manner, taking advantage of their schema. In addition, they provide new operations not available on RDDs, such as the ability to run SQL queries. SchemaRDDs can be created from external data sources, from the results of queries, or from regular RDDs.\n",
    "\n",
    "_See above for notes on HiveContext vs. more basic SQLContext_\n",
    "\n",
    "__Dataframes__\n",
    "\n",
    "Dataframe = RDD + metadata + optimisation\n",
    "\n",
    "Both loading data and executing queries return SchemaRDDs. SchemaRDDs are similar to tables in a traditional database. Under the hood, a SchemaRDD is an RDD composed of Row objects with additional schema information of the types in each column. Row objects are just wrappers around arrays of basic types (e.g., integers and strings),\n",
    "\n",
    "SchemaRDDs are also regular RDDs, so you can operate on them using existing RDD transformations like map() and filter(). However, they provide several additional capabilities. Most importantly, you can register any SchemaRDD as a temporary table to query it via _HiveContext.sql_ or _SQLContext.sql_. You do so using the SchemaRDD’s `registerTempTable()`.\n",
    "\n",
    "Refer to list of dtypes avaialble for Dataframes: BIGINT, FLOAT, DOUBLE, STRING, BOOLEAN, TIMESTAMP, .... you can also have stuctures nested within strucutres\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Dataframes: Basic operations__\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# show schema\n",
    "adultDataFrame.printSchema()\n",
    "\n",
    "## Selecting\n",
    "# Return the column\n",
    "DF.column_name\n",
    "\n",
    "# get row\n",
    "DF.row[i]\n",
    "\n",
    "DF.row[i].column_name\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Data munging__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# select columns\n",
    "adultDataFrame.select(\"workclass\",\"age\",\"education\",\"income\").show()\n",
    "\n",
    "# filter rows\n",
    " adultDataFrame\n",
    "      .select(\"workclass\",\"age\",\"education\",\"occupation\",\"income\")\n",
    "      .filter( adultDataFrame(\"age\") > 30 )\n",
    "      .show()\n",
    "\n",
    "# group by\n",
    "    adultDataFrame\n",
    "      .groupBy(\"income\")\n",
    "      .count()\n",
    "      .show()\n",
    "        \n",
    "# sort\n",
    "    adultDataFrame\n",
    "      .groupBy(\"income\",\"occupation\")\n",
    "      .count()\n",
    "      .sort(\"occupation\")\n",
    "      .show()\n",
    "\n",
    "# word count\n",
    "words = sc.textFile('hamlet.txt')\\\n",
    "        .flatMap(lambda line: re.split('\\W+', line.lower().strip()))\\\n",
    "        .filter(lambda x: len(x) > 2 )\\\n",
    "        .map(lambda word: (word, 1))\\\n",
    "        .reduceByKey(lambda a, b: a + b)\\\n",
    "        .map(lambda x: (x[1], x[0])).sortByKey(False) \n",
    "        \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Registering temp tables__\n",
    "\n",
    "The purpose is to create a point to facilitate SQL querying\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tbl = rows.registerTempTable(\"people\")\n",
    "pandaFriends = hiveCtx.sql(\"SELECT name FROM people WHERE favouriteAnimal = \\\"panda\\\"\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Dataframes: 'import' data__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Convert an RDD to a DF - use toDF() OR use inferSchema()\n",
    "df=RDD.toDF()\n",
    "df=RDD.inferSchema()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# refer to hive metastore\n",
    "from pyspark.sql import HiveContext\n",
    "\n",
    "hiveCtx = HiveContext(sc)\n",
    "rows = hiveCtx.sql(\"SELECT key, value FROM mytable\")\n",
    "keys = rows.map(lambda row: row[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# load from Parquet\n",
    "rows = hiveCtx.parquetFile(parquetFile)\n",
    "names = rows.map(lambda row: row.name)\n",
    "print \"Everyone\"\n",
    "print names.collect()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Using Hive metadata store\n",
    "\n",
    "    hiveContext.sql(\"\n",
    "\n",
    "        CREATE EXTERNAL TABLE IF NOT EXISTS adult3\n",
    "           (\n",
    "             idx             INT,\n",
    "             age             INT,\n",
    "             workclass       STRING,\n",
    "             fnlwgt          INT,\n",
    "             education       STRING,\n",
    "             educationnum    INT,\n",
    "             maritalstatus   STRING,\n",
    "             occupation      STRING,\n",
    "             relationship    STRING,\n",
    "             race            STRING,\n",
    "             gender          STRING,\n",
    "             capitalgain     INT,\n",
    "             capitalloss     INT,\n",
    "             nativecountry   STRING,\n",
    "             income          STRING\n",
    "           )\n",
    "           ROW FORMAT DELIMITED FIELDS TERMINATED BY ','\n",
    "           LOCATION '/data/spark/hive'\n",
    "\n",
    "                   \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## \"Registering\" a table so can use HiveSQL on it [registed in Hive Metadata ?]\n",
    "\n",
    "input = hiveCtx.jsonFile(inputFile)\n",
    "\n",
    "# Register the input schema RDD\n",
    "input.registerTempTable(\"tweets\")\n",
    "\n",
    "# Select tweets based on the retweetCount\n",
    "topTweets = hiveCtx.sql(\"\"\"SELECT text, retweetCount  FROM\n",
    "  tweets ORDER BY retweetCount LIMIT 10\"\"\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Various methods of \"import\" = point to data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Export"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using local python libraries for, say, plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "%pylab inline\n",
    "import numpy as np\n",
    "import matplotlib.mlab as mlab\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ParallelCollectionRDD[78] at parallelize at PythonRDD.scala:391 [76.28950775529303, 106.81330764302135, 105.47709593691775, 101.10762470261832, 95.167947143382221]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEACAYAAABcXmojAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nIElqGQqSpJahIElq/X/IX+u/Bn9L5AAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x105c08f90>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Example 1: feeding RDD into matplotlib\n",
    "# create random data\n",
    "mu = 100  # mean of distribution\n",
    "sigma = 15  # standard deviation of distribution\n",
    "x = mu + sigma * np.random.randn(10000)\n",
    "\n",
    "# now distribute as RDD\n",
    "rdd = sc.parallelize(x)\n",
    "print rdd, rdd.take(5)\n",
    "\n",
    "# show histogram: created by collect()ing RDD to local\n",
    "num_bins = 50\n",
    "n, bins, patches = plt.hist(rdd.collect(), num_bins, normed=1, facecolor='green', alpha=0.5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DataFrame[pclass: string, survived: string, name: string, sex: string, age: string, sibsp: float, parch: string, ticket: string, fare: float, cabin: string, embarked: string, boat: string, body: string, home.dest: string]\n",
      "+------+--------+--------------------+------+---+-----+-----+--------+-------+-------+--------+----+----+---------------+\n",
      "|pclass|survived|                name|   sex|age|sibsp|parch|  ticket|   fare|  cabin|embarked|boat|body|      home.dest|\n",
      "+------+--------+--------------------+------+---+-----+-----+--------+-------+-------+--------+----+----+---------------+\n",
      "|     2|       0|\"Campbell, Mr. Wi...|  male|   |  0.0|    0|  239853|    0.0|       |       S|    |    |        Belfast|\n",
      "|     3|       1|\"O'Leary, Miss. H...|female|   |  0.0|    0|  330919| 7.8292|       |       Q|  13|    |               |\n",
      "|     3|       1|\"Masselmani, Mrs....|female|   |  0.0|    0|    2649|  7.225|       |       C|   C|    |               |\n",
      "|     1|       1|\"Carter, Mrs. Wil...|female| 36|  1.0|    2|  113760|  120.0|B96 B98|       S|   4|    |\"Bryn Mawr, PA\"|\n",
      "|     1|       1|\"Cumings, Mrs. Jo...|female| 38|  1.0|    0|PC 17599|71.2833|    C85|       C|   4|    | \"New York, NY\"|\n",
      "+------+--------+--------------------+------+---+-----+-----+--------+-------+-------+--------+----+----+---------------+\n",
      "only showing top 5 rows\n",
      "\n",
      "None\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAF/CAYAAABOhqJZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nfyjinOtU6t0YAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1072f3f50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Example 2: converting Spark DataFrame to Pandas for plotting\n",
    "# read in tab delimited file\n",
    "titanicRdd = sc.textFile('titanic.txt')    #.map(lambda x:x.split('\\t'))\n",
    "#print titanicRdd.take(5)\n",
    "\n",
    "# take header\n",
    "header = titanicRdd.first()\n",
    "\n",
    "# build schema - set all to be strings then manually change a few\n",
    "fields = [StructField(field_name, StringType(), True) for field_name in header.split('\\t')]\n",
    "fields[5].dataType = FloatType()\n",
    "fields[8].dataType = FloatType()\n",
    "schema = StructType(fields)\n",
    "\n",
    "# 1. remove header from data - must parallelize or header is local only. Also, must be header into [] list\n",
    "# 2. split delimiter and convert columns to correct datatypes\n",
    "# 3. replace missings from float columns - note nifty use of 'or'\n",
    "# 4. Convert unicode strings to correct data types\n",
    "titanicRddNoHeader = titanicRdd.subtract(sc.parallelize([header]))\\\n",
    "                                .map(lambda x:x.split('\\t'))\\\n",
    "                                .map(lambda row: (row[0], row[1], row[2], row[3], row[4], float(row[5] or 0), row[6], row[7],\\\n",
    "                                                  float(row[8] or 0), row[9], row[10], row[11], row[12], row[13]) )\n",
    "# titanicRddNoHeader.take(5)\n",
    "\n",
    "# convert to dataframe with schema. Split out tab-delimiter as we go\n",
    "titanicdf = sqlContext.createDataFrame(titanicRddNoHeader, schema)\n",
    "print titanicdf\n",
    "print titanicdf.show(5)\n",
    "\n",
    "# now, convert to local pandas dataframe, and use pandas plotting\n",
    "titanicPandas = titanicdf.toPandas()\n",
    "\n",
    "from pandas.tools.plotting import scatter_matrix\n",
    "stuff, plot = scatter_matrix(titanicPandas, alpha=0.2, figsize=(6, 6), diagonal='kde')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: pylab import has clobbered these variables: ['random']\n",
      "`%matplotlib` prevents importing * from pylab and numpy\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAEACAYAAACuzv3DAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nrkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x105f21550>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%pylab inline\n",
    "import random\n",
    "\n",
    "# create an RDD of 100 random numbers\n",
    "x = [random.normalvariate(0,1) for i in range(100)]\n",
    "rdd = sc.parallelize(x)\n",
    "\n",
    "# plot data in RDD - use .collect() to bring data to local \n",
    "num_bins = 50\n",
    "n, bins, patches = plt.hist(rdd.collect(), num_bins, normed=1, facecolor='green', alpha=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAGCCAYAAADt+sSJAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10ad2f490>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# create a spark dataframe with 3 numeric columns and one categorical (colour)\n",
    "A = [random.normalvariate(0,1) for i in range(100)]\n",
    "B = [random.normalvariate(1,2) for i in range(100)]\n",
    "C = [random.normalvariate(-1,0.5) for i in range(100)]\n",
    "col = [random.choice(['#e41a1c', '#377eb8','#4eae4b']) for i in range(100)]\n",
    "\n",
    "df = sqlCtx.createDataFrame(zip(A,B,C,col), [\"A\",\"B\",\"C\",\"col\"])\n",
    "\n",
    "# convert to pandas and plot\n",
    "pdf = df.toPandas()\n",
    "\n",
    "from pandas.tools.plotting import scatter_matrix\n",
    "stuff = scatter_matrix(pdf, alpha=0.7, figsize=(6, 6), diagonal='kde', color=pdf.col)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'int' object has no attribute 'collect'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-4-ec0e8cc3ddb0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mnums\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparallelize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mnums\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreduce\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcollect\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'int' object has no attribute 'collect'"
     ]
    }
   ],
   "source": [
    "nums = sc.parallelize([1, 2, 3, 4])\n",
    "nums.reduce(lambda x,y: x+y)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}