import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

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

from sklearn.model_selection import train_test_split

# Algorithms to use
from sklearn import tree
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC

# Metrics to evaluate the model
from sklearn import metrics
from sklearn.metrics import confusion_matrix, classification_report, precision_recall_curve, recall_score
from sklearn.metrics import roc_auc_score

# To ignore warnings
import warnings
warnings.filterwarnings("ignore")

# Loading the dataset
df = pd.read_csv('C:\online_gaming_behavior_dataset.csv')

df.head()

# Let us see the info of the data
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

# Checking 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

# Dropping the columns 
df=df.drop(['PlayerID'],axis=1)  # axis 1 means column

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

# Creating categorical variables 
cat_cols = ['Gender', 'Location', 'GameGenre',
            'InGamePurchases', 'GameDifficulty',
            'EngagementLevel']

# Checking summary statistics
df[num_cols].describe().T

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

# Printing the % sub categories of each category
for i in cat_cols:
    print(df[i].value_counts (normalize=True))
    print('*'*40)

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
****************************************
InGamePurchases
0    0.799146
1    0.200854
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 i in cat_cols:
    if i!='EngagementLevel':
         (pd.crosstab(df[i],df['EngagementLevel'],normalize='index')*100).plot(kind='bar',figsize=(8,4),stacked=True)
         plt.ylabel('EngagementLevel %')

# Mean of numerical variables grouped by EngagementLevel
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: >

# Creating list of dummy columns
to_get_dummies_for = ['Gender', 'Location', 'GameGenre', 'GameDifficulty']

# Creating dummy variables
df = pd.get_dummies(data = df, columns = to_get_dummies_for, drop_first = True)

# Mapping target variable
dict_engagement = {'Low': 0, 'Medium': 1, 'High': 2}

df['EngagementLevel'] = df.EngagementLevel.map(dict_engagement)

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

# Splitting the data
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size = 0.3, random_state = 1, stratify = Y)

# Scaling the data
sc = StandardScaler()

# Fit_transform on train data
X_train_scaled = sc.fit_transform(X_train)
X_train_scaled = pd.DataFrame(X_train_scaled, columns = X.columns)

# Transform on test data
X_test_scaled = sc.transform(X_test)
X_test_scaled = pd.DataFrame(X_test_scaled, columns = X.columns)

# Creating metric function
def metrics_score(actual, predicted):
    print("Accuracy Score:", metrics.accuracy_score(actual, predicted))
    print(classification_report(actual, predicted))

    cm = confusion_matrix(actual, predicted)
    plt.figure(figsize=(20,12))

    sns.heatmap(cm, annot=True, fmt='d',
                xticklabels=['Low', 'Medium', 'High'],
                yticklabels=['Low', 'Medium', 'High'])
    plt.ylabel('Actual')
    plt.xlabel('Predicted')
    plt.show()


# Function to calculate multiclass AUC-ROC
def auc_roc_score_multiclass(actual, predicted_proba):
    auc_score = roc_auc_score(actual, predicted_proba, multi_class='ovr')
    print("AUC-ROC Score:", auc_score)

# Fitting Decision Tree model
dtree = DecisionTreeClassifier(random_state = 1)
dtree.fit(X_train, y_train)

DecisionTreeClassifier(random_state=1)

plt.figure(figsize=(20, 12))
tree.plot_tree(dtree,
               feature_names=X.columns,
               class_names=['Low', 'Medium', 'High'],
               filled=True,
               rounded=True,
               max_depth=2)
plt.show()

y_pred_train_dtree = dtree.predict(X_train)

metrics_score(y_train, y_pred_train_dtree)
auc_roc_score_multiclass(y_train, dtree.predict_proba(X_train))

Accuracy Score: 1.0
              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

AUC-ROC Score: 1.0

y_pred_test_dtree = dtree.predict(X_test)

metrics_score(y_test, y_pred_test_dtree)
auc_roc_score_multiclass(y_test, dtree.predict_proba(X_test))

Accuracy Score: 0.8295728915161102
              precision    recall  f1-score   support

           0       0.79      0.80      0.80      3097
           1       0.86      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

AUC-ROC Score: 0.8665163993692299

from sklearn.model_selection import GridSearchCV

# Defining the parameter grid
param_grid = {
    'criterion': ['gini', 'entropy'],
    'max_depth': [3, 5, 7, 10, None],
    'min_samples_split': [2, 5, 10, 20],
    'min_samples_leaf': [1, 2, 4, 8]
}

# Creating the Decision Tree model
dtree_tuned = DecisionTreeClassifier(random_state=1)

# Applying GridSearchCV
grid_search_dtree = GridSearchCV(estimator=dtree_tuned,
                                 param_grid=param_grid,
                                 cv=5,
                                 scoring='f1_weighted',
                                 n_jobs=-1)

# Fitting the grid search to the training data
grid_search_dtree.fit(X_train, y_train)

# Printing the best parameters and best score
print("Best Parameters:", grid_search_dtree.best_params_)
print("Best Cross-Validation Score:", grid_search_dtree.best_score_)

Best Parameters: {'criterion': 'gini', 'max_depth': 10, 'min_samples_leaf': 8, 'min_samples_split': 2}
Best Cross-Validation Score: 0.9028909723450014

# Best tuned Decision Tree model
best_dtree = grid_search_dtree.best_estimator_

# Training performance
y_pred_train_dtree_tuned = best_dtree.predict(X_train)
metrics_score(y_train, y_pred_train_dtree_tuned)
auc_roc_score_multiclass(y_train, best_dtree.predict_proba(X_train))

# Test performance
y_pred_test_dtree_tuned = best_dtree.predict(X_test)
metrics_score(y_test, y_pred_test_dtree_tuned)
auc_roc_score_multiclass(y_test, best_dtree.predict_proba(X_test))

Accuracy Score: 0.9167112728829889
              precision    recall  f1-score   support

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

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

AUC-ROC Score: 0.9682423176717928
Accuracy Score: 0.9035051203063859
              precision    recall  f1-score   support

           0       0.90      0.87      0.88      3097
           1       0.90      0.93      0.92      5813
           2       0.92      0.88      0.90      3101

    accuracy                           0.90     12011
   macro avg       0.90      0.89      0.90     12011
weighted avg       0.90      0.90      0.90     12011

AUC-ROC Score: 0.9365285163534648

# Checking feature importance for the tuned Decision Tree model

feature_importance = pd.DataFrame({
    'Feature': X.columns,
    'Importance': best_dtree.feature_importances_
})

# Sorting feature importance values from highest to lowest
feature_importance = feature_importance.sort_values(by='Importance', ascending=False)

# Displaying the top 10 most important features
feature_importance.head(10)

# Plotting the top 10 feature importances

plt.figure(figsize=(10, 6))
sns.barplot(data=feature_importance.head(10),
            x='Importance',
            y='Feature')

plt.title('Top 10 Feature Importances - Tuned Decision Tree')
plt.xlabel('Importance')
plt.ylabel('Feature')
plt.show()

# Fitting SVM with Linear Kernel
svm = SVC(kernel='linear')  # Linear kernel or linear decision boundary

# Fit the model
model = svm.fit(X=X_train_scaled, y=y_train)

# Checking performance on the training data
y_pred_train_svm = model.predict(X_train_scaled)

metrics_score(y_train, y_pred_train_svm)

Accuracy Score: 0.8246083574206902
              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

# Checking performance on the test data
y_pred_test_svm = model.predict(X_test_scaled)

metrics_score(y_test, y_pred_test_svm)

Accuracy Score: 0.8234118724502539
              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

# RBF Kernel
svm_rbf = SVC(kernel='rbf', probability=True, random_state=1)

# Fit the model
svm_rbf.fit(X_train_scaled, y_train)

# Predict probabilities on the training data
y_scores_svm = svm_rbf.predict_proba(X_train_scaled)

# precision_recall_curve() only works for binary classification.
# Since this dataset has three classes (Low, Medium, High),
# the target must be converted to a one-vs-rest binary format.
# Here:
# 1 = Low engagement
# 0 = Medium or High engagement
y_train_low_vs_rest = (y_train == 0).astype(int)

# Find the probability column for the Low engagement class
low_class_index = list(svm_rbf.classes_).index(0)

# Calculate precision, recall, and thresholds for Low vs Rest
precisions_svm, recalls_svm, thresholds_svm = precision_recall_curve(
    y_train_low_vs_rest,
    y_scores_svm[:, low_class_index]
)

# Plot values of precision, recall, and thresholds
plt.figure(figsize=(10,7))
plt.plot(thresholds_svm, precisions_svm[:-1], 'b--', label='precision')
plt.plot(thresholds_svm, recalls_svm[:-1], 'g--', label='recall')
plt.xlabel('Threshold')
plt.title('Precision-Recall Threshold Curve for Low Engagement vs Rest')
plt.legend(loc='upper left')
plt.ylim([0,1])
plt.show()

# Choosing a threshold from the graph
optimal_threshold_svm = 0.45

# Applying the threshold on the training data for Low vs Rest
y_pred_train_low = (y_scores_svm[:, low_class_index] > optimal_threshold_svm).astype(int)

print(classification_report(y_train_low_vs_rest, y_pred_train_low))

cm = confusion_matrix(y_train_low_vs_rest, y_pred_train_low)
plt.figure(figsize=(8,5))
sns.heatmap(cm, annot=True, fmt='d',
            xticklabels=['Not Low', 'Low'],
            yticklabels=['Not Low', 'Low'])
plt.ylabel('Actual')
plt.xlabel('Predicted')
plt.show()

              precision    recall  f1-score   support

           0       0.96      0.96      0.96     20796
           1       0.89      0.88      0.89      7227

    accuracy                           0.94     28023
   macro avg       0.93      0.92      0.92     28023
weighted avg       0.94      0.94      0.94     28023

# Converting the test target to Low vs Rest
y_test_low_vs_rest = (y_test == 0).astype(int)

# Predict probabilities on the test data
y_scores_svm_test = svm_rbf.predict_proba(X_test_scaled)

# Applying the same threshold on the test data
y_pred_test_low = (y_scores_svm_test[:, low_class_index] > optimal_threshold_svm).astype(int)

print(classification_report(y_test_low_vs_rest, y_pred_test_low))

cm = confusion_matrix(y_test_low_vs_rest, y_pred_test_low)
plt.figure(figsize=(8,5))
sns.heatmap(cm, annot=True, fmt='d',
            xticklabels=['Not Low', 'Low'],
            yticklabels=['Not Low', 'Low'])
plt.ylabel('Actual')
plt.xlabel('Predicted')
plt.show()

              precision    recall  f1-score   support

           0       0.95      0.95      0.95      8914
           1       0.86      0.85      0.86      3097

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

from sklearn.model_selection import GridSearchCV

# Defining a reduced parameter grid for SVM
# A smaller grid was used because SVM can be computationally expensive on a large dataset.
param_grid_svm = [
    {
        'kernel': ['linear'],
        'C': [1]
    },
    {
        'kernel': ['rbf'],
        'C': [1, 10],
        'gamma': ['scale', 0.1]
    }
]

# Creating SVM model
svm_tuned = SVC(random_state=1)

# Applying GridSearchCV
grid_search_svm = GridSearchCV(estimator=svm_tuned,
                               param_grid=param_grid_svm,
                               cv=3,
                               scoring='f1_weighted',
                               n_jobs=-1)

# Fitting the grid search to the scaled training data
grid_search_svm.fit(X_train_scaled, y_train)

# Printing the best parameters and best score
print("Best Parameters:", grid_search_svm.best_params_)
print("Best Cross-Validation Score:", grid_search_svm.best_score_)

Best Parameters: {'C': 1, 'gamma': 'scale', 'kernel': 'rbf'}
Best Cross-Validation Score: 0.8780220877471855

# Creating the best SVM model with probability=True for AUC-ROC
best_svm = SVC(**grid_search_svm.best_params_,
               probability=True,
               random_state=1)

# Fitting the best SVM model
best_svm.fit(X_train_scaled, y_train)

SVC(C=1, probability=True, random_state=1)

# Checking the performance on the training data
y_pred_train_svm_tuned = best_svm.predict(X_train_scaled)

metrics_score(y_train, y_pred_train_svm_tuned)
auc_roc_score_multiclass(y_train, best_svm.predict_proba(X_train_scaled))

Accuracy Score: 0.9058273561003461
              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

AUC-ROC Score: 0.950949445110719

# Checking the performance on the test data
y_pred_test_svm_tuned = best_svm.predict(X_test_scaled)

metrics_score(y_test, y_pred_test_svm_tuned)
auc_roc_score_multiclass(y_test, best_svm.predict_proba(X_test_scaled))

Accuracy Score: 0.8850220631088169
              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

AUC-ROC Score: 0.9396443476549677

# Comparing the best supervised models

model_comparison = pd.DataFrame({
    'Model': ['Tuned Decision Tree', 'Tuned SVM'],
    
    'Test Accuracy': [
        metrics.accuracy_score(y_test, y_pred_test_dtree_tuned),
        metrics.accuracy_score(y_test, y_pred_test_svm_tuned)
    ],
    
    'Test Precision Weighted': [
        metrics.precision_score(y_test, y_pred_test_dtree_tuned, average='weighted'),
        metrics.precision_score(y_test, y_pred_test_svm_tuned, average='weighted')
    ],
    
    'Test Recall Weighted': [
        metrics.recall_score(y_test, y_pred_test_dtree_tuned, average='weighted'),
        metrics.recall_score(y_test, y_pred_test_svm_tuned, average='weighted')
    ],
    
    'Test F1 Weighted': [
        metrics.f1_score(y_test, y_pred_test_dtree_tuned, average='weighted'),
        metrics.f1_score(y_test, y_pred_test_svm_tuned, average='weighted')
    ],
    
    'Test AUC-ROC': [
        roc_auc_score(y_test, best_dtree.predict_proba(X_test), multi_class='ovr'),
        roc_auc_score(y_test, best_svm.predict_proba(X_test_scaled), multi_class='ovr')
    ]
})

model_comparison

# Selecting the best model based on weighted F1-score

best_model_name = model_comparison.sort_values(
    by='Test F1 Weighted',
    ascending=False
).iloc[0]['Model']

print("Best supervised model based on weighted F1-score:", best_model_name)

Best supervised model based on weighted F1-score: Tuned Decision Tree

# Importing clustering libraries
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score

# Preparing data for clustering

# EngagementLevel is removed because clustering is unsupervised
# The aim is to discover hidden player segments without using the target label
cluster_data = df.drop(columns=['EngagementLevel'])

# Scaling the clustering data
# K-Means uses distance-based calculations, so scaling is required
sc_cluster = StandardScaler()
cluster_data_scaled = sc_cluster.fit_transform(cluster_data)

# Finding the optimal number of clusters using inertia and sampled silhouette score

inertia_values = []
silhouette_scores = []

k_values = range(2, 11)

for k in k_values:
    kmeans = KMeans(n_clusters=k, random_state=1, n_init=10)
    cluster_labels = kmeans.fit_predict(cluster_data_scaled)
    
    # Inertia is calculated using the full dataset
    inertia_values.append(kmeans.inertia_)
    
    # Silhouette score is calculated using a sample to reduce processing time
    silhouette_scores.append(
        silhouette_score(cluster_data_scaled,
                         cluster_labels,
                         sample_size=5000,
                         random_state=1)
    )

# Displaying the results
cluster_results = pd.DataFrame({
    'Number of Clusters': list(k_values),
    'Inertia': inertia_values,
    'Silhouette Score': silhouette_scores
})

cluster_results

# Plotting the elbow curve using inertia

plt.figure(figsize=(8,5))
plt.plot(k_values, inertia_values, marker='o')
plt.xlabel('Number of Clusters')
plt.ylabel('Inertia')
plt.title('Elbow Method for Choosing Number of Clusters')
plt.show()

# Plotting silhouette scores

plt.figure(figsize=(8,5))
plt.plot(k_values, silhouette_scores, marker='o')
plt.xlabel('Number of Clusters')
plt.ylabel('Silhouette Score')
plt.title('Silhouette Score for Different Numbers of Clusters')
plt.show()

# Hyperparameter tuning for K-Means clustering

from sklearn.model_selection import ParameterGrid

# Defining parameter grid for K-Means
param_grid_kmeans = {
    'n_clusters': [3, 4, 5, 6],
    'init': ['k-means++', 'random'],
    'n_init': [10, 20],
    'max_iter': [300, 500]
}

# Storing results
kmeans_tuning_results = []

# Testing each parameter combination
for params in ParameterGrid(param_grid_kmeans):
    
    kmeans_model = KMeans(
        n_clusters=params['n_clusters'],
        init=params['init'],
        n_init=params['n_init'],
        max_iter=params['max_iter'],
        random_state=1
    )
    
    cluster_labels = kmeans_model.fit_predict(cluster_data_scaled)
    
    inertia = kmeans_model.inertia_
    
    silhouette = silhouette_score(
        cluster_data_scaled,
        cluster_labels,
        sample_size=5000,
        random_state=1
    )
    
    kmeans_tuning_results.append({
        'n_clusters': params['n_clusters'],
        'init': params['init'],
        'n_init': params['n_init'],
        'max_iter': params['max_iter'],
        'Inertia': inertia,
        'Silhouette Score': silhouette
    })

# Converting results to DataFrame
kmeans_tuning_results_df = pd.DataFrame(kmeans_tuning_results)

# Sorting by Silhouette Score
kmeans_tuning_results_df = kmeans_tuning_results_df.sort_values(
    by='Silhouette Score',
    ascending=False
)

kmeans_tuning_results_df

# Selecting the best K-Means parameters
best_kmeans_params = kmeans_tuning_results_df.iloc[0]

print("Best K-Means Parameters:")
print(best_kmeans_params)

Best K-Means Parameters:
n_clusters                      5
init                       random
n_init                         20
max_iter                      500
Inertia             513958.185611
Silhouette Score         0.132229
Name: 29, dtype: object

# Building the final tuned K-Means model

best_kmeans = KMeans(
    n_clusters=int(best_kmeans_params['n_clusters']),
    init=best_kmeans_params['init'],
    n_init=int(best_kmeans_params['n_init']),
    max_iter=int(best_kmeans_params['max_iter']),
    random_state=1
)

# Adding tuned cluster labels to the dataframe
df['Tuned_Cluster'] = best_kmeans.fit_predict(cluster_data_scaled)

# Checking cluster sizes
df['Tuned_Cluster'].value_counts()

Tuned_Cluster
3    14412
1     7273
0     7226
2     7188
4     3935
Name: count, dtype: int64

# Analysing numerical feature averages by tuned cluster
tuned_cluster_profile_num = df.groupby('Tuned_Cluster')[num_cols].mean()
tuned_cluster_profile_num

# Checking engagement level distribution by tuned cluster
pd.crosstab(df['Tuned_Cluster'], df['EngagementLevel'], normalize='index') * 100

	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
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	SessionsPerWeek	AvgSessionDurationMinutes	PlayerLevel	AchievementsUnlocked
EngagementLevel
High	31.920085	12.069238	14.254547	131.921827	50.823723	25.095975
Low	31.896939	12.104915	4.530511	66.882119	46.101414	22.661565
Medium	32.082120	11.957503	9.553267	89.856405	50.926293	25.216424

	Feature	Importance
3	SessionsPerWeek	0.585923
4	AvgSessionDurationMinutes	0.331179
5	PlayerLevel	0.039280
6	AchievementsUnlocked	0.035409
1	PlayTimeHours	0.003516
0	Age	0.002490
15	GameDifficulty_Hard	0.000386
13	GameGenre_Sports	0.000378
10	Location_USA	0.000376
7	Gender_Male	0.000346

	Number of Clusters	Inertia	Silhouette Score
0	2	626213.239244	0.076699
1	3	587156.824349	0.107668
2	4	549504.639498	0.120195
3	5	520386.717065	0.106855
4	6	491310.700688	0.113239
5	7	477748.071240	0.096099
6	8	466964.103604	0.100742
7	9	457307.058341	0.096369
8	10	446928.706116	0.102801

	Age	PlayTimeHours	SessionsPerWeek	AvgSessionDurationMinutes	PlayerLevel	AchievementsUnlocked
Tuned_Cluster
0	31.976197	12.082769	9.503737	95.688486	49.901744	24.639773
1	32.039186	11.976763	9.500344	95.101471	49.938815	24.440671
2	32.161380	11.885782	9.469950	94.635364	49.057179	24.466472
3	31.901193	12.078230	9.450250	94.223702	49.543922	24.644463
4	31.962389	12.060967	9.442440	94.943837	50.181957	24.154511

	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

	criterion	'gini'
	splitter	'best'
	max_depth	None
	min_samples_split	2
	min_samples_leaf	1
	min_weight_fraction_leaf	0.0
	max_features	None
	random_state	1
	max_leaf_nodes	None
	min_impurity_decrease	0.0
	class_weight	None
	ccp_alpha	0.0
	monotonic_cst	None

	C	1
	kernel	'rbf'
	degree	3
	gamma	'scale'
	coef0	0.0
	shrinking	True
	probability	True
	tol	0.001
	cache_size	200
	class_weight	None
	verbose	False
	max_iter	-1
	decision_function_shape	'ovr'
	break_ties	False
	random_state	1

	Model	Test Accuracy	Test Precision Weighted	Test Recall Weighted	Test F1 Weighted	Test AUC-ROC
0	Tuned Decision Tree	0.903505	0.903606	0.903505	0.903285	0.936529
1	Tuned SVM	0.885022	0.886322	0.885022	0.884445	0.939644

	n_clusters	init	n_init	max_iter	Inertia	Silhouette Score
29	5	random	20	500	513958.185611	0.132229
21	5	random	20	300	513958.185611	0.132229
3	4	k-means++	20	300	545438.171611	0.126820
11	4	k-means++	20	500	545438.171611	0.126820
19	4	random	20	300	545438.171611	0.126820
27	4	random	20	500	545438.171611	0.126820
26	4	random	10	500	549581.478975	0.121152
18	4	random	10	300	549581.478975	0.121152
10	4	k-means++	10	500	549504.639498	0.120195
2	4	k-means++	10	300	549504.639498	0.120195
15	6	k-means++	20	500	491310.700688	0.113239
14	6	k-means++	10	500	491310.700688	0.113239
6	6	k-means++	10	300	491310.700688	0.113239
7	6	k-means++	20	300	491310.700688	0.113239
13	5	k-means++	20	500	519637.748598	0.112695
5	5	k-means++	20	300	519637.748598	0.112695
31	6	random	20	500	492558.476329	0.112636
23	6	random	20	300	492558.476329	0.112636
30	6	random	10	500	493096.036372	0.110059
22	6	random	10	300	493096.036372	0.110059
20	5	random	10	300	520202.780832	0.109989
28	5	random	10	500	520202.780832	0.109989
8	3	k-means++	10	500	587156.824349	0.107668
0	3	k-means++	10	300	587156.824349	0.107668
4	5	k-means++	10	300	520386.717065	0.106855
12	5	k-means++	10	500	520386.717065	0.106855
17	3	random	20	300	582852.794656	0.105370
16	3	random	10	300	582852.794656	0.105370
24	3	random	10	500	582852.794656	0.105370
25	3	random	20	500	582852.794656	0.105370
9	3	k-means++	20	500	583484.105465	0.097905
1	3	k-means++	20	300	583484.105465	0.097905

EngagementLevel	0	1	2
Tuned_Cluster
0	25.256020	48.796014	25.947966
1	25.601540	48.329438	26.069022
2	26.182526	47.398442	26.419032
3	25.804885	48.827366	25.367749
4	26.327827	48.005083	25.667090

Artificial Intelligence and Machine Learning (ACCA6011)¶

Wayne Howell (2207408)¶

Assignment – ML Model¶

Case Study: Predict Online Gaming Behaviour¶

Context¶

Objective¶

Dataset Description¶

Importing the libraries and overview of the dataset¶

Loading the Dataset¶

Checking the info of the dataset¶

Exploratory Data Analysis and Data Preprocessing¶

Univariate analysis of numerical columns¶

Univariate analysis for categorical variables¶

Bivariate and Multivariate analysis¶

Let's check the relationship between different numerical variables¶

Model Building - Approach¶

Data Preparation¶

Scaling the data¶

Model evaluation criterion¶

Building the model¶

Decision Tree Model¶

Fitting Decision Tree model¶

Visualising the Training Tree¶

Training Data Performance¶

Testing Data Performance¶

Hyperparameter Tuning for Decision Tree¶

Tuned Decision Tree Performance¶

Feature importance for the tuned Decision Tree model¶

Support Vector Machine (SVM)¶

Linear Kernel¶

Checking the performance on the training data¶

Checking the performance on the test data¶

RBF Kernal¶

Hyperparameter tuning for the SVM models¶

Evaluating the tuned SVM model¶

Model comparison and best supervised model¶

Clustering¶

Import Clustering Libraries¶

Prepare the data for clustering¶

Find the best number of clusters using inertia and sampled silhouette score¶

Plot the elbow curve¶

Plot the silhouette scores¶

Hyperparameter tuning for K-Means clustering¶

Select best K-Means Parameters¶

Build the final tuned K-Means Model¶

Analysis on feature averages by tuned cluster¶

K-Means cluster interpretation¶

Comparison of supervised and unsupervised learning insights¶

Practical business recommendations¶

Limitations¶