Video-Game-Recommendation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {},
       "report_default": {}
      }
     }
    }
   },
   "source": [
    "# Video Game Recommendation\n",
    "The following notebook will demonstrate a visual data analysis of various video game data and a video game recommendation algorithm. Selecting a platform from the \"Platform\" dropdown below will show three visual analyses related to that platform.\n",
    "After a platform is selected, you may choose a genre from the \"Genre\" dropdown, at which point the games fitting into those categories will be listed in the \"Game\" dropdown box. Selecting a game from this box will populate the \"Recommended\"\n",
    "dropdown with up to 5 game recommendations. These recommendations are based on multiple similarity factors including developer, name, critic score, and user score which can be examined in the table to the right of the dropdowns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "extensions": {
     "jupyter_dashboards": {
      "version": 1,
      "views": {
       "grid_default": {},
       "report_default": {}
      }
     }
    },
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a5f455b48eb74172b861b68c57e01b29",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1aaa81a980b14383aff42219b7c4a272",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib widget\n",
    "\n",
    "import pandas as pd\n",
    "import matplotlib as mpl\n",
    "from sklearn.metrics.pairwise import cosine_similarity\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "import numpy as np\n",
    "import ipywidgets as widgets\n",
    "import IPython.core.display\n",
    "import IPython.display\n",
    "\n",
    "\n",
    "def game_change(change):\n",
    "    global games_frame\n",
    "\n",
    "    refresh_recommended_list(change[\"new\"])\n",
    "\n",
    "\n",
    "def genre_change(change):\n",
    "    global selected_genre\n",
    "\n",
    "    selected_genre = change[\"new\"]\n",
    "\n",
    "    refresh_games_list()\n",
    "\n",
    "\n",
    "def platform_change(change):\n",
    "    global selected_platform\n",
    "    global selected_genre\n",
    "    global genre_dropdown_list\n",
    "    global genre_dropdown\n",
    "\n",
    "    selected_platform = change[\"new\"]\n",
    "\n",
    "    selected_platform_frame = videogame_database[videogame_database[\"Platform\"] == selected_platform]\n",
    "    genre_dropdown_list = selected_platform_frame[\"Genre\"].unique().tolist()\n",
    "    genre_dropdown_list.sort()\n",
    "\n",
    "    selected_genre = genre_dropdown_list[0]\n",
    "    genre_dropdown.options = genre_dropdown_list\n",
    "    genre_dropdown.value = selected_genre\n",
    "\n",
    "    refresh_games_list()\n",
    "    update_plots()\n",
    "\n",
    "\n",
    "def refresh_games_list():\n",
    "    global games_list\n",
    "    global games_frame\n",
    "    global games_dropdown\n",
    "    global selected_platform\n",
    "    global selected_genre\n",
    "\n",
    "    games_frame = videogame_database[(videogame_database[\"Platform\"] == selected_platform) & (videogame_database[\"Genre\"] == selected_genre)]\n",
    "    games_list = games_frame[\"Name\"].tolist()\n",
    "    games_list.sort()\n",
    "\n",
    "    games_dropdown.options = games_list\n",
    "\n",
    "    refresh_recommended_list(games_list[0])\n",
    "\n",
    "\n",
    "def refresh_recommended_list(selected_game_name):\n",
    "    global recommended_games_dropdown\n",
    "    global recommended_games_frame\n",
    "    global recommended_games_list\n",
    "    global games_frame\n",
    "    global dropdown_output\n",
    "\n",
    "    selected_game_row = games_frame[games_frame[\"Name\"] == selected_game_name]\n",
    "    vectorizer = CountVectorizer()\n",
    "\n",
    "    # Create developer name similarity vector.\n",
    "    developer_vocabulary = vectorizer.fit(selected_game_row[\"Developer\"])\n",
    "    developer_selected_vector = developer_vocabulary.transform(selected_game_row[\"Developer\"])\n",
    "    developer_similarity_vector = developer_vocabulary.transform(games_frame[\"Developer\"])\n",
    "\n",
    "    # Create game name similarity vector.\n",
    "    name_vocabulary = vectorizer.fit(selected_game_row[\"Name\"])\n",
    "    name_selected_vector = name_vocabulary.transform(selected_game_row[\"Name\"])\n",
    "    name_similarity_vector = name_vocabulary.transform(games_frame[\"Name\"])\n",
    "\n",
    "    # Create critic score similarity vector.\n",
    "    critic_score_selected_vector = selected_game_row[\"Critic_Score\"]\n",
    "    critic_score_similarity_vector = games_frame[\"Critic_Score\"]\n",
    "\n",
    "    critic_score_selected_vector = np.array(critic_score_selected_vector)\n",
    "    critic_score_similarity_vector = np.array(critic_score_similarity_vector)\n",
    "\n",
    "    # Create user score similarity vector.\n",
    "    user_score_selected_vector = selected_game_row[\"User_Score\"]\n",
    "    user_score_similarity_vector = games_frame[\"User_Score\"]\n",
    "\n",
    "    user_score_selected_vector = user_score_selected_vector.replace(to_replace=\"tbd\", value=\"0\")\n",
    "    user_score_similarity_vector = user_score_similarity_vector.replace(to_replace=\"tbd\", value=\"0\")\n",
    "\n",
    "    user_score_selected_vector = np.array(user_score_selected_vector)\n",
    "    user_score_similarity_vector = np.array(user_score_similarity_vector)\n",
    "\n",
    "    user_score_selected_vector = user_score_selected_vector.astype(\"float64\")\n",
    "    user_score_similarity_vector = user_score_similarity_vector.astype(\"float64\")\n",
    "\n",
    "    # Determine the similarity of all characteristics.\n",
    "    developer_cosine = cosine_similarity(developer_selected_vector, developer_similarity_vector)\n",
    "    name_cosine = cosine_similarity(name_selected_vector, name_similarity_vector)\n",
    "\n",
    "    # Invert critic score difference and scale to cosine similarities.\n",
    "    critic_score_similarity = ((100 - np.absolute(critic_score_selected_vector - critic_score_similarity_vector)) / 100)\n",
    "    user_score_similarity = ((10 - np.absolute(user_score_selected_vector - user_score_similarity_vector)) / 10)\n",
    "\n",
    "    similarity_vector = developer_cosine + name_cosine + critic_score_similarity + user_score_similarity\n",
    "\n",
    "    recommended_games_frame = pd.DataFrame(games_frame[[\"Name\", \"Developer\", \"Critic_Score\", \"User_Score\"]])\n",
    "    recommended_games_frame.insert(0, \"Similarity\", similarity_vector[0])\n",
    "    recommended_games_frame.sort_values(by=\"Similarity\", ascending=False, inplace=True)\n",
    "    recommended_games_frame = recommended_games_frame.head(6)\n",
    "    recommended_games_list = recommended_games_frame[\"Name\"].tolist()\n",
    "\n",
    "    # Don't include the already selected game in the recommendations.\n",
    "    recommended_games_list.remove(selected_game_name)\n",
    "\n",
    "    recommended_games_dropdown.options = recommended_games_list\n",
    "    recommended_games_dropdown.value = recommended_games_list[0]\n",
    "\n",
    "    with dropdown_output:\n",
    "        dropdown_output.clear_output()\n",
    "\n",
    "        items1 = widgets.VBox([platform_dropdown, genre_dropdown, games_dropdown, recommended_games_dropdown], layout=widgets.Layout(padding=\"50px 50px 0px 0px\"))\n",
    "        items2 = widgets.Output()\n",
    "        with items2:\n",
    "            display(recommended_games_frame)\n",
    "        display(widgets.HBox([items1, items2]))\n",
    "\n",
    "    update_output()\n",
    "\n",
    "\n",
    "def update_output():\n",
    "    global dropdown_output\n",
    "    global plot_output\n",
    "\n",
    "    IPython.display.clear_output()\n",
    "\n",
    "    display(dropdown_output)\n",
    "    display(plot_output)\n",
    "\n",
    "\n",
    "def update_plots():\n",
    "    global videogame_database\n",
    "    global selected_platform\n",
    "    global platform_dropdown\n",
    "    global genre_dropdown\n",
    "    global games_dropdown\n",
    "    global plot_output\n",
    "    global recommended_games_dropdown\n",
    "    global recommended_games_frame\n",
    "    global figure1\n",
    "    global figure2\n",
    "    global figure3\n",
    "\n",
    "    with plot_output:\n",
    "        plot_output.clear_output()\n",
    "\n",
    "        mpl.pyplot.close(1)\n",
    "        mpl.pyplot.close(2)\n",
    "        mpl.pyplot.close(3)\n",
    "        \n",
    "        print(\"This bar chart shows the average global sales among games on this platform by each genre available.\")\n",
    "        figure1 = mpl.pyplot.figure(figsize=(10,7))\n",
    "        print(\"This pie chart shows the percentage of games in each genre for this platform.\")\n",
    "        figure2 = mpl.pyplot.figure(figsize=(10,10))\n",
    "        print(\"This scatter plot shows possible correlations between critic scores and global sales.\")\n",
    "        figure3 = mpl.pyplot.figure(figsize=(10,5))\n",
    "\n",
    "        selected_platform_frame = videogame_database[videogame_database[\"Platform\"] == selected_platform]\n",
    "        genre = selected_platform_frame[\"Genre\"].unique().tolist()\n",
    "        genre.sort()\n",
    "\n",
    "        # Calculate the average global sales for each platform.\n",
    "        selected_platform_frame = selected_platform_frame.astype({\"Global_Sales\": \"float64\"})\n",
    "        mean_global_sales = selected_platform_frame.sort_values(\"Genre\").groupby([\"Genre\"])[\"Global_Sales\"].mean()\n",
    "        sales = mean_global_sales.tolist()\n",
    "\n",
    "        title = \"Average Global Sales by Genre on Platform: {0} (In Millions)\".format(selected_platform)\n",
    "\n",
    "        mpl.pyplot.figure(1)\n",
    "        mpl.pyplot.barh(genre, sales, color ='blue', align=\"edge\")\n",
    "        mpl.pyplot.title(title)\n",
    "        mpl.pyplot.xlabel(\"Sales\")\n",
    "        mpl.pyplot.ylabel(\"Genre\")\n",
    "\n",
    "        # Calculate the percentage of games in each genre on the platform.\n",
    "        title = \"Percentage of Games in Genre on Platform: {0}\".format(selected_platform)\n",
    "\n",
    "        genre_percentage = selected_platform_frame.sort_values(\"Genre\").groupby([\"Genre\"])[\"Name\"].count()\n",
    "\n",
    "        mpl.pyplot.figure(2)\n",
    "        mpl.pyplot.pie(genre_percentage, None, genre)\n",
    "        mpl.pyplot.title(title)\n",
    "        mpl.pyplot.legend(loc=\"right\")\n",
    "\n",
    "        # Calculate the scatter of global sales and critic scores on the platform.\n",
    "        sales = selected_platform_frame[\"Global_Sales\"]\n",
    "        scores = selected_platform_frame[\"Critic_Score\"]\n",
    "\n",
    "        title = \"Distribution of Sales over Critic Score on Platform: {0}\".format(selected_platform)\n",
    "\n",
    "        mpl.pyplot.figure(3)\n",
    "        mpl.pyplot.scatter(scores, sales)\n",
    "        mpl.pyplot.title(title)\n",
    "        mpl.pyplot.xlabel(\"Scores\")\n",
    "        mpl.pyplot.ylabel(\"Sales\")\n",
    "\n",
    "    update_output()\n",
    "\n",
    "\n",
    "videogame_database = pd.read_csv(\"Video_Games_Sales_as_at_22_Dec_2016.csv\")\n",
    "\n",
    "platform_dropdown_list = videogame_database[\"Platform\"].unique().tolist()\n",
    "\n",
    "selected_platform = platform_dropdown_list[0]\n",
    "selected_platform_frame = videogame_database[videogame_database[\"Platform\"] == selected_platform]\n",
    "\n",
    "genre_dropdown_list = selected_platform_frame[\"Genre\"].unique().tolist()\n",
    "genre_dropdown_list.sort()\n",
    "\n",
    "selected_genre = genre_dropdown_list[0]\n",
    "\n",
    "platform_dropdown = widgets.Dropdown(options=platform_dropdown_list, description=\"Platform:\", value=selected_platform)\n",
    "genre_dropdown = widgets.Dropdown(options=genre_dropdown_list, description=\"Genre:\", value=selected_genre)\n",
    "\n",
    "games_list = [None]\n",
    "games_dropdown = widgets.Dropdown(options=games_list, description=\"Game:\", value=None)\n",
    "\n",
    "recommended_games_list = [None]\n",
    "recommended_games_dropdown = widgets.Dropdown(options=recommended_games_list, description=\"Recommended:\", value=None, style = {\"description_width\": \"initial\"})\n",
    "\n",
    "# Do initial output setup.\n",
    "plot_output = widgets.Output()\n",
    "dropdown_output = widgets.Output()\n",
    "\n",
    "refresh_games_list()\n",
    "\n",
    "platform_dropdown.observe(platform_change, names = \"value\")\n",
    "genre_dropdown.observe(genre_change, names = \"value\")\n",
    "games_dropdown.observe(game_change, names = \"value\")\n",
    "\n",
    "update_plots()\n",
    "update_output()"
   ]
  }
 ],
 "metadata": {
  "extensions": {
   "jupyter_dashboards": {
    "activeView": "grid_default",
    "version": 1,
    "views": {
     "grid_default": {
      "cellMargin": 10,
      "defaultCellHeight": 20,
      "maxColumns": 12,
      "name": "grid",
      "type": "grid"
     },
     "report_default": {
      "name": "report",
      "type": "report"
     }
    }
   }
  },
  "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}