review-analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Review Analysis and Classification for Battlefield 2042\n",
    "\n",
    "By Liam Zalubas\n",
    "\n",
    "## Introduction: \n",
    "\n",
    "The Battlefield franchise of video games is generally known for combining multiplayer infantry and vehicle combat in dynamic and destructible environments. Battlefield 2042 is the latest entry in the series, having been released in October of 2021. The game is available on console and PC hardware, and is available on the Steam, Origin, and the Epic Games digital marketplaces. From this point forward, I will be referring to the Steam version of the game, as it is the version I was able to collect data on most readily. Because of this, any conclusions drawn from this project may not be applicable to the game as a whole.\n",
    "\n",
    "In terms of player reception, Battlefield 2042 initially released to overwhelmingly negative reviews, but has been updated consistently since release. Over two years after its release, the game has seen a significant increase in positive reviews, bringing its overall review score from \"Mostly Negative\" (~31% positive) to \"Mostly Positive\" (~71% positive).\n",
    "\n",
    "This project aims to analyze the reviews of Battlefield 2042 on Steam by using a classifier which we will train to predict the time a review was posted, given the text of the review. We will then use this classifier to analyze the reviews of Battlefield 2042 and see if there are any trends in the reviews over time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Gathering: \n",
    "\n",
    "The first step is to gather the data. To download reviews on Steam, we can use the Steam API. The Steam API is a web API which allows us to access data from the Steam store and community pages. For Python, we can import the `steamreviews` library to access the API. The following code makes a request to the API for some reviews of Battlefield 2042, and saves the results to a pandas dataframe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[appID = 1517290] expected #reviews = 80453\n",
      "     review_id                                        review_text  \\\n",
      "0    153522729  My friend was 10 feet in front of me picking m...   \n",
      "1    153527630  This could be a pretty decent game, but unfort...   \n",
      "2    153479542  Not the greatest Battlefield experience, but i...   \n",
      "3    153479197                                 it fixed play game   \n",
      "4    153477433                                               Nice   \n",
      "..         ...                                                ...   \n",
      "121  153444017  I avoided this game for a long time due to the...   \n",
      "122  153443143  (Only jumped in a quarter into season 6)\\nHone...   \n",
      "123  153355918  They've done a lot for the game since the horr...   \n",
      "124  153207345      dog shit, battlefield will never be the same.   \n",
      "125  153234689      This game suck so much, i tried i really did.   \n",
      "\n",
      "     latest_update  is_recommended  \n",
      "0       1702490638            True  \n",
      "1       1702496004           False  \n",
      "2       1702430202            True  \n",
      "3       1702429697            True  \n",
      "4       1702426992            True  \n",
      "..             ...             ...  \n",
      "121     1702389257            True  \n",
      "122     1702388319            True  \n",
      "123     1702276913            True  \n",
      "124     1702127280           False  \n",
      "125     1702149670           False  \n",
      "\n",
      "[126 rows x 4 columns]\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import steamreviews\n",
    "\n",
    "# Set the app ID for Battlefield 2042\n",
    "app_id = 1517290\n",
    "\n",
    "# Set the request parameters\n",
    "request_params = dict()\n",
    "request_params['review_type'] = 'all'\n",
    "request_params['filter'] = 'all'\n",
    "request_params['day_range'] = '7'\n",
    "request_params['language'] = 'english'\n",
    "request_params['purchase_type'] = 'steam'\n",
    "\n",
    "# Fetch the reviews using the steamreviews library\n",
    "review_dict, query_count = steamreviews.download_reviews_for_app_id(app_id, chosen_request_params=request_params)\n",
    "\n",
    "# Create a list to store the review data\n",
    "review_data = []\n",
    "\n",
    "# Iterate over the reviews in review_dict\n",
    "for review_id in review_dict['reviews']:\n",
    "    # Extract the desired values from the review\n",
    "    review_text = review_dict['reviews'][review_id]['review']\n",
    "    latest_update = review_dict['reviews'][review_id]['timestamp_updated']\n",
    "    is_recommended = review_dict['reviews'][review_id]['voted_up']\n",
    "\n",
    "    # Append the review data to the list\n",
    "    review_data.append([review_id, review_text, latest_update, is_recommended])\n",
    "\n",
    "# Create a pandas DataFrame from the review data\n",
    "df = pd.DataFrame(review_data, columns=['review_id', 'review_text', 'latest_update', 'is_recommended'])\n",
    "\n",
    "# Print the DataFrame\n",
    "print(df)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Ethics: \n",
    "\n",
    "When collecting data, it is important to consider the ethics of the data collection and how mistakes or oversights in the data collection process can skew our results. In this particular example, we are considering reviews in English on the Steam store. Because this game is available on other digital distribution platforms for the PC, on gaming consoles (XBox, PlayStation), and in other countries, we must recognize that this data set is a subset of a larger data set. This means that any conclusions we draw from this data set may not be applicable to the entirety of public opinion on the game as a whole. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Munging, Wrangling, and Cleaning Data: \n",
    "\n",
    "The next step in this project is to clean the data. This means removing any data that is not relevant to our analysis, and making sure that the data is in a format that is easy to work with. In this case, we will remove any reviews that are not in English, and follow by removing any \"stop words\" from the review text itself.\n",
    "\n",
    "- I have chosen to remove non-English reviews because I am not familiar enough with other languages nor do I trust online translation services enough to be confident that I can accurately translate reviews into English. By our previous discussion of data ethics, we know this means our analysis cannot be used to draw conclusions about the experiences of non-English speaking players.\n",
    "\n",
    "- I have chosen to remove stop words because they do not provide any useful information about the review itself. Examples of stop words include \"the\", \"a\", and \"of\". These are words which are common in the English language but do not convey individual meaning without context.\n",
    "\n",
    "We will use the ```preprocess_text``` method to clean the review text for each review in our data set as well as  the ```increment_word``` method to keep track of the frequency of each word in our data set, :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'datetime' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn [12], line 10\u001b[0m\n\u001b[0;32m      8\u001b[0m review_timestamp \u001b[38;5;241m=\u001b[39m row[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlatest_update\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[0;32m      9\u001b[0m \u001b[38;5;66;03m# convert the timestamp to a datetime object\u001b[39;00m\n\u001b[1;32m---> 10\u001b[0m review_datetime \u001b[38;5;241m=\u001b[39m \u001b[43mdatetime\u001b[49m\u001b[38;5;241m.\u001b[39mdatetime\u001b[38;5;241m.\u001b[39mfromtimestamp(review_timestamp)\n\u001b[0;32m     11\u001b[0m \u001b[38;5;66;03m# iterate over the time periods and find the correct one\u001b[39;00m\n\u001b[0;32m     12\u001b[0m time_period \u001b[38;5;241m=\u001b[39m ()\n",
      "\u001b[1;31mNameError\u001b[0m: name 'datetime' is not defined"
     ]
    }
   ],
   "source": [
    "# it appears I just lost all my code in this block before this point.\n",
    "\n",
    "# for each row in the DataFrame, process the review and update the 'review_text' column\n",
    "for index, row in df.iterrows():\n",
    "    review_text = row['review_text']\n",
    "\n",
    "    # get the review's timestamp to find the time period\n",
    "    review_timestamp = row['latest_update']\n",
    "    # convert the timestamp to a datetime object\n",
    "    review_datetime = datetime.datetime.fromtimestamp(review_timestamp)\n",
    "    # iterate over the time periods and find the correct one\n",
    "    time_period = ()\n",
    "\n",
    "    for interval in time_period_list:\n",
    "        if review_datetime >= interval[0] and review_datetime <= interval[1]:\n",
    "            time_period = interval\n",
    "            break\n",
    "    else:\n",
    "        # handle the case when the time period is not found\n",
    "        continue\n",
    "\n",
    "    processed_text = preprocess_text(review_text, time_period)\n",
    "\n",
    "    # if processed_text is empty, remove the row from the DataFrame\n",
    "    if not processed_text:\n",
    "        df.drop(index, inplace=True)\n",
    "    else:\n",
    "        df.at[index, 'review_text'] = processed_text\n",
    "\n",
    "# Print the updated dataframe\n",
    "# print(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Analysis: \n",
    "\n",
    "Assuming I had not lost the majority of my code, I would now have:\n",
    "- A comprehensive list of all the reviews for Battlefield 2042 on Steam\n",
    "- A list of all the words used in the reviews and their frequency for each month of the game's release\n",
    "- A word count for each month of the game's release\n",
    "\n",
    "From here, we would be able to use the word count to train a classifier to predict the month a review was posted based on the text of the review. \n",
    "\n",
    "To do this, we could use the ```train_test_split``` method from the ```sklearn``` library to split our data into a training set and a testing set. \n",
    "- We want to do this because we want to train our classifier on a subset of our data, and then test it on the rest of our data to see how accurate it is. If we didn't do this, we would be testing our classifier on the same data we trained it on, which would give us a false sense of accuracy.\n",
    "\n",
    "We would then use the ```fit``` method to train our classifier on the training set, and the ```predict``` method to predict the month a review was posted based on the text of the review. \n",
    "\n",
    "- Training our classifier means that we are teaching it how to predict the month a review was posted based on the text of the review. We do this by showing it the text of a review and the month it was posted, and then asking it to predict the month a review was posted based on the text of the review. Our model would be using Multinomial Naive Bayes, which is a classification algorithm that would use Bayes' Theorem to predict the probability of a review being posted in a given month based on the text of the review. For each review, our classifier would be calculating the probability of the review being posted in each month, and then predicting the month with the highest probability.\n",
    "\n",
    "We could then use the ```score``` method to determine the accuracy of our classifier.\n",
    "\n",
    "- Scoring our classifier means that we are asking it to predict the month a review was posted based on the text of the review, and then comparing its prediction to the actual month the review was posted. We would do this for each review in our testing set, and then calculate the percentage of correct predictions. This percentage would be our accuracy score. The higher our accuracy score, the more accurate our classifier is at making this particular prediction."
   ]
  }
 ],
 "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}