viral_tweets.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Off-Platform Project: Viral Tweets\n",
    "\n",
    "In this project, we are going to use the K-Nearest Neighbor algorithm to predict whether a tweet will go viral. Before jumping into using the classifier, let's first consider the problem we're trying to solve. Which features of a tweet are most closely linked to its popularity? Maybe the number of hashtags or the number of links in the tweet strongly influences its popularity. Maybe its virality is dependent on how many followers the person has. Maybe it's something more subtle like the specific language used in the tweets.\n",
    "\n",
    "Let's explore these options by looking at the data we have available to us. We've imported the dataset and printed the following information:\n",
    "\n",
    "* The total number of tweets in the dataset.\n",
    "* The columns, or features, of the dataset.\n",
    "* The text of the first tweet in the dataset.\n",
    "\n",
    "Some of these features are dictionaries. For example, the feature `\"user\"` is a dictionary. We might want to use some of the information found in these sub-dictionaries. Print `all_tweets.loc[0][\"user\"]` to see what the `\"user\"` feature looks like.\n",
    "\n",
    "After printing that, try printing just the `\"location\"` found in that `\"user\"` dictionary. For example, `all_tweets.loc[0][\"user\"][\"screen_name\"]` would give you only the screen name associated with the first tweet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11099\n",
      "Index(['created_at', 'id', 'id_str', 'text', 'truncated', 'entities',\n",
      "       'metadata', 'source', 'in_reply_to_status_id',\n",
      "       'in_reply_to_status_id_str', 'in_reply_to_user_id',\n",
      "       'in_reply_to_user_id_str', 'in_reply_to_screen_name', 'user', 'geo',\n",
      "       'coordinates', 'place', 'contributors', 'retweeted_status',\n",
      "       'is_quote_status', 'retweet_count', 'favorite_count', 'favorited',\n",
      "       'retweeted', 'lang', 'possibly_sensitive', 'quoted_status_id',\n",
      "       'quoted_status_id_str', 'extended_entities', 'quoted_status',\n",
      "       'withheld_in_countries'],\n",
      "      dtype='object')\n",
      "RT @KWWLStormTrack7: We are more than a month into summer but the days are getting shorter. The sunrise is about 25 minutes later on July 3…\n",
      "{'id': 145388018, 'id_str': '145388018', 'name': 'Derek Wolkenhauer', 'screen_name': 'derekw221', 'location': 'Waterloo, Iowa', 'description': '', 'url': None, 'entities': {'description': {'urls': []}}, 'protected': False, 'followers_count': 215, 'friends_count': 335, 'listed_count': 2, 'created_at': 'Tue May 18 21:30:10 +0000 2010', 'favourites_count': 3419, 'utc_offset': None, 'time_zone': None, 'geo_enabled': True, 'verified': False, 'statuses_count': 4475, 'lang': 'en', 'contributors_enabled': False, 'is_translator': False, 'is_translation_enabled': False, 'profile_background_color': '022330', 'profile_background_image_url': 'http://abs.twimg.com/images/themes/theme15/bg.png', 'profile_background_image_url_https': 'https://abs.twimg.com/images/themes/theme15/bg.png', 'profile_background_tile': False, 'profile_image_url': 'http://pbs.twimg.com/profile_images/995790590276243456/cgxRVviN_normal.jpg', 'profile_image_url_https': 'https://pbs.twimg.com/profile_images/995790590276243456/cgxRVviN_normal.jpg', 'profile_banner_url': 'https://pbs.twimg.com/profile_banners/145388018/1494937921', 'profile_link_color': '0084B4', 'profile_sidebar_border_color': 'A8C7F7', 'profile_sidebar_fill_color': 'C0DFEC', 'profile_text_color': '333333', 'profile_use_background_image': True, 'has_extended_profile': True, 'default_profile': False, 'default_profile_image': False, 'following': False, 'follow_request_sent': False, 'notifications': False, 'translator_type': 'none'}\n",
      "Waterloo, Iowa\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "all_tweets = pd.read_json(\"random_tweets.json\", lines=True)\n",
    "\n",
    "print(len(all_tweets))\n",
    "print(all_tweets.columns)\n",
    "print(all_tweets.loc[0]['text'])\n",
    "\n",
    "#Print the user here and the user's location here.\n",
    "print(all_tweets.loc[0][\"user\"])\n",
    "print(all_tweets.loc[0][\"user\"][\"location\"])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Defining Viral Tweets\n",
    "\n",
    "A K-Nearest Neighbor classifier is a supervised machine learning algorithm, and as a result, we need to have a dataset with tagged labels. For this specific example, we need a dataset where every tweet is marked as viral or not viral. Unfortunately, this isn't a feature of our dataset &mdash; we'll need to make it ourselves.\n",
    "\n",
    "So how do we define a viral tweet? A good place to start is to look at the number of retweets the tweet has. This can be found using the feature `\"retweet_count\"`. Let's say we wanted to create a column called `is_viral` that is a `1` if the tweet had more than `5` retweets and `0` otherwise. We could do that like this:\n",
    "\n",
    "```py\n",
    "all_tweets['is_viral'] = np.where(all_tweets['retweet_count'] > 5, 1, 0)\n",
    "```\n",
    "\n",
    "Instead of using `5` as the benchmark for a viral tweet, let's use the median number of retweets. You can find that by calling the `median()` function on `all_tweets[\"retweet_count\"]`. Print the median number of retweets to understand what this threshold is.\n",
    "\n",
    "Print the number of viral tweets and non-viral tweets. You can do this using `all_tweets['is_viral'].value_counts()`.\n",
    "\n",
    "After finishing this project, consider coming back and playing with this threshold number. How do you think your model would work if it was trying to find incredibly viral tweets? For example, how would it work if it were looking for tweets with 1000 or more retweets?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13.0\n",
      "1    5591\n",
      "0    5508\n",
      "Name: is_viral, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "median_retweets = all_tweets['retweet_count'].median()\n",
    "print(median_retweets)\n",
    "all_tweets['is_viral'] = np.where(all_tweets['retweet_count'] >= median_retweets, 1, 0)\n",
    "print(all_tweets['is_viral'].value_counts())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Making Features\n",
    "\n",
    "Now that we've created a label for every tweet in our dataset, we can begin thinking about which features might determine whether a tweet is viral. We can create new columns in our dataset to represent these features. For example, let's say we think the length of a tweet might be a valuable feature. The following line creates a new column containing the length of the tweet.\n",
    "\n",
    "```py\n",
    "all_tweets['tweet_length'] = all_tweets.apply(lambda tweet: len(tweet['text']), axis=1)\n",
    "```\n",
    "\n",
    "Setting `axis = 1` creates a new column rather than a new row.\n",
    "\n",
    "Create a new column called `followers_count` that contains the number of followers of each user. You can find this information in `tweet['user']['followers_count']`. Do the same for `friends_count`.\n",
    "\n",
    "For the rest of this project, we will be using these three features, but we encourage you to create your own. Here are some potential ideas for more features.\n",
    "\n",
    "* The number of hashtags in the tweet. You can find this by looking at the `text` of the tweet and using the `.count()` function with `#` as a parameter.\n",
    "* The number of links in the tweet. Using a similar strategy to the one above, use `.count()` to count the number of times `http` appears in the tweet.\n",
    "* The number of words in the tweet. Call `.split()` on the `text` of a tweet. This will give you a list of the words in the tweet. Find the length of that list.\n",
    "* The average length of the words in the tweet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_tweets['tweet_length'] = all_tweets.apply(lambda tweet: len(tweet['text']), axis=1)\n",
    "all_tweets['followers_count'] = all_tweets.apply(lambda tweet: tweet['user']['followers_count'], axis=1)\n",
    "all_tweets['friends_count'] = all_tweets.apply(lambda tweet: tweet['user']['friends_count'], axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Normalizing The Data\n",
    "\n",
    "We've now made the columns that we want to feed into our classifier. Let's get rid of all the data that is no longer relevant. Create a variable named `labels` and set it equal to the `'is_viral'` column of all_tweets.\n",
    "\n",
    "If we had a dataframe named `df` we could get a single column named `A` like this:\n",
    "\n",
    "```py\n",
    "one_column = df['A']\n",
    "```\n",
    "\n",
    "Create a variable named `data` and set it equal to all of the columns that you created in the last step. Those columns are `tweet_length`, `followers_count`, and `friends_count`.\n",
    "\n",
    "When selecting multiple columns, the names of the columns should be in a list. Check out the example below to see how to select column `A` *and* `B`:\n",
    "\n",
    "```py\n",
    "features = df[['A', 'B']]\n",
    "```\n",
    "\n",
    "Now create a new variable named `scaled_data`. `scaled_data` should be the result of the `scale` function with `data` as a parameter. Also include the parameter `axis = 0`. This scales the *columns* as opposed to the rows.\n",
    "\n",
    "The scale function will normalize the data so all of the features will vary within the same range.\n",
    "\n",
    "Print `scaled_data[0]` to get a sense of what our data looks like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.6164054  -0.02878298 -0.14483305]\n"
     ]
    }
   ],
   "source": [
    "from sklearn.preprocessing import scale\n",
    "\n",
    "labels = all_tweets['is_viral']\n",
    "data = all_tweets[['tweet_length','followers_count','friends_count']]\n",
    "scaled_data = scale(data, axis=0)\n",
    "\n",
    "print(scaled_data[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating the Training Set and Test Set\n",
    "\n",
    "To evaluate the effectiveness of our classifier, we now split `scaled_data` and `labels` into a training set and test set using scikit-learn's `train_test_split` function. This function takes two required parameters: It takes the data, followed by the labels. Set the optional parameter `test_size` to be `0.2`. You can also set the `random_state` parameter so your code will randomly split the data in the same way as our solution code splits the data. We used `random_state = 1`. Remember, this function returns 4 items in this order:\n",
    "\n",
    "1. The training data\n",
    "2. The testing data\n",
    "3. The training labels\n",
    "4. The testing labels\n",
    "\n",
    "Store the results in variables named `train_data`, `test_data`, `train_labels`, and `test_labels`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "train_data, test_data, train_labels, test_labels = train_test_split(scaled_data, labels, test_size = 0.2, random_state = 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using the Classifier\n",
    "\n",
    "We can finally use the K-Nearest Neighbor classifier. Let's test it using `k = 5`. Begin by creating a `KNeighborsClassifier` object named `classifier` with the parameter `n_neighbors` equal to `5`.\n",
    "\n",
    "Next, train `classifier` by calling the `.fit()` method with `train_data` and `train_labels` as parameters.\n",
    "\n",
    "Finally, let's test the model! Call `classifier`'s `.score()` method using `test_data` and `test_labels` as parameters. Print the results.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5905405405405405\n"
     ]
    }
   ],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "classifier = KNeighborsClassifier(n_neighbors = 5)\n",
    "classifier.fit(train_data, train_labels)\n",
    "print(classifier.score(test_data, test_labels))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Choosing K\n",
    "\n",
    "We've tested our classifier with `k = 5`, but maybe there's a `k` that will work better. Let's test many different values for `k` and graph the results. \n",
    "\n",
    "First, create an empty list called `scores`. Next, create a for loop that has a variable `k` that begins at `1` and ends at `200`.\n",
    "\n",
    "Inside the for loop, create a `KNeighobrsClassifier` object named `classifier` with the parameter `n_neighbors` equal to `k`.\n",
    "\n",
    "Train `classifier` by calling the `.fit()` method with `train_data` and `train_labels` as parameters.\n",
    "\n",
    "Next, let's test the model! Call `classifier`'s `.score()` method using `test_data` and `test_labels` as parameters. `append` the result to `scores`.\n",
    "\n",
    "Finally, let's plot the results. Outside of the loop, use Matplotlib's `plot()` function. `plot()` takes two parameters &mdash; the data on the x-axis and the data on the y-axis. Data on the x-axis should be the values we used for `k`. In this case, `range(1,200)`.  Data on the y-axis should be `scores`. Make sure to call the `plt.show()` function after calling `plt.plot()`. This should take a couple of seconds to run!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "scores = []\n",
    "for k in range(1, 200):\n",
    "    classifier = KNeighborsClassifier(n_neighbors = k)\n",
    "    classifier.fit(train_data, train_labels)\n",
    "    scores.append(classifier.score(test_data, test_labels))\n",
    "    \n",
    "plt.plot(range(1,200), scores)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Explore on your own\n",
    "\n",
    "Nice work! You can see the classifier gets better as `k` increases, but as `k` gets too high, underfitting starts to happen.\n",
    "\n",
    "By using the features `tweet_length`, `followers_count`, and `friends_count`, we were able to get up to around 63% accuracy. That is better than random, but still not exceptional. Can you find some different features that perform better? Share your graphs with us on Twitter and maybe it will go viral!"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}