Data_Cleaning_and_Exploration_The_Movie.ipynb

gistfile1.txt

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Cleaning and Exploration: The Movie\n",
    "\n",
    "(Go to the READ.ME of this repository for the entire write-up.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I collected quite a bit of data: 43837 separate movies. The actual cleaning of the data was as tedious and dry as the following paragraphs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "43837"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "import imdb\n",
    "import re\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import ast\n",
    "from datetime import datetime, timedelta\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lost of the data came in lists, such as a list of the first four actors in a film. I had to go through and strip all members of the lists, as well as join lists on pipes to later be separated by my count vectorizer. I wrote a bunch of functions to clean the data, even a few I didn't need. This functions did thing like turn data to floats or create new columns of data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def release_to_datetime(n):\n",
    "    if type(n) == str:\n",
    "        n = n.replace(' Nov ', '-11-').replace(' Jun ', '-6-').replace(' Aug ', '-8-').replace(' Dec ', '-12-')\n",
    "        n = n.replace(' Oct ', '-10-').replace(' Jan ', '-1-').replace(' Feb ', '-2-').replace(' Mar ', '-3-')\n",
    "        n = n.replace(' Apr ', '-4-').replace(' May ', '-5-').replace(' Jul ', '-7-').replace(' Sep ', '-9-')\n",
    "        n = datetime.strptime(n, '%d-%m-%Y').date()\n",
    "        return n\n",
    "    else:\n",
    "        return n\n",
    "\n",
    "def delta_release(n):\n",
    "    y2k = datetime.strptime('01-01-2000', '%d-%m-%Y').date()\n",
    "    try:\n",
    "        m = y2k - n\n",
    "        return m.days\n",
    "    except:\n",
    "        return np.nan\n",
    "\n",
    "def pull_month(n):\n",
    "    try:\n",
    "        return n.month\n",
    "    except:\n",
    "        return np.nan\n",
    "\n",
    "def pull_day(n):\n",
    "    try:\n",
    "        return n.day\n",
    "    except:\n",
    "        return np.nan\n",
    "    \n",
    "def runtime_to_float(x):\n",
    "    try:\n",
    "        return float(x)\n",
    "    except:\n",
    "        return np.nan\n",
    "    \n",
    "def boxoffice_to_float(x):\n",
    "    try:\n",
    "        return float(x.replace(',',\"\").replace(\"$\",\"\"))\n",
    "    except:\n",
    "        return np.nan\n",
    "\n",
    "def RT_pull_out(entry):\n",
    "    for m in entry:\n",
    "        if m['Source'] == 'Rotten Tomatoes':\n",
    "            n = (m['Value'].replace('%', ''))\n",
    "            return(int(n))\n",
    "        else:\n",
    "            return(np.nan)\n",
    "        \n",
    "def evan_train_test_df_cvec_capstone(train, test, min_df):\n",
    "    min_df = min_df\n",
    "    dummy_list_train = []\n",
    "    dummy_list_test = []\n",
    "    for x in train.columns:\n",
    "        cvec = CountVectorizer(binary=True,\n",
    "                               tokenizer=(lambda m: m.split('|') ),\n",
    "                               min_df = min_df,\n",
    "                               stop_words = 'english',\n",
    "                               strip_accents='unicode')\n",
    "        cvec.fit(train['{}'.format(x)])\n",
    "        lonely_matrix_train = cvec.transform(train['{}'.format(x)])\n",
    "        lonely_matrix_test = cvec.transform(test['{}'.format(x)])\n",
    "        df_train = pd.DataFrame(lonely_matrix_train.todense(), columns=cvec.get_feature_names())\n",
    "        df_test = pd.DataFrame(lonely_matrix_test.todense(), columns=cvec.get_feature_names())\n",
    "        dummy_list_train.append(df_train)\n",
    "        dummy_list_test.append(df_test)\n",
    "    dummied_df_train = pd.concat(dummy_list_train, axis=1)\n",
    "    dummied_df_test = pd.concat(dummy_list_test, axis=1)\n",
    "    return dummied_df_train, dummied_df_test\n",
    "\n",
    "def movie_split_and_join(train, test, func, min_df=1):\n",
    "    train_obj = train.select_dtypes(include=[np.object_])\n",
    "    train_num = train.select_dtypes(include=[np.number, np.bool_])\n",
    "    test_obj = test.select_dtypes(include=[np.object_])\n",
    "    test_num = test.select_dtypes(include=[np.number, np.bool_])\n",
    "    train_obj_dums, test_obj_dums = func(train_obj, test_obj, min_df)\n",
    "    train_obj_dums.reset_index(drop=True, inplace=True)\n",
    "    test_obj_dums.reset_index(drop=True, inplace=True)\n",
    "    train_num.reset_index(drop=True, inplace=True)\n",
    "    test_num.reset_index(drop=True, inplace=True)\n",
    "    final_train = pd.concat([train_num, train_obj_dums], axis=1)\n",
    "    final_test = pd.concat([test_num, test_obj_dums], axis=1)\n",
    "    return final_train, final_test\n",
    "\n",
    "def strip_list(column):\n",
    "    for n in column:\n",
    "        for m in range(len(n)):\n",
    "            n[m] = n[m].strip()\n",
    "    return column\n",
    "\n",
    "def put_in_avgs(train, test, df):\n",
    "    ind = 0\n",
    "    for n in train.columns:\n",
    "        for m in list(zip(df.name, df.avgscore)):\n",
    "            if n == m[0]:\n",
    "                train[n] *= m[1]\n",
    "            ind += 1\n",
    "            if ind % 10000 == 0:\n",
    "                print(ind)\n",
    "    ind = 0\n",
    "    for n in test.columns:\n",
    "        for m in list(zip(df.name, df.avgscore)):\n",
    "            if n == m[0]:\n",
    "                test[n] *= m[1]\n",
    "            ind += 1\n",
    "            if ind % 10000 == 0:\n",
    "                print(ind)\n",
    "    print(train.shape)\n",
    "    print(test.shape)\n",
    "    return train, test\n",
    "\n",
    "def single_column_cvec(train, test, min_df):\n",
    "    cvec = CountVectorizer(binary=True,\n",
    "                                   tokenizer=(lambda m: m.split('|') ),\n",
    "                                   min_df = min_df,\n",
    "                                   stop_words = 'english',\n",
    "                                   strip_accents='unicode')\n",
    "    cvec.fit(train)\n",
    "    lonely_matrix_train = cvec.transform(train)\n",
    "    lonely_matrix_test = cvec.transform(test)\n",
    "    new_train = pd.DataFrame(lonely_matrix_train.todense(), columns=cvec.get_feature_names())\n",
    "    new_test = pd.DataFrame(lonely_matrix_test.todense(), columns=cvec.get_feature_names())\n",
    "    return new_train, new_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"new_all_my_movies_final.csv\", converters={\"Actors\": ast.literal_eval, \n",
    "                                                        \"Director\": ast.literal_eval, \n",
    "                                                        \"Genre\": ast.literal_eval, \n",
    "                                                        \"RTRating\": ast.literal_eval, \n",
    "                                                        \"Writer\": ast.literal_eval,\n",
    "                                                        \"Year\": ast.literal_eval})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This following cell contains remnants from what I'll call \"The Actor Average Debacle\" later on in the presentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "award_df = pd.read_csv('meta_award_add_final.csv')\n",
    "writers_df = pd.read_csv('writers_df.csv')\n",
    "actors_df = pd.read_csv('actors_df.csv')\n",
    "directors_df = pd.read_csv('directors_df.csv')\n",
    "# actoravg= pd.read_csv('NewActorAvg.csv') # Plaguing problem \n",
    "# morta_df = pd.read_csv('morta.csv') # Same Plaguing problem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Getting rid of pesky extra spaces\n",
    "df.Actors = strip_list(df.Actors)\n",
    "df.Director = strip_list(df.Director)\n",
    "df.Writer = strip_list(df.Writer)\n",
    "\n",
    "# Getting rid of my silly index column and dropping the duplicates\n",
    "df.drop(['Unnamed: 0'], axis=1, inplace=True) \n",
    "df = df.drop_duplicates(subset=['imdbID'], keep='first')\n",
    "\n",
    "# Joining actor list as pipes\n",
    "df.Actors = df.Actors.map(lambda x: '|'.join(x))\n",
    "\n",
    "# Joining directors as pipes\n",
    "# Taking out any stuff in parentheses\n",
    "df.Director = df.Director.map(lambda x: '|'.join(x))\n",
    "df.Director = df.Director.map(lambda x: re.sub(\"[\\(\\[].*?[\\)\\]]\", \"\", x))\n",
    "\n",
    "# Joining genres as pipes\n",
    "df.Genre = df.Genre.map(lambda x: '|'.join(x))\n",
    "\n",
    "# Joining writers them as pipes\n",
    "# Taking out any stuff in parentheses\n",
    "df.Writer = df.Writer.map(lambda x: '|'.join(x))\n",
    "df.Writer = df.Writer.map(lambda x: re.sub(\"[\\(\\[].*?[\\)\\]]\", \"\", x))\n",
    "\n",
    "# Pulling out rotten tomato rating from the RTRating column\n",
    "df.RTRating = df.RTRating.map(RT_pull_out)\n",
    "\n",
    "# Turning released to datetime object as well as creating a delta column\n",
    "# Also creating a column for number of month and number of day\n",
    "df.Released = df.Released.map(release_to_datetime)\n",
    "df['days_from_y2k'] = df.Released.map(delta_release)\n",
    "df['month'] = df.Released.map(pull_month)\n",
    "df['day'] = df.Released.map(pull_day)\n",
    "\n",
    "# Turning runtime and boxxofice to to float objects\n",
    "df.Runtime = df.Runtime.map(runtime_to_float)\n",
    "df.BoxOffice = df.BoxOffice.map(boxoffice_to_float)\n",
    "\n",
    "# Sorting the DataFrame on released\n",
    "df = df.sort_values(['Released'], ascending=True)\n",
    "df.reset_index(drop=True, inplace=True)\n",
    "\n",
    "# Adding a title length column \n",
    "df['title_length'] = df.Title.map(lambda x: len(x))\n",
    "\n",
    "# Saving as a csv\n",
    "pd.DataFrame(df).to_csv('cleaned_movie_df.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because of the size of the database, I didn't spend much time imputing missing values, especially because lots of those came from lesser-known foreign films that probably wouldn't have added that much to a model. The graph of missing values is below. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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