import pandas as pd  # For data manipulation
import numpy as np # For numerical calculations
import matplotlib.pyplot as plt # For data visualisations
import seaborn as sns # Advanced statistics

# To scale the data using z-score 
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

# Algorithm packages
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV # automatically test different hyperparameters

# Model evaluation metrics
from sklearn import metrics
from sklearn.metrics import confusion_matrix, classification_report, precision_recall_curve,recall_score, precision_score, roc_auc_score, RocCurveDisplay

# To suppress warning messages for cleaner output
import warnings
warnings.filterwarnings("ignore")

# Packages for descion tree model
from sklearn.tree import DecisionTreeClassifier, plot_tree

# Packages for KMeans
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score

# Packages for hierarchy
from sklearn.cluster import AgglomerativeClustering
from scipy.cluster.hierarchy import dendrogram, linkage

# --- Load the dataset from a CSV file and asign to pandas dataframe ---
df = pd.read_csv('online_gaming_behavior_dataset.csv')

# Preview the first few rows
df.head()

# Display summary of your dataset’s structure
df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 40034 entries, 0 to 40033
Data columns (total 13 columns):
 #   Column                     Non-Null Count  Dtype  
---  ------                     --------------  -----  
 0   PlayerID                   40034 non-null  int64  
 1   Age                        40034 non-null  int64  
 2   Gender                     40034 non-null  object 
 3   Location                   40034 non-null  object 
 4   GameGenre                  40034 non-null  object 
 5   PlayTimeHours              40034 non-null  float64
 6   InGamePurchases            40034 non-null  int64  
 7   GameDifficulty             40034 non-null  object 
 8   SessionsPerWeek            40034 non-null  int64  
 9   AvgSessionDurationMinutes  40034 non-null  int64  
 10  PlayerLevel                40034 non-null  int64  
 11  AchievementsUnlocked       40034 non-null  int64  
 12  EngagementLevel            40034 non-null  object 
dtypes: float64(1), int64(7), object(5)
memory usage: 4.0+ MB

# Check for unique values in each column
df.nunique()

PlayerID                     40034
Age                             35
Gender                           2
Location                         4
GameGenre                        5
PlayTimeHours                40034
InGamePurchases                  2
GameDifficulty                   3
SessionsPerWeek                 20
AvgSessionDurationMinutes      170
PlayerLevel                     99
AchievementsUnlocked            50
EngagementLevel                  3
dtype: int64

# Drop columns not needeed for predictions
df=df.drop(['PlayerID'],axis=1)  # axis 1 means column

# --- Creating numerical columns ---
num_cols = [
    'Age',
    'PlayTimeHours',
    'InGamePurchases',
    'SessionsPerWeek',
    'AvgSessionDurationMinutes',
    'PlayerLevel',
    'AchievementsUnlocked'
]

# --- Creating categorical columns ---
cat_cols = [
    'Gender',
    'Location',
    'GameGenre',
    'GameDifficulty',
    'EngagementLevel'   # Target kept for data exploration (will be separated later)
]

# summary statistics for each numerical column
df[num_cols].describe().T

# Creating histograms
df[num_cols].hist(figsize=(14,14))
plt.show()

# Loop through each categorical column and print the percentage distribution of its categories,
for i in cat_cols:
    print(df[i].value_counts(normalize=True))
    print('')
    print('----'*20) #Separate for readability
    print('')

Gender
Male      0.598466
Female    0.401534
Name: proportion, dtype: float64

--------------------------------------------------------------------------------

Location
USA       0.399660
Europe    0.299845
Asia      0.202203
Other     0.098291
Name: proportion, dtype: float64

--------------------------------------------------------------------------------

GameGenre
Sports        0.201029
Action        0.200804
Strategy      0.200130
Simulation    0.199406
RPG           0.198631
Name: proportion, dtype: float64

--------------------------------------------------------------------------------

GameDifficulty
Easy      0.49995
Medium    0.30002
Hard      0.20003
Name: proportion, dtype: float64

--------------------------------------------------------------------------------

EngagementLevel
Medium    0.483939
High      0.258181
Low       0.257881
Name: proportion, dtype: float64

--------------------------------------------------------------------------------

for col in cat_cols:
    if col != 'EngagementLevel':
        
        # Create a percentage table showing how EngagementLevel is distributed within each feature.
        engagement_table = (
            pd.crosstab(df[col], df['EngagementLevel'], normalize='index')
            .mul(100)
        )

        # Plot the distribution using a stacked bar chart.
        ax = engagement_table.plot(
            kind='bar',
            figsize=(9, 5),
            stacked=True
        )
        
        # Add percentage labels on the bars
        for c in ax.containers:
            ax.bar_label(c, fmt='%.1f%%', label_type='center') 
        
        # Labels and titles
        plt.title(f'Engagement Level Distribution by {col}')
        plt.ylabel('Percentage (%)')
        plt.xlabel(col)
        plt.legend(title='EngagementLevel')
        
        plt.tight_layout()
        plt.show()

# Calculate the mean of each numerical feature for High, Medium, and Low engagement groups
df.groupby('EngagementLevel')[num_cols].mean()

# Plotting the correlation between numerical variables
plt.figure(figsize=(15,8))
sns.heatmap(df[num_cols].corr(), annot=True, fmt='0.2f', cmap='YlOrRd')

<Axes: >

# Step 1
# Create dummy variables for categorical features using the get_dummies pandas function
# Convert categorical columns into numerical because machine learning models cannot work with text
df = pd.get_dummies(
    data=df,
    columns=['Gender', 'Location', 'GameGenre', 'GameDifficulty'], 
    drop_first=True
)

# -------------------------------------------------------------

# Step 2 - Encode the target variable (EngagementLevel)
# Convert the target variables  into numbers so the model can
# learn to classify High, Medium, and Low.
engagement_mapping = {'Low': 0, 'Medium': 1, 'High': 2}
df['EngagementLevel'] = df['EngagementLevel'].map(engagement_mapping)

# -------------------------------------------------------------

# Step 3 - Separate independent (X) and dependent (y) variables
# X = features used for prediction
# y = what we are trying to predict (EngagementLevel)

X = df.drop(columns=['EngagementLevel'])
y = df['EngagementLevel']

# -------------------------------------------------------------

# Step 4-  Split the data into training and test sets
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.3,        # 70% train, 30% test
    random_state=1,       # ensures consistent results
    stratify=y            # keeps class ratios balanced
)

# Step 1 - Initialise the scaler
# StandardScaler transforms each feature so it has mean=0 and std=1
scaler = StandardScaler()

# -----------------------------------------------

# Step 2 -  Fit the scaler on the training data only
X_train_scaled = scaler.fit_transform(X_train)

# Convert back to DataFrame for readability
X_train_scaled = pd.DataFrame(X_train_scaled, columns=X_train.columns)

# -----------------------------------------------
# Step 3 - Transform the test data
X_test_scaled = scaler.transform(X_test)

# Convert back to DataFrame for readability
X_test_scaled = pd.DataFrame(X_test_scaled, columns=X_test.columns)

# Function to Prints classification report and displays a confusion matrix heatmap
def metrics_score(actual, predicted):
   
    # Print precision, recall and F1-score for each class
    print(classification_report(actual, predicted))
    
    # Generate confusion matrix
    cm = confusion_matrix(actual, predicted)
    
    # Plot the matrix
    plt.figure(figsize=(8,5))
    sns.heatmap(
        cm, 
        annot=True, 
        fmt='g',
        cmap='Blues',
        xticklabels=['High', 'Medium', 'Low'],
        yticklabels=['High', 'Medium', 'Low']
    )
    
    plt.title('Confusion Matrix')
    plt.xlabel('Predicted')
    plt.ylabel('Actual')
    plt.show()

# Create a Linear SVM model. The random_state is set to 1 so the results are reproducible each time the code is run.
svm_linear = SVC(kernel='linear', random_state=1)

# Fit model
svm_linear.fit(X_train_scaled, y_train)

# Predict on train
y_pred_train_linear = svm_linear.predict(X_train_scaled)
print("\nTrain Results (Linear):")
metrics_score(y_train, y_pred_train_linear)

# Predict on test
y_pred_test_linear = svm_linear.predict(X_test_scaled)
print("\nTest Results (Linear):")
metrics_score(y_test, y_pred_test_linear)

Train Results (Linear):
              precision    recall  f1-score   support

           0       0.79      0.71      0.75      7227
           1       0.81      0.87      0.84     13561
           2       0.89      0.85      0.87      7235

    accuracy                           0.82     28023
   macro avg       0.83      0.81      0.82     28023
weighted avg       0.83      0.82      0.82     28023

Test Results (Linear):
              precision    recall  f1-score   support

           0       0.79      0.71      0.75      3097
           1       0.81      0.87      0.84      5813
           2       0.89      0.85      0.87      3101

    accuracy                           0.82     12011
   macro avg       0.83      0.81      0.82     12011
weighted avg       0.82      0.82      0.82     12011

# Create a rbf SVM model. The random_state is set to 1 so the results are reproducible each time the code is run.
svm_rbf = SVC(kernel='rbf', random_state=1, probability=True)

# Fit model
svm_rbf.fit(X_train_scaled, y_train)

# Predict on train
y_pred_train_rbf = svm_rbf.predict(X_train_scaled)
print("\nTrain Results (RBF):")
metrics_score(y_train, y_pred_train_rbf)

# Predict on test
y_pred_test_rbf = svm_rbf.predict(X_test_scaled)
print("\nTest Results (RBF):")
metrics_score(y_test, y_pred_test_rbf)

Train Results (RBF):
              precision    recall  f1-score   support

           0       0.91      0.85      0.88      7227
           1       0.89      0.95      0.92     13561
           2       0.93      0.87      0.90      7235

    accuracy                           0.91     28023
   macro avg       0.91      0.89      0.90     28023
weighted avg       0.91      0.91      0.91     28023

Test Results (RBF):
              precision    recall  f1-score   support

           0       0.89      0.82      0.86      3097
           1       0.87      0.93      0.90      5813
           2       0.92      0.85      0.88      3101

    accuracy                           0.89     12011
   macro avg       0.89      0.87      0.88     12011
weighted avg       0.89      0.89      0.88     12011

#Create a polynomial SVM 
svm_poly3 = SVC(kernel='poly', degree=3, random_state=1)

# Fit model
svm_poly3.fit(X_train_scaled, y_train)

# Predict on train
y_pred_train_poly3 = svm_poly3.predict(X_train_scaled)
print("\nTrain Results (Polynomial):")
metrics_score(y_train, y_pred_train_poly3)

# Predict on test
y_pred_test_poly3 = svm_poly3.predict(X_test_scaled)
print("\nTest Results (Polynomial):")
metrics_score(y_test, y_pred_test_poly3)

Train Results (Polynomial):
              precision    recall  f1-score   support

           0       0.90      0.80      0.85      7227
           1       0.85      0.94      0.89     13561
           2       0.92      0.83      0.87      7235

    accuracy                           0.88     28023
   macro avg       0.89      0.86      0.87     28023
weighted avg       0.88      0.88      0.88     28023

Test Results (Polynomial):
              precision    recall  f1-score   support

           0       0.88      0.78      0.83      3097
           1       0.83      0.93      0.88      5813
           2       0.91      0.82      0.86      3101

    accuracy                           0.86     12011
   macro avg       0.87      0.84      0.86     12011
weighted avg       0.86      0.86      0.86     12011

# First We start with a base RBF SVM model
svm_rbf_base = SVC(
    kernel='rbf',
    probability=True,
    random_state=1
)

# Create a grid of hyperparameters to test
param_grid = {
    'C': [0.1, 1, 10],
    'gamma': ['scale', 0.1, 0.01],
    'class_weight': [None, 'balanced']
}

# GridSearch
# Scoring = recall_macro means we focus on calculating recall for each class (Low, Medium, High)
# cv=3 means 3-fold cross-validation, split training data into 3 parts, train on 2 parts, validate on 1 part
# n_jobs=-1 means use all CPU cores to enable to model to run faster

grid_search = GridSearchCV(
    estimator=svm_rbf_base,
    param_grid=param_grid,
    scoring='recall_macro',  
    cv=3,
    n_jobs=-1
)

# ----------------------------------------------------------------------------------------------------

# Run the hyperparameter search, tries all parameter combinations
grid_search.fit(X_train_scaled, y_train)

# ----------------------------------------------------------------------------------------------------

# Show the best parameters and best CV score fromt he grid search
print("\nBest parameters found: "), print(grid_search.best_params_)
print("\nBest cross-validated macro recall:", round(grid_search.best_score_, 3))

# Use the best model found by GridSearchCV,  
# This gives a fully-trained SVM using the best hyperparameters.
# This avoids the need to manually refit the model with the best parameters.
svm_rbf_tuned = grid_search.best_estimator_

# ----------------------------------------------------------------------------------------------------

# Evaluate the tuned model on train and test sets
# Predict on train
print("\nTrain Results (Tuned RBF):")
y_pred_train_rbf_tuned = svm_rbf_tuned.predict(X_train_scaled)
metrics_score(y_train, y_pred_train_rbf_tuned)

## Predict on test
print("\nTest Results (Tuned RBF):")
y_pred_test_rbf_tuned = svm_rbf_tuned.predict(X_test_scaled)
metrics_score(y_test, y_pred_test_rbf_tuned)

Best parameters found: 
{'C': 10, 'class_weight': 'balanced', 'gamma': 0.01}

Best cross-validated macro recall: 0.879

Train Results (Tuned RBF):
              precision    recall  f1-score   support

           0       0.82      0.90      0.86      7227
           1       0.93      0.86      0.89     13561
           2       0.87      0.91      0.89      7235

    accuracy                           0.88     28023
   macro avg       0.87      0.89      0.88     28023
weighted avg       0.89      0.88      0.88     28023

Test Results (Tuned RBF):
              precision    recall  f1-score   support

           0       0.82      0.89      0.85      3097
           1       0.92      0.85      0.89      5813
           2       0.87      0.90      0.88      3101

    accuracy                           0.88     12011
   macro avg       0.87      0.88      0.88     12011
weighted avg       0.88      0.88      0.88     12011

# Convert data to binary  (Low vs Not-Low)
# This checks every value in y_train and y_test:
#     If the value is 0 (Low) then TRUE is retunred
#     if the value is 1 or 2 → then FALSE is retunred
#     Finally convert True to 1 (Low) and False to 0 (Medium and High)
y_train_low = (y_train == 0).astype(int)
y_test_low  = (y_test == 0).astype(int)

# ----------------------------------------------------
# identify Probability of the LOW class

#Finds which column of predict_proba relates to Low engagement
low_index = list(svm_rbf_tuned.classes_).index(0)

#Gets the predicted probability for train and test
y_scores_train = svm_rbf_tuned.predict_proba(X_train_scaled)[:, low_index]
y_scores_test  = svm_rbf_tuned.predict_proba(X_test_scaled)[:, low_index]

# -----------------------------------------------------

# AUC-ROC score
auc = roc_auc_score(y_test_low, y_scores_test)
print("AUC-ROC (Test):", round(auc, 3))

# Plot result
RocCurveDisplay.from_predictions(y_test_low, y_scores_test)
plt.title("ROC Curve (Low vs Not-Low)")
plt.show()

# ----------------------------------------------------

# Plot values of precisions, recalls, and thresholds
precisions, recalls, thresholds = precision_recall_curve(y_train_low, y_scores_train)

plt.figure(figsize=(8,5))
plt.plot(thresholds, precisions[:-1], label='Precision', linestyle='--')
plt.plot(thresholds, recalls[:-1], label='Recall', linestyle='--')
plt.xlabel("Threshold")
plt.ylabel("Score")
plt.title("Precision–Recall vs Threshold (Low Engagement)")
plt.legend()
plt.grid(True)
plt.show()

AUC-ROC (Test): 0.94

# Assign and apply threshold
threshold = 0.34

#---------------------------------------------------------------
             
# Apply threshold (Train)
y_pred_train_low = (y_scores_train > threshold).astype(int)

# Use classifaction report function to output results
print("\nTRAIN Results (Low vs Not-Low):")
print(classification_report(
    y_train_low, 
    y_pred_train_low, 
    target_names=['Not-Low', 'Low']
))

# ----------------------------------------------------

# Apply threshold (TEST)

y_pred_test_low = (y_scores_test > threshold).astype(int)

print("\nTEST Results (Low vs Not-Low):")
print(classification_report(
    y_test_low, 
    y_pred_test_low, 
    target_names=['Not-Low', 'Low']
))

TRAIN Results (Low vs Not-Low):
              precision    recall  f1-score   support

     Not-Low       0.96      0.92      0.94     20796
         Low       0.80      0.90      0.85      7227

    accuracy                           0.92     28023
   macro avg       0.88      0.91      0.90     28023
weighted avg       0.92      0.92      0.92     28023


TEST Results (Low vs Not-Low):
              precision    recall  f1-score   support

     Not-Low       0.96      0.92      0.94      8914
         Low       0.80      0.90      0.85      3097

    accuracy                           0.92     12011
   macro avg       0.88      0.91      0.90     12011
weighted avg       0.92      0.92      0.92     12011

# Create Discion tree model
dtree = DecisionTreeClassifier(
    random_state=1 # make sure the results are not random on each run
)

# ---------------------------------------------------------------------------

# Fit the model on the TRAIN data.
dtree.fit(X_train_scaled, y_train)

# ------------------------------------------------------------

# Evaluation Decision Tree On Test Data

# ---- Train performance ----
print("\nDescision Tree Train Results:")
y_pred_train_dt = dtree.predict(X_train_scaled)
metrics_score(y_train, y_pred_train_dt) # Call metrics function for classifaction report and confusion matrix


# ---- Test performance ----
print("\nDescision Tree TEST Results:")
y_pred_test_dt = dtree.predict(X_test_scaled)
metrics_score(y_test, y_pred_test_dt) # Call metrics function for classifaction report and confusion matrix

Descision Tree Train Results:
              precision    recall  f1-score   support

           0       1.00      1.00      1.00      7227
           1       1.00      1.00      1.00     13561
           2       1.00      1.00      1.00      7235

    accuracy                           1.00     28023
   macro avg       1.00      1.00      1.00     28023
weighted avg       1.00      1.00      1.00     28023

Descision Tree TEST Results:
              precision    recall  f1-score   support

           0       0.79      0.80      0.80      3097
           1       0.87      0.85      0.86      5813
           2       0.80      0.81      0.81      3101

    accuracy                           0.83     12011
   macro avg       0.82      0.82      0.82     12011
weighted avg       0.83      0.83      0.83     12011

# The full Decision Tree is very large and difficult to read.
# By setting max_depth=3, we limit the tree to only the top levels.
# NOTE - This is just to understand how a Tree works and this model should not be used for prediction
dtree_small = DecisionTreeClassifier(
    random_state=1,   # ensures results are the same every run 
    max_depth=3       # limits depth of the tree
)

# Fit the shallow tree on the training data
dtree_small.fit(X_train_scaled, y_train)

# Plot the tree
plt.figure(figsize=(20, 10)) 

plot_tree(
    dtree_small,
    feature_names=X_train_scaled.columns,  # show feature names in the nodes
    class_names=['Low', 'Medium', 'High'], # label each class clearly
    filled=True,       # colour the nodes based on the class
)

plt.title("Decision Tree (max_depth=3)")
plt.show()

# To help witht he overfitting. We use a Grid Search to search through different settings and
# choose the model with the best results.

# Set up the model
dtree = DecisionTreeClassifier(
    random_state=1,   # keep model results reproducible
    class_weight='balanced'

)

# Define the hyperparameter grid.
param_grid_dt = {
    'criterion': ['gini', 'entropy', 'log_loss'],   # different ways to measure how good a split is
    'max_depth': [3, 5, 10, None],                  # limit how deep the tree can go (None = no limit)
    'min_samples_split': [2, 20, 50],               # minimum samples needed to split a node
    'min_samples_leaf': [1, 10, 50],                # minimum samples allowed in a leaf
    'max_features': [None, 'sqrt', 'log2'],         # number of features to consider at each split       
}

# Set up grid search
grid_search_dt = GridSearchCV(
    estimator=dtree,          # assign model to tune
    param_grid=param_grid_dt, # assign hyperparameters to try
    scoring='recall_macro',   # choose model with best overall recall
    cv=3,                     # 3-fold cross-validation splits the training data into 3 parts / train on two and validate on the third
    n_jobs=-1,                # use all CPU cores to run
)

#Preform grid search
grid_search_dt.fit(X_train_scaled, y_train)

#Print best parameterts
print("\nBest hyperparameters found:")
print(grid_search_dt.best_params_)

# assign best model results
best_dtree = grid_search_dt.best_estimator_

Best hyperparameters found:
{'criterion': 'gini', 'max_depth': 10, 'max_features': None, 'min_samples_leaf': 10, 'min_samples_split': 2}

# Evaluation of tuned Decision Tree

# Train performance for tuned tree
print("\nTuned Decision Tree TRAIN Results ===")
y_pred_train_best_dt = best_dtree.predict(X_train_scaled)
metrics_score(y_train, y_pred_train_best_dt)

# Test performance for tuned tree
print("\nTuned Decision Tree TEST performance")
y_pred_test_best_dt = best_dtree.predict(X_test_scaled)
metrics_score(y_test, y_pred_test_best_dt)

# ------------------------------------------------------------

# Find the probability column that belongs to the 'Low' class
low_idx = list(best_dtree.classes_).index(0)

# use redict_proba to get predicted probabilities for the Low-engagement class
y_scores_dt = best_dtree.predict_proba(X_test_scaled)[:, low_idx]

# Calculate AUC-ROC to show how well the model separates Low vs Not-Low
auc_score = roc_auc_score(y_test_low, y_scores_dt)
print("AUC-ROC - Low vs Not-Low:", round(auc_score, 3))

# Plot ROC curve for visual evaluation
RocCurveDisplay.from_predictions(y_test_low, y_scores_dt)
plt.title("AUC-ROC Curve (Low vs Not-Low)")
plt.show()

Tuned Decision Tree TRAIN Results ===
              precision    recall  f1-score   support

           0       0.89      0.90      0.90      7227
           1       0.93      0.93      0.93     13561
           2       0.92      0.90      0.91      7235

    accuracy                           0.92     28023
   macro avg       0.91      0.91      0.91     28023
weighted avg       0.92      0.92      0.92     28023

Tuned Decision Tree TEST performance
              precision    recall  f1-score   support

           0       0.88      0.89      0.89      3097
           1       0.92      0.92      0.92      5813
           2       0.91      0.89      0.90      3101

    accuracy                           0.91     12011
   macro avg       0.90      0.90      0.90     12011
weighted avg       0.91      0.91      0.91     12011

AUC-ROC - Low vs Not-Low: 0.934

# Read in raw data again to avoid using previous dataframes which have been moddifed
df_cluster = pd.read_csv("online_gaming_behavior_dataset.csv")

# # Define a list of features to be used for clustering 
cluster_features = [
    'Age',
    'PlayTimeHours',
    'SessionsPerWeek',
    'AvgSessionDurationMinutes',
    'InGamePurchases',
    'PlayerLevel',
    'AchievementsUnlocked'
]

# Select only the relevant features from the DataFrame for clustering
X_cluster = df_cluster[cluster_features]

# Initialize StandardScaler
scaler = StandardScaler()

# Fit the scaler to the clustering data and transform it
X_cluster_scaled = scaler.fit_transform(X_cluster)

inertia = []                       # Empty list to store inertia (WCSS) f

for k in range(2, 10):             # try k values from 2 up to 9
    km = KMeans(n_clusters=k,      # create K-Means model with k clusters
                random_state=1)
    km.fit(X_cluster_scaled)       # fit model on the scaled behavioural data
    inertia.append(km.inertia_)    

# Plot inertia against k
plt.plot(range(2, 10), inertia, marker='o')
plt.title("Elbow Method")
plt.xlabel("k")                    # number of clusters
plt.ylabel("Inertia")              # total within-cluster distance
plt.grid(True)
plt.show()

  File "c:\Users\WilcoxJo\AppData\Local\anaconda3\Lib\site-packages\joblib\externals\loky\backend\context.py", line 257, in _count_physical_cores
    cpu_info = subprocess.run(
               ^^^^^^^^^^^^^^^
  File "c:\Users\WilcoxJo\AppData\Local\anaconda3\Lib\subprocess.py", line 548, in run
    with Popen(*popenargs, **kwargs) as process:
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "c:\Users\WilcoxJo\AppData\Local\anaconda3\Lib\subprocess.py", line 1026, in __init__
    self._execute_child(args, executable, preexec_fn, close_fds,
  File "c:\Users\WilcoxJo\AppData\Local\anaconda3\Lib\subprocess.py", line 1538, in _execute_child
    hp, ht, pid, tid = _winapi.CreateProcess(executable, args,
                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

sil_scores = []   # Rmpyty list to store silhouette scores for each k

for k in range(2, 10):                         # test k values from 2 to 9
    km = KMeans(n_clusters=k, random_state=1)  # create K-Means model with k clusters
    labels = km.fit_predict(X_cluster_scaled)  # fit model and get cluster labels
    sil_scores.append(                         # calculate how well-separated clusters are
        silhouette_score(X_cluster_scaled, labels)
    )

# Plot silhouette score for each value of k
plt.plot(range(2, 10), sil_scores)
plt.title("Silhouette Scores")
plt.xlabel("k")                  # number of clusters
plt.ylabel("Silhouette Score")   # higher = better cluster separation
plt.grid(True)
plt.show()

# chosen because the elbow and silhouette plots both indicate k will work best at 3
k_final = 3

# Create the K-Means model with 3 clusters
kmeans_final = KMeans(n_clusters=k_final, random_state=1)

# Fit the model
df_cluster['Cluster'] = kmeans_final.fit_predict(X_cluster_scaled)

cluster_summary = df_cluster.groupby('Cluster')[cluster_features].mean()
cluster_summary

# Create bar chart for each feature across the 3 clusters
plt.figure(figsize=(12, 6))

cluster_summary.plot(kind='bar', figsize=(12,6))
plt.title("Cluster Behaviour Comparison")
plt.xlabel("Cluster")
plt.ylabel("Average Value")
plt.xticks(rotation=0)
plt.legend(title="Features", bbox_to_anchor=(1.05, 1), loc='upper left')
plt.tight_layout()
plt.show()

<Figure size 1200x600 with 0 Axes>

# Agglomerative Clustering uses the same number of clusters as KMeans based on the data analysis
agg = AgglomerativeClustering(n_clusters=3, linkage='ward')
df_cluster['Agg_Cluster'] = agg.fit_predict(X_cluster_scaled)

# Summary of hierarchical clusters
agg_summary = df_cluster.groupby('Agg_Cluster')[cluster_features].mean()
display(agg_summary)

# Create bar chart for each feature across the 3 Agglomerative clusters
plt.figure(figsize=(12, 6))

agg_summary.plot(kind='bar', figsize=(12,6))
plt.title("Agglomerative Cluster Behaviour Comparison")
plt.xlabel("Cluster")
plt.ylabel("Average Value")
plt.xticks(rotation=0)
plt.legend(title="Features", bbox_to_anchor=(1.05, 1), loc='upper left')

plt.tight_layout()
plt.show()

<Figure size 1200x600 with 0 Axes>

Feature	Description
PlayerID	Unique identifier for each player.
Age	Age of the player.
Gender	Gender of the player.
Location	Geographic location of the player.
GameGenre	Genre of the game the player is engaged in.
PlayTimeHours	Average hours spent playing per session.
InGamePurchases	Indicates whether the player makes in-game purchases (0 = No, 1 = Yes).
GameDifficulty	Difficulty level of the game.
SessionsPerWeek	Number of gaming sessions per week.
AvgSessionDurationMinutes	Average duration of each gaming session in minutes.
PlayerLevel	Current level of the player in the game.
AchievementsUnlocked	Number of achievements unlocked by the player.
EngagementLevel	TARGET VARIABLE, Categorized engagement level reflecting player retention ('High', 'Medium', 'Low').

	count	mean	std	min	25%	50%	75%	max
Age	40034.0	31.992531	10.043227	15.000000	23.000000	32.000000	41.000000	49.000000
PlayTimeHours	40034.0	12.024365	6.914638	0.000115	6.067501	12.008002	17.963831	23.999592
InGamePurchases	40034.0	0.200854	0.400644	0.000000	0.000000	0.000000	0.000000	1.000000
SessionsPerWeek	40034.0	9.471774	5.763667	0.000000	4.000000	9.000000	14.000000	19.000000
AvgSessionDurationMinutes	40034.0	94.792252	49.011375	10.000000	52.000000	95.000000	137.000000	179.000000
PlayerLevel	40034.0	49.655568	28.588379	1.000000	25.000000	49.000000	74.000000	99.000000
AchievementsUnlocked	40034.0	24.526477	14.430726	0.000000	12.000000	25.000000	37.000000	49.000000

	Age	PlayTimeHours	InGamePurchases	SessionsPerWeek	AvgSessionDurationMinutes	PlayerLevel	AchievementsUnlocked
EngagementLevel
High	31.920085	12.069238	0.206463	14.254547	131.921827	50.823723	25.095975
Low	31.896939	12.104915	0.197307	4.530511	66.882119	46.101414	22.661565
Medium	32.082120	11.957503	0.199752	9.553267	89.856405	50.926293	25.216424

	Age	PlayTimeHours	SessionsPerWeek	AvgSessionDurationMinutes	InGamePurchases	PlayerLevel	AchievementsUnlocked
Cluster
0	32.075835	6.047918	9.545364	95.168815	0.0	50.062508	24.267614
1	31.911249	18.032009	9.368684	94.566548	0.0	49.062520	24.783461
2	31.988807	11.940694	9.530780	94.493222	1.0	50.027609	24.529287

	Age	PlayTimeHours	SessionsPerWeek	AvgSessionDurationMinutes	InGamePurchases	PlayerLevel	AchievementsUnlocked
Agg_Cluster
0	37.278620	11.787043	9.422751	87.210790	0.0	44.280459	25.212072
1	31.988807	11.940694	9.530780	94.493222	1.0	50.027609	24.529287
2	25.244751	12.375290	9.500605	104.644296	0.0	56.306242	23.649420

	PlayerID	Age	Gender	Location	GameGenre	PlayTimeHours	InGamePurchases	GameDifficulty	SessionsPerWeek	AvgSessionDurationMinutes	PlayerLevel	AchievementsUnlocked	EngagementLevel
0	9000	43	Male	Other	Strategy	16.271119	0	Medium	6	108	79	25	Medium
1	9001	29	Female	USA	Strategy	5.525961	0	Medium	5	144	11	10	Medium
2	9002	22	Female	USA	Sports	8.223755	0	Easy	16	142	35	41	High
3	9003	35	Male	USA	Action	5.265351	1	Easy	9	85	57	47	Medium
4	9004	33	Male	Europe	Action	15.531945	0	Medium	2	131	95	37	Medium

Case Study - Predict Online Gaming Behavior Dataset¶

About The Dataset¶

Objective¶

Features:¶

Target Variable:¶

Import libraries¶

Load Dataset¶

Investigate The Dataset¶

Observations¶

Drop columns not needed¶

Split features into numerical & categorical columns¶

Exploratory Data¶

Univariate analysis of numerical columns¶

Observations¶

Distributions¶

Observations¶

Univariate analysis for categorical features¶

Observations¶

Bivariate and Multivariate analysis¶

Observations¶

Checking relationship between Engagement Levels and Numerical featuers¶

Observations¶

Correlation between all numerical variables¶

Observations¶

Model Building¶

Approach¶

1) Data Preparation¶

Scaling the Data¶

Model evaluation criterion¶

SVG Model¶

Train & compare different SVM kernels¶

Linear Kernel¶

Observations¶

RBF Kernel¶

Observations¶

Polynomial¶

Observations¶

Overall Comparison & Summary¶

Hyperparameter Tuning¶

Precision-Recall Curve & AUC-ROC score¶

Observations (Precision–Recall vs Threshold Curve & ROC Curve)¶

Observations (Threshold-Tuned Results)¶

Overall SVG Model Observations¶

Decision trees¶

Create and Fit Model¶

Observations¶

Display Tree¶

Hyperparameter tuning¶

Evaluation of tuned Decision Tree¶

Observations¶

Comparison of SVM and Decision Tree¶

Business Insights from the Supervised Learning Models¶

Unsupervised Learning: Player Segmentation with Clustering¶

Select Behavioural features¶

Scale the features¶

Elbow Plot¶

Observations from the Elbow Plot¶

Silhouette score plot¶

Observations from the Silhouette Scores¶

Fit K-Means with chosen k¶

Behaviour summary¶

Business Insights from the K-Means Clusters¶

Overall Insight¶

Agglomerative Clustering¶

Business Insights from Hierarchical Clusters¶

Overall Summary and Recommendations¶