BentoML Example¶
XGBoost League of legend Win prediction¶
This is a BentoML Demo Project demonstrating how to train a League of Legend win prdiction model, and use BentoML to package and serve the model for building applictions.
BentoML is an open source platform for machine learning model serving and deployment.
Example notebook built based on https://slundberg.github.io/shap/notebooks/League%20of%20Legends%20Win%20Prediction%20with%20XGBoost.html
In [1]:
%reload_ext autoreload
%autoreload 2
%matplotlib inline
import warnings
warnings.filterwarnings("ignore")
In [2]:
!pip install bentoml
!pip install numpy xgboost sklearn matplotlib kaggle
In [2]:
import pandas as pd
import numpy as np
import xgboost as xgb
import matplotlib.pyplot as pl
from sklearn.model_selection import train_test_split
Download Data¶
This notebook uses data from kaggle paololol/league-of-legends-ranked-matches
You can set your Kaggle credential below and download the dataset automatically. The kaggle key can be created by going to the 'Account' tab of your user profile (https://www.kaggle.com/
Alternativelly, you can download it manually from here and place unzip'd data in this folder.
In [4]:
%%bash
export KAGGLE_USERNAME=
export KAGGLE_KEY=
if [ ! -f ./league-of-legends-ranked-matches.zip ]; then
kaggle datasets download paololol/league-of-legends-ranked-matches
unzip -n league-of-legends-ranked-matches.zip
fi
Load data¶
In [3]:
# read in the data
matches = pd.read_csv("matches.csv")
participants = pd.read_csv("participants.csv")
stats1 = pd.read_csv("stats1.csv", low_memory=False)
stats2 = pd.read_csv("stats2.csv", low_memory=False)
stats = pd.concat([stats1,stats2])
# merge into a single DataFrame
a = pd.merge(participants, matches, left_on="matchid", right_on="id")
allstats_orig = pd.merge(a, stats, left_on="matchid", right_on="id")
allstats = allstats_orig.copy()
# drop games that lasted less than 10 minutes
allstats = allstats.loc[allstats["duration"] >= 10*60,:]
# Convert string-based categories to numeric values
cat_cols = ["role", "position", "version", "platformid"]
for c in cat_cols:
allstats[c] = allstats[c].astype('category')
allstats[c] = allstats[c].cat.codes
allstats["wardsbought"] = allstats["wardsbought"].astype(np.int32)
X = allstats.drop(["win"], axis=1)
y = allstats["win"]
# convert all features we want to consider as rates
rate_features = [
"kills", "deaths", "assists", "killingsprees", "doublekills",
"triplekills", "quadrakills", "pentakills", "legendarykills",
"totdmgdealt", "magicdmgdealt", "physicaldmgdealt", "truedmgdealt",
"totdmgtochamp", "magicdmgtochamp", "physdmgtochamp", "truedmgtochamp",
"totheal", "totunitshealed", "dmgtoobj", "timecc", "totdmgtaken",
"magicdmgtaken" , "physdmgtaken", "truedmgtaken", "goldearned", "goldspent",
"totminionskilled", "neutralminionskilled", "ownjunglekills",
"enemyjunglekills", "totcctimedealt", "pinksbought", "wardsbought",
"wardsplaced", "wardskilled"
]
for feature_name in rate_features:
X[feature_name] /= X["duration"] / 60 # per minute rate
# convert to fraction of game
X["longesttimespentliving"] /= X["duration"]
# define friendly names for the features
full_names = {
"kills": "Kills per min.",
"deaths": "Deaths per min.",
"assists": "Assists per min.",
"killingsprees": "Killing sprees per min.",
"longesttimespentliving": "Longest time living as % of game",
"doublekills": "Double kills per min.",
"triplekills": "Triple kills per min.",
"quadrakills": "Quadra kills per min.",
"pentakills": "Penta kills per min.",
"legendarykills": "Legendary kills per min.",
"totdmgdealt": "Total damage dealt per min.",
"magicdmgdealt": "Magic damage dealt per min.",
"physicaldmgdealt": "Physical damage dealt per min.",
"truedmgdealt": "True damage dealt per min.",
"totdmgtochamp": "Total damage to champions per min.",
"magicdmgtochamp": "Magic damage to champions per min.",
"physdmgtochamp": "Physical damage to champions per min.",
"truedmgtochamp": "True damage to champions per min.",
"totheal": "Total healing per min.",
"totunitshealed": "Total units healed per min.",
"dmgtoobj": "Damage to objects per min.",
"timecc": "Time spent with crown control per min.",
"totdmgtaken": "Total damage taken per min.",
"magicdmgtaken": "Magic damage taken per min.",
"physdmgtaken": "Physical damage taken per min.",
"truedmgtaken": "True damage taken per min.",
"goldearned": "Gold earned per min.",
"goldspent": "Gold spent per min.",
"totminionskilled": "Total minions killed per min.",
"neutralminionskilled": "Neutral minions killed per min.",
"ownjunglekills": "Own jungle kills per min.",
"enemyjunglekills": "Enemy jungle kills per min.",
"totcctimedealt": "Total crown control time dealt per min.",
"pinksbought": "Pink wards bought per min.",
"wardsbought": "Wards bought per min.",
"wardsplaced": "Wards placed per min.",
"turretkills": "# of turret kills",
"inhibkills": "# of inhibitor kills",
"dmgtoturrets": "Damage to turrets"
}
feature_names = [full_names.get(n, n) for n in X.columns]
X.columns = feature_names
# create train/validation split
Xt, Xv, yt, yv = train_test_split(X,y, test_size=0.2, random_state=10)
dt = xgb.DMatrix(Xt, label=yt.values)
dv = xgb.DMatrix(Xv, label=yv.values)
Train the XGBoost model¶
In [4]:
params = {
"eta": 0.5,
"max_depth": 4,
"objective": "binary:logistic",
"silent": 1,
"base_score": np.mean(yt),
"eval_metric": "logloss"
}
model = xgb.train(params, dt, 100, [(dt, "train"),(dv, "valid")], early_stopping_rounds=5, verbose_eval=10)
In [5]:
Xt[:3]
Out[5]:
In [6]:
model.predict(xgb.DMatrix(Xt[:3]))
Out[6]:
Create ML service with BentoML¶
In [10]:
%%writefile lol_win_predictions.py
from bentoml import api, env, BentoService, artifacts
from bentoml.artifact import XgboostModelArtifact
from bentoml.adapters import DataframeInput
import xgboost as xgb
@env(pip_dependencies=['xgboost'])
@artifacts([XgboostModelArtifact('model')])
class LeagueWinPrediction(BentoService):
@api(input=DataframeInput())
def predict(self, df):
dmatrix = xgb.DMatrix(df)
return self.artifacts.model.predict(dmatrix)
In [7]:
# 1) import the custom BentoService defined above
from lol_win_predictions import LeagueWinPrediction
# 2) `pack` it with required artifacts
bento_svc = LeagueWinPrediction()
bento_svc.pack('model', model)
# 3) save your BentoSerivce
saved_path = bento_svc.save()
In [8]:
from bentoml import load
svc = load(saved_path)
print(svc.predict(Xt[:3]))
In [9]:
!bentoml get LeagueWinPrediction
In [10]:
!bentoml get LeagueWinPrediction:latest
In [11]:
Xt[:3].to_csv('test.csv')
In [12]:
!bentoml run LeagueWinPrediction:latest predict --input test.csv
In [13]:
!bentoml serve LeagueWinPrediction:latest
In [ ]:
In [ ]:
Using BentoML archive as CLI tool¶
In [14]:
!pip install {saved_path}
In [16]:
!LeagueWinPrediction run predict --input=test.csv
Use archive as REST API server¶
notes: This doesn't work with Google Colab right now, because we can't access the local port from it.
In [ ]:
!bentoml serve {saved_path}
Make requeset to the REST server¶
After navigate to the location of this notebook, copy and paste the following code to your terminal and run it to make request
curl -i \
--request POST \
--header "Content-Type: text/csv" \
-d @test.csv \
localhost:5000/predict
In [ ]:
In [ ]:
In [18]:
!bentoml lambda deploy xgboost-lol -b LeagueWinPrediction:latest
In [21]:
!bentoml lambda list
In [20]:
!bentoml lambda get xgboost-lol
In [ ]:
!curl -i \
--request POST \
--header "Content-Type: text/csv" \
-d @test.csv \
https://esuj190n16.execute-api.us-west-2.amazonaws.com/Prod/predict
In [25]:
!bentoml lambda delete xgboost-lol
In [ ]: