ProjectEventDetection.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Tweets\n",
    "\n",
    "A tweet consists of many data fields. [Here is an example](https://gist.github.com/arapat/03d02c9b327e6ff3f6c3c5c602eeaf8b). You can learn all about them in the Twitter API doc. We are going to briefly introduce only the data fields that will be used in this homework.\n",
    "\n",
    "* `created_at`: Posted time of this tweet (time zone is included)\n",
    "* `id_str`: Tweet ID - we recommend using `id_str` over using `id` as Tweet IDs, becauase `id` is an integer and may bring some overflow problems.\n",
    "* `text`: Tweet content\n",
    "* `user`: A JSON object for information about the author of the tweet\n",
    "    * `id_str`: User ID\n",
    "    * `name`: User name (may contain spaces)\n",
    "    * `screen_name`: User screen name (no spaces)\n",
    "* `retweeted_status`: A JSON object for information about the retweeted tweet (i.e. this tweet is not original but retweeteed some other tweet)\n",
    "    * All data fields of a tweet except `retweeted_status`\n",
    "* `entities`: A JSON object for all entities in this tweet\n",
    "    * `hashtags`: An array for all the hashtags that are mentioned in this tweet\n",
    "    * `urls`: An array for all the URLs that are mentioned in this tweet\n",
    "\n",
    "\n",
    "## Data source\n",
    "\n",
    "All tweets are collected using the [Twitter Streaming API](https://dev.twitter.com/streaming/overview).\n",
    "\n",
    "\n",
    "## Users partition\n",
    "\n",
    "Besides the original tweets, we will provide you with a Pickle file, which contains a partition over 452,743 Twitter users. It contains a Python dictionary `{user_id: partition_id}`. The users are partitioned into 7 groups."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 0: Load data to a RDD"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The tweets data is stored on AWS S3. We have in total a little over 1 TB of tweets. We provide 10 MB of tweets for your local development. For the testing and grading on the homework server, we will use different data.\n",
    "\n",
    "## Testing on the homework server\n",
    "In the Playground, we provide three different input sizes to test your program: 1 GB, 10 GB, and 100 GB. To test them, read files list from `../Data/hw2-files-1gb.txt`, `../Data/hw2-files-5gb.txt`, `../Data/hw2-files-20gb.txt`, respectively.\n",
    "\n",
    "For final submission, make sure to read files list from `../Data/hw2-files-final.txt`. Otherwise your program will receive no points.\n",
    "\n",
    "## Local test\n",
    "\n",
    "For local testing, read files list from `../Data/hw2-files.txt`.\n",
    "Now let's see how many lines there are in the input files.\n",
    "\n",
    "1. Make RDD from the list of files in `hw2-files.txt`.\n",
    "2. Mark the RDD to be cached (so in next operation data will be loaded in memory) \n",
    "3. call the `print_count` method to print number of lines in all these files\n",
    "\n",
    "It should print\n",
    "```\n",
    "Number of elements: 2193\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "%pylab inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Your code here\n",
    "with open('../Data/hw2-files.txt') as f:\n",
    "    files = [l.strip() for l in f.readlines()]\n",
    "rdd1 = sc.textFile(','.join(files)).cache()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 1: Parse JSON strings to JSON objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has built-in support for JSON.\n",
    "\n",
    "**UPDATE:** Python built-in json library is too slow. In our experiment, 70% of the total running time is spent on parsing tweets. Therefore we recommend using [ujson](https://pypi.python.org/pypi/ujson) instead of json. It is at least 15x faster than the built-in json library according to our tests."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{u'id': 1,\n",
       " u'name': u'A green door',\n",
       " u'price': 12.5,\n",
       " u'tags': [u'home', u'green']}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import ujson\n",
    "\n",
    "json_example = '''\n",
    "{\n",
    "    \"id\": 1,\n",
    "    \"name\": \"A green door\",\n",
    "    \"price\": 12.50,\n",
    "    \"tags\": [\"home\", \"green\"]\n",
    "}\n",
    "'''\n",
    "\n",
    "json_obj = ujson.loads(json_example)\n",
    "json_obj"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Broken tweets and irrelevant messages\n",
    "\n",
    "The data of this assignment may contain broken tweets (invalid JSON strings). So make sure that your code is robust for such cases.\n",
    "\n",
    "In addition, some lines in the input file might not be tweets, but messages that the Twitter server sent to the developer (such as [limit notices](https://dev.twitter.com/streaming/overview/messages-types#limit_notices)). Your program should also ignore these messages.\n",
    "\n",
    "*Hint:* [Catch the ValueError](http://stackoverflow.com/questions/11294535/verify-if-a-string-is-json-in-python)\n",
    "\n",
    "\n",
    "(1) Parse raw JSON tweets to obtain valid JSON objects. From all valid tweets, construct a pair RDD of `(user_id, text)`, where `user_id` is the `id_str` data field of the `user` dictionary (read [Tweets](#Tweets) section above), `text` is the `text` data field."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import ujson\n",
    "\n",
    "def safe_parse(x):\n",
    "    try:\n",
    "        json_object = ujson.loads(x)\n",
    "    except ValueError, e:\n",
    "        pass # invalid json\n",
    "    else:\n",
    "        return json_object\n",
    "\n",
    "# your code here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2143"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rdd2 = rdd1.filter(lambda x: 'user' in x and 'id_str' in x and 'text' in x).map(safe_parse)\\\n",
    "        .map(lambda x:  x['text'].encode('utf-8')).cache()\n",
    "rdd2.count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Remove Punctuation Stopwords And Strip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[u'demdefend',\n",
       "  u'berniesand',\n",
       "  u'lordalmighty12',\n",
       "  u'',\n",
       "  u'hillaryclinton',\n",
       "  u'what',\n",
       "  u'get',\n",
       "  u'politician',\n",
       "  u'corrupt',\n",
       "  u'good',\n",
       "  u'one'],\n",
       " [u'ncaa', u'need', u'suspend', u'bitch', u'grayson', u'allen', u'']]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## removing punctuation stopwords and https\n",
    "import string\n",
    "import nltk\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.stem import PorterStemmer\n",
    "stop_words =set(stopwords.words(\"english\"))\n",
    "stop_words|=set([\"edu\", \"com\", \"also\", \"still\", \"anyone\", \"cc\" , \"ca\", \"us\", \"much\", \"even\", \"would\", \"see\", \"rt\", 'is', 'of'])\n",
    "st = PorterStemmer()\n",
    "\n",
    "#IMP: Put yout nltk_data folder in /usr/local/share for it to work :)\n",
    "\n",
    "def getwords(tweet):\n",
    "    return [st.stem(x) for x in tweet if not ( x.startswith('https') or x in stop_words or x is '')]\n",
    "\n",
    "table = string.maketrans(\" \", \" \")  ##TODO empty word\n",
    "tweetNeat = rdd2.map(lambda s: s.translate(table, string.punctuation)).map(lambda s: s.lower())\\\n",
    "            .map(lambda s: getwords(s.decode('utf-8').strip().split(\" \"))).filter(lambda x: len(x)>0)\n",
    "tweetNeat.take(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Make Dictionary of Words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "## make dictionary \n",
    "vocab = tweetNeat.flatMap(lambda x: x).distinct().collect()\n",
    "V = len(vocab)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Histogram of Words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "## Annotate words\n",
    "\n",
    "tweetHist = tweetNeat.map(lambda s: array([vocab.index(x) for x in s]))\\\n",
    "                    .map(lambda x: bincount(x, minlength=len(vocab)))\n",
    "N = tweetHist.count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 2 : Gibbs Sampler for Naive Bayes\n",
    "Naive Bayes:\\\\ \n",
    "//Prior\n",
    "• For each latent class c ∈ {1,...,K} \n",
    "    • θ(c) ∼ Dirichlet(α)\n",
    "• π ∼ Dirichlet(β) //Likelihood\n",
    "• For each document d ∈ {1,...,N}\n",
    "    • Document latent class z(d) ∼ discrete(π) \n",
    "    • For each word i in document d\n",
    "        • w(d) ∼ discrete(θ(z(d))) //Sample a word i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def sampleFromDiscrete(probs):\n",
    "    temp = random.random()\n",
    "    total =0\n",
    "    for i in range(len(probs)):\n",
    "        total+=probs[i]\n",
    "        if(temp<total):\n",
    "            return i\n",
    "    return -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "K=15 # NO of classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def gibbs_sampler():\n",
    "    doc_vectors = tweetHist.collect()\n",
    "    no_tweets = N\n",
    "    alpha = np.ones(V)*0.1 #hyperparameter\n",
    "    A = [alpha]*K\n",
    "    beta = np.ones(K)\n",
    "    pi = np.random.dirichlet(beta)\n",
    "    pi1=pi\n",
    "    theta = np.random.dirichlet(alpha, K)\n",
    "    print(pi)\n",
    "    z = np.array([sampleFromDiscrete(pi) for i in range(no_tweets)])\n",
    "\n",
    "    for i in range(200):\n",
    "        pi = np.random.dirichlet(beta + np.bincount(z))\n",
    "        sum = np.zeros((K, V))\n",
    "        for i in range(no_tweets):\n",
    "            sum[z[i]]+=doc_vectors[i]\n",
    "\n",
    "        for i in range(K):\n",
    "            theta[i] = np.random.dirichlet(A[i]+sum[i])\n",
    "        for d in range(no_tweets):\n",
    "            for i in range(K):\n",
    "                pi1[i]= np.dot(np.log(theta[i]),doc_vectors[d])+ np.log(pi[i])\n",
    "            max_pi = np.max(pi1)\n",
    "            for i in range(K):\n",
    "                pi1[i]-= max_pi\n",
    "                pi1[i] = np.exp(pi1[i])\n",
    "            norm = np.sum(pi1)\n",
    "            for i in range(K):\n",
    "                pi1[i]/= norm\n",
    "            z[d]=sampleFromDiscrete(pi1)\n",
    "        print z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.04149974  0.01908184  0.00542317  0.036769    0.18199069  0.11886851\n",
      "  0.04589672  0.1800046   0.04426902  0.02419871  0.01587578  0.04474824\n",
      "  0.01634503  0.0264644   0.19856454]\n",
      "[ 4  7 13 ...,  5 14  4]\n",
      "[ 4  7 13 ...,  5 14  4]\n",
      "[ 4  7 13 ...,  5 14  4]\n",
      "[ 4  7  6 ...,  5 14  4]\n",
      "[ 4  7  6 ...,  5 14  4]\n",
      "[ 4  7  6 ...,  5 14  4]\n",
      "[ 4  7  6 ...,  5 14  4]\n",
      "[ 4  7  6 ...,  5 14  4]\n",
      "[ 4  7  6 ...,  5 14  4]\n",
      "[ 4  7  6 ...,  5 14  4]\n",
      "[ 8  7  6 ...,  5 14  4]\n",
      "[ 8  7  6 ...,  5 14  4]\n",
      "[ 8  7  6 ...,  5 14  4]\n",
      "[ 8  7  6 ...,  5 14  4]\n",
      "[ 8  7  6 ...,  5 14  4]\n",
      "[ 8  7  6 ...,  5 14  4]\n",
      "[ 8  7  6 ...,  5 14  4]\n",
      "[ 8  7  6 ...,  5 14  4]\n",
      "[ 8  7  6 ...,  5 14  4]\n",
      "[ 8  7  6 ...,  5 14  4]\n",
      "[ 8  7  6 ...,  5 14  4]\n",
      "[ 8  7  6 ...,  5 14  4]\n",
      "[ 8  7  6 ...,  5 14  4]\n",
      "[ 8  7  6 ...,  5 14  4]\n",
      "[ 8  7  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  7]\n",
      "[ 8  0  6 ...,  5 14  7]\n",
      "[ 8  0  6 ...,  5 14  7]\n",
      "[ 8  0  6 ...,  5 14  7]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 8  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  7]\n",
      "[ 4  0  6 ...,  5 14  7]\n",
      "[ 4  0  6 ...,  5 14  7]\n",
      "[ 4  0  6 ...,  5 14  7]\n",
      "[ 4  0  6 ...,  5 14  7]\n",
      "[ 4  0  6 ...,  5 14  7]\n",
      "[ 4  0  6 ...,  5 14  7]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  4]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 4  0  6 ...,  5 14  0]\n",
      "[ 7  0  6 ...,  5 14  0]\n",
      "[ 7  0  6 ...,  5 14  0]\n",
      "[ 7  0  6 ...,  5 14  0]\n",
      "[ 7  0  6 ...,  5 14  0]\n",
      "[ 7  0  6 ...,  5 14  0]\n",
      "[ 7  0  6 ...,  5 14  0]\n",
      "[ 7  0  6 ...,  5 14  0]\n",
      "[ 7  0  6 ...,  5 14  0]\n",
      "[ 7  0  6 ...,  5 14  0]\n",
      "[ 7  0  6 ...,  5 14  0]\n",
      "[14  0  6 ...,  5 14  0]\n",
      "[14  0  6 ...,  5 14  0]\n",
      "[14  0  6 ...,  5 14  0]\n",
      "[14  0  6 ...,  5 14 14]\n",
      "[14  0  6 ...,  5 14 14]\n",
      "[14  0  6 ...,  5 14 14]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n",
      "[14  0  6 ...,  5 14  4]\n"
     ]
    }
   ],
   "source": [
    "gibbs_sampler()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 2: Number of posts from each user partition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the Pickle file `../Data/users-partition.pickle`, you will get a dictionary which represents a partition over 452,743 Twitter users, `{user_id: partition_id}`. The users are partitioned into 7 groups. For example, if the dictionary is loaded into a variable named `partition`, the partition ID of the user `59458445` is `partition[\"59458445\"]`. These users are partitioned into 7 groups. The partition ID is an integer between 0-6.\n",
    "\n",
    "Note that the user partition we provide doesn't cover all users appear in the input data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(1) Load the pickle file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# your code here\n",
    "import pickle\n",
    "file_Name = '../Data/users-partition.pickle'\n",
    "fileObject = open(file_Name,'r')  \n",
    "b = pickle.load(fileObject) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(2) Count the number of posts from each user partition\n",
    "\n",
    "Count the number of posts from group 0, 1, ..., 6, plus the number of posts from users who are not in any partition. Assign users who are not in any partition to the group 7.\n",
    "\n",
    "Put the results of this step into a pair RDD `(group_id, count)` that is sorted by key."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# your code here\n",
    "default = 7\n",
    "counts_id = rdd2.map(lambda x: (b.get( x[0], default), 1))\\\n",
    "                .reduceByKey(lambda x,y:x+y).sortByKey()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(3) Print the post count using the `print_post_count` function we provided.\n",
    "\n",
    "It should print\n",
    "\n",
    "```\n",
    "Group 0 posted 81 tweets\n",
    "Group 1 posted 199 tweets\n",
    "Group 2 posted 45 tweets\n",
    "Group 3 posted 313 tweets\n",
    "Group 4 posted 86 tweets\n",
    "Group 5 posted 221 tweets\n",
    "Group 6 posted 400 tweets\n",
    "Group 7 posted 798 tweets\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def print_post_count(counts):\n",
    "    for group_id, count in counts:\n",
    "        print 'Group %d posted %d tweets' % (group_id, count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Part 3:  Tokens that are relatively popular in each user partition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "In this step, we are going to find tokens that are relatively popular in each user partition.\n",
    "\n",
    "We define the number of mentions of a token $t$ in a specific user partition $k$ as the number of users from the user partition $k$ that ever mentioned the token $t$ in their tweets. Note that even if some users might mention a token $t$ multiple times or in multiple tweets, a user will contribute at most 1 to the counter of the token $t$.\n",
    "\n",
    "Please make sure that the number of mentions of a token is equal to the number of users who mentioned this token but NOT the number of tweets that mentioned this token.\n",
    "\n",
    "Let $N_t^k$ be the number of mentions of the token $t$ in the user partition $k$. Let $N_t^{all} = \\sum_{i=0}^7 N_t^{i}$ be the number of total mentions of the token $t$.\n",
    "\n",
    "We define the relative popularity of a token $t$ in a user partition $k$ as the log ratio between $N_t^k$ and $N_t^{all}$, i.e. \n",
    "\n",
    "\\begin{equation}\n",
    "p_t^k = \\log \\frac{C_t^k}{C_t^{all}}.\n",
    "\\end{equation}\n",
    "\n",
    "\n",
    "You can compute the relative popularity by calling the function `get_rel_popularity`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(0) Load the tweet tokenizer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# %load happyfuntokenizing.py\n",
    "#!/usr/bin/env python\n",
    "\n",
    "\"\"\"\n",
    "This code implements a basic, Twitter-aware tokenizer.\n",
    "\n",
    "A tokenizer is a function that splits a string of text into words. In\n",
    "Python terms, we map string and unicode objects into lists of unicode\n",
    "objects.\n",
    "\n",
    "There is not a single right way to do tokenizing. The best method\n",
    "depends on the application.  This tokenizer is designed to be flexible\n",
    "and this easy to adapt to new domains and tasks.  The basic logic is\n",
    "this:\n",
    "\n",
    "1. The tuple regex_strings defines a list of regular expression\n",
    "   strings.\n",
    "\n",
    "2. The regex_strings strings are put, in order, into a compiled\n",
    "   regular expression object called word_re.\n",
    "\n",
    "3. The tokenization is done by word_re.findall(s), where s is the\n",
    "   user-supplied string, inside the tokenize() method of the class\n",
    "   Tokenizer.\n",
    "\n",
    "4. When instantiating Tokenizer objects, there is a single option:\n",
    "   preserve_case.  By default, it is set to True. If it is set to\n",
    "   False, then the tokenizer will downcase everything except for\n",
    "   emoticons.\n",
    "\n",
    "The __main__ method illustrates by tokenizing a few examples.\n",
    "\n",
    "I've also included a Tokenizer method tokenize_random_tweet(). If the\n",
    "twitter library is installed (http://code.google.com/p/python-twitter/)\n",
    "and Twitter is cooperating, then it should tokenize a random\n",
    "English-language tweet.\n",
    "\n",
    "\n",
    "Julaiti Alafate:\n",
    "  I modified the regex strings to extract URLs in tweets.\n",
    "\"\"\"\n",
    "\n",
    "__author__ = \"Christopher Potts\"\n",
    "__copyright__ = \"Copyright 2011, Christopher Potts\"\n",
    "__credits__ = []\n",
    "__license__ = \"Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License: http://creativecommons.org/licenses/by-nc-sa/3.0/\"\n",
    "__version__ = \"1.0\"\n",
    "__maintainer__ = \"Christopher Potts\"\n",
    "__email__ = \"See the author's website\"\n",
    "\n",
    "######################################################################\n",
    "\n",
    "import re\n",
    "import htmlentitydefs\n",
    "\n",
    "######################################################################\n",
    "# The following strings are components in the regular expression\n",
    "# that is used for tokenizing. It's important that phone_number\n",
    "# appears first in the final regex (since it can contain whitespace).\n",
    "# It also could matter that tags comes after emoticons, due to the\n",
    "# possibility of having text like\n",
    "#\n",
    "#     <:| and some text >:)\n",
    "#\n",
    "# Most imporatantly, the final element should always be last, since it\n",
    "# does a last ditch whitespace-based tokenization of whatever is left.\n",
    "\n",
    "# This particular element is used in a couple ways, so we define it\n",
    "# with a name:\n",
    "emoticon_string = r\"\"\"\n",
    "    (?:\n",
    "      [<>]?\n",
    "      [:;=8]                     # eyes\n",
    "      [\\-o\\*\\']?                 # optional nose\n",
    "      [\\)\\]\\(\\[dDpP/\\:\\}\\{@\\|\\\\] # mouth      \n",
    "      |\n",
    "      [\\)\\]\\(\\[dDpP/\\:\\}\\{@\\|\\\\] # mouth\n",
    "      [\\-o\\*\\']?                 # optional nose\n",
    "      [:;=8]                     # eyes\n",
    "      [<>]?\n",
    "    )\"\"\"\n",
    "\n",
    "# The components of the tokenizer:\n",
    "regex_strings = (\n",
    "    # Phone numbers:\n",
    "    r\"\"\"\n",
    "    (?:\n",
    "      (?:            # (international)\n",
    "        \\+?[01]\n",
    "        [\\-\\s.]*\n",
    "      )?            \n",
    "      (?:            # (area code)\n",
    "        [\\(]?\n",
    "        \\d{3}\n",
    "        [\\-\\s.\\)]*\n",
    "      )?    \n",
    "      \\d{3}          # exchange\n",
    "      [\\-\\s.]*   \n",
    "      \\d{4}          # base\n",
    "    )\"\"\"\n",
    "    ,\n",
    "    # URLs:\n",
    "    r\"\"\"http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+\"\"\"\n",
    "    ,\n",
    "    # Emoticons:\n",
    "    emoticon_string\n",
    "    ,    \n",
    "    # HTML tags:\n",
    "     r\"\"\"<[^>]+>\"\"\"\n",
    "    ,\n",
    "    # Twitter username:\n",
    "    r\"\"\"(?:@[\\w_]+)\"\"\"\n",
    "    ,\n",
    "    # Twitter hashtags:\n",
    "    r\"\"\"(?:\\#+[\\w_]+[\\w\\'_\\-]*[\\w_]+)\"\"\"\n",
    "    ,\n",
    "    # Remaining word types:\n",
    "    r\"\"\"\n",
    "    (?:[a-z][a-z'\\-_]+[a-z])       # Words with apostrophes or dashes.\n",
    "    |\n",
    "    (?:[+\\-]?\\d+[,/.:-]\\d+[+\\-]?)  # Numbers, including fractions, decimals.\n",
    "    |\n",
    "    (?:[\\w_]+)                     # Words without apostrophes or dashes.\n",
    "    |\n",
    "    (?:\\.(?:\\s*\\.){1,})            # Ellipsis dots. \n",
    "    |\n",
    "    (?:\\S)                         # Everything else that isn't whitespace.\n",
    "    \"\"\"\n",
    "    )\n",
    "\n",
    "######################################################################\n",
    "# This is the core tokenizing regex:\n",
    "    \n",
    "word_re = re.compile(r\"\"\"(%s)\"\"\" % \"|\".join(regex_strings), re.VERBOSE | re.I | re.UNICODE)\n",
    "\n",
    "# The emoticon string gets its own regex so that we can preserve case for them as needed:\n",
    "emoticon_re = re.compile(regex_strings[1], re.VERBOSE | re.I | re.UNICODE)\n",
    "\n",
    "# These are for regularizing HTML entities to Unicode:\n",
    "html_entity_digit_re = re.compile(r\"&#\\d+;\")\n",
    "html_entity_alpha_re = re.compile(r\"&\\w+;\")\n",
    "amp = \"&amp;\"\n",
    "\n",
    "######################################################################\n",
    "\n",
    "class Tokenizer:\n",
    "    def __init__(self, preserve_case=False):\n",
    "        self.preserve_case = preserve_case\n",
    "\n",
    "    def tokenize(self, s):\n",
    "        \"\"\"\n",
    "        Argument: s -- any string or unicode object\n",
    "        Value: a tokenize list of strings; conatenating this list returns the original string if preserve_case=False\n",
    "        \"\"\"        \n",
    "        # Try to ensure unicode:\n",
    "        try:\n",
    "            s = unicode(s)\n",
    "        except UnicodeDecodeError:\n",
    "            s = str(s).encode('string_escape')\n",
    "            s = unicode(s)\n",
    "        # Fix HTML character entitites:\n",
    "        s = self.__html2unicode(s)\n",
    "        # Tokenize:\n",
    "        words = word_re.findall(s)\n",
    "        # Possible alter the case, but avoid changing emoticons like :D into :d:\n",
    "        if not self.preserve_case:            \n",
    "            words = map((lambda x : x if emoticon_re.search(x) else x.lower()), words)\n",
    "        return words\n",
    "\n",
    "    def tokenize_random_tweet(self):\n",
    "        \"\"\"\n",
    "        If the twitter library is installed and a twitter connection\n",
    "        can be established, then tokenize a random tweet.\n",
    "        \"\"\"\n",
    "        try:\n",
    "            import twitter\n",
    "        except ImportError:\n",
    "            print \"Apologies. The random tweet functionality requires the Python twitter library: http://code.google.com/p/python-twitter/\"\n",
    "        from random import shuffle\n",
    "        api = twitter.Api()\n",
    "        tweets = api.GetPublicTimeline()\n",
    "        if tweets:\n",
    "            for tweet in tweets:\n",
    "                if tweet.user.lang == 'en':            \n",
    "                    return self.tokenize(tweet.text)\n",
    "        else:\n",
    "            raise Exception(\"Apologies. I couldn't get Twitter to give me a public English-language tweet. Perhaps try again\")\n",
    "\n",
    "    def __html2unicode(self, s):\n",
    "        \"\"\"\n",
    "        Internal metod that seeks to replace all the HTML entities in\n",
    "        s with their corresponding unicode characters.\n",
    "        \"\"\"\n",
    "        # First the digits:\n",
    "        ents = set(html_entity_digit_re.findall(s))\n",
    "        if len(ents) > 0:\n",
    "            for ent in ents:\n",
    "                entnum = ent[2:-1]\n",
    "                try:\n",
    "                    entnum = int(entnum)\n",
    "                    s = s.replace(ent, unichr(entnum))\t\n",
    "                except:\n",
    "                    pass\n",
    "        # Now the alpha versions:\n",
    "        ents = set(html_entity_alpha_re.findall(s))\n",
    "        ents = filter((lambda x : x != amp), ents)\n",
    "        for ent in ents:\n",
    "            entname = ent[1:-1]\n",
    "            try:            \n",
    "                s = s.replace(ent, unichr(htmlentitydefs.name2codepoint[entname]))\n",
    "            except:\n",
    "                pass                    \n",
    "            s = s.replace(amp, \" and \")\n",
    "        return s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "from math import log\n",
    "\n",
    "tok = Tokenizer(preserve_case=False)\n",
    "\n",
    "def get_rel_popularity(c_k, c_all):\n",
    "    return log(1.0 * c_k / c_all) / log(2)\n",
    "\n",
    "\n",
    "def print_tokens(tokens, gid = None):\n",
    "    group_name = \"overall\"\n",
    "    if gid is not None:\n",
    "        group_name = \"group %d\" % gid\n",
    "    print '=' * 5 + ' ' + group_name + ' ' + '=' * 5\n",
    "    for n, t in tokens:\n",
    "        print \"%s\\t%.4f\" % (t.encode('utf-8'), -n)\n",
    "    print"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(1) Tokenize the tweets using the tokenizer we provided above named `tok`. Count the number of mentions for each tokens regardless of specific user group.\n",
    "\n",
    "Call `print_count` function to show how many different tokens we have.\n",
    "\n",
    "It should print\n",
    "```\n",
    "Number of elements: 8949\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# your code here\n",
    "rdd_token2 = rdd2.mapValues(lambda x: tok.tokenize(x.encode('utf-8')))\\\n",
    "                .reduceByKey(lambda a, b: a+b).mapValues(lambda x: list(set(x)))\\\n",
    "                .map(lambda (c,v): (b.get( c, default),v))\n",
    "rdd_freq= rdd_token2.flatMap(lambda (c, v) : v).map(lambda x: (x,1)).reduceByKey(lambda a,b:a+b)\n",
    "print_count(rdd_freq)\n",
    "#rdd_token2.take(2)\n",
    "rdd_token2.take(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(2) Tokens that are mentioned by too few users are usually not very interesting. So we want to only keep tokens that are mentioned by at least 100 users. Please filter out tokens that don't meet this requirement.\n",
    "\n",
    "Call `print_count` function to show how many different tokens we have after the filtering.\n",
    "\n",
    "Call `print_tokens` function to show top 20 most frequent tokens.\n",
    "\n",
    "It should print\n",
    "```\n",
    "Number of elements: 44\n",
    "===== overall =====\n",
    ":\t1388.0000\n",
    "rt\t1237.0000\n",
    ".\t826.0000\n",
    "…\t673.0000\n",
    "the\t623.0000\n",
    "trump\t582.0000\n",
    "to\t499.0000\n",
    ",\t489.0000\n",
    "a\t404.0000\n",
    "is\t376.0000\n",
    "in\t297.0000\n",
    "of\t292.0000\n",
    "and\t288.0000\n",
    "for\t281.0000\n",
    "!\t269.0000\n",
    "?\t210.0000\n",
    "on\t195.0000\n",
    "i\t192.0000\n",
    "you\t191.0000\n",
    "this\t190.0000\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# your code here\n",
    "rdd_filt = rdd_freq.filter(lambda (c,v): v >=100)\n",
    "freq_sort = rdd_filt.sortBy(lambda x: (-x[1], x[0])).map(lambda (c,v): (-v, c))\n",
    "print_count(rdd_filt)\n",
    "print_tokens(freq_sort.take(20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(3) For all tokens that are mentioned by at least 100 users, compute their relative popularity in each user group. Then print the top 10 tokens with highest relative popularity in each user group. In case two tokens have same relative popularity, break the tie by printing the alphabetically smaller one.\n",
    "\n",
    "**Hint:** Let the relative popularity of a token $t$ be $p$. The order of the items will be satisfied by sorting them using (-p, t) as the key.\n",
    "\n",
    "It should print\n",
    "```\n",
    "===== group 0 =====\n",
    "...\t-3.5648\n",
    "at\t-3.5983\n",
    "hillary\t-4.0875\n",
    "i\t-4.1255\n",
    "bernie\t-4.1699\n",
    "not\t-4.2479\n",
    "https\t-4.2695\n",
    "he\t-4.2801\n",
    "in\t-4.3074\n",
    "are\t-4.3646\n",
    "\n",
    "===== group 1 =====\n",
    "#demdebate\t-2.4391\n",
    "-\t-2.6202\n",
    "&\t-2.7472\n",
    "amp\t-2.7472\n",
    "clinton\t-2.7570\n",
    ";\t-2.7980\n",
    "sanders\t-2.8838\n",
    "?\t-2.9069\n",
    "in\t-2.9664\n",
    "if\t-3.0138\n",
    "\n",
    "===== group 2 =====\n",
    "are\t-4.6865\n",
    "and\t-4.7105\n",
    "bernie\t-4.7549\n",
    "at\t-4.7682\n",
    "sanders\t-4.9542\n",
    "that\t-5.0224\n",
    "in\t-5.0444\n",
    "donald\t-5.0618\n",
    "a\t-5.0732\n",
    "#demdebate\t-5.1396\n",
    "\n",
    "===== group 3 =====\n",
    "#demdebate\t-1.3847\n",
    "bernie\t-1.8480\n",
    "sanders\t-2.1887\n",
    "of\t-2.2356\n",
    "that\t-2.3785\n",
    "the\t-2.4376\n",
    "…\t-2.4403\n",
    "clinton\t-2.4467\n",
    "hillary\t-2.4594\n",
    "be\t-2.5465\n",
    "\n",
    "===== group 4 =====\n",
    "hillary\t-3.7395\n",
    "sanders\t-3.9542\n",
    "of\t-4.0199\n",
    "clinton\t-4.0790\n",
    "at\t-4.1832\n",
    "in\t-4.2143\n",
    "a\t-4.2659\n",
    "on\t-4.2854\n",
    ".\t-4.3681\n",
    "the\t-4.4251\n",
    "\n",
    "===== group 5 =====\n",
    "cruz\t-2.3861\n",
    "he\t-2.6280\n",
    "are\t-2.7796\n",
    "will\t-2.7829\n",
    "the\t-2.8568\n",
    "is\t-2.8822\n",
    "for\t-2.9250\n",
    "that\t-2.9349\n",
    "of\t-2.9804\n",
    "this\t-2.9849\n",
    "\n",
    "===== group 6 =====\n",
    "@realdonaldtrump\t-1.1520\n",
    "cruz\t-1.4532\n",
    "https\t-1.5222\n",
    "!\t-1.5479\n",
    "not\t-1.8904\n",
    "…\t-1.9269\n",
    "will\t-2.0124\n",
    "it\t-2.0345\n",
    "this\t-2.1104\n",
    "to\t-2.1685\n",
    "\n",
    "===== group 7 =====\n",
    "donald\t-0.6422\n",
    "...\t-0.7922\n",
    "sanders\t-1.0282\n",
    "trump\t-1.1296\n",
    "bernie\t-1.2106\n",
    "-\t-1.2253\n",
    "you\t-1.2376\n",
    "clinton\t-1.2511\n",
    "if\t-1.2880\n",
    "i\t-1.2996\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# your code here\n",
    "rdd_group= rdd_token2.flatMapValues(lambda v : v).map(lambda (c,v): (v,c))\\\n",
    "            .map(lambda x: (x,1)).reduceByKey(lambda a,b:a+b)\n",
    "#rdd_group.take(5)\n",
    "def getKey(item):\n",
    "    return item[1]\n",
    "#, key=getKey, reverse=True\n",
    "\n",
    "rdd_joined = rdd_filt.join(rdd_group.map(lambda ((t, w), u): (t, (w,u))))\\\n",
    "              .map(lambda (t, (v, (w, u))): ((t, w), (u, v)))\n",
    "rdd_grouped = rdd_joined.mapValues(lambda x: log(1.0 * x[0] / x[1]) / log(2))\\\n",
    "                   .map(lambda ((t, w), u): (w, (-u,t))).groupByKey()\\\n",
    "                    .mapValues(lambda x: sorted(x))\n",
    "        #.mapValues(lambda (c,v): (v, -c))\n",
    "#rdd_grouped.take(8)        \n",
    "for n in range(8):\n",
    "    print_tokens(rdd_grouped.collectAsMap()[n][0:10],n)\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "(4) (optional, not for grading) The users partition is generated by a machine learning algorithm that tries to group the users by their political preferences. Three of the user groups are showing supports to Bernie Sanders, Ted Cruz, and Donald Trump. \n",
    "\n",
    "If your program looks okay on the local test data, you can try it on the larger input by submitting your program to the homework server. Observe the output of your program to larger input files, can you guess the partition IDs of the three groups mentioned above based on your output?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# Change the values of the following three items to your guesses\n",
    "\n",
    "users_support = [\n",
    "    (-1, \"Bernie Sanders\"),\n",
    "    (-1, \"Ted Cruz\"),\n",
    "    (-1, \"Donald Trump\")\n",
    "]\n",
    "\n",
    "for gid, candidate in users_support:\n",
    "    print \"Users from group %d are most likely to support %s.\" % (gid, candidate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}