nlp_project_presentation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Necessary imports\n",
    "\n",
    "import os\n",
    "import json\n",
    "from typing import Dict, List, Optional, Union, cast\n",
    "import requests\n",
    "import pandas as pd\n",
    "import bs4\n",
    "import time\n",
    "import matplotlib.pyplot as plt\n",
    "from env import github_token, github_username\n",
    "\n",
    "import acquire\n",
    "from prepare import prep_data, remove_stopwords, split\n",
    "\n",
    "import nltk\n",
    "import unicodedata\n",
    "import re\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import classification_report, accuracy_score\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "\n",
    "from imblearn.over_sampling import SMOTE\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Acquire the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This code doesn't need to be run after the initial data acquisition as it takes some time\n",
    "\n",
    "# data = acquire.scrape_github_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Successfully acquired urls and turned into a df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This code doesn't need to be run after the initial data acquisition\n",
    "\n",
    "# df = pd.DataFrame(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This code doesn't need to be run after the csv has been acquired\n",
    "# Write df to csv file\n",
    "\n",
    "# df.to_csv('repos.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### *Start here*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert back to a df and specify the index\n",
    "\n",
    "data_df = pd.read_csv ('repos.csv', index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>repo</th>\n",
       "      <th>language</th>\n",
       "      <th>readme_contents</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>gocodeup/codeup-setup-script</td>\n",
       "      <td>Shell</td>\n",
       "      <td># Codeup Setup Script\\n\\nSetup script for Code...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>gocodeup/movies-application</td>\n",
       "      <td>JavaScript</td>\n",
       "      <td># Movies Application\\n\\nFor this project, we w...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>torvalds/linux</td>\n",
       "      <td>C</td>\n",
       "      <td>Linux kernel\\n============\\n\\nThere are severa...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>nwjs/nw.js</td>\n",
       "      <td>JavaScript</td>\n",
       "      <td>## node-webkit is renamed NW.js\\n\\n[![Gitter](...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>PKUanonym/REKCARC-TSC-UHT</td>\n",
       "      <td>HTML</td>\n",
       "      <td># 清华大学计算机系课程攻略\\n\\n[![](https://img.shields.io/...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                           repo    language  \\\n",
       "0  gocodeup/codeup-setup-script       Shell   \n",
       "1   gocodeup/movies-application  JavaScript   \n",
       "2                torvalds/linux           C   \n",
       "3                    nwjs/nw.js  JavaScript   \n",
       "4     PKUanonym/REKCARC-TSC-UHT        HTML   \n",
       "\n",
       "                                     readme_contents  \n",
       "0  # Codeup Setup Script\\n\\nSetup script for Code...  \n",
       "1  # Movies Application\\n\\nFor this project, we w...  \n",
       "2  Linux kernel\\n============\\n\\nThere are severa...  \n",
       "3  ## node-webkit is renamed NW.js\\n\\n[![Gitter](...  \n",
       "4  # 清华大学计算机系课程攻略\\n\\n[![](https://img.shields.io/...  "
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Checking out the df\n",
    "\n",
    "data_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Int64Index: 407 entries, 0 to 406\n",
      "Data columns (total 3 columns):\n",
      " #   Column           Non-Null Count  Dtype \n",
      "---  ------           --------------  ----- \n",
      " 0   repo             407 non-null    object\n",
      " 1   language         337 non-null    object\n",
      " 2   readme_contents  403 non-null    object\n",
      "dtypes: object(3)\n",
      "memory usage: 12.7+ KB\n"
     ]
    }
   ],
   "source": [
    "# Taking a closer look at the columns of my df\n",
    "\n",
    "data_df.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepare"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Checking out nulls in the 'language' column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "JavaScript          83\n",
       "NaN                 70\n",
       "Java                36\n",
       "C++                 30\n",
       "Python              28\n",
       "HTML                27\n",
       "C                   24\n",
       "C#                  17\n",
       "TypeScript          14\n",
       "Go                  11\n",
       "Shell                8\n",
       "Jupyter Notebook     8\n",
       "Swift                6\n",
       "CSS                  5\n",
       "PowerShell           4\n",
       "Ruby                 4\n",
       "Kotlin               4\n",
       "Objective-C          4\n",
       "TeX                  3\n",
       "Dart                 2\n",
       "Scala                2\n",
       "CoffeeScript         2\n",
       "PHP                  2\n",
       "Ada                  1\n",
       "Clojure              1\n",
       "Erlang               1\n",
       "Groovy               1\n",
       "PostScript           1\n",
       "Objective-C++        1\n",
       "Nunjucks             1\n",
       "Assembly             1\n",
       "Handlebars           1\n",
       "Rust                 1\n",
       "Nix                  1\n",
       "Makefile             1\n",
       "MATLAB               1\n",
       "Name: language, dtype: int64"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# I see that I have 70 nulls values\n",
    "\n",
    "data_df.language.value_counts(dropna=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Made the decision to drop all of the 'language' nulls, taking my data from 407 observations to 337 observations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dropping nulls\n",
    "\n",
    "data_df = data_df.dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(333, 3)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Checking out the df shape\n",
    "\n",
    "data_df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dropping any languages that have less than 10 occurances\n",
    "\n",
    "data_df = data_df.groupby('language').filter(lambda x : len(x)>10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "JavaScript    82\n",
       "Java          36\n",
       "C++           28\n",
       "Python        28\n",
       "HTML          27\n",
       "C             23\n",
       "C#            17\n",
       "TypeScript    14\n",
       "Go            11\n",
       "Name: language, dtype: int64"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Confirming the new look of the 'language' column\n",
    "\n",
    "data_df.language.value_counts(dropna=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(266, 3)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Checking out the df shape\n",
    "\n",
    "data_df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>repo</th>\n",
       "      <th>language</th>\n",
       "      <th>readme_contents</th>\n",
       "      <th>clean_lemmatized</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>gocodeup/movies-application</td>\n",
       "      <td>JavaScript</td>\n",
       "      <td># Movies Application\\n\\nFor this project, we w...</td>\n",
       "      <td>movie application project building single page...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>torvalds/linux</td>\n",
       "      <td>C</td>\n",
       "      <td>Linux kernel\\n============\\n\\nThere are severa...</td>\n",
       "      <td>linux kernel several guide kernel developer us...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>nwjs/nw.js</td>\n",
       "      <td>JavaScript</td>\n",
       "      <td>## node-webkit is renamed NW.js\\n\\n[![Gitter](...</td>\n",
       "      <td>nodewebkit renamed nwjs gitterhttpsbadgesgitte...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>PKUanonym/REKCARC-TSC-UHT</td>\n",
       "      <td>HTML</td>\n",
       "      <td># 清华大学计算机系课程攻略\\n\\n[![](https://img.shields.io/...</td>\n",
       "      <td>httpsimgshieldsiogithubwatcherspkuanonymrekcar...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>yeasy/docker_practice</td>\n",
       "      <td>Go</td>\n",
       "      <td># Docker — 从入门到实践\\n\\n[![](https://img.shields....</td>\n",
       "      <td>docker httpsimgshieldsiogithubstarsyeasydocker...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                          repo    language  \\\n",
       "0  gocodeup/movies-application  JavaScript   \n",
       "1               torvalds/linux           C   \n",
       "2                   nwjs/nw.js  JavaScript   \n",
       "3    PKUanonym/REKCARC-TSC-UHT        HTML   \n",
       "4        yeasy/docker_practice          Go   \n",
       "\n",
       "                                     readme_contents  \\\n",
       "0  # Movies Application\\n\\nFor this project, we w...   \n",
       "1  Linux kernel\\n============\\n\\nThere are severa...   \n",
       "2  ## node-webkit is renamed NW.js\\n\\n[![Gitter](...   \n",
       "3  # 清华大学计算机系课程攻略\\n\\n[![](https://img.shields.io/...   \n",
       "4  # Docker — 从入门到实践\\n\\n[![](https://img.shields....   \n",
       "\n",
       "                                    clean_lemmatized  \n",
       "0  movie application project building single page...  \n",
       "1  linux kernel several guide kernel developer us...  \n",
       "2  nodewebkit renamed nwjs gitterhttpsbadgesgitte...  \n",
       "3  httpsimgshieldsiogithubwatcherspkuanonymrekcar...  \n",
       "4  docker httpsimgshieldsiogithubstarsyeasydocker...  "
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get a visual of my df\n",
    "\n",
    "df = prep_data(data_df, 'readme_contents').reset_index().drop(columns='index')\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### After prepping my data, I have dropped from an initial 407 observatins to 266 observations\n",
    "\n",
    "- I dropped my null values: 70 in 'language\" and 4 in 'readme_contents'\n",
    "- I dropped any language that had less than 10 occurances\n",
    "- I used my prepare.py to clean, tokenize, and lemmatize the 'readme_contents' column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Explore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a dictionary to hold subsets by language\n",
    "\n",
    "lang_dict = {}\n",
    "\n",
    "for lang in df.language:\n",
    "    lang_dict[f'{lang}'] = df[df.language == lang]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['JavaScript', 'C', 'HTML', 'Go', 'TypeScript', 'C++', 'C#', 'Python', 'Java'])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Checking my dictionary keys\n",
    "\n",
    "lang_dict.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create strings of cleaned and lemmatized words by language\n",
    "\n",
    "js_words = ' '.join(lang_dict['JavaScript'].clean_lemmatized)\n",
    "c_words = ' '.join(lang_dict['C'].clean_lemmatized)\n",
    "html_words = ' '.join(lang_dict['HTML'].clean_lemmatized)\n",
    "go_words = ' '.join(lang_dict['Go'].clean_lemmatized)\n",
    "typescript_words = ' '.join(lang_dict['TypeScript'].clean_lemmatized)\n",
    "c_plus_words = ' '.join(lang_dict['C++'].clean_lemmatized)\n",
    "c_sharp_words = ' '.join(lang_dict['C#'].clean_lemmatized)\n",
    "python_words = ' '.join(lang_dict['Python'].clean_lemmatized)\n",
    "java_words = ' '.join(lang_dict['Java'].clean_lemmatized)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create df of top 20 words in each language subset\n",
    "top_20_words = pd.concat([pd.Series(js_words.split()).value_counts().head(20), pd.Series(html_words.split()).value_counts().head(20)], axis=1)\n",
    "\n",
    "# Rename columns in initial df\n",
    "top_20_words.columns = ['js_words', 'html_words']\n",
    "\n",
    "# Add columns of top 20 words for each language\n",
    "top_20_words['python_words'] = pd.Series(python_words.split()).value_counts().head(20)\n",
    "top_20_words['java_words'] = pd.Series(java_words.split()).value_counts().head(20)\n",
    "top_20_words['c_words'] = pd.Series(c_words.split()).value_counts().head(20)\n",
    "top_20_words['c_plus_words'] = pd.Series(c_plus_words.split()).value_counts().head(20)\n",
    "top_20_words['c_sharp_words'] = pd.Series(c_sharp_words.split()).value_counts().head(20)\n",
    "top_20_words['go_words'] = pd.Series(go_words.split()).value_counts().head(20)\n",
    "top_20_words['typescript_words'] = pd.Series(typescript_words.split()).value_counts().head(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>js_words</th>\n",
       "      <th>html_words</th>\n",
       "      <th>python_words</th>\n",
       "      <th>java_words</th>\n",
       "      <th>c_words</th>\n",
       "      <th>c_plus_words</th>\n",
       "      <th>c_sharp_words</th>\n",
       "      <th>go_words</th>\n",
       "      <th>typescript_words</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>component</th>\n",
       "      <td>292.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>41.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>22.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>detail</th>\n",
       "      <td>213.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>web</th>\n",
       "      <td>211.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>serverless</th>\n",
       "      <td>181.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>server</th>\n",
       "      <td>162.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>77.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>30.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            js_words  html_words  python_words  java_words  c_words  \\\n",
       "component      292.0         NaN           NaN         NaN      NaN   \n",
       "detail         213.0         NaN           NaN         NaN      NaN   \n",
       "web            211.0         NaN           NaN         NaN      NaN   \n",
       "serverless     181.0         NaN           NaN         NaN      NaN   \n",
       "server         162.0         NaN           NaN        77.0      NaN   \n",
       "\n",
       "            c_plus_words  c_sharp_words  go_words  typescript_words  \n",
       "component            NaN           41.0       NaN              22.0  \n",
       "detail               NaN            NaN       NaN               NaN  \n",
       "web                  NaN            NaN       NaN               NaN  \n",
       "serverless           NaN            NaN       NaN               NaN  \n",
       "server               NaN            NaN       NaN              30.0  "
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Checking out the df\n",
    "\n",
    "top_20_words.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make bigrams using nltk to get a better feel for the data\n",
    "\n",
    "js_bigrams = pd.Series(nltk.ngrams(js_words.split(), 2)).value_counts().head(10)\n",
    "java_bigrams = pd.Series(nltk.ngrams(java_words.split(), 2)).value_counts().head(10)\n",
    "python_bigrams = pd.Series(nltk.ngrams(python_words.split(), 2)).value_counts().head(10)\n",
    "html_bigrams = pd.Series(nltk.ngrams(html_words.split(), 2)).value_counts().head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(blog, post)               95\n",
       "(detail, detail)           90\n",
       "(serverless, component)    52\n",
       "(starter, kit)             46\n",
       "(web, component)           39\n",
       "(apollo, universal)        36\n",
       "(createdat, updatedat)     36\n",
       "(universal, starter)       36\n",
       "(ui5, web)                 35\n",
       "(open, source)             34\n",
       "dtype: int64"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "js_bigrams"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(quickstart, demonstrates)                  51\n",
       "(intermediate, _none_)                      38\n",
       "(dependency, groupidcomkumuluzeegroupid)    28\n",
       "(test, ok)                                  28\n",
       "(beginner, _none_)                          27\n",
       "(command, line)                             21\n",
       "(following, command)                        20\n",
       "(wildfly, server)                           19\n",
       "(spring, boot)                              19\n",
       "(actual, value)                             16\n",
       "dtype: int64"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "java_bigrams"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(cumulative, number)              59\n",
       "(number, point)                   40\n",
       "(number, question)                33\n",
       "(span, stylecolorgreysospan)      29\n",
       "(span, stylecolororangehnspan)    28\n",
       "(question, span)                  27\n",
       "(open, source)                    23\n",
       "(time, series)                    21\n",
       "(topic, span)                     21\n",
       "(google, cloud)                   19\n",
       "dtype: int64"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "python_bigrams"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(face, recognition)          101\n",
       "(3d, face)                    43\n",
       "(face, detection)             31\n",
       "(deep, face)                  27\n",
       "(face, alignment)             22\n",
       "(adversarial, network)        21\n",
       "(face, reconstruction)        21\n",
       "(docker, image)               18\n",
       "(implementation, status)      17\n",
       "(generative, adversarial)     17\n",
       "dtype: int64"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "html_bigrams"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>js_words</th>\n",
       "      <th>html_words</th>\n",
       "      <th>python_words</th>\n",
       "      <th>java</th>\n",
       "      <th>c_words</th>\n",
       "      <th>c_plus_words</th>\n",
       "      <th>c_sharp_words</th>\n",
       "      <th>go_words</th>\n",
       "      <th>typescript_words</th>\n",
       "      <th>languages_with_word</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>use</th>\n",
       "      <td>256.0</td>\n",
       "      <td>62.0</td>\n",
       "      <td>76.0</td>\n",
       "      <td>113.0</td>\n",
       "      <td>46.0</td>\n",
       "      <td>59.0</td>\n",
       "      <td>40.0</td>\n",
       "      <td>17.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>project</th>\n",
       "      <td>291.0</td>\n",
       "      <td>57.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>78.0</td>\n",
       "      <td>37.0</td>\n",
       "      <td>63.0</td>\n",
       "      <td>58.0</td>\n",
       "      <td>18.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>using</th>\n",
       "      <td>213.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>71.0</td>\n",
       "      <td>84.0</td>\n",
       "      <td>41.0</td>\n",
       "      <td>67.0</td>\n",
       "      <td>56.0</td>\n",
       "      <td>31.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>file</th>\n",
       "      <td>208.0</td>\n",
       "      <td>107.0</td>\n",
       "      <td>64.0</td>\n",
       "      <td>99.0</td>\n",
       "      <td>82.0</td>\n",
       "      <td>68.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>18.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>&amp;#9;</th>\n",
       "      <td>3247.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>71.0</td>\n",
       "      <td>415.0</td>\n",
       "      <td>102.0</td>\n",
       "      <td>146.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>48.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>build</th>\n",
       "      <td>190.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>120.0</td>\n",
       "      <td>86.0</td>\n",
       "      <td>53.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>22.0</td>\n",
       "      <td>42.0</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>run</th>\n",
       "      <td>160.0</td>\n",
       "      <td>60.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>103.0</td>\n",
       "      <td>50.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>14.0</td>\n",
       "      <td>38.0</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>install</th>\n",
       "      <td>138.0</td>\n",
       "      <td>62.0</td>\n",
       "      <td>76.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>51.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>36.0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>code</th>\n",
       "      <td>161.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>79.0</td>\n",
       "      <td>73.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>40.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>26.0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>technology</th>\n",
       "      <td>142.0</td>\n",
       "      <td>63.0</td>\n",
       "      <td>71.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            js_words  html_words  python_words   java  c_words  c_plus_words  \\\n",
       "use            256.0        62.0          76.0  113.0     46.0          59.0   \n",
       "project        291.0        57.0           NaN   78.0     37.0          63.0   \n",
       "using          213.0         NaN          71.0   84.0     41.0          67.0   \n",
       "file           208.0       107.0          64.0   99.0     82.0          68.0   \n",
       "&#9;          3247.0         NaN          71.0  415.0    102.0         146.0   \n",
       "build          190.0         NaN           NaN  120.0     86.0          53.0   \n",
       "run            160.0        60.0           NaN  103.0     50.0           NaN   \n",
       "install        138.0        62.0          76.0    NaN     51.0           NaN   \n",
       "code           161.0         NaN          79.0   73.0      NaN           NaN   \n",
       "technology     142.0        63.0          71.0    NaN      NaN           NaN   \n",
       "\n",
       "            c_sharp_words  go_words  typescript_words  languages_with_word  \n",
       "use                  40.0      17.0              30.0                    9  \n",
       "project              58.0      18.0               NaN                    7  \n",
       "using                56.0      31.0               NaN                    7  \n",
       "file                  NaN      18.0               NaN                    7  \n",
       "&#9;                  NaN      48.0               NaN                    6  \n",
       "build                 NaN      22.0              42.0                    6  \n",
       "run                   NaN      14.0              38.0                    6  \n",
       "install               NaN       NaN              36.0                    5  \n",
       "code                 40.0       NaN              26.0                    5  \n",
       "technology            NaN       NaN               NaN                    3  "
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a column that counts the number of repos a word appears in.\n",
    "\n",
    "top_20_words['languages_with_word'] = top_20_words.loc[:,'js_words':'typescript_words'].notnull().sum(axis=1)\n",
    "\n",
    "top_20_words.sort_values('languages_with_word', ascending=False).head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the words that appear in the most repos to find noise that can be removed\n",
    "plt.figure(figsize=(12, 8))\n",
    "\n",
    "top_20_words.languages_with_word.sort_values(ascending=False).head(15).plot(kind='barh')\n",
    "plt.gca().invert_yaxis()\n",
    "\n",
    "plt.ylabel('noise words')\n",
    "plt.xlabel('number of repos')\n",
    "plt.title('Most Common Noise Words Across the Languages')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Viz Takeaway\n",
    "- A lot of pretty generic words are sprinkled in here \n",
    "- Probably not very insightful since these words appear in the majority of the languages\n",
    "- These seems like good candidates to drop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['use',\n",
       " 'project',\n",
       " 'using',\n",
       " 'file',\n",
       " '&#9;',\n",
       " 'build',\n",
       " 'run',\n",
       " 'install',\n",
       " 'code',\n",
       " 'technology']"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Isolating the 10 most common 'noise' words\n",
    "\n",
    "top_20_words.sort_values('languages_with_word', ascending=False).index[:10].tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Grouping the 10 noisiest words together\n",
    "\n",
    "extra_words=['use','project','using','file','&#9;','build','install','run','application','code']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Removing the 10 noisiest words from the df\n",
    "\n",
    "df = remove_stopwords(df, 'clean_lemmatized', extra_words = extra_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>repo</th>\n",
       "      <th>language</th>\n",
       "      <th>readme_contents</th>\n",
       "      <th>clean_lemmatized</th>\n",
       "      <th>clean_clean_lemmatized</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>gocodeup/movies-application</td>\n",
       "      <td>JavaScript</td>\n",
       "      <td># Movies Application\\n\\nFor this project, we w...</td>\n",
       "      <td>movie application project building single page...</td>\n",
       "      <td>movie building single page movie spa allow use...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>torvalds/linux</td>\n",
       "      <td>C</td>\n",
       "      <td>Linux kernel\\n============\\n\\nThere are severa...</td>\n",
       "      <td>linux kernel several guide kernel developer us...</td>\n",
       "      <td>linux kernel several guide kernel developer us...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>nwjs/nw.js</td>\n",
       "      <td>JavaScript</td>\n",
       "      <td>## node-webkit is renamed NW.js\\n\\n[![Gitter](...</td>\n",
       "      <td>nodewebkit renamed nwjs gitterhttpsbadgesgitte...</td>\n",
       "      <td>nodewebkit renamed nwjs gitterhttpsbadgesgitte...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>PKUanonym/REKCARC-TSC-UHT</td>\n",
       "      <td>HTML</td>\n",
       "      <td># 清华大学计算机系课程攻略\\n\\n[![](https://img.shields.io/...</td>\n",
       "      <td>httpsimgshieldsiogithubwatcherspkuanonymrekcar...</td>\n",
       "      <td>httpsimgshieldsiogithubwatcherspkuanonymrekcar...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>yeasy/docker_practice</td>\n",
       "      <td>Go</td>\n",
       "      <td># Docker — 从入门到实践\\n\\n[![](https://img.shields....</td>\n",
       "      <td>docker httpsimgshieldsiogithubstarsyeasydocker...</td>\n",
       "      <td>docker httpsimgshieldsiogithubstarsyeasydocker...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                          repo    language  \\\n",
       "0  gocodeup/movies-application  JavaScript   \n",
       "1               torvalds/linux           C   \n",
       "2                   nwjs/nw.js  JavaScript   \n",
       "3    PKUanonym/REKCARC-TSC-UHT        HTML   \n",
       "4        yeasy/docker_practice          Go   \n",
       "\n",
       "                                     readme_contents  \\\n",
       "0  # Movies Application\\n\\nFor this project, we w...   \n",
       "1  Linux kernel\\n============\\n\\nThere are severa...   \n",
       "2  ## node-webkit is renamed NW.js\\n\\n[![Gitter](...   \n",
       "3  # 清华大学计算机系课程攻略\\n\\n[![](https://img.shields.io/...   \n",
       "4  # Docker — 从入门到实践\\n\\n[![](https://img.shields....   \n",
       "\n",
       "                                    clean_lemmatized  \\\n",
       "0  movie application project building single page...   \n",
       "1  linux kernel several guide kernel developer us...   \n",
       "2  nodewebkit renamed nwjs gitterhttpsbadgesgitte...   \n",
       "3  httpsimgshieldsiogithubwatcherspkuanonymrekcar...   \n",
       "4  docker httpsimgshieldsiogithubstarsyeasydocker...   \n",
       "\n",
       "                              clean_clean_lemmatized  \n",
       "0  movie building single page movie spa allow use...  \n",
       "1  linux kernel several guide kernel developer us...  \n",
       "2  nodewebkit renamed nwjs gitterhttpsbadgesgitte...  \n",
       "3  httpsimgshieldsiogithubwatcherspkuanonymrekcar...  \n",
       "4  docker httpsimgshieldsiogithubstarsyeasydocker...  "
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a dictionary to hold subsets by language\n",
    "\n",
    "lang_dict2 = {}\n",
    "\n",
    "for lang in df.language:\n",
    "    lang_dict2[f'{lang}'] = df[df.language == lang]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create strings of cleaned and lemmatized words by language\n",
    "\n",
    "js_words = ' '.join(lang_dict2['JavaScript'].clean_clean_lemmatized)\n",
    "c_words = ' '.join(lang_dict2['C'].clean_clean_lemmatized)\n",
    "html_words = ' '.join(lang_dict2['HTML'].clean_clean_lemmatized)\n",
    "go_words = ' '.join(lang_dict2['Go'].clean_clean_lemmatized)\n",
    "typescript_words = ' '.join(lang_dict2['TypeScript'].clean_clean_lemmatized)\n",
    "c_plus_words = ' '.join(lang_dict2['C++'].clean_clean_lemmatized)\n",
    "c_sharp_words = ' '.join(lang_dict2['C#'].clean_clean_lemmatized)\n",
    "python_words = ' '.join(lang_dict2['Python'].clean_clean_lemmatized)\n",
    "java_words = ' '.join(lang_dict2['Java'].clean_clean_lemmatized)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create df of top 20 words in each language subset\n",
    "top_20_words2 = pd.concat([pd.Series(js_words.split()).value_counts().head(20), pd.Series(html_words.split()).value_counts().head(20)], axis=1)\n",
    "\n",
    "# Rename columns in initial df.\n",
    "top_20_words2.columns = ['js_words', 'html_words']\n",
    "\n",
    "# Add columns of top 20 words for each language\n",
    "top_20_words2['python_words'] = pd.Series(python_words.split()).value_counts().head(20)\n",
    "top_20_words2['java_words'] = pd.Series(java_words.split()).value_counts().head(20)\n",
    "top_20_words2['c_words'] = pd.Series(c_words.split()).value_counts().head(20)\n",
    "top_20_words2['c_plus_words'] = pd.Series(c_plus_words.split()).value_counts().head(20)\n",
    "top_20_words2['c_sharp_words'] = pd.Series(c_sharp_words.split()).value_counts().head(20)\n",
    "top_20_words2['go_words'] = pd.Series(go_words.split()).value_counts().head(20)\n",
    "top_20_words2['typescript_words'] = pd.Series(typescript_words.split()).value_counts().head(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>js_words</th>\n",
       "      <th>html_words</th>\n",
       "      <th>python_words</th>\n",
       "      <th>java_words</th>\n",
       "      <th>c_words</th>\n",
       "      <th>c_plus_words</th>\n",
       "      <th>c_sharp_words</th>\n",
       "      <th>go_words</th>\n",
       "      <th>typescript_words</th>\n",
       "      <th>languages_with_word</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>131.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>65.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>30.0</td>\n",
       "      <td>102.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>25.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>data</th>\n",
       "      <td>120.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>122.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>36.0</td>\n",
       "      <td>14.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>component</th>\n",
       "      <td>292.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>41.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>22.0</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>version</th>\n",
       "      <td>NaN</td>\n",
       "      <td>50.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>85.0</td>\n",
       "      <td>34.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>server</th>\n",
       "      <td>162.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>77.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>30.0</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>technology</th>\n",
       "      <td>142.0</td>\n",
       "      <td>63.0</td>\n",
       "      <td>71.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>support</th>\n",
       "      <td>124.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>81.0</td>\n",
       "      <td>32.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>image</th>\n",
       "      <td>NaN</td>\n",
       "      <td>74.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>57.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>html</th>\n",
       "      <td>116.0</td>\n",
       "      <td>47.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>need</th>\n",
       "      <td>125.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>36.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            js_words  html_words  python_words  java_words  c_words  \\\n",
       "1              131.0         NaN          65.0         NaN     30.0   \n",
       "data           120.0         NaN         122.0         NaN      NaN   \n",
       "component      292.0         NaN           NaN         NaN      NaN   \n",
       "version          NaN        50.0           NaN        85.0     34.0   \n",
       "server         162.0         NaN           NaN        77.0      NaN   \n",
       "technology     142.0        63.0          71.0         NaN      NaN   \n",
       "support        124.0         NaN           NaN        81.0     32.0   \n",
       "image            NaN        74.0           NaN         NaN      NaN   \n",
       "html           116.0        47.0           NaN         NaN      NaN   \n",
       "need           125.0         NaN           NaN         NaN     36.0   \n",
       "\n",
       "            c_plus_words  c_sharp_words  go_words  typescript_words  \\\n",
       "1                  102.0            NaN      25.0               NaN   \n",
       "data                 NaN           36.0      14.0               NaN   \n",
       "component            NaN           41.0       NaN              22.0   \n",
       "version              NaN            NaN       NaN               NaN   \n",
       "server               NaN            NaN       NaN              30.0   \n",
       "technology           NaN            NaN       NaN               NaN   \n",
       "support              NaN            NaN       NaN               NaN   \n",
       "image                NaN           57.0       NaN               NaN   \n",
       "html                 NaN            NaN       NaN               NaN   \n",
       "need                 NaN            NaN       NaN               NaN   \n",
       "\n",
       "            languages_with_word  \n",
       "1                             5  \n",
       "data                          4  \n",
       "component                     3  \n",
       "version                       3  \n",
       "server                        3  \n",
       "technology                    3  \n",
       "support                       3  \n",
       "image                         2  \n",
       "html                          2  \n",
       "need                          2  "
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a column that counts the number of repos a word appears in\n",
    "\n",
    "top_20_words2['languages_with_word'] = top_20_words2.loc[:,'js_words':'typescript_words'].notnull().sum(axis=1)\n",
    "\n",
    "top_20_words2.sort_values('languages_with_word', ascending=False).head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the words that appear in the most repos to find noise that can be removed\n",
    "\n",
    "plt.figure(figsize=(12, 8))\n",
    "\n",
    "top_20_words2.languages_with_word.sort_values(ascending=False).head(15).plot(kind='barh')\n",
    "plt.gca().invert_yaxis()\n",
    "\n",
    "plt.ylabel('noise words')\n",
    "plt.xlabel('number of repos')\n",
    "plt.title('Most Common Noise Words Across the Languages, Part Two')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove a few more words that appear to be noise and move on\n",
    "\n",
    "extra_words = ['1', 'data', 'make', 'version', 'server', 'technology', 'support']\n",
    "df = remove_stopwords(df, 'clean_lemmatized', extra_words = extra_words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Prep Takeaways\n",
    "- Removed many more words that were noisy: too generic too helpful predictors "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modeling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>repo</th>\n",
       "      <th>language</th>\n",
       "      <th>readme_contents</th>\n",
       "      <th>clean_lemmatized</th>\n",
       "      <th>clean_clean_lemmatized</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>205</th>\n",
       "      <td>googlevr/seurat-unity-plugin</td>\n",
       "      <td>C#</td>\n",
       "      <td># Importing Seurat Meshes Into Unity\\n\\nSeurat...</td>\n",
       "      <td>importing seurat mesh unity seurat scene simpl...</td>\n",
       "      <td>importing seurat mesh unity seurat scene simpl...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>128</th>\n",
       "      <td>shuaishaui/springboot-technology</td>\n",
       "      <td>Java</td>\n",
       "      <td># springboot-technology\\nspringboot整合自己到目前学习到的...</td>\n",
       "      <td>springboottechnology springboot</td>\n",
       "      <td>springboottechnology springboot</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>208</th>\n",
       "      <td>kalaspuff/tomodachi</td>\n",
       "      <td>Python</td>\n",
       "      <td>``tomodachi`` - a lightweight microservices li...</td>\n",
       "      <td>tomodachi lightweight microservices library py...</td>\n",
       "      <td>tomodachi lightweight microservices library py...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75</th>\n",
       "      <td>dolevf/Damn-Vulnerable-GraphQL-Application</td>\n",
       "      <td>JavaScript</td>\n",
       "      <td># Damn Vulnerable GraphQL Application\\nDamn Vu...</td>\n",
       "      <td>damn vulnerable graphql application damn vulne...</td>\n",
       "      <td>damn vulnerable graphql application damn vulne...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>214</th>\n",
       "      <td>tyrchen/book_next</td>\n",
       "      <td>JavaScript</td>\n",
       "      <td>---\\ntitle: '程序君的公众号'\\nauthor:\\n  - 程序君\\nkeywo...</td>\n",
       "      <td>title author keywords readme</td>\n",
       "      <td>title author keywords readme</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                           repo    language  \\\n",
       "205                googlevr/seurat-unity-plugin          C#   \n",
       "128            shuaishaui/springboot-technology        Java   \n",
       "208                         kalaspuff/tomodachi      Python   \n",
       "75   dolevf/Damn-Vulnerable-GraphQL-Application  JavaScript   \n",
       "214                           tyrchen/book_next  JavaScript   \n",
       "\n",
       "                                       readme_contents  \\\n",
       "205  # Importing Seurat Meshes Into Unity\\n\\nSeurat...   \n",
       "128  # springboot-technology\\nspringboot整合自己到目前学习到的...   \n",
       "208  ``tomodachi`` - a lightweight microservices li...   \n",
       "75   # Damn Vulnerable GraphQL Application\\nDamn Vu...   \n",
       "214  ---\\ntitle: '程序君的公众号'\\nauthor:\\n  - 程序君\\nkeywo...   \n",
       "\n",
       "                                      clean_lemmatized  \\\n",
       "205  importing seurat mesh unity seurat scene simpl...   \n",
       "128                    springboottechnology springboot   \n",
       "208  tomodachi lightweight microservices library py...   \n",
       "75   damn vulnerable graphql application damn vulne...   \n",
       "214                       title author keywords readme   \n",
       "\n",
       "                                clean_clean_lemmatized  \n",
       "205  importing seurat mesh unity seurat scene simpl...  \n",
       "128                    springboottechnology springboot  \n",
       "208  tomodachi lightweight microservices library py...  \n",
       "75   damn vulnerable graphql application damn vulne...  \n",
       "214                       title author keywords readme  "
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Split my data\n",
    "\n",
    "train, validate, test = split(df, 'language')\n",
    "train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(148, 5) (64, 5) (54, 5)\n"
     ]
    }
   ],
   "source": [
    "# Visualize my split data\n",
    "\n",
    "print(train.shape, validate.shape, test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set up my X variables\n",
    "\n",
    "X_train = train.clean_clean_lemmatized\n",
    "X_validate = validate.clean_clean_lemmatized\n",
    "X_test = test.clean_clean_lemmatized"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set up my y variables\n",
    "\n",
    "y_train = train.language\n",
    "y_validate = validate.language\n",
    "y_test = test.language"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vectorize my data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the tfidf vectorizer object\n",
    "# Step 1, this creates a tf-idf values for each word, for each document\n",
    "# Step 2, encodes these values so that we can use models that only work on numbers, like classification models\n",
    "tfidf = TfidfVectorizer()\n",
    "\n",
    "# Fit on the training data\n",
    "tfidf.fit(X_train)\n",
    "\n",
    "# Use the object\n",
    "X_train_vectorized = tfidf.transform(X_train)\n",
    "X_validate_vectorized = tfidf.transform(X_validate)\n",
    "X_test_vectorized = tfidf.transform(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create my baseline accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3082706766917293"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# My baseline accuracy is 31% because JavaScript, the mode value, represents 31% of the language values in the df\n",
    "\n",
    "((df.language.value_counts().head(1).values / df.shape[0])[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Logistic Regression Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression()"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Running a LR model on my vectorized dataset\n",
    "lm = LogisticRegression()\n",
    "\n",
    "# Fit the classification model on our vectorized train data\n",
    "lm.fit(X_train_vectorized, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Showing the actual values\n",
    "\n",
    "train_eval = pd.DataFrame(dict(actual=y_train))\n",
    "validate_eval = pd.DataFrame(dict(actual=y_validate))\n",
    "test_eval = pd.DataFrame(dict(actual=y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use the trained model to predict y given those vectorized inputs of X\n",
    "\n",
    "train_eval['predicted'] = lm.predict(X_train_vectorized)\n",
    "validate_eval[\"predicted\"] = lm.predict(X_validate_vectorized)\n",
    "test_eval['predicted'] = lm.predict(X_test_vectorized)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>actual</th>\n",
       "      <th>predicted</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>205</th>\n",
       "      <td>C#</td>\n",
       "      <td>JavaScript</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>128</th>\n",
       "      <td>Java</td>\n",
       "      <td>Java</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>208</th>\n",
       "      <td>Python</td>\n",
       "      <td>JavaScript</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75</th>\n",
       "      <td>JavaScript</td>\n",
       "      <td>JavaScript</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>214</th>\n",
       "      <td>JavaScript</td>\n",
       "      <td>JavaScript</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         actual   predicted\n",
       "205          C#  JavaScript\n",
       "128        Java        Java\n",
       "208      Python  JavaScript\n",
       "75   JavaScript  JavaScript\n",
       "214  JavaScript  JavaScript"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Getting a preview of actual vs predicted\n",
    "\n",
    "train_eval.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5540540540540541"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Train Accuracy\n",
    "\n",
    "(train_eval.actual == train_eval.predicted).mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.296875"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Out of sample accuracy\n",
    "\n",
    "(validate_eval.actual == validate_eval.predicted).mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           C       1.00      0.23      0.38        13\n",
      "          C#       0.00      0.00      0.00        10\n",
      "         C++       1.00      0.40      0.57        15\n",
      "          Go       0.00      0.00      0.00         6\n",
      "        HTML       1.00      0.27      0.42        15\n",
      "        Java       1.00      0.95      0.97        20\n",
      "  JavaScript       0.41      1.00      0.58        46\n",
      "      Python       1.00      0.27      0.42        15\n",
      "  TypeScript       0.00      0.00      0.00         8\n",
      "\n",
      "    accuracy                           0.55       148\n",
      "   macro avg       0.60      0.35      0.37       148\n",
      "weighted avg       0.65      0.55      0.49       148\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Classification report on train\n",
    "\n",
    "from sklearn.metrics import classification_report\n",
    "print(classification_report(train_eval.actual, train_eval.predicted))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           C       0.00      0.00      0.00         5\n",
      "          C#       0.00      0.00      0.00         4\n",
      "         C++       0.00      0.00      0.00         7\n",
      "          Go       0.00      0.00      0.00         3\n",
      "        HTML       0.00      0.00      0.00         7\n",
      "        Java       0.00      0.00      0.00         9\n",
      "  JavaScript       0.30      1.00      0.46        19\n",
      "      Python       0.00      0.00      0.00         7\n",
      "  TypeScript       0.00      0.00      0.00         3\n",
      "\n",
      "    accuracy                           0.30        64\n",
      "   macro avg       0.03      0.11      0.05        64\n",
      "weighted avg       0.09      0.30      0.14        64\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Classification report on validate\n",
    "\n",
    "from sklearn.metrics import classification_report\n",
    "print(classification_report(validate_eval.actual, validate_eval.predicted))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Takeaway\n",
    "- Logistic Regression model performed pretty weak on train data\n",
    "- The same model performed even worse on validate data\n",
    "- The model was overfit, but it did improve on the baseline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Decision Tree w depth=3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DecisionTreeClassifier(max_depth=3, random_state=123)"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# modeling and evaluating\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "\n",
    "# Create the model\n",
    "\n",
    "clf = DecisionTreeClassifier(max_depth=3, random_state=123)\n",
    "\n",
    "# Fit the model\n",
    "\n",
    "clf.fit(X_train_vectorized, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use the model to get accuracy score for train dataset\n",
    "\n",
    "clf.score(X_train_vectorized, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of Decision Tree classifier on training set: 43%\n"
     ]
    }
   ],
   "source": [
    "print(f'Accuracy of Decision Tree classifier on training set: {round(clf.score(X_train_vectorized, y_train) * 100)}%')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Validate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use the model to get accuracy score for Validate dataset\n",
    "\n",
    "clf.score(X_validate_vectorized, y_validate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of Decision Tree classifier on training set: 38%\n"
     ]
    }
   ],
   "source": [
    "print(f'Accuracy of Decision Tree classifier on training set: {round(clf.score(X_validate_vectorized, y_validate) * 100)}%')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Takeaway\n",
    "- Decision Tree had low accuracy on train data\n",
    "- Even lower accuracy on validate\n",
    "- The model was also overfit, but it outperformed the baseline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create df to dig into accuracy by language.\n",
    "\n",
    "dt_train_eval = pd.DataFrame(dict(actual=y_train))\n",
    "dt_validate_eval = pd.DataFrame(dict(actual=y_validate))\n",
    "dt_test_eval = pd.DataFrame(dict(actual=y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use the trained dt model to predict y given those vectorized inputs of X.\n",
    "\n",
    "dt_train_eval['predicted'] = clf.predict(X_train_vectorized)\n",
    "dt_validate_eval[\"predicted\"] =clf.predict(X_validate_vectorized)\n",
    "dt_test_eval['predicted'] = clf.predict(X_test_vectorized)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "JavaScript    82\n",
       "Java          36\n",
       "C++           28\n",
       "Python        28\n",
       "HTML          27\n",
       "C             23\n",
       "C#            17\n",
       "TypeScript    14\n",
       "Go            11\n",
       "Name: language, dtype: int64"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.language.value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Dig into JavaScript Accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "js_dt_eval = dt_train_eval[dt_train_eval.actual == 'JavaScript']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(js_dt_eval.actual == js_dt_eval.predicted).mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Dig into Python Accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "python_dt_eval = dt_train_eval[dt_train_eval.actual == 'Python']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(python_dt_eval.actual == python_dt_eval.predicted).mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Dig into Java Accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "j_dt_eval = dt_train_eval[dt_train_eval.actual == 'Java']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.45"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(j_dt_eval.actual == j_dt_eval.predicted).mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Dig into TypeScript Accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "t_dt_eval = dt_train_eval[dt_train_eval.actual == 'TypeScript']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(t_dt_eval.actual == t_dt_eval.predicted).mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Dig into Go Accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g_dt_eval = dt_train_eval[dt_train_eval.actual == 'Go']\n",
    "(g_dt_eval.actual == g_dt_eval.predicted).mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Takeaway\n",
    "- The lesser-occuring languages are dragging the accuracy down\n",
    "- Maybe drop some of the languages that occur less\n",
    "- Maybe try to balance the dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's Try Balancing the Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create SMOTE object\n",
    "\n",
    "sm = SMOTE(random_state=123)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fit the SMOTE object and resample\n",
    "\n",
    "X_train_sm, y_train_sm = sm.fit_resample(X_train_vectorized, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of X before SMOTE: (148, 16620)\n",
      "Shape of X after SMOTE: (414, 16620)\n"
     ]
    }
   ],
   "source": [
    "print(f'''Shape of X before SMOTE: {X_train_vectorized.shape}\n",
    "Shape of X after SMOTE: {X_train_sm.shape}''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Balance of positive and negative classes (%):\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Java          11.111111\n",
       "C++           11.111111\n",
       "C             11.111111\n",
       "JavaScript    11.111111\n",
       "Go            11.111111\n",
       "C#            11.111111\n",
       "HTML          11.111111\n",
       "TypeScript    11.111111\n",
       "Python        11.111111\n",
       "Name: language, dtype: float64"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The train dataset is perfectly balanced now\n",
    "\n",
    "print('\\nBalance of positive and negative classes (%):')\n",
    "y_train_sm.value_counts(normalize=True) * 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train a DT Model on Oversampled Train Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DecisionTreeClassifier(max_depth=3, random_state=123)"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create the model\n",
    "\n",
    "clf_sm = DecisionTreeClassifier(max_depth=3, random_state=123)\n",
    "\n",
    "# Fit the model\n",
    "\n",
    "clf_sm.fit(X_train_sm, y_train_sm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.3647342995169082"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use the model to get accuracy score for train dataset\n",
    "\n",
    "clf_sm.score(X_train_sm, y_train_sm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of Decision Tree classifier after SMOTE on training set: 36%\n"
     ]
    }
   ],
   "source": [
    "print(f'Accuracy of Decision Tree classifier after SMOTE on training set: {round(clf_sm.score(X_train_sm, y_train_sm) * 100)}%')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Use New DT Model Trained on Oversampled Data with Validate Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of Decision Tree classifier After SMOTE on validate dataset: 14%\n"
     ]
    }
   ],
   "source": [
    "# Use the model to get accuracy score for Validate dataset\n",
    "\n",
    "print(f'Accuracy of Decision Tree classifier After SMOTE on validate dataset: {round(clf_sm.score(X_validate_vectorized, y_validate) * 100)}%')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Takeaway\n",
    "- Both train and validate accuracy were lowest yet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What if I narrow my languages to the top 5?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Isolating my top 5 languages\n",
    "\n",
    "top_5_train = train[train.language.isin(['JavaScript', 'Java', 'Python', 'C', 'HTML'])]\n",
    "top_5_val = validate[validate.language.isin(['JavaScript', 'Java', 'Python', 'C', 'HTML'])]\n",
    "top_5_test = test[test.language.isin(['JavaScript', 'Java', 'Python', 'C', 'HTML'])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(109, 5) (47, 5) (40, 5)\n"
     ]
    }
   ],
   "source": [
    "# Check out the shape \n",
    "\n",
    "print(top_5_train.shape, top_5_val.shape, top_5_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create X and y\n",
    "\n",
    "X_top_5_train = top_5_train.clean_clean_lemmatized\n",
    "X_top_5_val = top_5_val.clean_clean_lemmatized\n",
    "X_top_5_test = top_5_test.clean_clean_lemmatized"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_top_5_train = top_5_train.language\n",
    "y_top_5_val = top_5_val.language\n",
    "y_top_5_test = top_5_test.language"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the tfidf vectorizer object\n",
    "# Step 1, this creates a tf-idf values for each word, for each document\n",
    "# Step 2, encodes these values so that we can use models that only work on numbers, like classifications model\n",
    "tfidf = TfidfVectorizer()\n",
    "\n",
    "# Fit on the training data\n",
    "tfidf.fit(X_top_5_train)\n",
    "\n",
    "# Use the object\n",
    "X_top_5_train_vectorized = tfidf.transform(X_top_5_train)\n",
    "X_top_5_val_vectorized = tfidf.transform(X_top_5_val)\n",
    "X_top_5_test_vectorized = tfidf.transform(X_top_5_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(109, 13049)"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check out the shape post-vectorizing\n",
    "\n",
    "X_top_5_train_vectorized.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Top 5 Languages Before Oversampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DecisionTreeClassifier(max_depth=3, random_state=123)"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create the Decision Tree model for the top 5 languages\n",
    "\n",
    "clf5 = DecisionTreeClassifier(max_depth=3, random_state=123)\n",
    "\n",
    "# Fit the model\n",
    "\n",
    "clf5.fit(X_top_5_train_vectorized, y_top_5_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of Decision Tree classifier on Top 5 Languges Before SMOTE on training set: 61%\n"
     ]
    }
   ],
   "source": [
    "print(f'Accuracy of Decision Tree classifier on Top 5 Languges Before SMOTE on training set: {round(clf5.score(X_top_5_train_vectorized, y_top_5_train) * 100)}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of Decision Tree classifier on Top 5 Languages Before SMOTE on validate dataset: 55%\n"
     ]
    }
   ],
   "source": [
    "print(f'Accuracy of Decision Tree classifier on Top 5 Languages Before SMOTE on validate dataset: {round(clf5.score(X_top_5_val_vectorized, y_top_5_val) * 100)}%')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Takeaway\n",
    "- By limiting my languages to the top 5, I got better results on both train and validate "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Oversampling using SMOTE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fit the SMOTE object and resample the top_5_train dataset\n",
    "\n",
    "X_train_sm5, y_train_sm5 = sm5.fit_resample(X_top_5_train_vectorized, y_top_5_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(230, 13049) (230,)\n"
     ]
    }
   ],
   "source": [
    "print(X_train_sm5.shape, y_train_sm5.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Balance of languauges (%):\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Java          20.0\n",
       "HTML          20.0\n",
       "C             20.0\n",
       "JavaScript    20.0\n",
       "Python        20.0\n",
       "Name: language, dtype: float64"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The train dataset is perfectly balanced now\n",
    "\n",
    "print('\\nBalance of languauges (%):')\n",
    "y_train_sm5.value_counts(normalize=True) * 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DecisionTreeClassifier(max_depth=3, random_state=123)"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create the model for the top 5 languages; X is vectorized and oversampled\n",
    "\n",
    "clf_sm5 = DecisionTreeClassifier(max_depth=3, random_state=123)\n",
    "\n",
    "# Fit the model\n",
    "\n",
    "clf_sm5.fit(X_train_sm5, y_train_sm5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of Decision Tree classifier on Top 5 Languges after SMOTE on training set: 63%\n"
     ]
    }
   ],
   "source": [
    "# Use the model to get accuracy score for train dataset\n",
    "\n",
    "print(f'Accuracy of Decision Tree classifier on Top 5 Languges after SMOTE on training set: {round(clf_sm5.score(X_train_sm5, y_train_sm5) * 100)}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of Decision Tree classifier on Top 5 Languages After SMOTE on validate dataset: 28%\n"
     ]
    }
   ],
   "source": [
    "# Use the model to get accuracy score for validate dataset\n",
    "\n",
    "print(f'Accuracy of Decision Tree classifier on Top 5 Languages After SMOTE on validate dataset: {round(clf_sm5.score(X_top_5_val_vectorized, y_top_5_val) * 100)}%')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Takeaway\n",
    "- Decision Tree performed reasonably well on my balanced train data\n",
    "- The dropoff was substantial on  balanced validate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test the Data\n",
    "- I chose my best-performing model: Decision Tree using top 5 languages with the dataset not oversampled"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of Decision Tree classifier on Top 5 Languges on test set: 60%\n"
     ]
    }
   ],
   "source": [
    "print(f'Accuracy of Decision Tree classifier on Top 5 Languges on test set: {round(clf5.score(X_top_5_test_vectorized, y_top_5_test) * 100)}%')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Takeaway:\n",
    "- My Decision Tree Top 5 model performed better than expected at 60%\n",
    "- The test model was right in line with the train and validate - both hovering between 61% and 55%\n",
    "- I consider this a success although still much room for improvement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion:\n",
    "- Because the initial baseline was so low, even a weak-performing model could beat it\n",
    "- Each model was overfit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Next steps:\n",
    "- As small training datasets are prone to over-fitting, I'd get a larger dataset to sample\n",
    "- I'd like to work with SMOTE more and get the hang of it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}