Introduction

Welcome to the second installment of my data expert role-play series in the iGaming industry. In this article, we'll explore building a predictive model to evaluate bonus requests from VIP segment personal consultants. The model will analyze historical data to determine whether bonus requests should be approved.

Objective

Build a predictive model that:

• Evaluates bonus requests from VIP personal consultants
• Determines approval eligibility based on historical patterns
• Provides data-driven decision support for bonus allocation

Data Description

Dataset: bonus_request_dataset.csv

Key Features:

User Profile:

• person_age
• annual_deposit_amount
• tier_segment_duration
• current_segment_tier

Bonus Request Details:

• requested_bonus_type
• requested_bonus_value
• bonus_wagering_requirement

Behavioral & Historical Factors:

• preferred_game_category
• bonus_hist_length
• previous_segment_downgrade

Target Variable:

• bonus_status (Approved/Rejected)

Methodology

Feature Engineering

• Process numerical and categorical features separately
• Handle missing values appropriately
• Encode categorical features using OneHotEncoder

Model Training

• Implement XGBClassifier (XGBoost) as primary model
• Conduct hyperparameter tuning with HalvingGridSearchCV
• Optimize key parameters: learning_rate and max_depth

Evaluation

• Assess model using cross-validation
• Measure accuracy metrics
• Final testing on holdout dataset

Visualization

• Generate heatmaps for correlation analysis
• Create count plots for categorical distributions
• Plot feature distributions

POC Implementation

• Test model with randomized customer profiles
• Validate real-world applicability

import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
from sklearn.feature_selection import mutual_info_regression
from sklearn.preprocessing import OneHotEncoder
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
import sklearn.metrics as sm
from sklearn.ensemble import RandomForestClassifier
from xgboost import XGBClassifier
from sklearn.linear_model import RidgeClassifier
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.model_selection import cross_val_score
from sklearn.compose import ColumnTransformer
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt
from plotly.offline import init_notebook_mode
init_notebook_mode(connected=True)

df = pd.read_csv("C:/Users/Memre/Documents/GitHub/EmreToktay.github.io/blogpost/bonus_request_dataset.csv")

df

	person_age	annual_deposit_amount	preferred_game_category	tier_segment_duration	requested_bonus_type	current_segment_tier	requested_bonus_value	bonus_wagering_requirement	bonus_status	bonus_to_deposit_ratio	previous_segment_downgrade	bonus_hist_length
0	22	59000	CASINO	123.0	CASHBACK	D	35000	16.02	1	0.59	Y	3
1	21	9600	BET	5.0	FREESPIN	B	1000	11.14	0	0.10	N	2
2	25	9600	LIVECAS	1.0	DEPOSIT	C	5500	12.87	1	0.57	N	3
3	23	65500	CASINO	4.0	DEPOSIT	C	35000	15.23	1	0.53	N	2
4	24	54400	CASINO	8.0	DEPOSIT	C	35000	14.27	1	0.55	Y	4
...	...	...	...	...	...	...	...	...	...	...	...	...
32576	57	53000	LIVECAS	1.0	CASHBACK	C	5800	13.16	0	0.11	N	30
32577	54	120000	LIVECAS	4.0	CASHBACK	A	17625	7.49	0	0.15	N	19
32578	65	76000	CASINO	3.0	LOWWAGERING	B	35000	10.99	1	0.46	N	28
32579	56	150000	LIVECAS	5.0	CASHBACK	B	15000	11.48	0	0.10	N	26
32580	66	42000	CASINO	2.0	DEPOSIT	B	6475	9.99	0	0.15	N	30

32581 rows × 12 columns

df.head()

	person_age	annual_deposit_amount	preferred_game_category	tier_segment_duration	requested_bonus_type	current_segment_tier	requested_bonus_value	bonus_wagering_requirement	bonus_status	bonus_to_deposit_ratio	previous_segment_downgrade	bonus_hist_length
0	22	59000	CASINO	123.0	CASHBACK	D	35000	16.02	1	0.59	Y	3
1	21	9600	BET	5.0	FREESPIN	B	1000	11.14	0	0.10	N	2
2	25	9600	LIVECAS	1.0	DEPOSIT	C	5500	12.87	1	0.57	N	3
3	23	65500	CASINO	4.0	DEPOSIT	C	35000	15.23	1	0.53	N	2
4	24	54400	CASINO	8.0	DEPOSIT	C	35000	14.27	1	0.55	Y	4

df.columns

Index(['person_age', 'annual_deposit_amount', 'preferred_game_category',
       'tier_segment_duration', 'requested_bonus_type', 'current_segment_tier',
       'requested_bonus_value', 'bonus_wagering_requirement', 'bonus_status',
       'bonus_to_deposit_ratio', 'previous_segment_downgrade',
       'bonus_hist_length'],
      dtype='object')

import seaborn as sns
import matplotlib.pyplot as plt

plt.figure(figsize=(10, 8))
corr = df.select_dtypes(include=['number']).corr()
sns.heatmap(corr, 
            annot=True, 
            fmt=".2f",
            cmap='coolwarm', 
            center=0,
            square=True)
plt.title("Feature Correlation Heatmap")
plt.tight_layout()
plt.show()

plt.figure(figsize=(10,6))
ax = sns.countplot(x=df["bonus_status"], 
                  palette = {'0': "#FF6B6B", '1': "#4ECDC4"} ,  # Red for denied, teal for approved
                  edgecolor="black",
                  linewidth=1.2)

for p in ax.patches:
    ax.annotate(f'{p.get_height():,.0f}', 
                (p.get_x() + p.get_width() / 2., p.get_height()), 
                ha='center', va='center', 
                xytext=(0, 10), 
                textcoords='offset points',
                fontsize=12)


plt.xlabel("Bonus Request Status", fontsize=12, labelpad=10)
plt.ylabel("Count", fontsize=12, labelpad=10)
plt.title("Bonus Request Approval Status\n(0 = Denied, 1 = Approved)", 
          fontsize=14, pad=20)



plt.grid(axis='y', alpha=0.3)

sns.despine()


total = len(df["bonus_status"])
for p in ax.patches:
    percentage = f'{100 * p.get_height() / total:.1f}%'
    ax.annotate(percentage, 
                (p.get_x() + p.get_width() / 2., p.get_height()/2), 
                ha='center', va='center',
                color='white',
                fontsize=12,
                fontweight='bold')

plt.tight_layout()
plt.show()

C:\Users\Memre\AppData\Local\Temp\ipykernel_12868\1192482614.py:2: FutureWarning:



Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.

status_colors = {0: '#FF6B6B', 1: '#4ECDC4'} 
status_labels = {0: 'Denied', 1: 'Approved'}


fig, axes = plt.subplots(1, len(df['requested_bonus_type'].unique()), figsize=(15,6))

for i, bonus_type in enumerate(df['requested_bonus_type'].unique()):

    counts = df[df['requested_bonus_type'] == bonus_type]['bonus_status'].value_counts()

    pie = counts.plot(
        kind='pie',
        ax=axes[i],
        colors=[status_colors[x] for x in counts.index],
        title=f'Bonus Type: {bonus_type}\nTotal Request: {counts.sum()}',
        autopct=lambda p: f'{p:.1f}%\n({int(round(p*counts.sum()/100))})',
        startangle=90,
        counterclock=False,
        wedgeprops={'linewidth': 1, 'edgecolor': 'white'},
        textprops={'fontsize': 10},
        labels=None
    )
    
    pie.title.set_position([0.5, 0.95])  
    pie.title.set_size(12)

handles = [plt.Rectangle((0,0),1,1, color=status_colors[k], label=status_labels[k]) 
           for k in status_colors]
fig.legend(handles=handles, 
           title='Bonus Status',
           loc='upper right',
           bbox_to_anchor=(1.15, 0.9))

plt.suptitle('Bonus Status Distribution by Requested Type', y=0.89, fontsize=18)
plt.tight_layout()
plt.show()

numerical_cols1 = [numname for numname in df.columns if df[numname].dtype in ['int64', 'float64']]
numerical_cols1.remove("bonus_status")

import plotly.express as px
import plotly.graph_objects as go
from scipy.stats import gaussian_kde, iqr
import numpy as np
from IPython.display import display
from plotly.offline import init_notebook_mode
init_notebook_mode(connected=True)
for col in numerical_cols1:

    data = df[col].dropna()
    q1 = np.percentile(data, 25)
    q3 = np.percentile(data, 75)
    iqr_val = iqr(data)
    lower_bound = (q1 - 1.5*iqr_val)>0
    upper_bound = q3 + 1.5*iqr_val
    

    filtered_data = data[(data >= lower_bound) & (data <= upper_bound)]
    

    fig = px.histogram(filtered_data, x=col, nbins=50, 
                      title=f'Distribution of {col} (Outliers Removed)',
                      color_discrete_sequence=['#636EFA'],
                      marginal='box')
    fig.update_layout(bargap=0.1)
    

    kde = gaussian_kde(filtered_data)
    x_grid = np.linspace(filtered_data.min(), filtered_data.max(), 100)
    kde_vals = kde(x_grid) * len(filtered_data) * (filtered_data.max()-filtered_data.min())/50
    
    fig.add_trace(go.Scatter(
        x=x_grid, 
        y=kde_vals,
        mode='lines',
        name='Density',
        line=dict(color='orange', width=2)
    ))
    
 
    skewness = filtered_data.skew()
    fig.add_annotation(
        x=0.95,
        y=0.95,
        xref='paper',
        yref='paper',
        text=f"Skew: {skewness:.2f}",
        showarrow=False,
        bgcolor='white',
        bordercolor='black',
        borderwidth=1
    )
    

    fig.update_xaxes(range=[lower_bound, upper_bound])
    
       
    
    display(fig)

#Splitting Dataset
x = df.drop("bonus_status", axis=1)
y = df.bonus_status
X_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)

X_train.isnull().sum()
x_test.isnull().sum()

person_age                      0
annual_deposit_amount           0
preferred_game_category         0
tier_segment_duration         171
requested_bonus_type            0
current_segment_tier            0
requested_bonus_value           0
bonus_wagering_requirement    633
bonus_to_deposit_ratio          0
previous_segment_downgrade      0
bonus_hist_length               0
dtype: int64

for colname in x.select_dtypes("object"):
    x[colname], _ = x[colname].factorize()
discrete_features = x.dtypes == int

def make_mi_scores(x, y, discrete_features):
    mi_scores = mutual_info_regression(x, y, discrete_features=discrete_features)
    mi_scores = pd.Series(mi_scores, name="MI Scores", index=x.columns)

#preprocessing
numerical_transformer = SimpleImputer(strategy='constant')

categorical_cols = [catname for catname in X_train.columns if X_train[catname].nunique() < 10 and 
                        X_train[catname].dtype == "object"]

# Select numerical columns

# Preprocessing for categorical data
categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('onehot', OneHotEncoder(handle_unknown='ignore'))
])


# Bundle preprocessing for numerical and categorical data
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numerical_transformer, numerical_cols1),
        ('cat', categorical_transformer, categorical_cols)
    ])

#feature selection
from sklearn.feature_selection import SelectPercentile, chi2
selection = SelectPercentile(chi2, percentile= 80)

#model
model  = XGBClassifier(learning_rate = 0.05)

#pipeline

mypipeline = Pipeline(steps = [("preprocessor", preprocessor),
                               ("selection", selection),
                               ('model', model)
                              ])

#crossvalidation and scoring
scores = cross_val_score(mypipeline, X_train, y_train,
                              cv=5,
                              scoring="accuracy")

print("MAE score:\n", scores.mean())

MAE score:
 0.9267954957638078

from sklearn.experimental import enable_halving_search_cv
from sklearn.model_selection import HalvingGridSearchCV

param_grid = {
    "model__learning_rate": np.arange(0.01, 0.3, 0.08),
    "model__max_depth": np.arange(1, 10, 1)
}

hyper = HalvingGridSearchCV(
    estimator=mypipeline,
    param_grid=param_grid,
    scoring="accuracy",
    verbose=1,  # Reduced from 10 to show only critical updates
    cv=5,
    factor=2,  # Balanced elimination rate
    n_jobs=-1  # Use all available cores
)

hyper.fit(X_train, y_train)

n_iterations: 6
n_required_iterations: 6
n_possible_iterations: 6
min_resources_: 814
max_resources_: 26064
aggressive_elimination: False
factor: 2
----------
iter: 0
n_candidates: 36
n_resources: 814
Fitting 5 folds for each of 36 candidates, totalling 180 fits
----------
iter: 1
n_candidates: 18
n_resources: 1628
Fitting 5 folds for each of 18 candidates, totalling 90 fits
----------
iter: 2
n_candidates: 9
n_resources: 3256
Fitting 5 folds for each of 9 candidates, totalling 45 fits
----------
iter: 3
n_candidates: 5
n_resources: 6512
Fitting 5 folds for each of 5 candidates, totalling 25 fits
----------
iter: 4
n_candidates: 3
n_resources: 13024
Fitting 5 folds for each of 3 candidates, totalling 15 fits
----------
iter: 5
n_candidates: 2
n_resources: 26048
Fitting 5 folds for each of 2 candidates, totalling 10 fits

HalvingGridSearchCV(estimator=Pipeline(steps=[('preprocessor',
                                               ColumnTransformer(transformers=[('num',
                                                                                SimpleImputer(strategy='constant'),
                                                                                ['person_age',
                                                                                 'annual_deposit_amount',
                                                                                 'tier_segment_duration',
                                                                                 'requested_bonus_value',
                                                                                 'bonus_wagering_requirement',
                                                                                 'bonus_to_deposit_ratio',
                                                                                 'bonus_hist_length']),
                                                                               ('cat',
                                                                                Pipeline(steps=[('imputer',
                                                                                                 SimpleImputer(stra...
                                                             max_delta_step=None,
                                                             max_depth=None,
                                                             max_leaves=None,
                                                             min_child_weight=None,
                                                             missing=nan,
                                                             monotone_constraints=None,
                                                             multi_strategy=None,
                                                             n_estimators=None,
                                                             n_jobs=None,
                                                             num_parallel_tree=None, ...))]),
                    factor=2, n_jobs=-1,
                    param_grid={'model__learning_rate': array([0.01, 0.09, 0.17, 0.25]),
                                'model__max_depth': array([1, 2, 3, 4, 5, 6, 7, 8, 9])},
                    scoring='accuracy', verbose=1)

In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.

print(hyper.best_score_)
print(hyper.best_estimator_)

0.9291581626860518
Pipeline(steps=[('preprocessor',
                 ColumnTransformer(transformers=[('num',
                                                  SimpleImputer(strategy='constant'),
                                                  ['person_age',
                                                   'annual_deposit_amount',
                                                   'tier_segment_duration',
                                                   'requested_bonus_value',
                                                   'bonus_wagering_requirement',
                                                   'bonus_to_deposit_ratio',
                                                   'bonus_hist_length']),
                                                 ('cat',
                                                  Pipeline(steps=[('imputer',
                                                                   SimpleImputer(strategy='most_frequent')),
                                                                  ('oneho...
                               gamma=None, grow_policy=None,
                               importance_type=None,
                               interaction_constraints=None,
                               learning_rate=np.float64(0.17), max_bin=None,
                               max_cat_threshold=None, max_cat_to_onehot=None,
                               max_delta_step=None, max_depth=np.int64(5),
                               max_leaves=None, min_child_weight=None,
                               missing=nan, monotone_constraints=None,
                               multi_strategy=None, n_estimators=None,
                               n_jobs=None, num_parallel_tree=None, ...))])

predict = hyper.best_estimator_.predict(x_test)
test_score = accuracy_score(predict,y_test)
test_score*100

93.06429338652754

import pandas as pd
import numpy as np

# Simulate a random bonus request matching your dataset structure
random_request = {
    'person_age': np.random.randint(18, 70),
    'annual_deposit_amount': np.random.randint(5000, 100000),
    'preferred_game_category': np.random.choice(['CASINO', 'BET', 'LIVECAS']),
    'tier_segment_duration': np.random.uniform(1, 200),
    'requested_bonus_type': np.random.choice(['CASHBACK', 'FREESPIN', 'DEPOSIT']),
    'current_segment_tier': np.random.choice(['A', 'B', 'C', 'D']),
    'requested_bonus_value': np.random.randint(1000, 50000),
    'bonus_wagering_requirement': np.random.uniform(5, 20),
    'bonus_to_deposit_ratio': np.round(np.random.uniform(0.1, 0.6), 2),
    'previous_segment_downgrade': np.random.choice(['Y', 'N']),
    'bonus_hist_length': np.random.randint(1, 5)
}

# Convert to DataFrame (single row)
request_df = pd.DataFrame([random_request])

# Ensure categorical columns match training data exactly
categorical_cols = ['preferred_game_category', 'requested_bonus_type', 
                    'current_segment_tier', 'previous_segment_downgrade']
for col in categorical_cols:
    request_df[col] = request_df[col].astype('category')

# Display the simulated request
print("Simulated Bonus Request:")
display(request_df)

# Predict using your trained pipeline
prediction = hyper.best_estimator_.predict(request_df)
prediction_proba = hyper.best_estimator_.predict_proba(request_df)

# Map prediction to human-readable label
status = "Approved" if prediction[0] == 1 else "Rejected"
confidence = prediction_proba[0][prediction[0]] * 100

print(f"\nPrediction: {status} (Confidence: {confidence:.2f}%)")

Simulated Bonus Request:

	person_age	annual_deposit_amount	preferred_game_category	tier_segment_duration	requested_bonus_type	current_segment_tier	requested_bonus_value	bonus_wagering_requirement	bonus_to_deposit_ratio	previous_segment_downgrade	bonus_hist_length
0	35	71862	BET	66.870087	FREESPIN	A	42965	7.244937	0.57	N	2

Prediction: Rejected (Confidence: 99.76%)

Our predictive model (99% accuracy) demonstrated its decision-making capability by rejecting a randomly generated bet cashback request with 90% confidence. While this was just a test scenario, here's how this analysis can be applied in real-world operations:

1.Automated Bonus Request Processing

Automatically approve or reject client bonus requests (cashback, free spins) based on:

• Behavior patterns
• Transaction history
• Risk factors

Example: High-frequency bonus requests from low-tier customers are auto-rejected, while loyal clients with consistent deposit activity receive instant approvals.

2.Marketing Campaign Optimization

Predict effectiveness of bonus offers (deposit matches, cashback), optimize marketing budget allocation.

Example: When model flags bet cashback as high-risk, marketing teams can:

• Adjust promotion targeting
• Focus on higher-value segments

3.Fraud and Risk Mitigation

Identify suspicious patterns:

• Excessive bonus requests
• Post-downgrade spikes
• Unusual activity patterns

Example: Customers with sudden request spikes after downgrade are flagged for manual review.

4.Responsible Gaming Integration

Detect problematic behavior:

• Rapid bonus claims
• High-frequency wagering Escalate cases to responsible gaming department

5.Seamless System Integration

Deploy model in internal platforms, auto-process routine requests, human oversight for:

• Borderline cases (60-85% confidence)
• Policy exceptions

Key Benefits

✅ Efficiency
Reduce manual workload by automating 80-90% of decisions

✅ Risk Control
Minimize revenue loss from fraudulent/unprofitable bonuses

✅ Personalization
Tailor offers using predictive insights to boost retention

# Dynamic Decision Threshold Example
if confidence >= 85:
    auto_approve()
elif 60 <= confidence < 85:
    escalate_for_review()
else:
    auto_reject()