steam-user-score-gradient-boosting

Youtube Presentation Video:

https://www.youtube.com/watch?v=YExGbJ1_Cbw

Part 1 — Dataset Overview

For this project I used the Steam Store Games Dataset, which contains information about 27,000+ games published on the Steam platform. Each row represents a game, with details such as: Game info: name, developer, publisher, release year

containing detailed information about 27,075 games on the Steam platform. Each row represents a game, and the dataset includes 18 columns

Engagement: positive/negative ratings, playtime

Attributes: genres, categories, tags, price, platforms

Target Variable I created a User Score metric based on player sentiment:

User Score

This score reflects how well players received the game.

Goal

The main goal of the project was to answer: “Can we predict a game’s user score based on its attributes and metadata?” This guided the EDA, feature engineering, regression models, and later the classification task.ֿ

📘 Part 2 — Exploratory Data Analysis (EDA) Understanding the Steam Games Dataset & Preparing for Modeling

The goal of this EDA stage is to clean the data, identify important patterns, detect anomalies, and ask meaningful questions that guide the modeling process – both for regression and classification.

1. Data Cleaning Missing Values

The dataset contains very few missing values (mainly in developer and publisher). Since they are not required for modeling, these rows were kept. Numeric columns were converted safely using to_numeric(errors='coerce') and missing numeric values were filled using the median.

Duplicate Rows

No duplicate entries were found (0 duplicates), so no additional filtering was required.

Removing Non-Game and Irrelevant Content

The Steam dataset includes software tools, multimedia programs, and adult content. To focus strictly on games, rows containing the following keywords were removed:

Software, Utilities, Animation, Photo, Video, Web Publishing, Sexual, Nudity, Adult, NSFW, Mature

This ensured:

Only real games remain

Cleaner statistical patterns

No model bias from non-game entries

Creating main_genre

Genres often include multiple categories separated by ;. We extracted the first genre to obtain a clean categorical variable:

main_genre = first genre listed

Filtering Low-Quality Ratings

Games with fewer than 200 ratings were removed to avoid noisy, unreliable user scores.

Creating user_score

User score was defined as:

user_score = (positive_ratings / total_ratings) * 100

Removing Free Games

Free games were excluded (price == 0) because their rating dynamics differ significantly from paid titles.

Final cleaned shape: ➡️ 5,348 games (from 27,075 originally)

1. Outlier Detection & Handling Price Outliers

We capped price values at the 99th percentile to remove extreme, unrealistic prices.

User Score Outliers

We kept scores between 1 and 99 to remove abnormal or corrupted entries.

Playtime Outliers

For visualizations, games with extremely high playtime (avg_playtime > 20,000) were excluded from specific plots to avoid skewed scaling.

1. Descriptive Statistics & Patterns

Here are the core insights revealed by our EDA.

3.1 Distribution of User Score

📈 Your histogram showed:

Most games score between 70–90%

Very few games score below 40%

This distribution is strongly right-skewed

🔎 Implication: User scores are positive-biased → models must account for limited variance.

3.2 Correlation Heatmap (Numeric Features)

Key observations:

Strong correlation between average_playtime and median_playtime

User score is only weakly correlated with numeric features

No direct linear relationship with price

🔎 Implication: Simple linear regression will struggle → we need engineered features and non-linear models later.

3.3 Price vs User Score

Your scatterplot demonstrates:

No clear linear trend

Cheap and expensive games both receive high or low scores

Very high variance across the price axis

🔎 Implication: Price alone is not a strong predictor of user satisfaction.

3.4 Average Playtime vs User Score

After trimming extreme outliers:

Games with very low engagement (~0–200 min) tend to have lower scores

Long-engagement games generally score higher

But high variance → playtime alone is insufficient

🔎 Implication: Playtime may contribute to prediction but not as a standalone feature.

3.5 User Score by Number of Supported Platforms

Your bar chart showed:

Games available on more platforms tend to have slightly higher scores

3-platform games average the highest ratings

Hypothesis: More polished or higher-budget titles tend to release on multiple platforms.

3.6 Genre-Level Insights

Your Top-10 average score bar chart showed:

Adventure, Casual, Indie, RPG, and Action genres receive the highest average user scores

Simulation and Violent genres rated lower

🔎 Implication: Genre is a strong categorical feature → one-hot encoding it for models is essential.

🔎 Implication: Tags hint at user expectations and quality signals, which may inspire feature engineering.

❓ 4. Research Questions

Here are interpretive questions and your answers based on your plots: Q1: Do more platforms correlate with better user scores? ✔ Yes — average user score increases with the number of supported platforms. Q2: Do certain genres consistently outperform others? ✔ Yes — Adventure, Casual, Indie, and RPG genres show the highest average scores. Q3: Does higher playtime indicate higher user satisfaction? ⭕ Partially — many high-engagement games receive high scores, but the variance is large. Q4: Does price predict user score? ❌ No — the relationship is weak; high- and low-priced games can succeed or fail equally. Q5: Are there quality signals hidden in SteamSpy tags? ✔ Yes — certain tags strongly correlate with high user scores, while others correlate with low ones.

📘 Part 3 — Baseline Regression Model Regression Goal

Our goal is to predict the user score (%) that a Steam game receives, based only on simple, raw game attributes. The baseline model helps us understand how well a very simple linear model performs before introducing feature engineering or more advanced algorithms.

Feature Selection (Baseline)

For the baseline, we intentionally start with very simple numerical features:

price

average_playtime

median_playtime

required_age

release_year

num_platforms

These are intuitive and easy-to-interpret features that reflect game complexity, age, availability, and engagement.

No feature engineering is used at this stage — the baseline is meant to be simple and honest.

Train–Test Split

We split the data using an 80/20 ratio

Using a fixed random_state ensures reproducibility, which is required.

Model Training — Linear Regression (Baseline)

We train a simple Linear Regression model:

baseline_model = LinearRegression() baseline_model.fit(X_train, y_train)

This model assumes linear relationships between the features and the user score.

Feature Importance (Linear Regression Coefficients)

To understand what the baseline model thinks is important, we visualize the absolute coefficients:

Interpretation:

num_platforms dominates the coefficients — the model incorrectly believes it is the strongest predictor

Other features have coefficients very close to zero

This confirms the model is unstable and weak — it assigns importance arbitrarily

📘 Part 4 — Feature Engineering & Clustering (Short Version)

1. Feature Engineering

I created new features to better describe each game:

total_ratings, pos_ratio, rating_balance – improved measures of user sentiment

log_avg_playtime, log_median_playtime – reduce the impact of extreme values

year_since_2000 – game age

playtime_per_dollar – value for money

complexity_score – combines platforms and playtime

Then I applied:

StandardScaler to numeric features

OneHotEncoder to main_genre, platforms, and later cluster_5

1. Clustering (KMeans)

I used KMeans (k=5) on standardized features:

price, average_playtime, num_platforms, total_ratings, pos_ratio

Each game received a new feature: cluster_5.

1. PCA Visualization

I visualized the clusters using PCA (2D). The clusters formed clear groups, meaning KMeans captured real patterns in the data.

1. Cluster Meaning

The clusters represent different game types:

High-rating AAA games

Small indie titles

Free-to-play or live-service patterns

ֿ

📘 Part 5 — Train and Evaluate Three Improved Models

After creating new features and adding the cluster-based feature (cluster_5), I trained three different regression models to improve on the baseline:

Improved Linear Regression

Random Forest Regressor

Gradient Boosting Regressor

1. Modeling Setup

I used the engineered dataset containing all numeric features + one-hot encoded categorical features + the new cluster_5 feature.

Train/test split: 80/20, with random_state=42 for reproducibility.

A preprocessing pipeline applied:

StandardScaler to numeric features

OneHotEncoder to categorical features

This ensures all models receive clean, well-scaled data.

1. Models Trained Improved Linear Regression

linear model applied to the engineered feature space.

Random Forest

A non-linear ensemble model that captures interactions between features.

Gradient Boosting (GBR)

A boosting model that builds trees sequentially and handles complex patterns.

1. Evaluation Metrics

All models were evaluated using:

MAE – Mean Absolute Error

RMSE – Root Mean Squared Error

R² – Variance explained by the model

These metrics allow a direct comparison against the baseline.

uploaded to HuggingFace

📘 Part 7 — Regression to Classification

In this section, I reframed the original regression problem (predicting a continuous user score) into a classification problem. This allows us to categorize games into performance groups and train classifiers on the engineered feature space.

7.1 Creating Classes From the Numeric Target

I converted the continuous user_score into three classes using quantile binning:

Class 0 — Low Score (bottom 33%)

Class 1 — Medium Score (middle 33%)

Class 2 — High Score (top 33%)

This strategy splits the dataset into equally sized groups, avoiding class imbalance and producing meaningful tiers of game quality.

The computed quantile thresholds were:

0 → Low: user_score ≤ Q33

1 → Medium: Q33 < user_score ≤ Q66

2 → High: user_score > Q66

📘 Part 8: Train & Evaluate Classification Models 8.1 Precision vs. Recall – What Matters More?

In this project, the goal is to predict the rating class of a Steam game (Low / Medium / High). Since this task is similar to recommending good games, the most important thing is precision for the High class.

Why Precision > Recall?

If the model predicts a game as High-rated, we want to be confident it is truly high quality. A low-precision model would recommend many mediocre games as “High”, harming user trust.

Missing a few good games (lower recall) is less harmful than recommending bad ones.

Conclusion: Precision and F1-score for Class 2 (High) are the most important metrics, more than global accuracy.

False Positives vs. False Negatives What is more problematic? — False Positives

False Positive (predicting High when the game is actually Medium/Low): The user receives a bad recommendation, causing disappointment. This is the more harmful mistake.

False Negative (predicting Medium/Low for a real High-rated game): A missed recommendation — still bad, but it does NOT harm the user directly.

Conclusion: False Positives are more critical because they reduce user trust in the recommendation system.

8.2 Train Three Classification Models

I trained 3 different classification models using the same feature engineering, preprocessing pipeline, and cluster feature:

Models Trained

Logistic Regression (Multinomial)

Random Forest Classifier

Gradient Boosting Classifier

All models were trained on the same:

17 engineered features

Categorical + numeric preprocessing

KMeans cluster feature

Stratified train/test split

8.3 Evaluation of All Models

For each model, I computed:

Accuracy

Macro F1-score (important due to balanced classes)

Weighted F1-score

Confusion Matrix

Classification Report

Below is a summary of the performance:

All models tend to confuse Medium and High classes.

Gradient Boosting shows:

Better separation of the High class

Higher precision for High

Fewer severe misclassifications

➡️ Gradient Boosting is the most stable and best overall performer.

8.4 Selecting the Winner & Exporting the Model Winning Model: Gradient Boosting

Chosen because:

Best macro F1-score

Best weighted F1-score

Best handling of the High class (our priority)

Best overall confusion matrix