arenaelo.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import pickle\n",
    "import os\n",
    "from collections import defaultdict\n",
    "import datetime\n",
    "\n",
    "import dateutil\n",
    "import scipy\n",
    "from dateutil.relativedelta import relativedelta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alias_map = {}\n",
    "clean = lambda x: ''.join(x.split()).lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('arena_matches3.pkl','rb') as fp: #cs_matches\n",
    "    results = pickle.load(fp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "data = []\n",
    "for k in results:\n",
    "    basics = [k] + list(results[k][:3]) +[results[k][-1]]\n",
    "    for m in results[k][3]:\n",
    "        new_elem = basics + list(m)\n",
    "        if new_elem[5] == '':\n",
    "            new_elem[5] = new_elem[3]\n",
    "        if new_elem[5] == '':\n",
    "            continue\n",
    "        t1 = clean(new_elem[6])\n",
    "        t2 = clean(new_elem[7])\n",
    "        \n",
    "        \n",
    "        new_elem[6] = alias_map.get(t1,t1)\n",
    "        new_elem[7] = alias_map.get(t2,t2)\n",
    "        \n",
    "\n",
    "        data.append(new_elem)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_elem,len(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame(data,columns=['venue','tier','type','vtime','game','mtime','t1','t2','s1','s2','rnds'])\n",
    "df['mtime'] = df['mtime'].map(lambda x: dateutil.parser.parse(x.replace('??','01')) if type(x) == str else x)\n",
    "df['mtime'] = pd.to_datetime(df['mtime'],utc=True)\n",
    "\n",
    "df['t1'] = df['t1'].map(lambda x: x.lower())\n",
    "df['t2'] = df['t2'].map(lambda x: x.lower())\n",
    "\n",
    "\n",
    "df = df[df['t1'] != 'bye']\n",
    "df = df[df['t2'] != 'bye']\n",
    "df = df[df['t1'] != '']\n",
    "df = df[df['t2'] != '']\n",
    "df = df[~df.t1.map(lambda x: 'bye' in x)]\n",
    "df = df[~df.t2.map(lambda x: 'bye' in x)]\n",
    "df = df[~df.t1.map(lambda x: 'tbd' == x)]\n",
    "df = df[~df.t2.map(lambda x: 'tbd' == x)]\n",
    "df = df[~df.t1.map(lambda x: 'bracketmatch' in x)]\n",
    "df = df[~df.t2.map(lambda x: 'bracketmatch' in x)]\n",
    "\n",
    "subs = [('dj:)','dj'),('destrukt','dkt'),('razerj','jibo'),('a1r-r41d','a1r_r41d'),('cooler','cooller')]\n",
    "subs += [('toxic','toxjq'),('tox','toxjq'),('dragoax','dragaox'),('razerj','jibo'),('razerjibo','jibo'),('fox','fojji')]\n",
    "subs += [('matr0xpl','matr0xpl'),('toxic(americanplayer){{!}}toxic','toxic_us'),('solll_','solll')]\n",
    "subs += [('inz_', 'inz'), ('j_skey', 'jskey'), ('memento_mori', 'mementomori'), ('pie_hero', 'piehero'), ('septic_flesh', 'septicflesh'), ('sib_', 'sib'), ('st_germain', 'stgermain'), ('zanes_', 'zanes')]\n",
    "subs += [('brute-', 'brute'),('dr.doom', 'drdoom'), ('ms.x', 'msx'),('1grayfoxz', 'grayfoxz'),('astz!', 'astz')]\n",
    "subs += [('buggunsjoey', 'biggunsjoey')]\n",
    "subs += [('bootss', 'boots'),('bootsss', 'boots'),('ch33rra', 'ch3rra')]\n",
    "subs += [('zblazin', 'blazin'),('troolzy', 'troolz'),('vedmedik', 'vedemedik'),('vigur', 'vigurr'),('spawn2k', 'spawn2k4'),('spawn2k4', 'spawn2k'),('stenx', 'strenx'),('scoob', 'scooby'),('richochet', 'ricochet'),('sassmaster2', 'sassmaster'),('phosgenee', 'phosgene'),('overflux1', 'overflux'),('nonserium', 'nonservium'),('naaani', 'naani'),('maggotkil', 'maggotkill'),('k11lsen', 'k1llsen'),('k1lsen', 'k1llsen'),('lakermann', 'lakerman'),('d-pecka', 'pecka'),('dazatorr', 'dazator'),('defense', 'defense1'),('headbang3rr', 'headbang3r'),('infinte', 'infinite'),('karwik', 'karwick')]\n",
    "subs += [('?joker', 'joker')]\n",
    "subs += [('insan3', 'ins')]\n",
    "subs += [('ballin4life_', 'ballin4life')]\n",
    "subs += [('janky','jankygoatsmugla')]\n",
    "subs += [('jankygoat','jankygoatsmugla')]\n",
    "subs += [('koda','cody')]\n",
    "subs += [('p0ngmeister','p0ng')]\n",
    "subs += [('antreax2','strongsage')]\n",
    "subs += [('vigi1ante','vig1lante')]\n",
    "subs += [('quake2rizzy','rizzy')]\n",
    "\n",
    "for old, new in subs:\n",
    "    df.loc[df['t1'] == old,'t1'] = new\n",
    "    df.loc[df['t2'] == old,'t2'] = new\n",
    "\n",
    "df.loc[(df.t1 == 'ins') & df.mtime.map(lambda x: x.year < 2007),'t2'] = 'insane'\n",
    "df.loc[(df.t2 == 'ins') & df.mtime.map(lambda x: x.year < 2007),'t2'] = 'insane'\n",
    "    \n",
    "df.loc[df['game'] == 'db','game'] = 'dbt'\n",
    "df.loc[df['game'] == 're','game'] = 'reflex'\n",
    "df.loc[df['game'] == 'dmb','game'] = 'doombringer'\n",
    "\n",
    "df.loc[df['game'].map(lambda x: x in['ut99','ut2k3','ut2k4']),'game'] = 'unreal'\n",
    "\n",
    "\n",
    "if False:\n",
    "    df = df[df.game != 'dbt']\n",
    "    df = df[df.game != 'reflex']\n",
    "    df = df[df.game != 'avp2']\n",
    "    df = df[df.game != 'wsw']\n",
    "    df = df[df.game != 'ws']\n",
    "    df = df[df.game != 'ut3']\n",
    "    df = df[df.game != 'doom2']\n",
    "    df = df[df.game != 'doombringer']\n",
    "    df = df[df.game != 'd2']\n",
    "\n",
    "      \n",
    "\n",
    "df.loc[df['tier'] != '1','tier'] = 'O'\n",
    "\n",
    "df.loc[df.venue.map(lambda x: 'XSReality' in x),'tier'] = '1'\n",
    "df.loc[df.venue.map(lambda x: 'MediaMarkt' in x),'tier'] = '1'\n",
    "df.loc[df.venue.map(lambda x: 'Invitational' in x),'tier'] = '1'\n",
    "df.loc[df.venue.map(lambda x: 'LAN Arena' in x),'tier'] = 'O'\n",
    "df.loc[df.venue.map(lambda x: 'Atomic' in x),'tier'] = 'O'\n",
    "\n",
    "#df = df[df.tier.isin(['A','S'])]\n",
    "df['type'] = df['type'].map(lambda x: 'Online' if 'Offline' != x else 'Offline')\n",
    "df = df.drop(df[(df.game == 'dbt') & (df.mtime.map(lambda x: x.year < 2021)) & (df.mtime.map(lambda x: x.month < 9))].index)\n",
    "print(df.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.tier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[df.venue == 'QuakeCon/2015/Quake Live/Duel/Grand Master']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.loc[df.venue == 'Quake Pro League/Season 1/Stage 3/Finals','type'] = 'Offline'\n",
    "df.loc[df.venue == 'Quake Pro League/Season 1/Stage 4/Finals','type'] = 'Offline'\n",
    "df.loc[df.venue == 'Quake World Championship/2020','type'] = 'Offline'\n",
    "df.loc[df.venue == 'Quake Pro League/Season 2/Stage 1/Finals','type'] = 'Offline'\n",
    "df.loc[df.venue == 'Quake Pro League/Season 2/Stage 2/Finals','type'] = 'Offline'\n",
    "\n",
    "\n",
    "for tts in [_ for _ in df[df.game == 'dbt'].venue.unique() if 'Test Tournament Series' in _]:\n",
    "    df.loc[df.venue == tts,'type'] = 'Offline'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import date\n",
    "import matplotlib.pyplot as plt\n",
    "tweight2= np.arange(df.shape[0])\n",
    "tweight2=tweight2/tweight2.max()/5 + 1\n",
    "tweight2=tweight2/tweight2.max()\n",
    "tweight2\n",
    "\n",
    "tweight = (pd.Timestamp(date.today(),tz='UTC')-df.mtime).map(lambda x: x.days)\n",
    "plt.hist(tweight,30)\n",
    "#tweight = (np.tanh(-(tweight-120)/360) +1)/2\n",
    "tweight = np.exp(-tweight/1000)*tweight2\n",
    "\n",
    "tweight = tweight/tweight.max()\n",
    "gweight = ((df.game == 'qc')  ).astype(int) + 1e-3\n",
    "eweight = ((df['type'] == 'Offline')  ).astype(int)*2 + 1\n",
    "\n",
    "names = sorted(list(set(list(df.t1.unique()) + list(df.t2.unique()))))\n",
    "lenN = len(names)\n",
    "n_idx = {k:v for v,k in enumerate(names)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.scatter(df.mtime,tweight*eweight*gweight)\n",
    "plt.xlim(left=datetime.date(2020,1,1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.sparse import dok_matrix\n",
    "\n",
    "#S = dok_matrix((len(df), lenN), dtype=np.float32)\n",
    "S = np.zeros((len(df), lenN), dtype=np.float32)\n",
    "labels = []\n",
    "for i,row in enumerate(df.itertuples()):\n",
    "    t1 = n_idx[row[7]]\n",
    "    t2 = n_idx[row[8]]\n",
    "    s1 = row[9]\n",
    "    s2 = row[10]\n",
    "    S[i,t1] = 1\n",
    "    S[i,t2] = -1\n",
    "    #labels.append(int(s1 > s2))\n",
    "    labels.append(max(0,s1)/(max(0,s1)+max(0,s2)))\n",
    "labels = np.array(labels)[:,None]\n",
    "S.shape,labels.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#gweight = np.ones_like(gweight)\n",
    "#tweight = np.ones_like(tweight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torchvision.datasets as dsets\n",
    "import torchvision.transforms as transforms\n",
    "from torch.autograd import Variable\n",
    "from torch.utils.data import TensorDataset, DataLoader\n",
    "\n",
    "X = torch.Tensor(S)\n",
    "y = torch.Tensor(labels)\n",
    "w = torch.Tensor((gweight*tweight*eweight)[:,None])\n",
    "\n",
    "\n",
    "criterion = nn.BCELoss(reduction='none')  \n",
    "model = nn.Linear(S.shape[1], 1)\n",
    "optimizer = torch.optim.LBFGS([model.weight])\n",
    "m = nn.Sigmoid()\n",
    "\n",
    "num_epochs =100\n",
    "for epoch in range(num_epochs):\n",
    "        \n",
    "    # Forward + Backward + Optimize\n",
    "    def closure():\n",
    "        optimizer.zero_grad()\n",
    "        outputs = m(model(X))\n",
    "        loss = criterion(outputs, y)\n",
    "        loss_class_weighted = loss * w\n",
    "        loss_class_weighted = loss_class_weighted.mean() + (model.weight**2).mean()/50\n",
    "        loss_class_weighted.backward()\n",
    "        print(loss_class_weighted)\n",
    "        return loss_class_weighted\n",
    "\n",
    "    optimizer.step(closure)\n",
    "        \n",
    "    #print(loss_class_weighted)\n",
    "outputs = m(model(X))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coef = model.weight.detach().numpy().ravel() # clf.coef_.ravel()\n",
    "\n",
    "coef.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#tourney = ['drrifted','skabuda','vig1lante','zorakwar','tiltedthanks','erebux','linchpin','ardi','vonslakken','rizzy','blindlight','xzist','lampyre','ballin4life','kk_horo','rey','thump4','flame','fortiss','minikieff','jagriff','coffinfiller','p0ng','davjs','julbars','kev','jojtherat','angrytetris','en1gma','jankygoatsmugla','ohurcool','jagriff','vexatiousluck','ryunyaan']\n",
    "#tourney = ['rey','julbars','ballin4life','jagriff','kev','ohurcool','davjs','jankygoatsmugla']\n",
    "tourney = ['whaz','malinkifox','supremegti','yup','davjs','georgi3','boots','v0dkax','strongsage','chance','cirux','deathr0w','festiveturtle','charle20','veske','korssa1r']\n",
    "#tourney = ['rmv27','st0n3','pasita','inz','toxjq','arseny','enesy','phaze','xron','evmadic','pepco','klyb','prox1mo','ins','overtime','bukster']\n",
    "tset = set(tourney)\n",
    "sort_lr = sorted([(round(z*173+1500),n) for n,z in zip(names,coef)],reverse=True)\n",
    "[_ for _ in sort_lr if _[1] in tset]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.stats\n",
    "predProbs = outputs.detach().numpy()#clf.predict_proba(S)\n",
    "weightS = gweight*tweight\n",
    "weightS = weightS/weightS.max()\n",
    "V = np.diagflat(np.product(predProbs, axis=1))\n",
    "\n",
    "sW = scipy.sparse.diags(weightS)\n",
    "\n",
    "wS =  sW @ S\n",
    "cov = wS.T @ V @ wS \n",
    "covLogit = np.linalg.inv(cov+np.identity(cov.shape[0])/5)\n",
    "\n",
    "sigma_estimates = np.sqrt(np.diag(covLogit))\n",
    "\n",
    "z_scores = coef/sigma_estimates # z-score for eaach model coefficient\n",
    "p_values = [scipy.stats.norm.sf(abs(x))*2 for x in z_scores] ### two tailed test for p-values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sort_lr = sorted([(round(z*173+1500),n,s*173) for n,z,s in zip(names,coef,sigma_estimates)],reverse=True)\n",
    "\n",
    "resT = [_ for _ in sort_lr if _[1] in tset] + [(-1,n,0) for n in tourney if n not in names]\n",
    "print(len(resT))\n",
    "for a,b,c in resT:\n",
    "    print('{:4d} ±{:3d}\\t{}'.format(a,round(c),b))\n",
    "#[_ for _ in tset if _ not in names]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "resT2 = sorted([_ for _ in sort_lr if _[1] in names],reverse=True)\n",
    "for a,b,c in resT2[:50]:\n",
    "    print('{:4d} ±{:3d}\\t{}'.format(a,round(c),b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[(df.t1 == 'jojtherat') | (df.t2 == 'jojtherat')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[_ for _ in names if 'tilt' in _]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "\n",
    "pc = Counter(list(df[(df.game == 'dbt')].t1) + list(df[(df.game == 'dbt')].t2))\n",
    "sorted([(v,k) for k,v in pc.items()],reverse=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[_ for _ in pc if 'vig' in _]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.game.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_events = dict(df.tier.value_counts())\n",
    "num_type = dict(df.type.value_counts())\n",
    "N = df.shape[0]\n",
    "num_type\n",
    "\n",
    "score_mul = {  }\n",
    "for t in num_type:\n",
    "    for e in num_events:\n",
    "        score_mul[(e,t)] = (N/num_type[t]) * (N/num_events[e])\n",
    "        if t == 'Offline':\n",
    "            score_mul[(e,t)]  *= 5\n",
    "        if e == '1':\n",
    "            score_mul[(e,t)]  *= 2\n",
    "score_mul\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.sort_values('mtime',0,kind='mergesort')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[((df.s1 < 0 ) | (df.s2  < 0))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import datetime\n",
    "# opt'd, low online\n",
    "initial_v2= np.array([4.7467349168917297e+00, 2.8868572247883139e+02,\n",
    "       6.4308658654774092e+01, 3.5468460498078309e+02,\n",
    "       1.0815731752527216e+02, 1.5370825990888963e+02,\n",
    "       1.1454452976515610e+01, 9.6774122757823349e+01,\n",
    "       2.4091686971980901e+00, 9.7201728546434940e-01,\n",
    "       7.6030441601557150e+00, 1.1510774881638908e+00,\n",
    "       2.3782641811627565e+00, 2.9961924748222518e+01,\n",
    "       1.1364910564528891e+01, 1.9505842310367453e-02,\n",
    "       5.1463218032083313e-01, 3.4836163497475772e-02,\n",
    "       9.7760304203004145e-01])\n",
    "initial_v2 = np.array([5.11376841e+00, 3.34361568e+02, 6.81220696e+01, 3.44940340e+02,\n",
    "       1.00599206e+02, 1.10393118e+02, 1.05370386e+01, 8.91482963e+01,\n",
    "       1.36000055e+00, 1.06277688e+00, 8.44375624e+00, 1.24040835e+00,\n",
    "       2.26389484e+00, 2.41575562e+01, 9.13975773e+00, 2.27318022e-02,\n",
    "       5.57500119e-01, 3.58215040e-01, 9.24151215e-01])\n",
    "sigmoid = lambda x: 1/(1+10**(-x/400)) \n",
    "\n",
    "def sigmoid(x):\n",
    "    \"Numerically-stable sigmoid function.\"\n",
    "    if x >= 0:\n",
    "        z = 10**(-x/400.0)\n",
    "        return 1 / (1 + z)\n",
    "    else:\n",
    "        z = 10**(x/400.0)\n",
    "        return z / (1 + z)\n",
    "def benchmark_func(x):\n",
    "    #x = x*initial_v2\n",
    "    ratings = defaultdict(lambda: 1500)\n",
    "    ratings_game = defaultdict(lambda: 1500)\n",
    "\n",
    "    prev_update = {}\n",
    "    x = (np.array(x).flatten())\n",
    "    \n",
    "\n",
    "    #print(blend,amount)\n",
    "\n",
    "    x = abs(x)\n",
    "    per_ratings = {\n",
    "        ('O','Online'): x[0],\n",
    "        ('O','Offline'): x[1],\n",
    "        ('1','Online'): x[2],\n",
    "        ('1','Offline'): x[3],\n",
    "    }\n",
    "    per_ratings_const = {\n",
    "        ('O','Online'): x[4],\n",
    "        ('O','Offline'): x[5],\n",
    "        ('1','Online'): x[6],\n",
    "        ('1','Offline'): x[7],\n",
    "    }\n",
    "    power = x[8]\n",
    "    power2 = x[9]\n",
    "    cMean = 100*x[10]\n",
    "    cVar =  x[11]\n",
    "    blend= np.exp(-x[12])\n",
    "    amount= np.exp(-x[13])\n",
    "    \n",
    "    fix_hack = np.exp(-x[14])\n",
    "    fix_hack2 = np.exp(-x[15])\n",
    "    blend2 = np.exp(-x[16])\n",
    "    blend3 = np.exp(-x[17])\n",
    "    target_reset = np.exp(-x[18])\n",
    "    #print(target_reset)\n",
    "    score = 0.0\n",
    "\n",
    "    correct = 0\n",
    "    total_g = 0\n",
    "\n",
    "    for row in df.itertuples():\n",
    "        game = row[5]\n",
    "        t1 = row[7] #+ '_' + row[5]\n",
    "        t2 = row[8] #+ '_' + row[5]\n",
    "        cTime = row[6].replace(tzinfo=None)\n",
    "\n",
    "        total = row[9]+row[10]\n",
    "        bot,top = sorted([row[9],row[10]])\n",
    "        diff = top - bot\n",
    "        if total < 1 or diff <1:\n",
    "            prev_update[t1] = cTime\n",
    "            prev_update[t2] = cTime\n",
    "            continue\n",
    "        diff /= total\n",
    "\n",
    "        # per game ratings\n",
    "        t1g = t1 + '_' + game\n",
    "        t2g = t2 + '_' + game\n",
    "        \n",
    "        if t1g in ratings_game:\n",
    "            r1 = ratings_game[t1g]\n",
    "            time1 = prev_update.get(t1g,cTime)\n",
    "        else:\n",
    "            r1 = ratings[t1]*blend2+1500*(1-blend2)\n",
    "            time1 = prev_update.get(t1,cTime)\n",
    "\n",
    "            \n",
    "        if t2g in ratings_game:\n",
    "            r2 = ratings_game[t2g]\n",
    "            time2 = prev_update.get(t2g,cTime)\n",
    "        else:\n",
    "            r2 = ratings[t2]*blend2+1500*(1-blend2)  \n",
    "            time2 = prev_update.get(t2,cTime)\n",
    "        \n",
    "        # time adjust\n",
    "        td1 = float((cTime - time1).days)\n",
    "        to1500_1 = float(sigmoid((td1-cMean)*cVar))*target_reset\n",
    "        r1 = (to1500_1)*1500 + (1-to1500_1)*r1\n",
    "\n",
    "        td2 = float((cTime - time2).days)\n",
    "        to1500_2 = float(sigmoid((td2-cMean)*cVar))*target_reset\n",
    "        r2 = (to1500_2)*1500 + (1-to1500_2)*r2\n",
    "\n",
    "\n",
    "\n",
    "        rdiff = abs(r1-r2)\n",
    "        p1 = sigmoid(r1-r2)\n",
    "        p2 = 1 - p1\n",
    "        K = (diff**power) * (per_ratings[row[2:4]] ) + per_ratings_const[row[2:4]]\n",
    "        K = K*blend + amount*rdiff*(1-blend)\n",
    "\n",
    "        if top < 2 and top > 1:\n",
    "            K *= fix_hack\n",
    "        if top < 3 and top > 2:\n",
    "            K *= fix_hack2\n",
    "        #print(blend)\n",
    "        #raise\n",
    "        #if r1+r2 > 3400:\n",
    "\n",
    "        #else:\n",
    "        #    correct += 0.5\n",
    "        #    total_g += 1\n",
    "        sMul = score_mul[row[2:4]] * max(0.1,(r1+r2)/3000.0)**2\n",
    "        #print(K,sMul)\n",
    "\n",
    "        correct += int((row[9] > row[10]) == ( r1 > r2)) *sMul\n",
    "        total_g += sMul\n",
    "\n",
    "        if row[9] > row[10]:\n",
    "            E = p2\n",
    "            ratings[t1] = r1 + K * E**power2\n",
    "            ratings[t2] = r2 - K * E**power2\n",
    "\n",
    "            score += -np.log(max(p1,5e-2)) * sMul\n",
    "        else:\n",
    "            E = p1\n",
    "            ratings[t1] = r1 - K * E**power2\n",
    "            ratings[t2] = r2 + K * E**power2\n",
    "\n",
    "            score += -np.log(max(p2,5e-2)) * sMul\n",
    "        prev_update[t1] = cTime\n",
    "        prev_update[t2] = cTime\n",
    "        prev_update[t1g] = cTime\n",
    "        prev_update[t2g] = cTime\n",
    "        ratings_game[t1g] = ratings[t1]\n",
    "        ratings_game[t2g] = ratings[t2]\n",
    "    return score/max(1e-3,(correct)/total_g-0.5)**0.25#,ratings\n",
    "initial_v = np.ones(19).astype(np.float32)\n",
    "initial_v =initial_v2\n",
    "\n",
    "s= benchmark_func(initial_v)\n",
    "s,s<385566.4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#import cma #\n",
    "#es = cma.CMAEvolutionStrategy(initial_v, 0.01, {'tolx':1e-6,'tolfun':1e-6,})\n",
    "#es.optimize(benchmark_func,n_jobs=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# you might wonder why two versions of the same code\n",
    "# this is a silly way for me to force myself to do code review for myself\n",
    "from collections import defaultdict\n",
    "ratings = defaultdict(lambda: 1500)\n",
    "rt = defaultdict(list)\n",
    "ratings_game = defaultdict(lambda: 1500)\n",
    "prev_update = {}\n",
    "top_games = []\n",
    "\n",
    "per_ratings = {\n",
    "    ('O','Online'): initial_v[0],\n",
    "    ('O','Offline'): initial_v[1],\n",
    "    ('1','Online'): initial_v[2],\n",
    "    ('1','Offline'): initial_v[3],\n",
    "}\n",
    "per_ratings_const = {\n",
    "    ('O','Online'): initial_v[4],\n",
    "    ('O','Offline'): initial_v[5],\n",
    "    ('1','Online'): initial_v[6],\n",
    "    ('1','Offline'): initial_v[7],\n",
    "}\n",
    "power = initial_v[8]\n",
    "power2 = initial_v[9]\n",
    "cMean = 100*initial_v[10]\n",
    "cVar =  initial_v[11]\n",
    "blend= np.exp(-initial_v[12])\n",
    "amount= np.exp(-initial_v[13])\n",
    "\n",
    "fix_hack = np.exp(-initial_v[14])\n",
    "fix_hack2 = np.exp(-initial_v[15])\n",
    "blend2 = np.exp(-initial_v[16])\n",
    "blend3 = np.exp(-initial_v[17])\n",
    "target_reset = np.exp(-initial_v[18])\n",
    "\n",
    "print(fix_hack)\n",
    "score = 0.0\n",
    "\n",
    "correct = 0\n",
    "total_g = 0\n",
    "\n",
    "for row in df.itertuples():\n",
    "    game = row[5]\n",
    "    t1 = row[7] #+ '_' + row[5]\n",
    "    t2 = row[8] #+ '_' + row[5]\n",
    "    cTime = row[6].replace(tzinfo=None)\n",
    "    time1 = prev_update.get(t1,cTime)\n",
    "    time2 = prev_update.get(t2,cTime)\n",
    "\n",
    "    total = row[9]+row[10]\n",
    "    diff = abs(row[9]-row[10])\n",
    "    if total < 1 or diff <1:\n",
    "        prev_update[t1] = cTime\n",
    "        prev_update[t2] = cTime\n",
    "        continue\n",
    "    diff /= total\n",
    "\n",
    "    \n",
    "    # per game ratings\n",
    "    t1g = t1 + '_' + game\n",
    "    t2g = t2 + '_' + game\n",
    "\n",
    "    if t1g in ratings_game:\n",
    "        r1 = ratings_game[t1g]\n",
    "        time1 = prev_update.get(t1g,cTime)\n",
    "    else:\n",
    "        r1 = ratings[t1]*blend2+1500*(1-blend2)\n",
    "        time1 = prev_update.get(t1,cTime)\n",
    "\n",
    "\n",
    "    if t2g in ratings_game:\n",
    "        r2 = ratings_game[t2g]\n",
    "        time2 = prev_update.get(t2g,cTime)\n",
    "    else:\n",
    "        r2 = ratings[t2]*blend2+1500*(1-blend2)  \n",
    "        time2 = prev_update.get(t2,cTime)\n",
    "\n",
    "    # time adjust\n",
    "    td1 = float((cTime - time1).days)\n",
    "    to1500_1 = float(sigmoid((td1-cMean)*cVar))*target_reset\n",
    "    r1 = (to1500_1)*1500 + (1-to1500_1)*r1\n",
    "\n",
    "    td2 = float((cTime - time2).days)\n",
    "    to1500_2 = float(sigmoid((td2-cMean)*cVar))*target_reset\n",
    "    r2 = (to1500_2)*1500 + (1-to1500_2)*r2\n",
    "\n",
    "    \n",
    "    top_games.append( (r1/2+r2/2,t1,t2,game,cTime) )\n",
    "    \n",
    "    if td1 > 300:\n",
    "        rt[t1].append((cTime,np.nan,row[5]))\n",
    "    if td2 > 300:\n",
    "        rt[t2].append((cTime,np.nan,row[5]))\n",
    "    \n",
    "    rdiff = abs(r1-r2)\n",
    "    p1 = sigmoid(r1-r2)\n",
    "    p2 = 1 - p1\n",
    "    K = (diff**power) * (per_ratings[row[2:4]] ) + per_ratings_const[row[2:4]]\n",
    "    K = K*blend + amount*rdiff*(1-blend)\n",
    "\n",
    "    bot,top = sorted([row[9],row[10]])\n",
    "    if top < 2 and top > 1:\n",
    "        K *= fix_hack\n",
    "    if top < 3 and top > 2:\n",
    "        K *= fix_hack2\n",
    "    #print(blend)\n",
    "    #raise\n",
    "    #if r1+r2 > 3400:\n",
    "\n",
    "    #else:\n",
    "    #    correct += 0.5\n",
    "    #    total_g += 1\n",
    "    sMul = score_mul[row[2:4]] * max(0.1,(r1+r2)/3000.0)**2\n",
    "    #print(K,sMul)\n",
    "\n",
    "    correct += int((row[9] > row[10]) == ( r1 > r2)) *sMul\n",
    "    total_g += sMul\n",
    "\n",
    "    if row[9] > row[10]:\n",
    "        E = p2\n",
    "        ratings[t1] = r1 + K * E**power2\n",
    "        ratings[t2] = r2 - K * E**power2\n",
    "\n",
    "        score += -np.log(max(p1,5e-2)) * sMul\n",
    "    else:\n",
    "        E = p1\n",
    "        ratings[t1] = r1 - K * E**power2\n",
    "        ratings[t2] = r2 + K * E**power2\n",
    "\n",
    "        score += -np.log(max(p2,5e-2)) * sMul\n",
    "    prev_update[t1] = cTime\n",
    "    prev_update[t2] = cTime\n",
    "    prev_update[t1g] = cTime\n",
    "    prev_update[t2g] = cTime\n",
    "    ratings_game[t1g] = ratings[t1]\n",
    "    ratings_game[t2g] = ratings[t2]\n",
    "\n",
    "    rt[t1].append((cTime,ratings[t1],row[5]))\n",
    "    rt[t2].append((cTime,ratings[t2],row[5]))\n",
    "score,100*correct/total_g,score*(1-correct/total_g),score/max(1e-3,(correct)/total_g-0.5)**0.25#,ratings\n",
    "\n",
    "# 57841.09221530504\n",
    "# per_ratings = {('A','Online'): 6.35,\n",
    "#               ('S','Online'): 29.43,\n",
    "#               ('A','Offline'): 8.56,\n",
    "#               ('S','Offline'): 17.6}\n",
    "\n",
    "#const = 14.86\n",
    "#weeks = 45\n",
    "#power = 2.24\n",
    "# 17185 w/ 61.8 to get 6550 (no games)\n",
    "# 16616 w/ 59.1 to get 6801 (games)\n",
    "# 15940 w/ 56.14 to get 6991 (no games)\n",
    "# 15986 w/ 53.72 to get 7397.8 (games)\n",
    "\n",
    "# 16991 w/ 64.9 to get 5966 and 11414 (games)\n",
    "# 17172 w/ 68.1 to get 5470 and 94649 (no games)357033"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted(top_games,reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dbt = []\n",
    "for k,v in ratings_game.items():\n",
    "    if k[-4:] == '_dbt':\n",
    "        dbt.append((round(v),k))\n",
    "sorted(dbt,reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted([_ for _ in dbt if _[1][:-4] in tset],reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "#cMean,cVar = 1000,1\n",
    "xn = np.linspace(0,365*5)\n",
    "yn = [sigmoid((_-cMean)*cVar)*target_reset for _ in xn]\n",
    "plt.plot(xn,yn)\n",
    "cMean,cVar,initial_v[10],initial_v[11]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted([(v,k) for k,v in ratings.items()],reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "top_teams = []\n",
    "for p,res in rt.items():\n",
    "    for game in df.game.unique():\n",
    "        if game == 'q3':\n",
    "            v = [_ for _ in res if _[2] == game  and _[0].year < 2006 and np.isfinite(_[1])]\n",
    "        else:\n",
    "            v = [_ for _ in res if _[2] == game and np.isfinite(_[1])]\n",
    "\n",
    "        if p =='fojji' and game == 'q3':\n",
    "            pass#raise\n",
    "        if len(v) > 0:\n",
    "            #v = v[len(v)//3:]\n",
    "            best_idx = np.argmax(np.array(v)[:,1])\n",
    "            top_teams.append((v[best_idx][1:],p,v[best_idx][0]))\n",
    "top_teams = sorted(top_teams,reverse=True)\n",
    "#top_teams = sorted([(v[np.argmax(np.array(v)[:,1])][1:],k) for k,v in rt.items() if len(v) > 0],reverse=True)\n",
    "top_teams"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[((df.t1 == 'julbars') & (df.t2 == 'rey')) | ((df.t1 == 'rey') & (df.t2 == 'julbars')) ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[((df.t1 == 'strenx') | (df.t2 == 'strenx')) &  (df.game == 'ql') &  (df.mtime.map(lambda x: x.year == 2011))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#df[df.venue == 'Quake Pro League/Season 1/Stage 1/Finals']\n",
    "rt['julbars']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "color_dict = defaultdict(lambda: ('#ff00ff'))\n",
    "color_dict['zero4'] = '#cc3311'\n",
    "color_dict['fatal1ty'] = '#66CCEE'\n",
    "color_dict['cooller'] = '#CCBB44'\n",
    "color_dict['cypher'] = '#AA3377'\n",
    "color_dict['rapha'] = '#4477AA'\n",
    "color_dict['toxjq'] = '#228833'\n",
    "color_dict['vo0'] = '#EE8866' \n",
    "\n",
    "color_dict['czm'] = '#6ab04c'\n",
    "color_dict['z4muz'] = '#e58e26'\n",
    "color_dict['lexer'] = '#6555e0'\n",
    "color_dict['av3k'] = '#0077bb'\n",
    "color_dict['dahang'] = '#663333'\n",
    "color_dict['fojji'] = '#EE6677'\n",
    "color_dict['ztrider'] = '#222255'\n",
    "color_dict['gellehsak'] = '#bb5566'\n",
    "color_dict['stermy'] = '#bbcc33'\n",
    "color_dict['zyz'] = '#ddaa33'\n",
    "\n",
    "\n",
    "#'#4477AA', '#EE6677', '#228833', '#CCBB44', '#66CCEE','#AA3377',"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import datetime\n",
    "from matplotlib.ticker import MaxNLocator\n",
    "import matplotlib.dates as mdates\n",
    "from collections import OrderedDict\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.style.use('fivethirtyeight')\n",
    "for game in df.game.unique():#['q3','pk','q4','ql','qc']:\n",
    "    plt.figure(figsize=(10,5),dpi=120)\n",
    "    tt = [_ for _ in top_teams if game == _[0][1]]\n",
    "    if game == 'qc':\n",
    "        tt = [_ for _ in tt if _[1] != 'evil']\n",
    "    for i in range(min(len(tt),6)):\n",
    "        tm = tt[i][1]\n",
    "        team_plot = np.array([_ for _ in rt[tm] if _[2] == game and np.isfinite(_[1])])\n",
    "        c = color_dict[tm]\n",
    "        plt.plot(team_plot[:,0],team_plot[:,1],label=tm,lw=5.5,alpha=0.72)\n",
    "\n",
    "        team_plot = team_plot[min(5,len(team_plot)-1):]\n",
    "        argmin = np.argmax(team_plot[:,1])\n",
    "        peak = team_plot[argmin]\n",
    "        \n",
    "        plt.scatter([peak[0]],[peak[1]],c=plt.gca().lines[-1].get_color(),s=200)\n",
    "    if game == 'qc' and False:\n",
    "        tm = 'clawz'\n",
    "        team_plot = np.array([_ for _ in rt[tm] if _[2] == game and np.isfinite(_[1])])\n",
    "        c = color_dict.get(tm,'#f15bb5')\n",
    "        plt.plot(team_plot[:,0],team_plot[:,1],label=tm,lw=5.5,alpha=0.72,c=c)\n",
    "\n",
    "        team_plot = team_plot[min(5,len(team_plot)-1):]\n",
    "        argmin = np.argmax(team_plot[:,1])\n",
    "        peak = team_plot[argmin]\n",
    "\n",
    "        plt.scatter([peak[0]],[peak[1]],c=plt.gca().lines[-1].get_color(),s=200)\n",
    "    plt.legend(ncol=6,loc='lower center')\n",
    "    plt.ylabel('Elo',weight='semibold')\n",
    "    locator = mdates.YearLocator()\n",
    "    # Specify the format - %b gives us Jan, Feb...\n",
    "    fmt = mdates.DateFormatter('%Y')\n",
    "\n",
    "\n",
    "    X = plt.gca().xaxis\n",
    "    X.set_major_locator(locator)\n",
    "    X.set_major_formatter(fmt)\n",
    "\n",
    "    if game in ['pk','q4']:\n",
    "        #plt.xlim(datetime.datetime(2018,9,1),datetime.datetime(2019,1,1))\n",
    "        locator = mdates.MonthLocator(interval=4)\n",
    "        # Specify the format - %b gives us Jan, Feb...\n",
    "        fmt = mdates.DateFormatter('%b%Y')\n",
    "\n",
    "\n",
    "        X = plt.gca().xaxis\n",
    "        X.set_major_locator(locator)\n",
    "        X.set_major_formatter(fmt)\n",
    "    #if game == 'ql':\n",
    "    plt.ylim(bottom=1500)\n",
    "    games_dict = {'unreal':'Unreal Tournament','pk':'Painkiller','ql':\"Quake Live\",'q2':'Quake 2','q3':'Quake 3','q4': 'Quake 4','qc':'Quake Champions'}\n",
    "    plt.title('Top 1v1 players in ' +games_dict.get(game,game),weight='medium')\n",
    "    if game == 'ql':\n",
    "        plt.xlim(datetime.datetime(2009,6,1), datetime.datetime(2016,10,1))\n",
    "    plt.tight_layout()\n",
    "    plt.savefig(game+'.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "rt['zorakwar']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[(df.t1=='cypher') & (df.mtime.map(lambda x: x.year ==2018)) & (df.mtime.map(lambda x: x.month ==8))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted([(([(0,0)] +[(_[1],_[0]) for _ in v if _[-1] == 'qc'] )[-1],k) for k,v in rt.items()],reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rt['cooller']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[_ for _ in top_teams if _[0][1] == 'q3']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[df.mtime.map(lambda x: x.year == 2017) & (df.game == 'qc') & ((df.t1 == 'cooller') | (df.t2 == 'cooller'))  ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[(((df.t1 == 'cypher') & (df.t2 == 'rapha')) | ((df.t1 == 'rapha') & (df.t2 == 'cypher'))) & (df.game == 'ql') ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted([(v,k) for k,v in ratings.items()],reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_top_at(time,team_data,timedel = datetime.timedelta(weeks=30)):\n",
    "    td = timedel\n",
    "    rt = team_data\n",
    "    time = tm\n",
    "    team_idx = {k: abs(np.array([_[0].replace(tzinfo=None) for _ in v])-tm) for k,v in rt.items() if len(v) > 0}\n",
    "    team_idx = {k:np.argmin(v) for k,v in team_idx.items() if sum(v < td) > 1}\n",
    "    top_teams_year = sorted([(round(np.nan_to_num(rt[k][i][1])),k) for k,i in team_idx.items()],reverse=True)\n",
    "    return top_teams_year"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tm = datetime.datetime(month=5,year=2021,day=1)\n",
    "top_teams_year = get_top_at(tm,rt)\n",
    "print(tm,top_teams_year[:13])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for yr in range(2020,2020):\n",
    "    tm = datetime.datetime(month=1,year=yr+1,day=1)\n",
    "    top_teams_year = get_top_at(tm,rt)\n",
    "    print(tm,top_teams_year[:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "_ = plt.hist(df.mtime,100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "max_year = defaultdict(dict)\n",
    "for k in rt:\n",
    "    yrs = set([int(_[0].year) for _ in rt[k]])\n",
    "    yrs = list(sorted(yrs))\n",
    "    tm_d = {}\n",
    "    for y in yrs:\n",
    "        max_year[y][k] = max([(_[1],_[0]) for _ in rt[k] if _[0].year == y and not math.isnan(_[1]) ])\n",
    "\n",
    "const_W = 1\n",
    "alt_year = defaultdict(dict)\n",
    "for k in rt:\n",
    "    yrs = set([int(_[0].year) for _ in rt[k]])\n",
    "    yrs = list(sorted(yrs))\n",
    "    tm_d = {}\n",
    "    for y in yrs:\n",
    "        valid_g = [_[1] for _ in rt[k] if _[0].year == y and not math.isnan(_[1]) ]\n",
    "        weights = [const_W] + [1 if valid_g[i] > valid_g[i-1] else const_W for i in range(1,len(valid_g))]\n",
    "        weights = np.array(weights)\n",
    "        weights = weights/(np.mean(weights))\n",
    "        valid_g = np.array(valid_g) * np.array(weights)\n",
    "        idx = np.argsort(valid_g)#[1:-1]\n",
    "        #if k == 'czm' and y == 2008:\n",
    "        #   raise\n",
    "        valid_g = valid_g[idx]\n",
    "        weights = weights[idx]\n",
    "        #num_games  = len([_ for _ in rt[k] if _[0].year == y])**0.15\n",
    "        if len(valid_g) > 5:\n",
    "            #alt_year[y][k] =  np.mean(valid_g)\n",
    "            alt_year[y][k] = ( np.mean([_**2 for _ in valid_g]))**(1/2)\n",
    "        #alt_year[y][k] = np.sqrt(np.mean([_[1]**2 for _ in rt[k] if _[0].year == y and not math.isnan(_[1]) ]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rt['unkind']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#df[((df.t1=='rix') | (df.t2 == 'rix')) & (df.mtime.map(lambda x: x.year < 2002))]\n",
    "#rt['makaveli']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for yr in range(1995,2022):\n",
    "    top_teams_year = sorted([(v,k) for k,v in alt_year[yr].items()  if 'sweden' not in k],reverse=True)\n",
    "    if len(top_teams_year) < 1:\n",
    "        continue\n",
    "    print('* **' +str(yr) + '**',end='\\t')#,top_teams_year[:5])\n",
    "    i=0\n",
    "    sidx = min(5,len(top_teams_year))\n",
    "    for s,n in top_teams_year[:5]:\n",
    "        i+=1\n",
    "        entk = ', ' if i!=sidx else '\\n'\n",
    "        print('{} ({})'.format(n,int(s)),end=entk)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_best_ever = []\n",
    "for yr, res in max_year.items():\n",
    "    for tm, pelo in res.items():\n",
    "        #if yr != 2000:\n",
    "        #    continue\n",
    "        max_best_ever.append( (pelo[0],pelo[1].strftime(\"%Y-%m-%d\"),str(yr) +'__' + tm))\n",
    "sorted(max_best_ever,reverse=True)[:150]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_best_ever = []\n",
    "for yr, res in max_year.items():\n",
    "    for tm, pelo in res.items():\n",
    "        max_best_ever.append( (pelo[0],pelo[1].strftime(\"%Y-%m-%d\"),str(yr) +'__' + tm))\n",
    "sorted(max_best_ever,reverse=True)[:50]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[df.venue.map(lambda x: 'intel' in x.lower()) & (df.type=='Online')].venue.unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alt_best_ever = []\n",
    "for yr, res in alt_year.items():\n",
    "    for tm, pelo in res.items():\n",
    "        alt_best_ever.append( (pelo,str(yr) +'__' + tm))\n",
    "sorted(alt_best_ever,reverse=True)[:50]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[df.venue == 'Quake Pro League/Season 1/Stage 2/Finals']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "top_teams"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_top_year_elo(tm,yr,rt):\n",
    "    return max([(_[1],_[0]) for _ in rt[tm] if _[0].year == yr])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib.ticker import MaxNLocator\n",
    "import matplotlib.dates as mdates\n",
    "from collections import OrderedDict\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "color_dict['av3k'] ='#f15bb5'\n",
    "color_dict['socrates'] = '#293241'\n",
    "color_dict['mojo'] ='#f15bb5'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[(df.t1 == 'koda') | (df.t2 == 'koda')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.figure(figsize=(12,4))\n",
    "names = ['rey','warden','zorakwar','davjs','ballin4life','ohurcool','julbars']\n",
    "cmap = plt.get_cmap(\"tab10\")\n",
    "cmaps = [cmap((i)/float(len(names))) for i in range(len(names))]\n",
    "years = [range(2015,2022) for i in range(len(names))]\n",
    "for n,y,c in zip(names,years,cmaps):\n",
    "    print(list(y))\n",
    "    vs = np.array([_ for _ in rt[n] if _[0].year in list(y)])\n",
    "    #c = color_dict[n]\n",
    "    plt.plot(vs[:,0],vs[:,1],alpha=0.95,label=n,c=c,lw=5)\n",
    "    for yr in y:\n",
    "        top_teams_year = sorted([(v,k) for k,v in alt_year[yr].items()],reverse=True)\n",
    "        for ratingT, tm in top_teams_year[:0]:\n",
    "            if tm in names:\n",
    "                idx = names.index(tm)\n",
    "                if yr in years[idx]:\n",
    "                    continue\n",
    "            ratings = np.array([_ for _ in rt[tm] if _[0].year == yr])\n",
    "            plt.plot(ratings[:,0],ratings[:,1],c='k',alpha=0.08,lw=1.5)\n",
    "plt.legend(loc=4,ncol=7)\n",
    "plt.ylim(bottom=1200)\n",
    "plt.xlim(left=datetime.datetime(2020,1,1))\n",
    "plt.ylabel('Elo')\n",
    "plt.title('across all games (including doombringer lol)')\n",
    "#plt.title('')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(12,4))\n",
    "names = ['fatal1ty','zero4','cooller','vo0','toxjq','cypher','rapha']\n",
    "cmap = plt.get_cmap(\"tab10\")\n",
    "cmaps = [cmap((i)/float(len(names))) for i in range(len(names))]\n",
    "years = [range(1999,2008),range(2000,2005),range(2003,2021),range(2004,2006),range(2006,2010),range(2008,2021),range(2009,2021),range(2000,2020)]\n",
    "for n,y,c in zip(names,years,cmaps):\n",
    "    print(list(y))\n",
    "    vs = np.array([_ for _ in rt[n] if _[0].year in list(y)])\n",
    "    c = color_dict[n]\n",
    "    plt.plot(vs[:,0],vs[:,1],alpha=0.95,label=n,c=c,lw=5)\n",
    "    for yr in y:\n",
    "        top_teams_year = sorted([(v,k) for k,v in alt_year[yr].items()],reverse=True)\n",
    "        for ratingT, tm in top_teams_year[:10]:\n",
    "            if tm in names:\n",
    "                idx = names.index(tm)\n",
    "                if yr in years[idx]:\n",
    "                    continue\n",
    "            ratings = np.array([_ for _ in rt[tm] if _[0].year == yr])\n",
    "            plt.plot(ratings[:,0],ratings[:,1],c='k',alpha=0.08,lw=1.5)\n",
    "plt.legend(loc=4,ncol=7)\n",
    "plt.ylim(bottom=1200)\n",
    "plt.xlim(left=datetime.datetime(1999,6,1))\n",
    "plt.ylabel('Elo')\n",
    "plt.title('Top 1v1 ArenaFPS Players\\n(other top players in light gray)')\n",
    "plt.savefig('1v1.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[(df.t1 == 'ins') | (df.t2 == 'ins')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dft = df[df.tier == '1']\n",
    "for n in (dft.t2.value_counts() + dft.t1.value_counts()).dropna().sort_values(0,False).items():\n",
    "    print(df[((df.t1 == 'cooller') & (df.t2 == n[0])) | ((df.t1 == n[0]) & (df.t2 == 'cooller'))  ].shape[0],n[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[((df.t1 == 'cooller') & (df.t2 == 'cypher')) | ((df.t1 == 'cypher') & (df.t2 == 'cooller'))  ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}