cselo.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",
    "import datetime\n",
    "\n",
    "import dateutil\n",
    "from dateutil.relativedelta import relativedelta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tdf = pd.read_html('team_templates.html')\n",
    "alias_map = {}\n",
    "clean = lambda x: ''.join(x.split()).lower()\n",
    "for row in tdf[0].itertuples():\n",
    "    tn = clean(row[2])\n",
    "    alias_map[tn] = tn\n",
    "    for i in range(1,5):\n",
    "        alias_map[clean(row[i])] = tn\n",
    "alias_map['pgs.mym'] = 'meetyourmakers'\n",
    "\n",
    "alias_map['nv'] = 'teamenvy'\n",
    "alias_map['g2e'] = 'gamers2'\n",
    "alias_map['g2esports'] = 'gamers2'\n",
    "alias_map['natusvincere'] = 'navi'\n",
    "alias_map['verygames'] = 'vg'\n",
    "alias_map['reasongaming'] = 'reason'\n",
    "alias_map['gambitesports'] = 'gambit'\n",
    "alias_map['fazeclan'] = 'faze'\n",
    "alias_map['opticgaming'] = 'optic'\n",
    "alias_map['teamenvyus'] = 'teamenvy'\n",
    "alias_map['ategaming'] = 'ate'\n",
    "alias_map['cm'] = 'clan-mystik'\n",
    "alias_map['teamalternate'] = 'alternateattax'\n",
    "alias_map['teamagent'] = 'agent'\n",
    "alias_map['k1ckesports'] = 'k1ckesportsclub'\n",
    "alias_map['ad'] = 'astanadragons'\n",
    "alias_map['teamdignitas'] = 'dignitas'\n",
    "alias_map['teamldlc.com'] = 'teamldlc'\n",
    "alias_map['platinium-esport'] = 'platiniumesport'\n",
    "alias_map['teamliquid'] = 'tl'\n",
    "alias_map['swolepatrol'] = 'swole'\n",
    "alias_map['titanesports'] = 'titan'\n",
    "alias_map['luminositygaming'] = 'lg'\n",
    "alias_map['nihilumgaming'] = 'nihilum'\n",
    "alias_map['keydstars'] = 'keyd'\n",
    "alias_map['teamkinguin'] = 'kinguin'\n",
    "alias_map['teamebettle'] = 'ebettle'\n",
    "alias_map['renegades'] = 'rng'\n",
    "alias_map['immortals'] = 'imt'\n",
    "alias_map['teamvitality'] = 'vitality'\n",
    "alias_map['windigogaming'] = 'windigo'\n",
    "alias_map['planetkeydynamics'] = 'pdynamics'\n",
    "alias_map['fm-esports'] = 'fm'\n",
    "alias_map['vegasquadron'] = 'vega'\n",
    "alias_map['100thieves'] = '100t'\n",
    "alias_map['teamldlc.comwhite']= 'ldlcw'\n",
    "alias_map['teamsolemn']= 'solemn'\n",
    "alias_map['c0ntactgaming']= 'c0ntact'\n",
    "alias_map['gen.gesports']= 'gen.g'\n",
    "alias_map['funplusphoenix'] = 'fpx'\n",
    "alias_map['chaosec']= 'chaos' \n",
    "alias_map['ex-luminosity'] = 'luminosity'\n",
    "alias_map['cybernetsonline'] = 'cno'\n",
    "alias_map['spiritofamiga'] = 'soa'\n",
    "alias_map['b.o.o.t-dream[s]cape'] = 'bootds'\n",
    "alias_map['pandagaming'] = 'panda.cn'\n",
    "alias_map['nãotemcomo'] = 'ntc'\n",
    "alias_map['agoesports']= 'ago'\n",
    "alias_map['selflessgaming']= 'selfless'\n",
    "alias_map['swaygaming']= 'sway' \n",
    "alias_map['counter-strikearmageddoneurope'] = 'c-sarmaggedon'\n",
    "alias_map['communityforfreestylers'] = 'c.freestylers'\n",
    "alias_map['unitedcounterstrikesquad'] = 'unitedcssquad'\n",
    "alias_map['clananimus']= 'animus'\n",
    "alias_map['teamxeno']= 'xeno'\n",
    "alias_map['rs-orange'] = 'rs.orange'\n",
    "alias_map['w.e.w.'] = 'wew'\n",
    "alias_map['elitemilitardebrasília'] = 'emb'\n",
    "alias_map['neverendingviolence']= 'nev' \n",
    "alias_map['teamboomtown']= 'boomtown' \n",
    "alias_map['team64.amd']= 'team64' \n",
    "alias_map['revolutionsportsgaming']= 'tsg' \n",
    "alias_map['team64.amd']= 'team64' \n",
    "alias_map['teamst']= 'st' \n",
    "alias_map['afterlife.se']= 'afterlife' \n",
    "alias_map['e-fraggaming']= 'e-frag' \n",
    "alias_map['lionsesportsklubb']= 'lions' \n",
    "alias_map['wickedesports']= 'wicked' \n",
    "alias_map['wickedesports']= 'wicked' \n",
    "alias_map['oslf.dk']= 'oslf' \n",
    "alias_map['wickedesports']= 'wicked' \n",
    "alias_map['teamusa']= 'usa' \n",
    "alias_map['lionsesportsklubb']= 'lions' \n",
    "alias_map['ckrasgaming']= 'ckras' \n",
    "alias_map['teamneverstop']= 'neverstop' \n",
    "alias_map['dkhmultigaming']= 'dkh'\n",
    "alias_map['andthensome']= 'andthensome' \n",
    "alias_map['dobry&gaming']= 'loungegaming' \n",
    "alias_map['ebettle']= 'ebettle'\n",
    "alias_map['liquid'] = 'tl'\n",
    "alias_map['emulate']= 'emulate!' \n",
    "alias_map['emulate!']= 'emulate!' \n",
    "alias_map['gameplay']= 'gameplay.tv' \n",
    "alias_map['gameplay.tv']= 'gameplay.tv' \n",
    "alias_map['global.gaming']= 'woosai' \n",
    "alias_map['loungegaming']= 'loungegaming' \n",
    "alias_map['mirror']= 'andthensome' \n",
    "alias_map['singaporesword']= 'singaporesword' \n",
    "alias_map['vexedgaming']= 'ebettle' \n",
    "alias_map['vitriolicgaming']= 'pgs.mym' \n",
    "alias_map['woosai']= 'woosai' \n",
    "alias_map['wuhandragon']= 'singaporesword' \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('cs_matchesB2.pkl','rb') as fp: #cs_matches\n",
    "    results = pickle.load(fp)\n",
    "results['DreamHack/2010/Summer']"
   ]
  },
  {
   "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][-2]]\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",
    "        if new_elem[6] == 'teamliquid':\n",
    "            raise\n",
    "\n",
    "        data.append(new_elem)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_elem,t1"
   ]
  },
  {
   "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",
    "df = df[df['t1'] != 'bye']\n",
    "df = df[df['t2'] != 'bye']\n",
    "#df = df[df.tier.isin(['A','S','B','C'])]\n",
    "df['type'] = df['type'].map(lambda x: 'Online' if 'Offline' != x else 'Offline')\n",
    "#df['tier'] = df['tier'].map(lambda x: x if x in set(['A','S','Q']) else 'U')\n",
    "df['tier'] = df['tier'].map(lambda x: x if x in set(['A','S','B','C']) else 'Q')\n",
    "\n",
    "df.loc[df.s2 < 0,'s2'] = 0\n",
    "\n",
    "# golden five hacks\n",
    "df.loc[(df.t1 == 'again'),'t1'] = 'goldenfive'\n",
    "df.loc[(df.t2 == 'again'),'t2'] = 'goldenfive'\n",
    "\n",
    "df.loc[(df.t1 == 'fragexecutors') & (df['mtime'].dt.tz_convert(None) > datetime.datetime(year=2010,month=2,day=16)),'t1'] = 'goldenfive'\n",
    "df.loc[(df.t2 == 'fragexecutors') & (df['mtime'].dt.tz_convert(None) > datetime.datetime(year=2010,month=2,day=16)),'t2'] = 'goldenfive'\n",
    "\n",
    "\n",
    "df.loc[(df.t1 == 'escgaming') & (df['mtime'].dt.tz_convert(None) > datetime.datetime(year=2011,month=12,day=7)) & (df['mtime'].dt.tz_convert(None) < datetime.datetime(year=2013,month=10,day=18)),'t1'] = 'goldenfive'\n",
    "df.loc[(df.t2 == 'escgaming') & (df['mtime'].dt.tz_convert(None) > datetime.datetime(year=2011,month=12,day=7)) & (df['mtime'].dt.tz_convert(None) < datetime.datetime(year=2013,month=10,day=18)),'t2'] = 'goldenfive'\n",
    "\n",
    "\n",
    "df.loc[df.mtime.map(lambda x: x.year == 2020 and x.month > 6),'mtime'] = df.loc[df.mtime.map(lambda x: x.year == 2020 and x.month > 6),'vtime']\n",
    "df.loc[(df.t1 == 'meetyourmakers') & (df['mtime'].dt.tz_convert(None) > datetime.datetime(year=2007,month=12,day=17)) & (df['mtime'].dt.tz_convert(None) < datetime.datetime(year=2009,month=3,day=17)),'t1'] = 'goldenfive'\n",
    "df.loc[(df.t2 == 'meetyourmakers') & (df['mtime'].dt.tz_convert(None) > datetime.datetime(year=2007,month=12,day=17)) & (df['mtime'].dt.tz_convert(None) < datetime.datetime(year=2009,month=3,day=17)),'t2'] = 'goldenfive'\n",
    "df = df.sort_values('mtime',0,kind='mergesort')"
   ]
  },
  {
   "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]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "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)]  *= 3\n",
    "        \n",
    "        if e == 'S':\n",
    "            score_mul[(e,t)]  *= 3\n",
    "        elif e == 'A':\n",
    "            pass\n",
    "        elif e == 'B' or e=='C':\n",
    "            score_mul[(e,t)]  *= 0.5\n",
    "        else:\n",
    "            score_mul[(e,t)]  *= 0.1\n",
    "score_mul\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#xn = np.linspace(0,500)\n",
    "#plt.plot(xn,sigmoid((xn-cMean)*cVar))\n",
    "#print(blend,amount)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import datetime\n",
    "\n",
    "def sigmoid2(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 sigmoid(x):\n",
    "    #if type(x) != np.array:\n",
    "    #    return sigmoid2(x)\n",
    "\n",
    "    z1 = 10**(-x/400.0)\n",
    "    z2 = 10**(x/400.0)\n",
    "\n",
    "    return np.select([x>=0,x<0],[1/(1+z1),z2/(1+z2)])\n",
    "scale_magic = np.sqrt(initial_v)\n",
    "def benchmark_func(x):\n",
    "\n",
    "    ratings = {}\n",
    "    prev_update = {}\n",
    "    x = (np.array(x).flatten()) * scale_magic\n",
    "\n",
    "    x = abs(x)\n",
    "    per_ratings = {('Q','Online'):x[0],\n",
    "                   ('C','Online'):x[1],\n",
    "                   ('B','Online'):x[2],\n",
    "                   ('A','Online'):x[3],\n",
    "                   ('S','Online'):x[4],\n",
    "                   ('Q','Offline'):x[5],\n",
    "                   ('C','Offline'):x[6],\n",
    "                   ('B','Offline'):x[7],\n",
    "                   ('A','Offline'):x[8],\n",
    "                   ('S','Offline'):x[9]}\n",
    "    per_ratings_const = {('Q','Online'):x[10],\n",
    "                   ('C','Online'):x[11],\n",
    "                   ('B','Online'):x[12],\n",
    "                   ('A','Online'):x[13],\n",
    "                   ('S','Online'):x[14],\n",
    "                   ('Q','Offline'):x[15],\n",
    "                   ('C','Offline'):x[16],\n",
    "                   ('B','Offline'):x[17],\n",
    "                   ('A','Offline'):x[18],\n",
    "                   ('S','Offline'):x[19]}\n",
    "    power = x[20]\n",
    "    power2 = x[21]\n",
    "    cMean = 100*x[22]\n",
    "    cVar =  x[23]\n",
    "    blend= np.exp(-x[24])\n",
    "    amount= np.exp(-x[25])\n",
    "    score = 0.0\n",
    "    correct = 0\n",
    "    total_g = 0\n",
    "    for row in df.itertuples():\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",
    "        r1 = ratings.get(t1,1500)\n",
    "        r2 = ratings.get(t2,1500)\n",
    "        \n",
    "        td1 = float((cTime - time1).days)\n",
    "        to1500_1 = float(sigmoid((td1-cMean)*cVar))\n",
    "        r1 = (to1500_1)*1500 + (1-to1500_1)*r1\n",
    "        \n",
    "        td2 = float((cTime - time2).days)\n",
    "        to1500_2 = float(sigmoid((td2-cMean)*cVar))\n",
    "        r2 = (to1500_2)*1500 + (1-to1500_2)*r2\n",
    "        \n",
    "        rdiff = abs(r1-r2)\n",
    "        p1 = float(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",
    "    \n",
    "        sMul = score_mul[row[2:4]] * max(0.1,(r1+r2)/3000.0)\n",
    "        \n",
    "        if row[2] in ['A','S']:\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,1e-3)) * 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,1e-3)) * sMul\n",
    "        prev_update[t1] = cTime\n",
    "        prev_update[t2] = cTime\n",
    "    return score#/(max(1e-3,(correct)/total_g-0.5))**0.1#,ratings\n",
    "initial_v2 = np.array([  0.36898797,   9.18643443, 119.75259179,  57.97762704,\n",
    "       145.12612498, 215.13104508,   1.99478431, 192.44794057,\n",
    "        13.86448357,   7.17607518, 141.78574903,  19.26903679,\n",
    "         8.70247483,   1.73506721,  34.6487012 ,   1.20132298,\n",
    "         1.44099928,  40.05764688])\n",
    "initial_v = np.ones(26).astype(np.float32)*2\n",
    "\n",
    "initial_v = np.array([   0.36898797, 0.36898797,0.36898797,\n",
    "                      9.18643443, 119.75259179,  57.97762704,57.97762704,57.97762704,\n",
    "       145.12612498, 215.13104508,   1.99478431,1.99478431,1.99478431, 192.44794057,\n",
    "        13.86448357,   7.17607518, 7.17607518, 7.17607518, 141.78574903,  19.26903679,\n",
    "         8.70247483,   1.73506721,  34.6487012 ,   1.20132298,\n",
    "         1.44099928,  40.05764688])\n",
    "\n",
    "initial_v = np.array([ 18.25072838,  74.59076659,  95.96793023, 114.93916893,  11.30159452,\n",
    "  64.72672347,   1.90024806,  63.24657822,  43.70996726,  79.62341069,\n",
    "  10.29926388,  14.5887735,   71.14937516,  63.98827863,  80.96915655,\n",
    "  83.31334684,  33.7840958,   92.0514089,  135.24950821,  25.94777709,\n",
    "   5.01919907,   2.07565228,  34.60000695 , 19.7854935,    0.8508004,\n",
    "  14.9930185, ])\n",
    "\n",
    "# two dais\n",
    "initial_v = [  0.000001 ,    0.00002568 ,  0.00001593, 132.66496462, 386.4914683,\n",
    "  74.74613172,  95.83931716,   0.00005563, 134.98681673, 306.2403323,\n",
    "   0.00000039,   0.00001299,  14.9428415,  274.32772789,  86.78671798,\n",
    "   0.00047612,   0.00009709,   0.00015441, 136.9136137,    0.00009243,\n",
    "  13.46715752,   1.69961637,  17.54813621, 162.45646977,   1.82940522,\n",
    " 102.31210837]\n",
    "\n",
    "\n",
    "scale_magic = np.sqrt(initial_v)\n",
    "#initial_v = np.ones(18).astype(np.float32)*2 #2979704\n",
    "s= benchmark_func(initial_v/scale_magic)\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#2194176.4888980826\n",
    "#2213824\n",
    "# full acc: 6.0875\n",
    "# 1/4 acc: 3906712"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cma\n",
    "from cma import optimization_tools\n",
    "es = cma.CMAEvolutionStrategy(initial_v/scale_magic, 1, {'tolx':1e-2,'tolfun':1e-2})\n",
    "#es.optimize(benchmark_func,n_jobs=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "es.result_pretty()  #"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.set_printoptions(suppress=True)\n",
    "\n",
    "abs(es.best.x)*scale_magic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(benchmark_func(np.array([ 5, 25 , 2,  10, 31, 45, 1])))\n",
    "#print(benchmark_func(np.array([ 2, 22 , 0.2,  9, 26, 42, 0.5])))\n",
    "print(benchmark_func(initial_v/scale_magic))\n",
    "print(benchmark_func(es.best.x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "per_ratings = {('Q','Online'):initial_v[0],\n",
    "               ('C','Online'):initial_v[1],\n",
    "               ('B','Online'):initial_v[2],\n",
    "               ('A','Online'):initial_v[3],\n",
    "               ('S','Online'):initial_v[4],\n",
    "               ('Q','Offline'):initial_v[5],\n",
    "               ('C','Offline'):initial_v[6],\n",
    "               ('B','Offline'):initial_v[7],\n",
    "               ('A','Offline'):initial_v[8],\n",
    "               ('S','Offline'):initial_v[9]}\n",
    "per_ratings_const = {('Q','Online'):initial_v[10],\n",
    "               ('C','Online'):initial_v[11],\n",
    "               ('B','Online'):initial_v[12],\n",
    "               ('A','Online'):initial_v[13],\n",
    "               ('S','Online'):initial_v[14],\n",
    "               ('Q','Offline'):initial_v[15],\n",
    "               ('C','Offline'):initial_v[16],\n",
    "               ('B','Offline'):initial_v[17],\n",
    "               ('A','Offline'):initial_v[18],\n",
    "               ('S','Offline'):initial_v[19]}\n",
    "power = initial_v[20]\n",
    "power2 = initial_v[21]\n",
    "cMean = 100*initial_v[22]\n",
    "cVar =  initial_v[23]\n",
    "blend= np.exp(-initial_v[24])\n",
    "amount= np.exp(-initial_v[25])\n",
    "score = 0.0\n",
    "tmpd = []\n",
    "tmpd2 = []\n",
    "correct = 0\n",
    "total_g = 0\n",
    "\n",
    "rt = defaultdict(list)\n",
    "\n",
    "\n",
    "ratings = {}\n",
    "prev_update = {}\n",
    "\n",
    "score = 0.0\n",
    "\n",
    "for row in df.itertuples():\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",
    "    r1 = ratings.get(t1,1500)\n",
    "    r2 = ratings.get(t2,1500)\n",
    "\n",
    "    td1 = float((cTime - time1).days)\n",
    "    to1500_1 = float(sigmoid2((td1-cMean)*cVar))\n",
    "    r1 = (to1500_1)*1500 + (1-to1500_1)*r1\n",
    "\n",
    "    td2 = float((cTime - time2).days)\n",
    "    to1500_2 = float(sigmoid2((td2-cMean)*cVar))\n",
    "    r2 = (to1500_2)*1500 + (1-to1500_2)*r2\n",
    "\n",
    "    rdiff = abs(r1-r2)\n",
    "    p1 = float(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",
    "\n",
    "    sMul = score_mul[row[2:4]] * max(0.1,(r1+r2)/3000.0)\n",
    "\n",
    "    if row[2] in ['A','S']:\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,1e-3)) * 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,1e-3)) * sMul\n",
    "    prev_update[t1] = cTime\n",
    "    prev_update[t2] = cTime\n",
    "\n",
    "    rt[t1].append((row[6],ratings[t1]))\n",
    "    rt[t2].append((row[6],ratings[t2]))\n",
    "score,100*correct/total_g,score/max(1e-3,(correct)/total_g-0.5)**0.25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rt['godsent_csgo'] #65.6185791669261 #2507147"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "max(np.array(rt['skgaming_csgo'])[:,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "top_teams = sorted([(max(np.array(v)[:,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": [
    "import matplotlib.pyplot as plt\n",
    "import datetime\n",
    "plt.style.use('fivethirtyeight')\n",
    "plt.figure(dpi=120)\n",
    "for i in range(5):\n",
    "    tm = top_teams[i][1]\n",
    "    team_plot = np.array(rt[tm])\n",
    "    \n",
    "    argmin = np.argmax(team_plot[:,1])\n",
    "    peak = team_plot[argmin]\n",
    "    print(tm,peak[0])\n",
    "    plt.plot(team_plot[:,0],team_plot[:,1],label=tm,lw=2,alpha=0.5)\n",
    "    \n",
    "    plt.scatter([peak[0]],[peak[1]],c=plt.gca().lines[-1].get_color(),s=100)\n",
    "plt.legend()\n",
    "plt.xlim(datetime.datetime(year=2004,month=1,day=1),datetime.datetime(year=2020,month=6,day=1))\n",
    "plt.xlabel('year')\n",
    "plt.ylabel('Elo')\n",
    "plt.title('Top 5 CS teams of all time')"
   ]
  },
  {
   "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": [
    "import matplotlib.pyplot as plt\n",
    "import datetime\n",
    "plt.style.use('fivethirtyeight')\n",
    "plt.figure(dpi=120,figsize=(8,6))\n",
    "for tm in ['navi_cs16','skgaming_cs16','ninjasinpyjamas_cs16','fnatic_cs16','astralis_csgo','goldenfive_cs16']:\n",
    "    team_plot = np.array(rt[tm])\n",
    "    \n",
    "    argmin = np.argmax(team_plot[:,1])\n",
    "    peak = team_plot[argmin]\n",
    "    print(tm,peak[0])\n",
    "    plt.plot(team_plot[:,0],team_plot[:,1],label=tm,lw=2,alpha=0.5)\n",
    "    \n",
    "    plt.scatter([peak[0]],[peak[1]],c=plt.gca().lines[-1].get_color(),s=100)\n",
    "plt.legend(loc=3)\n",
    "plt.xlim(datetime.datetime(year=1995,month=1,day=1),datetime.datetime(year=2020,month=6,day=1))\n",
    "plt.xlabel('year')\n",
    "plt.ylabel('Elo')\n",
    "plt.title('A few more top teams')\n",
    "plt.tight_layout()"
   ]
  },
  {
   "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=6,year=2020,day=12)\n",
    "top_teams_year = get_top_at(tm,rt,datetime.timedelta(weeks=3))\n",
    "print(tm,top_teams_year[:16])"
   ]
  },
  {
   "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": []
  },
  {
   "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",
    "\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",
    "        vals = [_[1]**2 for _ in rt[k] if _[0].year == y and not math.isnan(_[1]) ]\n",
    "        vals = sorted(vals)#[3:]\n",
    "        if len(vals) > 3:\n",
    "            alt_year[y][k] = np.sqrt(np.mean(vals))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for yr in range(2000,2021):\n",
    "    top_teams_year = sorted([(v,k) for k,v in alt_year[yr].items() if 'sweden' not in k and 'ladies' not in k],reverse=True)\n",
    "    print('* **' +str(yr) + '**',end='\\t')#,top_teams_year[:5])\n",
    "    i=0\n",
    "    for s,n in top_teams_year[:6]:\n",
    "        i+=1\n",
    "        entk = ', ' if i!=6 else '\\n'\n",
    "        print('{} ({})'.format(n.split('_')[0],int(s)),end=entk)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " \n",
    "max_best_ever = []\n",
    "for yr, res in max_year.items():\n",
    "    for tm, pelo in res.items():\n",
    "        max_best_ever.append( (int(round(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": [
    "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": [
    "alias_map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from colorthief import ColorThief\n",
    "\n",
    "color_dict = {}\n",
    "for fn in os.listdir('.'):\n",
    "    nm, ext = os.path.splitext(fn)\n",
    "    if ext == '.png':\n",
    "        color_dict[nm] = [np.array(_)/255.0 for _ in ColorThief(fn).get_palette(2)]\n",
    "for k,v in color_dict.items():\n",
    "    idx = 0\n",
    "    if k == 'mousesports':\n",
    "        idx = 1\n",
    "    elif k == 'goldenfive' or k=='fragexecutors':\n",
    "        idx = 2\n",
    "    elif k == 'teamenvy':\n",
    "        idx = 2\n",
    "    elif k == 'vg':\n",
    "        idx = 2\n",
    "    elif k == 'faze':\n",
    "        idx = 1\n",
    "    elif k == 'virtus.pro':\n",
    "        idx = 1\n",
    "    color_dict[k] = v[idx]\n",
    "    if k == 'navi':\n",
    "        color_dict[k] *= 0.8\n",
    "    elif k == 'mtw':\n",
    "        color_dict[k] *= 0.8\n",
    "    elif k == 'fragexecutors':\n",
    "        color_dict[k] *= 0.6\n",
    "\n",
    "#color_dict['teamsolomid'] = color_dict['astralis']"
   ]
  },
  {
   "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": [
    "tp_tm_merged = {}\n",
    "for r,tm in top_teams:\n",
    "    gm = tm.split('_')[-1]\n",
    "    tm = '_'.join(tm.split('_')[:-1])\n",
    "    if tm == 'mtw':\n",
    "         r += 7\n",
    "    tp_tm_merged[tm] = max((r,gm),tp_tm_merged.get(tm,(0,gm)))\n",
    "\n",
    "top_tm = sorted([(v[0],k,v[1]) for k,v in tp_tm_merged.items()],reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "top_tm[0][2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import datetime\n",
    "plt.style.use('fivethirtyeight')\n",
    "plt.figure(dpi=120,figsize=(12,8))\n",
    "plt.subplot(2,1,1)\n",
    "\n",
    "for i in range(6):\n",
    "    tog = top_tm[i][1] + '_' + top_tm[i][2]\n",
    "    team_plot = np.array(rt[tog])\n",
    "\n",
    "    tm =  top_tm[i][1]\n",
    "    \n",
    "    argmin = np.argmax(team_plot[:,1])\n",
    "    peak = team_plot[argmin]\n",
    "    color = color_dict[tm]\n",
    "    print(tm,peak[0])\n",
    "    plt.plot(team_plot[:,0],team_plot[:,1],label=tm,lw=4,alpha=0.7,c=color)\n",
    "    \n",
    "    team_plot = np.array(rt[tm + \"_csgo\"])\n",
    "    plt.plot(team_plot[:,0],team_plot[:,1],lw=4,alpha=0.7,c=color)\n",
    "\n",
    "    \n",
    "    plt.scatter([peak[0]],[peak[1]],c=plt.gca().lines[-1].get_color(),s=150)\n",
    "    if tm == 'skgaming':\n",
    "        y,x = get_top_year_elo(tog,2004,rt)\n",
    "        plt.scatter([x],[y],c=plt.gca().lines[-1].get_color(),s=150)\n",
    "    if tm == 'fnatic':\n",
    "        y,x = get_top_year_elo(tm + \"_cs16\",2010,rt)\n",
    "        plt.scatter([x],[y],c=plt.gca().lines[-1].get_color(),s=150)\n",
    "        y,x = get_top_year_elo(tm + '_csgo',2015,rt)\n",
    "        plt.scatter([x],[y],c=plt.gca().lines[-1].get_color(),s=150)\n",
    "plt.legend(loc=\"lower left\", ncol=6)\n",
    "#it's safer to use linestyle='none' and marker='none' that setting the color to white\n",
    "#should be invisible whatever is the background\n",
    "plt.xlim(datetime.datetime(year=2003,month=6,day=1),datetime.datetime(year=2020,month=6,day=1))\n",
    "plt.xlim(datetime.datetime(year=2003,month=6,day=1),datetime.datetime(year=2020,month=6,day=1))\n",
    "plt.ylim(top=1950,bottom= 1600)\n",
    "\n",
    "plt.xlabel('year')\n",
    "plt.ylabel('Elo')\n",
    "plt.title('Top CS teams of all time (by peak Elo) #1')\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import datetime\n",
    "plt.style.use('fivethirtyeight')\n",
    "plt.subplot(2,1,2)\n",
    "tmp_teams = []\n",
    "for i in range(6,12):\n",
    "    tog = top_tm[i][1] + '_' + top_tm[i][2]\n",
    "    team_plot = np.array(rt[tog])\n",
    "\n",
    "    tm =  top_tm[i][1]\n",
    "    \n",
    "    color = color_dict[tm]\n",
    "\n",
    "    argmin = np.argmax(team_plot[:,1])\n",
    "    peak = team_plot[argmin]\n",
    "    print(tm,peak[0])\n",
    "    tm = 'tsm' if 'teamsolomid' in tm else tm\n",
    "    plt.plot(team_plot[:,0],team_plot[:,1],label=tm if tm not in tmp_teams else '',lw=4,alpha=0.7,c=color)\n",
    "    tmp_teams.append(tm)\n",
    "    plt.scatter([peak[0]],[peak[1]],c=plt.gca().lines[-1].get_color(),s=150)\n",
    "    \n",
    "    if 'csgo' in top_tm[i][2]:\n",
    "        team_plot = np.array(rt[tm + \"_cs16\"])\n",
    "        if team_plot.shape[0] > 0:\n",
    "            plt.plot(team_plot[:,0],team_plot[:,1],lw=4,alpha=0.7,c=color)\n",
    "    \n",
    "    if 'cs16' in top_tm[i][2]:\n",
    "        team_plot = np.array(rt[tm + \"_csgo\"])\n",
    "        if team_plot.shape[0] > 0:\n",
    "            plt.plot(team_plot[:,0],team_plot[:,1],lw=4,alpha=0.7,c=color)\n",
    "    if tm == 'ninjasinpyjamas':\n",
    "        y,x = get_top_year_elo(tm + \"_csgo\",2013,rt)\n",
    "        plt.scatter([x],[y],c=plt.gca().lines[-1].get_color(),s=150)\n",
    "        y,x = get_top_year_elo(tm + \"_csgo\",2014,rt)\n",
    "        plt.scatter([x],[y],c=plt.gca().lines[-1].get_color(),s=150)\n",
    "\n",
    "    if tm == 'mousesports':\n",
    "        y,x = get_top_year_elo(tm+\"_cs16\",2008,rt)\n",
    "        plt.scatter([x],[y],c=plt.gca().lines[-1].get_color(),s=150)\n",
    "    if tm == 'navi':\n",
    "        y,x = get_top_year_elo(tm + \"_csgo\",2020,rt)\n",
    "        plt.scatter([x],[y],c=plt.gca().lines[-1].get_color(),s=150)\n",
    "        y,x = get_top_year_elo(tm + \"_csgo\",2016,rt)\n",
    "        plt.scatter([x],[y],c=plt.gca().lines[-1].get_color(),s=150)\n",
    "plt.legend(loc=\"upper left\", ncol=6)\n",
    "plt.xlim(datetime.datetime(year=2003,month=6,day=1),datetime.datetime(year=2020,month=6,day=8))\n",
    "plt.ylim(top=1950,bottom= 1600)\n",
    "plt.xlabel('year')\n",
    "plt.ylabel('Elo')\n",
    "plt.title('Top CS teams of all time (by peak Elo) #2')\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nm"
   ]
  },
  {
   "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\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TP = 'astralis'\n",
    "plt.figure(figsize=(8,4))\n",
    "valid_years = set([2017,2018,2019,2020])\n",
    "\n",
    "tm2 = TP + '_csgo'\n",
    "ratings = np.array([_ for _ in rt[tm2] if _[0].year in valid_years])\n",
    "plt.plot(ratings[:,0],ratings[:,1],c=color_dict[TP])\n",
    "\n",
    "for yr in valid_years:\n",
    "    top_teams_year = sorted([(v,k) for k,v in alt_year[yr].items() if k != 'sweden'],reverse=True)\n",
    "    for ratingT, tm in top_teams_year[:10]:\n",
    "        if tm == tm2:\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.2)\n",
    "# Set the locator\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",
    "# Specify formatter\n",
    "X.set_major_formatter(fmt)\n",
    "plt.ylabel('Elo')\n",
    "plt.title('Astralis vs. the other top 10 teams')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TP = 'ninjasinpyjamas'\n",
    "plt.figure(figsize=(8,4))\n",
    "valid_years = list(range(2012,2015))\n",
    "\n",
    "tm2 = TP + '_csgo'\n",
    "ratings = np.array([_ for _ in rt[tm2] if _[0].year in valid_years])\n",
    "plt.plot(ratings[:,0],ratings[:,1],c=color_dict[TP])\n",
    "\n",
    "for yr in valid_years:\n",
    "    top_teams_year = sorted([(v,k) for k,v in alt_year[yr].items() if k != 'sweden' and  '_csgo' in k],reverse=True)\n",
    "    for ratingT, tm in top_teams_year[:10]:\n",
    "        if tm == tm2:\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.2)\n",
    "# Set the locator\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",
    "# Specify formatter\n",
    "X.set_major_formatter(fmt)\n",
    "plt.ylabel('Elo')\n",
    "plt.title('NiP vs. the other top 10 teams')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TP = 'skgaming_cs16'\n",
    "plt.figure(figsize=(8,4))\n",
    "valid_years = set(range(2002,2006))\n",
    "\n",
    "tm = TP\n",
    "ratings = np.array([_ for _ in rt[tm] if _[0].year in valid_years])\n",
    "plt.plot(ratings[:,0],ratings[:,1],c=color_dict['skgaming'])\n",
    "\n",
    "for yr in valid_years:\n",
    "    top_teams_year = sorted([(v,k) for k,v in alt_year[yr].items() if k != 'sweden'],reverse=True)\n",
    "    for ratingT, tm in top_teams_year[:10]:\n",
    "        if tm == TP:\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.2)\n",
    "#plt.xlim(datetime.datetime(year=2017,month=1,day=1),datetime.datetime(year=2020,month=6,day=8))\n",
    "# Set the locator\n",
    "locator = mdates.YearLocator()  # every month\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",
    "# Specify formatter\n",
    "X.set_major_formatter(fmt)\n",
    "plt.ylabel('Elo')\n",
    "plt.title('SK vs. the other top 10 teams')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TP = 'fnatic_csgo'\n",
    "plt.figure(figsize=(8,4))\n",
    "valid_years = set(range(2012,2017))\n",
    "\n",
    "tm = TP\n",
    "ratings = np.array([_ for _ in rt[tm] if _[0].year in valid_years])\n",
    "plt.plot(ratings[:,0],ratings[:,1],c=color_dict[tm.split('_')[0]])\n",
    "\n",
    "for yr in valid_years:\n",
    "    top_teams_year = sorted([(v,k) for k,v in alt_year[yr].items() if '_csgo' in k and k != 'sweden'],reverse=True)\n",
    "    for ratingT, tm in top_teams_year[:10]:\n",
    "        if tm == TP:\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.2)\n",
    "#plt.xlim(datetime.datetime(year=2017,month=1,day=1),datetime.datetime(year=2020,month=6,day=8))\n",
    "# Set the locator\n",
    "locator = mdates.YearLocator()  # every month\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",
    "# Specify formatter\n",
    "X.set_major_formatter(fmt)\n",
    "plt.ylabel('Elo')\n",
    "plt.title('fnatic vs. the other top 10 teams')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(8,4))\n",
    "\n",
    "TP = 'ninjasinpyjamas_csgo'\n",
    "valid_years = set(range(2012,2015))\n",
    "\n",
    "tm = TP\n",
    "ratings = np.array([_ for _ in rt[tm] if _[0].year in valid_years])\n",
    "plt.plot(ratings[:,0],ratings[:,1],c=color_dict[tm.split('_')[0]],label='NiP')\n",
    "\n",
    "for yr in valid_years:\n",
    "    top_teams_year = sorted([(v,k) for k,v in alt_year[yr].items() if k != 'sweden' and '_csgo' in k],reverse=True)\n",
    "    for ratingT, tm in top_teams_year[:10]:\n",
    "        print(tm)\n",
    "        if tm == TP or tm in ['vg']:\n",
    "            continue\n",
    "        ratings = np.array([_ for _ in rt[tm] if _[0].year == yr ])\n",
    "        if len(ratings) < 1:\n",
    "            continue\n",
    "        plt.plot(ratings[:,0],ratings[:,1],c='k',alpha=0.2,lw=2)\n",
    "\n",
    "\n",
    "TP = 'fnatic_csgo'\n",
    "valid_years = set(range(2015,2017))\n",
    "\n",
    "tm = TP\n",
    "ratings = np.array([_ for _ in rt[tm] if _[0].year in valid_years or (_[0].year == 2014 and _[0].month >10) ])\n",
    "plt.plot(ratings[:,0],ratings[:,1],c=color_dict[tm.split('_')[0]],label=TP.split('_')[0])\n",
    "\n",
    "valid_years = set(range(2015,2017))\n",
    "\n",
    "for yr in valid_years:\n",
    "    top_teams_year = sorted([(v,k) for k,v in alt_year[yr].items() if k != 'sweden' and '_csgo' in k],reverse=True)\n",
    "    for ratingT, tm in top_teams_year[:10]:\n",
    "        if tm == TP or tm == 'teamenvy' or tm == 'navi':\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.2,lw=2)\n",
    "\n",
    "TP = 'teamsolomid_csgo'\n",
    "valid_years = set(range(2015,2016))\n",
    "\n",
    "tm = TP\n",
    "ratings = np.array([_ for _ in rt[tm] if _[0].year in valid_years])\n",
    "plt.plot(ratings[:,0],ratings[:,1],c=color_dict[tm.split('_')[0]],label='tsm')\n",
    "\n",
    "        \n",
    "TP = 'astralis_csgo'\n",
    "valid_years = set(range(2018,2018))\n",
    "\n",
    "tm = TP\n",
    "#ratings = np.array([_ for _ in rt[tm] if _[0].year in valid_years])\n",
    "#plt.plot(ratings[:,0],ratings[:,1],c=color_dict[tm.split('_')[0]],label='FaZe')\n",
    "\n",
    "for yr in valid_years:\n",
    "    top_teams_year = sorted([(v,k) for k,v in alt_year[yr].items() if k != 'sweden' and '_csgo' in k],reverse=True)\n",
    "    for ratingT, tm in top_teams_year[:10]:\n",
    "        if tm == TP:\n",
    "            continue\n",
    "        #if tm == 'faze': continue\n",
    "        ratings = np.array([_ for _ in rt[tm] if _[0].year == yr])\n",
    "        plt.plot(ratings[:,0],ratings[:,1],c='k',alpha=0.2,lw=2)\n",
    "\n",
    "TP = 'astralis_csgo'\n",
    "valid_years = set(range(2017,2021))\n",
    "\n",
    "tm = TP\n",
    "ratings = np.array([_ for _ in rt[tm] if _[0].year in valid_years])\n",
    "plt.plot(ratings[:,0],ratings[:,1],c=color_dict[tm.split('_')[0]],label=TP.split('_')[0])\n",
    "\n",
    "for yr in valid_years:\n",
    "    top_teams_year = sorted([(v,k) for k,v in alt_year[yr].items() if k != 'sweden' and '_csgo' in k],reverse=True)\n",
    "    for ratingT, tm in top_teams_year[:10]:\n",
    "        if tm == TP:\n",
    "            continue\n",
    "        if yr == 2019 and tm == 'tl': continue\n",
    "        #if tm == 'faze': continue\n",
    "        ratings = np.array([_ for _ in rt[tm] if _[0].year == yr])\n",
    "        plt.plot(ratings[:,0],ratings[:,1],c='k',alpha=0.2,lw=2)\n",
    "        \n",
    "TP = 'tl_csgo'\n",
    "valid_years = set(range(2019,2020))\n",
    "\n",
    "tm = TP\n",
    "ratings = np.array([_ for _ in rt[tm] if _[0].year in valid_years])\n",
    "plt.plot(ratings[:,0],ratings[:,1],c=color_dict[tm.split('_')[0]],label='liquid')\n",
    "\n",
    "\n",
    "TP = 'gamers2_csgo'\n",
    "valid_years = set(range(2013,2021))\n",
    "\n",
    "tm = TP\n",
    "ratings = np.array([_ for _ in rt[tm] if _[0].year in valid_years])\n",
    "#plt.plot(ratings[:,0],ratings[:,1],c='k',label=TP.split('_')[0])\n",
    "\n",
    "plt.legend(loc=\"lower center\", ncol=6)\n",
    "\n",
    "# Set the locator\n",
    "locator = mdates.YearLocator()\n",
    "# Specify the format - %b gives us Jan, Feb...\n",
    "fmt = mdates.DateFormatter('%Y')\n",
    "\n",
    "X = plt.gca().xaxis\n",
    "X.set_major_locator(locator)\n",
    "# Specify formatter\n",
    "X.set_major_formatter(fmt)\n",
    "plt.ylabel('Elo')\n",
    "plt.title('Top Teams in CS:GO\\n (other top 10 teams in gray)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(12,4))\n",
    "\n",
    "TP = 'ninjasinpyjamas_cs16'\n",
    "valid_years = set(range(2001,2002))\n",
    "\n",
    "tm = TP\n",
    "ratings = np.array([_ for _ in rt[tm] if _[0].year in valid_years])\n",
    "plt.plot(ratings[:,0],ratings[:,1],c=color_dict[tm.split('_')[0]],label='NiP')\n",
    "\n",
    "for yr in valid_years:\n",
    "    top_teams_year = sorted([(v,k) for k,v in alt_year[yr].items() if k != 'sweden' and '_cs16' in k],reverse=True)\n",
    "    for ratingT, tm in top_teams_year[:10]:\n",
    "        if tm == TP:\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.2,lw=2)\n",
    "        \n",
    "TP = 'mtw_cs16'\n",
    "valid_years = set(range(2002,2003))\n",
    "\n",
    "tm = TP\n",
    "ratings = np.array([_ for _ in rt[tm] if _[0].year in valid_years])\n",
    "plt.plot(ratings[:,0],ratings[:,1],c=color_dict[tm.split('_')[0]],label='mTw')\n",
    "\n",
    "for yr in valid_years:\n",
    "    top_teams_year = sorted([(v,k) for k,v in alt_year[yr].items() if k != 'sweden' and '_cs16' in k],reverse=True)\n",
    "    for ratingT, tm in top_teams_year[:10]:\n",
    "        if tm == TP:\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.2,lw=2)\n",
    "        \n",
    "\n",
    "TP = 'skgaming_cs16'\n",
    "valid_years = set(range(2003,2007))\n",
    "\n",
    "tm = TP\n",
    "ratings = np.array([_ for _ in rt[tm] if _[0].year in valid_years])\n",
    "plt.plot(ratings[:,0],ratings[:,1],c=color_dict[tm.split('_')[0]])\n",
    "valid_years = set(range(2003,2006))\n",
    "\n",
    "for yr in valid_years:\n",
    "    top_teams_year = sorted([(v,k) for k,v in alt_year[yr].items() if k != 'sweden' and '_cs16' in k],reverse=True)\n",
    "    for ratingT, tm in top_teams_year[:10]:\n",
    "        if tm == TP:\n",
    "            continue\n",
    "        if tm == 'ninjasinpyjamas_cs16' and yr == 2006:\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.2,lw=2)\n",
    "\n",
    "TP = 'ninjasinpyjamas_cs16'\n",
    "valid_years = set(range(2006,2007))\n",
    "\n",
    "tm = TP\n",
    "ratings = np.array([_ for _ in rt[tm] if _[0].year in valid_years])\n",
    "plt.plot(ratings[:,0],ratings[:,1],c=color_dict[tm.split('_')[0]])\n",
    "\n",
    "for yr in valid_years:\n",
    "    top_teams_year = sorted([(v,k) for k,v in alt_year[yr].items() if k != 'sweden' and '_cs16' in k],reverse=True)\n",
    "    for ratingT, tm in top_teams_year[:10]:\n",
    "        if tm == TP or tm == 'skgaming_cs16':\n",
    "            print('skip ',tm)\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.2,lw=2)\n",
    "        \n",
    "        \n",
    "TP = 'fnatic_cs16'\n",
    "valid_years = set(range(2007,2009))\n",
    "\n",
    "tm = TP\n",
    "ratings = np.array([_ for _ in rt[tm] if _[0].year in valid_years])\n",
    "plt.plot(ratings[:,0],ratings[:,1],c=color_dict[tm.split('_')[0]],label='fnatic')\n",
    "valid_years = set(range(2007,2011))\n",
    "for yr in valid_years:\n",
    "    top_teams_year = sorted([(v,k) for k,v in alt_year[yr].items() if k != 'sweden' and '_cs16' in k],reverse=True)\n",
    "    for ratingT, tm in top_teams_year[:10]:\n",
    "        if tm == TP or tm in set(['mtw_cs16','skgaming_cs16']):\n",
    "            continue\n",
    "        ratings = np.array([_ for _ in rt[tm] if _[0].year == yr])\n",
    "        if ratings.shape[0] < 1:\n",
    "            continue\n",
    "        plt.plot(ratings[:,0],ratings[:,1],c='k',alpha=0.2,lw=2)\n",
    "\n",
    "TP = 'skgaming_cs16'\n",
    "valid_years = set(range(2008,2009))\n",
    "\n",
    "tm = TP\n",
    "ratings = np.array([_ for _ in rt[tm] if _[0].year in valid_years])\n",
    "plt.plot(ratings[:,0],ratings[:,1],c=color_dict[tm.split('_')[0]])\n",
    "\n",
    "TP = 'mtw_cs16'\n",
    "valid_years = set(range(2009,2010))\n",
    "\n",
    "tm = TP\n",
    "ratings = np.array([_ for _ in rt[tm] if _[0].year in valid_years])\n",
    "plt.plot(ratings[:,0],ratings[:,1],c=color_dict[tm.split('_')[0]])\n",
    "\n",
    "\n",
    "TP = 'mousesports_cs16'\n",
    "valid_years = set(range(2008,2009))\n",
    "\n",
    "tm = TP\n",
    "ratings = np.array([_ for _ in rt[tm] if _[0].year in valid_years])\n",
    "plt.plot(ratings[:,0],ratings[:,1],c=color_dict[tm.split('_')[0]],label='mouz')\n",
    "\n",
    "\n",
    "\n",
    "TP = 'skgaming_cs16'\n",
    "valid_years = set(range(2011,2013))\n",
    "\n",
    "tm = TP\n",
    "ratings = np.array([_ for _ in rt[tm] if _[0].year in valid_years])\n",
    "plt.plot(ratings[:,0],ratings[:,1],c=color_dict[tm.split('_')[0]],label='SK')\n",
    "\n",
    "for yr in valid_years:\n",
    "    top_teams_year = sorted([(v,k) for k,v in alt_year[yr].items() if k != 'sweden' and '_cs16' in k],reverse=True)\n",
    "    for ratingT, tm in top_teams_year[:10]:\n",
    "        if tm == TP:\n",
    "            continue\n",
    "        #if tm == 'ninjasinpyjamas_cs16': continue\n",
    "        #if tm == 'navi_cs16': continue\n",
    "        #if tm == 'goldenfive_cs16': continue\n",
    "        ratings = np.array([_ for _ in rt[tm] if _[0].year == yr])\n",
    "        plt.plot(ratings[:,0],ratings[:,1],c='k',alpha=0.2,lw=2)\n",
    "\n",
    "\n",
    "TP = 'navi_cs16'\n",
    "valid_years = set(range(2011,2012))\n",
    "\n",
    "tm = TP\n",
    "ratings = np.array([_ for _ in rt[tm] if _[0].year in valid_years])\n",
    "plt.plot(ratings[:,0],ratings[:,1],c=color_dict[tm.split('_')[0]],label='NAVI')\n",
    "\n",
    "TP = 'fnatic_cs16'\n",
    "valid_years = set(range(2010,2011))\n",
    "\n",
    "tm = TP\n",
    "ratings = np.array([_ for _ in rt[tm] if _[0].year in valid_years])\n",
    "plt.plot(ratings[:,0],ratings[:,1],c=color_dict[tm.split('_')[0]])\n",
    "\n",
    "TP = 'goldenfive_cs16'\n",
    "valid_years = set(range(2011,2012))\n",
    "\n",
    "tm = TP\n",
    "ratings = np.array([_ for _ in rt[tm] if _[0].year in valid_years])\n",
    "plt.plot(ratings[:,0],ratings[:,1],c='#00a86b',label='GoldenFive')\n",
    "\n",
    "\n",
    "\n",
    "TP = 'fnatic_cs16'\n",
    "valid_years = set(range(2012,2013))\n",
    "\n",
    "tm = TP\n",
    "ratings = np.array([_ for _ in rt[tm] if _[0].year in valid_years])\n",
    "plt.plot(ratings[:,0],ratings[:,1],c=color_dict[tm.split('_')[0]])\n",
    "\n",
    "if False:\n",
    "    valid_list = []\n",
    "    valid_lines = []\n",
    "    for line, label in zip(handles, labels):\n",
    "        if label in valid_list:\n",
    "            continue\n",
    "        valid_list.append(label)\n",
    "        valid_lines.append(line)\n",
    "plt.legend(loc=\"lower center\", ncol=7)\n",
    "\n",
    "# Set the locator\n",
    "locator = mdates.YearLocator()\n",
    "# Specify the format - %b gives us Jan, Feb...\n",
    "fmt = mdates.DateFormatter('%Y')\n",
    "\n",
    "X = plt.gca().xaxis\n",
    "X.set_major_locator(locator)\n",
    "# Specify formatter\n",
    "X.set_major_formatter(fmt)\n",
    "plt.ylabel('Elo')\n",
    "plt.title('Top Teams in CS1.6\\n (other top 10 teams in gray)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tm,yr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[_ for _ in top_teams if '_css' in _[1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TP = 'vg_css'\n",
    "valid_years = set(range(2005,2014))\n",
    "\n",
    "tm = TP\n",
    "ratings = np.array([_ for _ in rt[tm] if _[0].year in valid_years])\n",
    "plt.plot(ratings[:,0],ratings[:,1],c='b',label='VG')\n",
    "\n",
    "for yr in valid_years:\n",
    "    top_teams_year = sorted([(v,k) for k,v in alt_year[yr].items() if '_css' in k],reverse=True)\n",
    "    for ratingT, tm in top_teams_year[:10]:\n",
    "        if tm == TP:\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.2)\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[_ for _ in top_teams if '_cso' in _[1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(xn,sigmoid((xn-cMean)*cVar))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ratings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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
}