Applying Machine Learning Is Not Enough, Predicting Ratings From Games Genres

Preface

In this blog post we fit a naive Bayes model to predict games critic ratings given their genres. Data are scraped from best metacritic ps4 games through a scrapper of mine. We do not claim a result of value. An introductory recommender system course yields results much more accurate and reliable than approach presented here. Why am I doing this then? As machine learning today is overwhelmingly hyped, It is nice to have a facet of it in my portfolio. Jump directly to discussion to briefly get into the gist of this post.

---

Table of Contentes

Intro

• Preface

Data Preprocessing

• Data Cleansing
• Discretize Critic Rating
• Obtain Unique Series of Genres
• Create Column For Each Genre. Its Value Corresponds To Whether It is in Game’s Genres

Applying Machine Learning

• Naive Gaussian Bayes
• Predicting Upcoming Games
• Discussion

---

Import Libraries and Local Files

# 3rd-party libraries
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
# local-files
import jsonRW as jsRW
import discretizeIntoCategories as discIntCat

---

Data Cleansing

Read Data

# read its local json file
metacritic_json = jsRW.readJson('metacritic2019ps4_data')
# parse it as pandas dataframe, then map platform name to it
df = pd.DataFrame(metacritic_json)

df

---

Drop Irrelevant Columns

df = df.drop(['developer', 'name', 'publisher', 'release_data', 'users_rating'], axis=1)

df

Critic Rating Data Type To Integer

df.dtypes

critic_rating    object
genres           object
dtype: object

df['critic_rating'] = pd.to_numeric(df['critic_rating'])

df.dtypes

critic_rating     int64
genres           object
dtype: object

---

Discretize Critic Rating

# categories to be mapped as they fall within certain ranges
categories = pd.Series(["very_low", "low", "moderate", "high", "very_high"])
# critic ratings ranges to be mapped
intervals_categories = [0, 20, 40, 60, 80]

# compute categories according to ranges specified
df['category'] = df.apply(discIntCat.numToCat, axis=1, args=('critic_rating', categories, intervals_categories))
# let categories be recognized by pandas
df['category'] = df['category'].astype("category")
# order categories
df['category'] = df['category'].cat.set_categories(categories, ordered=True)    

df

---

Drop Critic Rating

df = df.drop(['critic_rating'], axis=1)

df

---

Obtain Unique Series of Genres

sr_genres = df['genres']

sr_genres

0                [Role-Playing, Massively Multiplayer]
1                           [Role-Playing, Action RPG]
2                         [Action Adventure, Survival]
3                          [Action Adventure, General]
4                           [Role-Playing, Action RPG]
                            ...                       
336          [Action, Shooter, Shoot-'Em-Up, Top-Down]
337                        [Action Adventure, General]
338                         [Role-Playing, Action RPG]
339    [Sci-Fi, Action, Shooter, First-Person, Arcade]
340                                   [Puzzle, Action]
Name: genres, Length: 341, dtype: object

# concatenate genres lists, then filter duplicated elements
unique_genres = np.unique(np.concatenate(sr_genres, axis=0))

unique_genres

array(['2D', '3D', '4X', 'Action', 'Action Adventure', 'Action RPG',
       'Adventure', 'Arcade', 'Automobile', 'Baseball', 'Basketball',
       "Beat-'Em-Up", 'Biking', 'Billiards', 'Boxing / Martial Arts',
       'Business / Tycoon', 'Card Battle', 'Career', 'Civilian', 'Combat',
       'Command', 'Compilation', 'Cricket', 'Dancing', 'Defense',
       'Fantasy', 'Fighting', 'First-Person', 'Flight', 'Football',
       'General', 'Golf', 'Government', 'Ice Hockey', 'Individual',
       'Japanese-Style', 'Light Gun', 'Linear', 'Management', 'Marine',
       'Massively Multiplayer', 'Matching', 'Miscellaneous', 'Music',
       'Open-World', 'Other', 'Party / Minigame', 'Platformer',
       'Point-and-Click', 'Puzzle', 'Racing', 'Real-Time', 'Rhythm',
       'Roguelike', 'Role-Playing', 'Sandbox', 'Sci-Fi', "Shoot-'Em-Up",
       'Shooter', 'Sim', 'Simulation', 'Skate / Skateboard', 'Soccer',
       'Space', 'Sports', 'Strategy', 'Survival', 'Tactical', 'Tactics',
       'Team', 'Third-Person', 'Top-Down', 'Turn-Based', 'Vehicle',
       'Virtual', 'Virtual Life', 'Visual Novel', 'Western-Style',
       'Wrestling'], dtype='<U21')

---

Remove Spaces, Slashes and Dashes From Genres Names

# spaces, slashes and dashes converter to underscores and empty string
def underscoreCleaner(strLis_in):
    tem_string = strLis_in
    tem_string = tem_string.replace(' ', '_')
    tem_string = tem_string.replace('/', '')
    tem_string = tem_string.replace('-', '_')
    return tem_string

temLis = pd.Series(unique_genres)

# apply cleaner
temLis = temLis.apply(underscoreCleaner)

cleanedUniqueGenres = temLis

cleanedUniqueGenres

0                   2D
1                   3D
2                   4X
3               Action
4     Action_Adventure
            ...       
74             Virtual
75        Virtual_Life
76        Visual_Novel
77       Western_Style
78           Wrestling
Length: 79, dtype: object

---

Create Column For Each Genre. Its Value Corresponds To Whether It is in Game’s Genres

# maps genresList_in to a boolean array, corresponding to whether a genre is in game's genres list
def isGenreIn(row_in, column_in, genresList_in):
    # game's genres list
    row_value = pd.Series(row_in[column_in])
    # all unique genres
    genresSer = pd.Series(genresList_in)
    # check whether each genre in all unique genres is in game's genres list
    # return a boolean array, corresponding to whether genre is found in game's list.
    return genresSer.isin(row_value)

# apply above function
genresAsColumns = df.apply(isGenreIn, axis=1, args=('genres', cleanedUniqueGenres))

# rename columns to all unique genres
genresAsColumns.columns = cleanedUniqueGenres

genresAsColumns

# map boolean values to integers. True to 1 and False to 0
genresAsColumns = genresAsColumns.astype(int)

genresAsColumns

---

Map Classes To Their Corresponding Numeric Indices

# a mapper from class string to its index
classesArr = np.array(["very_low", "low", "moderate", "high", "very_high"])
catToIndDict = {"very_low":0, "low":1, "moderate":2, "high":3, "very_high":4}
def catToInd(str_in):
    return catToIndDict[str_in]

classes = df['category']

classes

0      very_high
1      very_high
2      very_high
3      very_high
4      very_high
         ...    
336          low
337          low
338          low
339          low
340          low
Name: category, Length: 341, dtype: category
Categories (5, object): [very_low < low < moderate < high < very_high]

# apply above mapper
classes = classes.apply(lambda x: catToInd(x))

classes

0      4
1      4
2      4
3      4
4      4
      ..
336    1
337    1
338    1
339    1
340    1
Name: category, Length: 341, dtype: category
Categories (5, int64): [0 < 1 < 2 < 3 < 4]

---

Naive Gaussian Bayes

Convert X and Y To Numpy Arrays

genresAsColumns = genresAsColumns.to_numpy()

classes = classes.to_numpy()

genresAsColumns

array([[0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       ...,
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0]])

classes

array([4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
       4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
       4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
       4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
       3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
       3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
       3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
       3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
       3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
       3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
       3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
       3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
       3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1])

Split Data For Testing and Training

X_train, X_test, y_train, y_test = train_test_split(genresAsColumns, classes, test_size=0.3, random_state=0)

Fit Model

# initialize a guassian model
gnb = GaussianNB()
# fit model games genres and classes
clf = gnb.fit(X_train, y_train)

Predicting Test Data

y_pred = clf.predict(X_test)

Accuracy

# Number of correctly labeled points out of total, respectively
correctlyLabeledNum = (y_test == y_pred).sum()
totalPointsNum = X_test.shape[0]
print("Number of Correctly Labeled: ", correctlyLabeledNum)
print("Number of Total Points: ", totalPointsNum)

Number of Correctly Labeled:  17
Number of Total Points:  103

print("Accuracy Percentage: ", correctlyLabeledNum/totalPointsNum)

Accuracy Percentage:  0.1650485436893204

---

Predicting Upcoming Games

A Mapper From A Series Element To Its Corresponding Index

def indexFromName(series_in, str_in):
    return series_in[series_in == str_in].index[0]

indexFromName(cleanedUniqueGenres, '2D')

0

Construct Array of Indices From Strings

def arrayFromNames(series_in, strLis_in):
    # Initialize an array of 79 zeros, corresponding to genres numbers
    gameGenres = np.array([0] * 79)
    
    # for each input genre, set its corresponding value to 1
    for name in strLis_in:
        gameGenres[indexFromName(series_in, name)] = 1
        
    return gameGenres

Predict Class Name From Genres Strings

def predictClassFromGenres(strLis_in):
    # map genres strings to their corresponding indices
    gameGenreArray = arrayFromNames(cleanedUniqueGenres, strLis_in)
    # prediction of class numeric value
    gamePred = clf.predict([
        gameGenreArray
    ])
    # return predicted class name
    return classesArr[gamePred[0]]

---

Doom Eternal

predictClassFromGenres(['Action', 'Shooter', 'First_Person', 'Arcade'])

'low'

Control: The Foundation

predictClassFromGenres(['Action_Adventure', 'General'])

'low'

Resident Evil 3

predictClassFromGenres(['Action_Adventure', 'Survival'])

'moderate'

---

Discussion

Let’s now analyze the embarrassing results I reached. A realization of ignorance is not as bad as an ignorance of being ignorant. For the latter case, There is no chance for remediation, but for the former, I am skeptic of guaranteed chances.

There is no pattern to be fitted. I have seen plenty of computer science students who just care about machine learning models and give no interest to the data itself! That is exactly alike claiming astronomy is all about telescopes. In fact, Data science is all based about our understanding of real-life data and whether we could discover and verify patterns found in them. Machine learning models are toolbox for the data scientist so that he could reveal insights in data, but they are not his principal goal. Regarding our case in this blog post, It is well-known that genres are not indicators of a game’s quality at all. If the data contains no pattern, then the hypothesized pattern shall not emerge from whatever model you apply. I would doubt my self in case the model reached a high accuracy rate.

Features vectors is ridiculously simplifing the item. Two action-adventure 3rd-person games probably have totally different playing-style/theme. Simplifing games by their genres is alike describing a student’s skills qualifications through his faculty. Is graduating from CS major an indicator of student’s skills? He might be either a lazy or a dedicated student. A curious and challenging inquiry arises here. How do we represent aesthetics in terms of numbers? How do we objectively measure a game’s degree of fun? Is it even possible for science to reach at someday objective measures of human-feelings? The only aspect I am sure of is that no one is sure of answers to these questions (sounds like a self-contradictory statement, right?)

Finally, Note that naive bayes is based on the assumption that features are independant from each other, which is not the case here. Action games are more likely to be adventure, for instance.