Modelling the Impact of Early Objetives in League of Legends

%matplotlib inline

from concurrent.futures import ThreadPoolExecutor, as_completed
from functools import partial
from json import load as json_load
from joblib import dump as joblib_dump
from joblib import load as joblib_load
from operator import itemgetter
from os import listdir, remove
from os.path import expanduser, isfile, join, exists, isfile
from time import sleep


import numpy as np
import pandas as pd
import pymc3 as pm
import matplotlib.pyplot as plt
import seaborn as sb
from IPython.display import clear_output, display

def _extract_indicator_from_teams(key: str, match_details: dict) -> int:
    indicator = 0
    for team in match_details['teams']:
        if team['teamId'] == 100:
            indicator -= team[key]
        else:
            indicator += team[key]
    return indicator

def _extract_participant_stat(aggregator: callable, key: str, match_details: dict) -> int:
    blue = aggregator(
        participant['stats'][key] if key in participant['stats'] else 0
        for participant in match_details['participants']
        if participant['teamId'] == 100)

    red = aggregator(
        participant['stats'][key] if key in participant['stats'] else 0
        for participant in match_details['participants']
        if participant['teamId'] == 200)
    
    return red-blue

def _extract_participant_timeline_key(team_id: int, lane: str, key: str, frame: str, match_details: dict):
    '''
    - team_id (int): Possible values are 100 (blue)
        and 200 (red).

    - lane (str): Possible values are 'MIDDLE', 'TOP',
        'JUNGLE' and 'BOTTOM'.

    - key (str): Possbile values are 'goldPerMinDeltas',
        'creepsPerMinDeltas', 'xpPerMinDeltas' and
        'damageTakenPerMinDeltas'

    - frame (str): Possible values are '0-10', '10-20',
        '20-30' and '30-end'.

    - match_details (dict): whole dictionary of parse
        match json.
    '''
    metric = 0.0  # sum because two players are bottom

    for participant in match_details['participants']:
        is_lane = participant['timeline']['lane'] == lane
        is_team = participant['teamId'] == team_id
        
        if is_lane and is_team:
            try:
                metric += participant['timeline'][key][frame]
            except KeyError:
                return np.nan
            
    return metric

def extract_red_win(match_details: dict) -> bool:
    team = match_details['teams'][0]
    
    if team['teamId'] == 100:  # blue
        if team['win'] == 'Win':
            return False
        else:
            return True
    else:  # red
        if team['win'] == 'Win':
            return True
        else:
            return False

team_to_text = {100: 'blue', 200: 'red'}
        
def generate_participant_timeline_extractors(team_ids: (int,), lanes: (str,), keys: (str,), frames: (str,)):
    for team_id in (100, 200):
        for lane in ('BOTTOM', 'MIDDLE', 'TOP', 'JUNGLE'):
            for key in ('goldPerMinDeltas', 'creepsPerMinDeltas', 'xpPerMinDeltas', 'damageTakenPerMinDeltas'):
                for frame in ('0-10',):
                    yield (
                        f"{key}{team_to_text[team_id].title()}{lane.title()}{frame.split('-')[-1]}",
                        'f4',
                        partial(_extract_participant_timeline_key, team_id, lane, key, frame)
                    )

def get_features_and_extractors() -> ((str, type, callable),):
    return (
        ('redWin', 'i1', extract_red_win),

        ('firstDragon', 'f4', partial(_extract_indicator_from_teams, 'firstDragon')),
        ('firstRiftHerald', 'f4', partial(_extract_indicator_from_teams, 'firstRiftHerald')),

        ('firstBlood', 'f4', partial(_extract_indicator_from_teams, 'firstBlood')),
        ('anyFirstBloodAssist', 'f4', partial(_extract_participant_stat, any, 'firstBloodAssist')),
        ('sumFirstBloodAssist', 'f4', partial(_extract_participant_stat, sum, 'firstBloodAssist')),

        ('firstTower', 'f4', partial(_extract_indicator_from_teams, 'firstTower')),
        ('anyFirstTowerAssist', 'f4', partial(_extract_participant_stat, any, 'firstTowerAssist')),
        ('sumFirstTowerAssist', 'f4', partial(_extract_participant_stat, sum, 'firstTowerAssist'))
    )+tuple(
        extractor for extractor in
        generate_participant_timeline_extractors(
            (100, 200),
            ('BOTTOM', 'MIDDLE', 'TOP', 'JUNGLE'),
            ('goldPerMinDeltas', 'creepsPerMinDeltas', 'xpPerMinDeltas', 'damageTakenPerMinDeltas'),
            ('0-10',)
        )
    )

def load_matches_from_folder(base_path: str, features: ((str, type, callable),)):
    filelist = listdir(base_path)

    data = np.zeros(len(filelist), dtype=[(f, t) for f, t, _ in features])
    

    type_to_default = {'i1': -128, 'f4': np.nan}
    for f, t, _ in features:
        data[f] = type_to_default[t]

    print(f"loading max. {len(filelist)} files")

    def load_and_parse_match_details(file_i: int, base_path: str, file_name: str):
        file_path = join(base_path, file_name)

        if isfile(file_path):
            with open(file_path, 'r') as match_file:
                match_details = load(match_file)

            if not match_details['queueId'] in (420, 440):
                remove(file_path)
            else:
                for feature, _, extractor in features:
                    try:
                        data[feature][file_i] = extractor(match_details)
                    except Exception as exception:
                        print(f"error parsing feature {feature} for {file_name}")
                        raise

        return file_i

    max_file_done = 0

    with ThreadPoolExecutor(max_workers=4) as executor:

        print(f"using {executor._max_workers} threads")

        futures = tuple(
            executor.submit(load_and_parse_match_details, file_i, base_path, file_name)
            for file_i, file_name in enumerate(filelist)
            if file_name.endswith('.json')
        )

        print(f"submitted all {len(futures)} to the executor")

        for future in as_completed(futures):
            try:
                file_i = future.result()
            except Exception as exception:
                executor.shutdown()
                print(f"error parsing files - {exception}")
                raise
            else:
                max_file_done = max(max_file_done, file_i)
                if file_i%1000 == 0 or max_file_done+1==len(filelist):
                    clear_output(wait=True)
                    display(f"{100.0*float(max_file_done+1)/float(len(filelist)):>5.1f}%")
                    
    return data

features_path = join(expanduser('~'), 'Downloads', '20190208-logistic-features.joblib')
data_path = join(expanduser('~'), 'Downloads', '20190208-logistic.joblib')
if exists(features_path) and exists(data_path) and isfile(features_path) and isfile(data_path):
    features = joblib_load(features_path)
    data = joblib_load(data_path)
    print(f"LOADED CACHED DATA FROM {data_path}")
else:
    features = get_features_and_extractors()
    data = load_matches_from_folder(join(expanduser('~'), 'Downloads', 'lol_matches'), features)

def generate_computed_feature_names(features: ((str, type, callable))):
    for key in ('goldPerMinDeltas', 'creepsPerMinDeltas', 'xpPerMinDeltas', 'damageTakenPerMinDeltas'):
        for lane in ('BOTTOM', 'MIDDLE', 'TOP', 'JUNGLE'):
            k1 = f"{key}Red{lane.title()}10"
            k2 = f"{key}Blue{lane.title()}10"
            feature_name = f"{key}{lane.title()}10"
            if feature_name in map(itemgetter(0), features):
                continue
            yield feature_name, 'f4', lambda d: d[k1]-d[k2]
            
new_data = np.zeros(len(data), dtype=[(f, t) for f, t, _ in features+tuple(generate_computed_feature_names(features))])

for f, _, _ in features:
    if f in data.dtype.names:
        new_data[f] = data[f]

for f, _, e in generate_computed_feature_names(features):
    new_data[f] = e(new_data)
    
data = new_data

features = features+tuple(generate_computed_feature_names(features))

missing_mask = np.zeros(len(data), dtype=np.bool)

for f, _, _ in features:
    missing_mask |= np.isnan(data[f])
    
data = data[~missing_mask].copy()

data = data[:][((data['firstBlood'] != 0) | (data['firstTower'] != 0))].copy()

keep_columns = []
for f, _, _ in features:
    if f not in data.dtype.names:
        continue
    if not (data[f] == data[f][0]).all():
        keep_columns.append(f)
    else:
        print(f"dropping {f}")

data = data[keep_columns].copy()

features = tuple(f for f in features if f[0] in keep_columns)

for f, _, _ in features:
    if f == 'redWin':
        continue
    data[f] = (data[f]-np.mean(data[f]))/np.std(data[f])

_ = joblib_dump(data, join(expanduser('~'), 'Downloads', '20190208-logistic.joblib'))
_ = joblib_dump(tuple((f, t, None) for f, t, _ in features),
            join(expanduser('~'), 'Downloads', '20190208-logistic-features.joblib'))

# Compute the correlation matrix
corr = np.zeros((len(features), len(features)), dtype='float32')

for f1_i, (f1, _, _) in enumerate(features):
    for f2_i, (f2, _, _) in enumerate(features):
        corr[f1_i, f2_i] = np.corrcoef(data[f1], data[f2])[0, 1]

# Generate a mask for the upper triangle
mask = np.zeros_like(corr, dtype=np.bool)
mask[np.triu_indices_from(mask)] = True

# Set up the matplotlib figure
f, ax = plt.subplots(figsize=(12, 11))
f.set_dpi(227.0)

# Generate a custom diverging colormap
cmap = sb.diverging_palette(220, 10, as_cmap=True)

# Draw the heatmap with the mask and correct aspect ratio
_ = sb.heatmap(
    corr, mask=mask, cmap=cmap, vmin=-1, vmax=1,
    linewidths=.5, cbar_kws={"shrink": .5},
    ax=ax, # annot=True,
    xticklabels=tuple(f for f, _, _ in features),
    yticklabels=tuple(f for f, _, _ in features))

def create_tr_te_split(data: np.ndarray, target_variable: str, tr_pct: float = 0.6):
    # feature_vars = tuple(f for f in data.dtype.names if f != target_variable)

    tr_te_split = int(len(data)*tr_pct)

    X_tr = np.zeros(tr_te_split, dtype=[(f, 'f4') for f in data.dtype.names])
    y_tr = np.zeros(tr_te_split, dtype='bool')

    X_te = np.zeros(len(data)-tr_te_split, dtype=[(f, 'f4') for f in data.dtype.names])
    y_te = np.zeros(len(data)-tr_te_split, dtype='bool')

    for f in data.dtype.names:
        X_tr[f] = data[f][:tr_te_split]
        X_te[f] = data[f][tr_te_split:]
    
    return X_tr, X_te

X_tr, X_te = create_tr_te_split(data, 'redWin')

del data

feature_names = (
    f for f, _, _
    in features
    if f != 'redWin'
    and 'Red' not in f
    and 'Blue' not in f
)
model_equation = f"redWin ~ {' + '.join(feature_names)}"
indent = ' '.join('' for _ in range(len(model_equation.split('~')[0])+1))
print(model_equation.replace('+', f"\n{indent}+"), end='\n\n')
del feature_names
del indent

with pm.Model() as logistic_model:
    pm.glm.GLM.from_formula(model_equation, X_tr, family=pm.glm.families.Binomial())
    print(logistic_model.check_test_point())
    trace_logistic_model = pm.sample(
        2000,
        chains=None,
        tune=1000)

 pm.backends.ndarray.save_trace(
     trace_logistic_model,
     directory=join(expanduser('~'), 'Dropbox', 'lol-analysis',
                    '20190208-logistic-difference-lane-factors', 'model'),
     overwrite=False)

def plot_traces(traces, retain=1000):
    '''
    Convenience function:
    Plot traces with overlaid means and values
    '''

    ax = pm.traceplot(traces[-retain:], figsize=(12, len(traces.varnames)*1.5),
        lines={k: v['mean'] for k, v in pm.summary(traces[-retain:]).iterrows()})

    for i, mn in enumerate(pm.summary(traces[-retain:])['mean']):
        ax[i,0].annotate(
            f"{mn:.2f}", xy=(mn,0), xycoords='data',
            xytext=(5,10), textcoords='offset points',
            rotation=90,va='bottom', fontsize='large',
            color='#AA0022')

plot_traces(trace_logistic_model, retain=1000)

for mean, name in sorted(zip(pm.summary(trace_logistic_model[-1000:])['mean'], trace_logistic_model.varnames), reverse=True):
    print(f"{name:>35}: {mean:5.2f}")

with pm.Model() as logistic_model:
    pm.glm.GLM.from_formula(model_equation, X_te, family=pm.glm.families.Binomial())
    trace_logistic_model = pm.backends.ndarray.load_trace(
         join(expanduser('~'), 'Dropbox', 'lol-analysis',
              '20190208-logistic-difference-lane-factors', 'model'),
         model=logistic_model)
    ppc = pm.sample_ppc(trace_logistic_model, model=logistic_model, samples=1000)

from sklearn.metrics import roc_curve, auc, f1_score, accuracy_score

y_pred = np.mean(ppc['y'], axis=0) > 0.5

print(f"accuracy: {100.0*accuracy_score(X_te['redWin'], y_pred):>4.1f}%")
print(f"f1 score: {f1_score(X_te['redWin'], y_pred):>4.3f}")

fpr, tpr, thresholds = roc_curve(X_te['redWin'], np.mean(ppc['y'], axis=0))
roc_auc = auc(fpr, tpr)

import matplotlib.pyplot as plt
%matplotlib inline

figure = plt.figure(figsize=(12,12))
axis = figure.gca()

_ = axis.set_title('Receiver Operating Characteristic')
_ = axis.plot(fpr, tpr, 'b', label = f"AUC = {roc_auc:0.2f}")
_ = axis.legend(loc = 'lower right')
_ = axis.plot([0, 1], [0, 1],'r--')
_ = axis.set_xlim([0, 1])
_ = axis.set_ylim([0, 1])
_ = axis.set_ylabel('True Positive Rate')
_ = axis.set_xlabel('False Positive Rate')