main.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# League of Legends Tournament Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import pyspark.sql.functions as F\n",
    "import seaborn as sns\n",
    "from ipywidgets import widgets\n",
    "from pandas_profiling import ProfileReport\n",
    "from pyspark.ml.classification import LogisticRegression\n",
    "from pyspark.ml.feature import VectorAssembler\n",
    "from pyspark.mllib.evaluation import MulticlassMetrics\n",
    "from pyspark.sql import SparkSession\n",
    "from pyspark.sql.functions import *\n",
    "from pyspark.sql.types import *\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.model_selection import GridSearchCV, train_test_split\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "            <div>\n",
       "                <p><b>SparkSession - in-memory</b></p>\n",
       "                \n",
       "        <div>\n",
       "            <p><b>SparkContext</b></p>\n",
       "\n",
       "            <p><a href=\"http://n3-12-254.dhcp.drexel.edu:4040\">Spark UI</a></p>\n",
       "\n",
       "            <dl>\n",
       "              <dt>Version</dt>\n",
       "                <dd><code>v3.1.1</code></dd>\n",
       "              <dt>Master</dt>\n",
       "                <dd><code>local[*]</code></dd>\n",
       "              <dt>AppName</dt>\n",
       "                <dd><code>League of Legends Tournament Analysis</code></dd>\n",
       "            </dl>\n",
       "        </div>\n",
       "        \n",
       "            </div>\n",
       "        "
      ],
      "text/plain": [
       "<pyspark.sql.session.SparkSession at 0x7fc03be674c0>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "APP_NAME = \"League of Legends Tournament Analysis\"\n",
    "spark = SparkSession.builder.appName(APP_NAME).getOrCreate()\n",
    "spark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "cols = spark.read.options(inferSchema='True',header='True').csv(\"./leagueoflegends/Columns.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----------------+--------------------------------------------------------------------------------------------------+\n",
      "|ColumnName      |ColumnDescription                                                                                 |\n",
      "+----------------+--------------------------------------------------------------------------------------------------+\n",
      "|MatchHistory    | website address the data is scraped from                                                         |\n",
      "|League          | League or Tournament the match took place in                                                     |\n",
      "|Season          | Season - Spring, Summer, Winter, or Tournament - the match took place in                         |\n",
      "|Year            | Year the match took place in                                                                     |\n",
      "|blueTeamTag     | Blue Team's tag name (ex. Team SoloMid is TSM)                                                   |\n",
      "|bResult         | Result of the match for Blue Team - 1 is a win, 0 is a loss                                      |\n",
      "|rResult         | Result of the match for Red Team - 1 is a win, 0 is a loss                                       |\n",
      "|redTeamTag      | Red Team's Tag Name (ex. Team SoloMid is TSM)                                                    |\n",
      "|gamelength      | Game length in minutes                                                                           |\n",
      "|golddiff        | Gold difference - computed Blue minus Red - by minute                                            |\n",
      "|goldblue        | Blue Team's total gold value by minute                                                           |\n",
      "|bKills          | List of Blue Team's kills - [Time in minutes, Victim, Killer, Assist1, Assist2, Assist3, Assist4]|\n",
      "|bTowers         | List of minutes that Blue Team destroyed a tower                                                 |\n",
      "|bInhibs         | List of minutes that Blue Team destroyed an inhibitor                                            |\n",
      "|bDragons        | List of minutes that Blue Team killed a dragon                                                   |\n",
      "|bBarons         | List of minutes that Blue Team killed a baron nashor                                             |\n",
      "|bHeralds        | List of minutes that Blue Team killed a rift herald                                              |\n",
      "|goldred         | Red Team's total gold value by minute                                                            |\n",
      "|rKills          | List of Red Team's kills - [Time in minutes, Victim, Killer, Assist1, Assist2, Assist3, Assist4] |\n",
      "|rTowers         | List of minutes that Red Team destroyed a tower                                                  |\n",
      "|rInhibs         | List of minutes that Red Team destroyed an inhibitor                                             |\n",
      "|rDragons        | List of minutes that Red Team killed a dragon                                                    |\n",
      "|rBarons         | List of minutes that Red Team killed a baron nashor                                              |\n",
      "|rHeralds        | List of minutes that Red Team killed a rift herald                                               |\n",
      "|blueTop         | Name of Blue Team's player in the top position                                                   |\n",
      "|blueTopChamp    | Name of Blue Team's champion in the top position                                                 |\n",
      "|goldblueTop     | Blue's Top position player's gold value by minute                                                |\n",
      "|blueJungle      | Name of Blue Team's player in the jungle position                                                |\n",
      "|blueJungleChamp | Name of Blue Team's champion in the jungle position                                              |\n",
      "|goldblueJungle  | Blue's Jungle position player's gold value by minute                                             |\n",
      "|blueMiddle      | Name of Blue Team's player in the middle position                                                |\n",
      "|blueMiddleChamp | Name of Blue Team's champion in the middle position                                              |\n",
      "|goldblueMiddle  | Blue's Middle position player's gold value by minute                                             |\n",
      "|blueADC         | Name of Blue Team's player in the ADC position                                                   |\n",
      "|blueADCChamp    | Name of Blue Team's champion in the ADC position                                                 |\n",
      "|goldblueADC     | Blue's ADC position player's gold value by minute                                                |\n",
      "|blueSupport     | Name of Blue Team's player in the support position                                               |\n",
      "|blueSupportChamp| Name of Blue's champion in the support position                                                  |\n",
      "|goldblueSupport | Blue's Support player's gold value by minute                                                     |\n",
      "|blueBans        | List of champions Blue Team banned (in order)                                                    |\n",
      "|redTop          | Name of Red Team's player in the top position                                                    |\n",
      "|redTopChamp     | Name of Red Team's champion in the top position                                                  |\n",
      "|goldredTop      | Red's Top position player's gold value by minute                                                 |\n",
      "|redJungle       | Name of Red Team's player in the jungle position                                                 |\n",
      "|redJungleChamp  | Name of Red Team's champion in the jungle position                                               |\n",
      "|goldredJungle   | Red's Jungle position player's gold value by minute                                              |\n",
      "|redMiddle       | Name of Red Team's player in the middle position                                                 |\n",
      "|redMiddleChamp  | Name of Red Team's champion in the middle position                                               |\n",
      "|goldredMiddle   | Red's Middle position player's gold value by minute                                              |\n",
      "|redADC          | Name of Red Team's player in the ADC position                                                    |\n",
      "|redADCChamp     | Name of Red Team's champion in the ADC position                                                  |\n",
      "|goldredADC      | Red's ADC position player's gold value by minute                                                 |\n",
      "|redSupportChamp | Name of Red Team's player in the support position                                                |\n",
      "|redSupport      | Name of Red Team's champion in the support position                                              |\n",
      "|goldredSupport  | Red's Support position player's gold value by minute                                             |\n",
      "|redBans         | List of champions Red Team banned (in order)                                                     |\n",
      "+----------------+--------------------------------------------------------------------------------------------------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "cols.show(60,truncate=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "56"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cols.count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We originally had 6 files containing different types of data from all different professional tournaments hosted by Riot Games. The **cols** Dataframe shows column name and their description. For the sake of this project, we're going to focus on only one file called **LeagueofLegends.csv**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "lol = spark.read.options(inferSchema='True',header='True').csv(\"./leagueoflegends/LeagueofLegends.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      " |-- League: string (nullable = true)\n",
      " |-- Year: integer (nullable = true)\n",
      " |-- Season: string (nullable = true)\n",
      " |-- Type: string (nullable = true)\n",
      " |-- blueTeamTag: string (nullable = true)\n",
      " |-- bResult: integer (nullable = true)\n",
      " |-- rResult: integer (nullable = true)\n",
      " |-- redTeamTag: string (nullable = true)\n",
      " |-- gamelength: integer (nullable = true)\n",
      " |-- golddiff: string (nullable = true)\n",
      " |-- goldblue: string (nullable = true)\n",
      " |-- bKills: string (nullable = true)\n",
      " |-- bTowers: string (nullable = true)\n",
      " |-- bInhibs: string (nullable = true)\n",
      " |-- bDragons: string (nullable = true)\n",
      " |-- bBarons: string (nullable = true)\n",
      " |-- bHeralds: string (nullable = true)\n",
      " |-- goldred: string (nullable = true)\n",
      " |-- rKills: string (nullable = true)\n",
      " |-- rTowers: string (nullable = true)\n",
      " |-- rInhibs: string (nullable = true)\n",
      " |-- rDragons: string (nullable = true)\n",
      " |-- rBarons: string (nullable = true)\n",
      " |-- rHeralds: string (nullable = true)\n",
      " |-- blueTop: string (nullable = true)\n",
      " |-- blueTopChamp: string (nullable = true)\n",
      " |-- goldblueTop: string (nullable = true)\n",
      " |-- blueJungle: string (nullable = true)\n",
      " |-- blueJungleChamp: string (nullable = true)\n",
      " |-- goldblueJungle: string (nullable = true)\n",
      " |-- blueMiddle: string (nullable = true)\n",
      " |-- blueMiddleChamp: string (nullable = true)\n",
      " |-- goldblueMiddle: string (nullable = true)\n",
      " |-- blueADC: string (nullable = true)\n",
      " |-- blueADCChamp: string (nullable = true)\n",
      " |-- goldblueADC: string (nullable = true)\n",
      " |-- blueSupport: string (nullable = true)\n",
      " |-- blueSupportChamp: string (nullable = true)\n",
      " |-- goldblueSupport: string (nullable = true)\n",
      " |-- blueBans: string (nullable = true)\n",
      " |-- redTop: string (nullable = true)\n",
      " |-- redTopChamp: string (nullable = true)\n",
      " |-- goldredTop: string (nullable = true)\n",
      " |-- redJungle: string (nullable = true)\n",
      " |-- redJungleChamp: string (nullable = true)\n",
      " |-- goldredJungle: string (nullable = true)\n",
      " |-- redMiddle: string (nullable = true)\n",
      " |-- redMiddleChamp: string (nullable = true)\n",
      " |-- goldredMiddle: string (nullable = true)\n",
      " |-- redADC: string (nullable = true)\n",
      " |-- redADCChamp: string (nullable = true)\n",
      " |-- goldredADC: string (nullable = true)\n",
      " |-- redSupport: string (nullable = true)\n",
      " |-- redSupportChamp: string (nullable = true)\n",
      " |-- goldredSupport: string (nullable = true)\n",
      " |-- redBans: string (nullable = true)\n",
      " |-- Address: string (nullable = true)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "lol.printSchema()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "57"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(lol.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7620"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lol.count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are 57 different columns and 7620 samples in our LOL (League Of Legends) dataframe. A lot of these columns are not helpful in predicting game outcomes or to help make different EDAs. So, we'll be dropping them. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "cols = ('Year', 'Season', 'Type', \"golddiff\", 'blueTop',\n",
    "        'blueTopChamp', 'goldblueTop', 'blueJungle', 'blueJungleChamp',\n",
    "        'goldblueJungle', 'blueMiddle', 'blueMiddleChamp', 'goldblueMiddle',\n",
    "        'blueADC', 'blueADCChamp', 'goldblueADC', 'blueSupport',\n",
    "        'blueSupportChamp', 'goldblueSupport', 'blueBans', 'redTop',\n",
    "        'redTopChamp', 'goldredTop', 'redJungle', 'redJungleChamp',\n",
    "        'goldredJungle', 'redMiddle', 'redMiddleChamp', 'goldredMiddle',\n",
    "        'redADC', 'redADCChamp', 'goldredADC', 'redSupport', 'redSupportChamp',\n",
    "        'goldredSupport', 'redBans', 'Address')\n",
    "\n",
    "lol = lol.drop(*cols)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# copy dataframe over to a new variable\n",
    "lol1 = lol.select(\"*\")\n",
    "\n",
    "lol1 = lol1.filter('gamelength > 31')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Only game stats where **gamelength** exceeds 31 minutes. We do this because a lot most professional games go past this mark and also because up until 30 mins, players are still gaining levels, collecting gold,  buying items etc. Usually we call this early stage of games. Although early stage of game, small leads and action plays a big role in team winning or losing a game"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5622"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We have good amount of data\n",
    "lol1.count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function below gets mins marks in list, this functions get all the stats up until 30 mins marks any kills, or gold earned after isn't super advantageous because after 30 mins the game becomes heavily dependent on whole team rather than one single players. So function below gets the number of action (kills or objective taken) up until 30 mins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def min_marks(x,length=30):\n",
    "\n",
    "    s=[]\n",
    "    for i in re.split(r\"\\[\\[|\\], \\[\",x):\n",
    "        try:\n",
    "            times = float(i.split(', ')[0])\n",
    "            if times <= length:\n",
    "                s.append(times)\n",
    "        except:\n",
    "            pass\n",
    "\n",
    "    return len(s)\n",
    "min_udf = udf(lambda x:min_marks(x),StringType())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# apply yhe function min_marks on the following columns\n",
    "cols=['bKills','bTowers','bInhibs','bDragons','bBarons','bHeralds',\n",
    "        'rKills','rTowers','rInhibs','rDragons','rBarons','rHeralds']\n",
    "\n",
    "for i in cols:\n",
    "    lol1 = lol1.withColumn(i,min_udf(col(i)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+------+-----------+-------+-------+----------+----------+--------------------+------+-------+-------+--------+-------+--------+--------------------+------+-------+-------+--------+-------+--------+\n",
      "|League|blueTeamTag|bResult|rResult|redTeamTag|gamelength|            goldblue|bKills|bTowers|bInhibs|bDragons|bBarons|bHeralds|             goldred|rKills|rTowers|rInhibs|rDragons|rBarons|rHeralds|\n",
      "+------+-----------+-------+-------+----------+----------+--------------------+------+-------+-------+--------+-------+--------+--------------------+------+-------+-------+--------+-------+--------+\n",
      "| NALCS|        TSM|      1|      0|        C9|        40|[2415, 2415, 2711...|     9|      6|      1|       0|      0|       0|[2415, 2415, 2725...|     5|      3|      0|       2|      0|       0|\n",
      "| NALCS|        CST|      0|      1|       DIG|        38|[2415, 2415, 2705...|     8|      5|      0|       2|      0|       0|[2415, 2415, 2731...|     7|      5|      0|       1|      0|       0|\n",
      "| NALCS|        WFX|      1|      0|        GV|        40|[2415, 2415, 2726...|    15|      6|      0|       2|      0|       0|[2415, 2415, 2716...|     7|      1|      0|       0|      0|       0|\n",
      "+------+-----------+-------+-------+----------+----------+--------------------+------+-------+-------+--------+-------+--------+--------------------+------+-------+-------+--------+-------+--------+\n",
      "only showing top 3 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# small glimpse of data\n",
    "lol1.show(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **goldBlue** and **goldRed** is a list of gold from each min mark. We only want last recorded gold amount for the team. Function below (final_gold) will do that job for us.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def final_gold(x):   \n",
    "    s=[]\n",
    "    for i in re.split(r\"\\[|, \",x):\n",
    "        try:\n",
    "            gold = int(i)\n",
    "            s.append(gold)\n",
    "        except:\n",
    "            pass\n",
    "\n",
    "    return s[-1]\n",
    "\n",
    "gold_udf = udf(lambda x:final_gold(x),StringType())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# applying funciton to goldblue and goldred\n",
    "lol1 = lol1.withColumn('goldblue',gold_udf(col('goldblue')))\n",
    "lol1 = lol1.withColumn('goldred',gold_udf(col('goldred')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------+-------+\n",
      "|goldblue|goldred|\n",
      "+--------+-------+\n",
      "|   59940|  55254|\n",
      "|   56911|  53185|\n",
      "|   68928|  55004|\n",
      "+--------+-------+\n",
      "only showing top 3 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# thats alot better\n",
    "lol1.select('goldblue','goldred').show(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# copying blue and red team tags and result \n",
    "lol1 = lol1.withColumn(\"blueTeamTag\", lol[\"blueTeamTag\"])\n",
    "lol1 = lol1.withColumn(\"blueResult\", lol[\"bResult\"])\n",
    "lol1 = lol1.withColumn(\"redTeamTag\", lol[\"redTeamTag\"])\n",
    "lol1 = lol1.withColumn(\"redResult\", lol[\"rResult\"])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, we create a new column called **Winner**. Winner will have value of 0 if blue team won, and 1 if red team won."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----------+---------+------+\n",
      "|blueResult|redResult|Winner|\n",
      "+----------+---------+------+\n",
      "|         1|        0|     0|\n",
      "|         0|        1|     1|\n",
      "+----------+---------+------+\n",
      "only showing top 2 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "lol1 = lol1.withColumn(\"Winner\", when((lol1.blueResult == 1), lit(0)).otherwise(lit(1)) )\n",
    "\n",
    "lol1.select('blueResult','redResult','Winner').show(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we drop the **blueResult**, and **redResult** columns since we have the Winner Column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "cols_1 = ('blueResult', 'redResult', 'bResult', 'rResult')\n",
    "lol1 = lol1.drop(*cols_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "change_dataype = [\n",
    "    'goldblue', 'bKills', 'bTowers', 'bInhibs', 'bDragons', 'bBarons',\n",
    "    'bHeralds', 'goldred', 'rKills', 'rTowers', 'rInhibs', 'rDragons',\n",
    "    'rBarons', 'rHeralds'\n",
    "]\n",
    "for i in change_dataype:\n",
    "    lol1 = lol1.withColumn(i, lol1[i].cast('int'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      " |-- League: string (nullable = true)\n",
      " |-- blueTeamTag: string (nullable = true)\n",
      " |-- redTeamTag: string (nullable = true)\n",
      " |-- gamelength: integer (nullable = true)\n",
      " |-- goldblue: integer (nullable = true)\n",
      " |-- bKills: integer (nullable = true)\n",
      " |-- bTowers: integer (nullable = true)\n",
      " |-- bInhibs: integer (nullable = true)\n",
      " |-- bDragons: integer (nullable = true)\n",
      " |-- bBarons: integer (nullable = true)\n",
      " |-- bHeralds: integer (nullable = true)\n",
      " |-- goldred: integer (nullable = true)\n",
      " |-- rKills: integer (nullable = true)\n",
      " |-- rTowers: integer (nullable = true)\n",
      " |-- rInhibs: integer (nullable = true)\n",
      " |-- rDragons: integer (nullable = true)\n",
      " |-- rBarons: integer (nullable = true)\n",
      " |-- rHeralds: integer (nullable = true)\n",
      " |-- Winner: integer (nullable = false)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "lol1.printSchema()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "19"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(lol1.columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 1\n",
    "Here we will use Pandas_Profiling module which will create a report for us. This will provides us with some important insights like Correlations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pandas_profiling import ProfileReport\n",
    "from ipywidgets import widgets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "lol_report = lol1.withColumn(\"Blue Total Objective\", lol1.bTowers + lol1.bInhibs + lol1.bDragons +\n",
    "                lol1.bBarons + lol1.bHeralds)\\\n",
    "                .withColumn(\"Red Total Objective\", lol1.rTowers + lol1.rInhibs + lol1.rDragons +\n",
    "                lol1.rBarons + lol1.rHeralds)\\\n",
    "                .select('gamelength','goldblue','bKills','Blue Total Objective','goldred',\n",
    "                        'rKills','Red Total Objective','winner').toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "profile = ProfileReport(lol_report,html={'style':{'full_width':True}})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6cd16b6db8704b88a45f1368dc76e35b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Summarize dataset:   0%|          | 0/21 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e39c7e18df254702aad78f9680d872f1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Generate report structure:   0%|          | 0/1 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Render widgets:   0%|          | 0/1 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c65f0cd8aea542e5847ab929dcce9e04",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Tab(children=(Tab(children=(GridBox(children=(VBox(children=(GridspecLayout(children=(HTML(valu…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "profile.to_widgets()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bc7c0ac5f2ef4ed9b19908a265fffe1d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Render HTML:   0%|          | 0/1 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b177d33879a94dc7989605fb266f6a83",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Export report to file:   0%|          | 0/1 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "profile.to_file(\"League_Pandas_Profiling.html\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "lol_report = lol_report.rename(columns={\"Blue Total Objective\": \"Blue_Obj\", \"Red Total Objective\": \"Red_Obj\",})\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.heatmap(lol_report.corr(),annot=True, cmap=\"Blues\",cbar=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From Report shown above or [here](./League_Pandas_Profiling.html). Under Overview and Warnings tab, we are shown that **gamelength** has High correlation with **goldblue**, and **goldred**. This is understandable since as the game goes on, earning gold from killing mini monsters or taking objectives or killing opponents grants you gold. Also, players gain gold 20.4 gold per minute passively. \n",
    "\n",
    "According to report, we don't have any null values as well which is perfect. \n",
    "\n",
    "Although, we have high number of zeros in **bKills, Blue Total Objective, rKills, and Red Total Objective** which is surprising since pro tournament games having team which had **0 kills and/or 0 objectives** is rare. Most likely it means that the opposing team dominated the game."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 2\n",
    "Which side of the map, **Blue or Red**, has the most number of wins?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Numbers of wins comparions for blue vs. red side of the map\n",
    "wins_side = lol1.groupBy('winner').count().toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(5,5))\n",
    "\n",
    "sns.barplot(x=\"winner\", y=\"count\",data=wins_side, palette=[\"blue\",\"red\"])\n",
    "plt.title('Blue vs. Red side Winners')\n",
    "plt.show()\n",
    "# 0 is the blue side, and orange is the red side."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>winner</th>\n",
       "      <th>count</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>2662</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>2960</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   winner  count\n",
       "0       1   2662\n",
       "1       0   2960"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wins_side"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usually when we think of game maps, we think its designed fairly for both team sides and in this case that's true. But the reason that **Blue (0)** has more win count compared to red is because of players play style. In game, you're allowed to play with locked screen, where screen is locked on to your champion's (character) movements and unlocked screen, where player can explore map with mouse hover. \n",
    "\n",
    "Playing with lock screen seems to be harder when on the red side of the map based on Pro players interviews and personal experience."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 3\n",
    "Now we know that there is slight advantage when playing on the blue side of the map. Let's see the top 5 team's\n",
    "gold count when they play on blue side compare it to when they play on the red side of the map."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "bGold = lol1.groupBy('blueTeamTag').sum(\"goldblue\")\\\n",
    "            .orderBy('sum(goldblue)', ascending=False)\\\n",
    "            .withColumnRenamed(\"sum(goldblue)\", \"Gold\")\\\n",
    "            .withColumnRenamed(\"blueTeamTag\", \"Teams\")\n",
    "\n",
    "p_bGold = bGold.toPandas()[:5]\n",
    "p_bGold['side'] = 'Blue Side'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Teams</th>\n",
       "      <th>Gold</th>\n",
       "      <th>side</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>SKT</td>\n",
       "      <td>9630871</td>\n",
       "      <td>Blue Side</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>SSG</td>\n",
       "      <td>8850898</td>\n",
       "      <td>Blue Side</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>kt</td>\n",
       "      <td>8631637</td>\n",
       "      <td>Blue Side</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>JAG</td>\n",
       "      <td>8348230</td>\n",
       "      <td>Blue Side</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>FNC</td>\n",
       "      <td>7524742</td>\n",
       "      <td>Blue Side</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Teams     Gold       side\n",
       "0   SKT  9630871  Blue Side\n",
       "1   SSG  8850898  Blue Side\n",
       "2    kt  8631637  Blue Side\n",
       "3   JAG  8348230  Blue Side\n",
       "4   FNC  7524742  Blue Side"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p_bGold"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Now let's see the same team's gold stat when they play on the red side of the map.\n",
    "\n",
    "\n",
    "p_rGold = lol1.groupBy('redTeamTag').sum(\"goldred\").filter( (lol1.redTeamTag  == \"SKT\") | (lol1.redTeamTag  == \"SSG\") |\n",
    "               (lol1.redTeamTag  == \"kt\") | (lol1.redTeamTag  == \"JAG\") |\n",
    "               (lol1.redTeamTag  == \"FNC\")\n",
    "              ).withColumnRenamed(\"sum(goldred)\",\"Gold\").withColumnRenamed(\"redTeamTag\",\"Teams\")\n",
    "\n",
    "p_rGold = p_rGold.toPandas()\n",
    "p_rGold['side']='Red Side'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# concat the dataframes for graphing purpose\n",
    "g1 = pd.concat([p_bGold[:5],p_rGold[:5]],0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAGPCAYAAABceqcQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAApyklEQVR4nO3deZxe893/8ddMNkSiqaQkWrQ3PqqWIESV29rNUq2lRSyxK2kUtZXatyq1lBsVbq2K+6c7dymtpdq6LYlQig9a1BJtREoSkpjl98c5I1cmk5mJzHWNmbyej0cembN/z7mu67zP+Z5zvqeuubkZSZLqu7sAkqQPBgNBkgQYCJKkkoEgSQIMBElSyUCQJAHQt7sLoM6LiIuAPYA3yl6ZmV9rNc79wHJAfyCAx8tBf83MMbUq66JExHrAacAGQAPQBFwLXJyZ7d4DHREvALtn5qRW/XcHxmXm1q36rw78jfnboB6YBVySmTeX45wJPJeZP46IscCZwFPARcA1wD+BrTLznUWUaSTwc+DfwG6Z+UL7W6DNebQuJ8DywMvAgZn598Wc3yxg3fdTlsVYRjPwBNBIsV2bgdMy81fl+jyRmct34fKOB/YG6oA+wG+Bb2fmvMrPsNU0Q4FpmVnXVeXo7QyEnmVzYM/MvH9RI2Tm5vDeTuaJzBxZm6J1LCI2AH4HHJKZu5f9hgK/Lkf5fhUW+07lNoiI1YC7IqIxM3+emadWjLsfxU7mJxFxHXBNZp7dwfy/BNyTmQd3cTnrgMuAc4C9lnDe1bJNZr4OEBGjgbsjYkhXLyQi9gC+Anw6M9+JiGWAnwGnU3xep7Y3vTrPQOghImIAsCFwfET8B/AMcHRm/qOT0/cHvgtsRXGENQUYn5lvRcROwLcpzio+AvwoM78TEVsD5wH/oDjbmA2cD4wvu3+emUdHxPLAfwNrUhzxTwYOy8ymVsU4G7ggM1sCgMx8PSIOA9Yvy9mPIhi2ozj6fLBcz5mt1udMYAwwHXi2M9ugXN6LEXEqcBzw84i4nuJIdxVgU+DjETEc+DLwTkSskJnHtTWviBgDHAH0iYhlM3NMRHyHYgfeQPEZjcvM1yLiXoozu7WBKzPzBx0UdRlgBPBauaz2Pr8tgR9QHKU/TBtVwRHxOeCizFyv7P4Q8DzwCWBP4HBgHjCH4rN7soPytfZhYFq53pXLPR0YmpnjWndHxArApcB6QD/gLuC4zFxgHsDwcp2XpQjOORExjuK7SstnmJkXRsSuFCH6drktKstyEMXnVU/xvRmXmU8v5nr2al5D6DlGAHcDp1DsPB8Afl0eSXbGiRQ/1o0zcwPgVeD8cvpjgf0zcxSwGXBSeeQOsAlwfnn0+hZwErAjsBFwZESMoDh6G1SOs0k53SfaKMOWwB2te2bmE5k5sew8pVzXDcp/9cD3KsePiF2A3YCRFGdNK3RyG7R4jGInVFmGo4FJFDuk7wG3UFRjtRkG5TQ3AlcB/68MgwOALwKbZOb6FEFzfcUkMzJznUWEwbIR8WhEPB4R/wQeAZ4GTiiHL+rz6w/8FDg2MzcE7qHYcbb2O2D5iBhVdu8F/IbiM70E+EJmbgL8ENhiUevcyj1lmZ8r53VOGwcB7bkYmJyZG1Mc7AwFjmljvB9RVMm9FhH/V1adrpqZD1WOFBErAddRVN1tDLxYMWwrYH9gy3I7XQD8cjHKulQwEHqIzHw+M3cod57NwIXAfwCrd3IWOwG7AFMi4lGKI+B1ynntDGwcEadRHJ3XAQPL6Z7PzCnl33+jqB6ZV1YVvEVxZPgn4FPlUfCJFHX0z7VRhjqKo1gAIuLiip3g38reXwSuysx3y53LD8p+lbYHfpGZM8ujyes6uQ1aNFMcQXa1LwL/nZmzy+5Lge3KnTbAH9uZ9p3MHFkewe9HsXO8NTNnlcPb/Pwogu3dzLwLIDNvAma2mjfl53wdMLbsdQBFlVgjRaDcHxGXU+x4r+3k+m5TlnkNYGPgvIj4TCenbVmnw8r1mUxxhrZe65Ey883M/BzF2dUEijOD30TEd1uNugXweMXZzdUVw3YE1qBYz0cpAmFIRHx4Mcrb6xkIPURErB8R+7bqXQe828lZ9AGOKn/AIyl+fLtHxECK6oeNKI5Kjyvn2XLmMbfVfBZaXmY+T/FjOw8YDPw+InZuowz3A1tXTHd0WZadgZUqyll5cbmeojqhtcozo9ZVDB3ZhAUv4HaVtsrel/llnbXQFG3IzDsogvmnETG4Yt4LfX7lsNZniYvaHtcBe5QXwj+UmX8ol7cPxWfwHEWg39SZcrYq8xSKA4PWZxfNrcrXv+LvPsAeFes0GhjXet4RcXxEbJ6Zf8/MazNzX4rwPbKNoizqe9EHuKFiWRsBo4AZnVm/pYWB0HM0AZdFxMfL7q8Df8nMlzs5/R3AuIjoHxH1FHfQnEdR7z8YOCUzb6XYYQ+g+AF1SkR8neIawp2ZeUK5rI3aGPUkiuqoHVuquiJiWWBXiusFUNw98vWI6FeW80iK6o5Kt1Ps2D5UjtM6KNsr61rAdyjuIupqvwUOLEMWimst92Vm61DtjAspjvTPKLsX9fn9BaiLiB0AIuJLQJsXdjPzFeAhiiPnCeX4QyPiJWB6Zl5CUWW3SVvTtyciPkKxg3241aBpFGefdRExiOKsoMUdwNHlsAEU1XQLBQLFXXPntzqaX4/iAKbSfRRnqhuU3WNbLWuv8voQFNdM7urUyi1FDIQeIjOfAL4B3BoRT1HU2y/O3SdnAS9QnA08SXEkdSzFDuV/gafL+e5cDl9jMeb9Y4oAeTIiJlPU6V/Wxjo8CmxLcTH4LxHxV4p69nUorl1AceH5NeBRits/+wFHtZrPbRRHu5MoLjq/2U7ZWurmH42IRyjq9E/KzN90duUiYkQ5/YgORr0W+D3wULktNyrXdbFl5rsUO8dxEbEui/j8yvG+DJxVVoXsCvyrnVlfQ1Ff/6NyOa9TbPO7ys/ufOAQgIg4PCImtDOvlmsIjwJ/oLjWdHercW6kCIVnKb5nf6gYNp6iavJxiu/h4xRVOa2dRbFd74+IpyLiGYozka9WjpSZ0yhuTb2x/Kw/XjHsToqL8r+LiL+U4+2aHdzqvLSps/lrSRJ4hiBJKhkIkiTAQJAklQwESRJgIEiSSgaCJAnoBY3blU9y3g/slIto7rd8MvP6il7DKNqVWbfa5ZOknqJHB0IUTe5eA6zV3njlA1Ejy2mWo3ha8/AqF0+SepQeHQgUT1QeCdzQ0iMi9gO+SVEdNhk4MjPnVExzEvCHzPxTDcspSR94veJJ5SjepLU1xWPwVwGfLdtMPw+Y3fKSk7L99WeA9TKzvcf7JWmp09PPEFrbhqKxtgciAoqWFSsbwNoH+JVhIEkL622B0Ae4OTPHA5Rv8qpcxy8D53ZDuSTpA6+33XZ6L/CViPhI2bzylRTXE1reUbsx8H/dVjpJ+gDrVYGQmY9RtB9/N/BXijOG88vBw4B5rS4wS5JKveKisiRpyfXUawgDKN7qNJX5b9qSJLWvDzCc4s12C73Jr6cGwia0/8JySdKibUnxDuwF9NRAmAowY8Zsmpqs8pKkzqivr2PIkIFQ7kNb66mB0AjQ1NRsIEjS4muzqr1X3WUkSXr/DARJEmAgSJJKPfUagqReorGxgRkzptHQMK+7i9Jr9O3bnyFDhtGnz+Lt4g0ESd1qxoxpLLPMcgwcuDJ1dXXdXZwer7m5mdmz32LGjGkMHTp8saa1ykhSt2pomMfAgYMNgy5SV1fHwIGD39cZl4EgqdsZBl3r/W5PA0GSBBgIkrSQp59+klNOOb7NYccf/01uu+3WGpeoNgwESWpl7bXX4eyzL+juYtScdxlJWqq9/fbbnHvuGbz88kvU19cR8Um23/7zXHLJ97jhhpt5/fVpnH32abz++uusvPLKzJgx471pX3jheS699ELefPNNmpqa2H33r7HTTrt049osGQNB0lLtvvvu4e233+b66yfS2NjIhReex6uvvvLe8Isu+i6f+tR6HHLI13n55Zc44IC9AWhoaOCUU07gO985k4i1mTVrFocffgCrr/4J1l13ve5anSViIEhaqq2//kh++MP/Yty4Q9lkk9Hsscde/Pvf888CJk16iHHjvgnARz/6MTbaaBQAL730D1599WXOO+/M98adO3cuzz6bBsLSasgK/enbf0DVl9Mwby4z3vRJTqmrjRixCv/zP79kypTJTJ78MEcffQTHHXfye8Pr6uqofLNky9O/TU1NDBy4PNdfP/G9YW+8MZ2BA5evXeG7mIGwhPr2H8DkCw6u+nI2Pn4CYCBIXe2Xv/wZjz02hdNOO5vRoz/NjBlv8MwzT783fPToT3PLLb/giCOO4rXXXuORRyaxxRb/yaqrrsaAAQO4447b+Pznd+Cf/3yNgw7ah3PPvZD11x/ZfSu0BAwESUu1L3xhR6ZMmcw+++zBgAHLsNJKK/Mf/7Em99zzewCOOeYEzjvvDMaM2Z1hwz7CmmuuBUC/fv0477yLuPTSC5k48cc0NDRw8MGH99gwAKirPBXqQVYHnp8+fVa3vyBn2LBBNTtDmDZtZtWXI9Xaa6+9yMorr9bdxeh12tqu9fV1rLji8gAfB15oPY3PIUiSAANBklQyECRJgIEgSSoZCJIkwECQJJV8DkHSB8qgwcuwzIB+XT7fOXPfZeZbc9od55FHJnHCCUezyiofo7m5mYaGd9lll9346lf3AmD33XfmBz+4muHDRyxRWR55ZBJXX30Fc+bMobGxkc03/wyHHTaOPn36cP75Z/HlL+/G2muvs8A055xzOhtuuDE77LDzEi27PQaCpA+UZQb0Y+/jb+zy+U68YAwzaT8QACI+yeWX/xCAt9+ezT77fJVNNhnNxz/+iS4px7x58zjjjFO48sprGTFiFd59911OPvl4fvGLn7LHHnty4onf6ZLlvB8GgiQtwty5c6mvr2f55Rdsn+i2225lypTJnHzy6QCMG3coBx54KBttNIobbriee+75HY2NTYwevRlf//r4BV5pOWfOHGbPnsWcOe8AxRPPRx11LO+8884C89pww425/PKL+fOf/8TQoUNpampiww03BuD22/+Xn/70JpqamolYm2OOOYEBA5a8TTUDQZIqZD7F2LF709zcxMsvv8S2236WoUOHdWraBx64n8ynuOaaH1NXV8dZZ53KnXfezuc/v8N74wwePJh99z2AAw/ch9VWW50NNxzFNttszwYbjFxgXvfeexfPPJP85Cc3M3PmTMaO3ROAv//9b9x666+48srrGDBgAFdddTk33XQDY8cueYsJBoIkVaisMpo9exbHHjuen/zkevbd94AOp5006SGefPIJDjpoXwDmzp3DSiutvNB4++9/ELvsshsPP/wADz/8IN/61ngOOeRwvvrVvd8bZ8qUyWy11Tb07duXIUOGsNlmnyn7T+Lll1/isMOK8jQ0vMtaa629xOsNBoIkLdLAgcuz7bafZdKkBxfo37pJ7MbGBgCamhr56lf3Ys899wFg5syZ9OnTZ4Fpn3jicZ555ml23XUPPvvZL5T/Ps+ll35/gUAoljF/upb5NDY2se222/PNbx4HFG98a2xs7JL19bZTSVqExsZGpkyZvNAR+AorfIgXX3ye5uZmXn31FZ577jkANtpoE+644zbefvttGhoaOOmkY7n33rsWmHbw4MFcd90PefbZZ97rl/k0a60VC4w3atSm3H3375g3bx5vvfUWDz74fwBsuOHG3HffvcyY8QbNzc1cdNF53HzzRLqCZwiSVKHlGkJdXfGazDXWWIsxY/ZfYJxRozblN7/5NXvttRurrbbae01eb7HFf/Lcc89w6KFjaWpqZPTozfniF3daYNpVV12Nk08+jfPPP4vZs2dRV1fHOut8iqOPPn6B8bbccmueeupJ9tvva3z4wyuy+urFXU5rrrkWBxxwCOPHH05zczNrrLEW++wztkvW3eavl5DNX0tLpnUzzd35HEJv8n6av/YMQdIHysy35nTqeQF1Pa8hSJKAKp8hRMRg4H5gp8x8odWwkcAEYDBwH3B4ZjZUszySpEWr2hlCRIwG/gSstYhRfgKMy8y1gDrgkGqVRZLUsWpWGR0CHAm82npARKwGLJuZD5S9rgf2qGJZJEkdqFqVUWYeDBARbQ0eAUyt6J4KfHRxl1FeLV9qDBs2qLuLIHW5f/2rnr59vZzZ1err6xd7n9FddxnVA5X3i9YBTYs7kw/Kbae14m2n6o2amppoaJj/8x+yQn/69l/yhtpaa5g3lxlvzuvy+X5QNTU1LbTPqLjttE3dFQgvA8MrulemjaolSUufvv0HVOXZno2PnwC0HwhTp77KXnvt+t5DYM3NTcyePZsvfnEnDjrosE4v69prrwZYaJrnnnuWyy67iDfffJPGxkbWXXc9jjrqWyy77LJMmHAVa6/9SbbYYqtOzasauiUQMvPFiJgTEZ/JzD8D+wK3d0dZJKnS0KHDuP76+U1BvP76NPbc8ytst93nWH31jy/RvE877SROOulU1l13fZqamvj+97/LhAlX8o1vHMPBBx++pEVfYjUNhIi4DTg1MycBY4BryltTHwEuq2VZJKkzXn/9dZqbm1luueUAFvm+g4kTf8wtt/ySFVb4EIMGDeKTn/zUQvOaPn06c+YUD93V19dzwAGHMHVqcTm18o1oi5rXAw/cz7XXXkVDQwPDh6/CCSeczAorfKjL1rXqgZCZq1f8vUPF348Bm1Z7+ZK0OF5/fRpjx+7NvHlzefPNf7P22p/i3HMv5CMfWWmR7ztYbbXV+c1vbuG6626krq6Oww8/oM1AGD/+GE488RiGDh3GhhuOYsstt2LzzbdYYJynn36yzXnNmDGDq666nMsuu4rBgwfzq1/9nCuv/EGXvmHNpiskqUJLlVFTUxOXX34xL7zwPJtsMhpY9PsOpk+fzmabfea9s4htttm+zSapd9hhZ7beelsefvghJk16iHPPPZ3PfvaLHHXUse+N88gjk9uc15NPPsE///ka48cXVUtNTY0MHrxCl667gSBJbaivr+eII47igAP25qabbmDMmP0X+b6DX//6F1TeONmnT5+FAuGll/7BXXfdydixB7PVVtuw1VbbsMcee3LggWMWCITidZsLz6upqZH119+A7373YqB4vWfLaze7bJ27dG6S1Iv07duXI4/8Jtdffy3Tp7++yPcdjBq1CX/+8x+ZNWsWc+fO5b777lloXh/60BB++tObmDz54ff6Pftssuaard+D0Pa81llnXf7618f5xz9eBOD66ydwxRWXdO36duncJGkJNcybW94i2vXzfT8222xz1l13PSZMuIoTTjilzfcd1NXVsccee3HwwfsxaNAgVlpp+ELzGTRoEBdccClXXnkZ559/Nv369WXVVVfj9NPPWWC8NdeMNue14opDOfHEUzn11JNoampk2LCVOPXUM9/XOi2K70NYQr4PQVoybbXbryXn+xBK1XrBhiT1Zr0yEJYZ0I+9j7+xJsuaeMGYmixHkqrNi8qSul0Prbr+wHq/29NAkNSt+vbtz+zZbxkKXaS5uZnZs9+ib9/+iz1tr6wyktRzDBkyjBkzpjFr1r+7uyi9Rt++/RkyZNjiT1eFskhSp/Xp05ehQxe+TVO1ZyBIqppqvdugLUvb+w6qwUCQVDXVerdBWzrzvgO1z4vKkiTAQJAklQwESRJgIEiSSgaCJAkwECRJJQNBkgQYCJKkkoEgSQIMBElSyUCQJAEGgiSpZCBIkgADQZJUsvnrXm7Q4GVYZkC/mixrztx3mfnWnJosS1LXMxB6uWUG9GPv42+sybImXjCGmRgIUk9llZEkCTAQJEklA0GSBBgIkqSSF5W11KjVHVfebaWeykDQUqNWd1x5t5V6KquMJEmAgSBJKhkIkiTAQJAklbyoLHWxpoZ3GTZsUE2W1TBvLjPenFeTZan3MxDUZWq1I/yg7wTr+/Zj8gUH12RZGx8/Afjgbgv1LAaCukytdoTuBJdcLVvBVc9hIEhLoVo+k6Gew4vKkiTAQJAklQwESRJgIEiSSgaCJAmo8l1GEbE3cArQD7gkM69oNXwj4GqgP/ASsE9m/ruaZZIkta1qZwgRsQpwDrAFMBI4NCLWaTXapcCpmbkBkMC3qlUeSVL7qllltD1wd2a+kZmzgZ8Bu7capw8wuPx7OeCdKpZHktSOalYZjQCmVnRPBTZtNc4xwJ0RcQkwGxi9OAtYccXll6R8PU6t2sfpCdwW87kt5nNbLJlqBkI90FzRXQc0tXRExLLAtcD2mflQRBwD/BjYsbMLmD59Fk1NzQv1761fimnTZi72NG6L+dwW87ktlk719XXtHkhXs8roZWB4RffKwKsV3esC72TmQ2X31cDWVSyPJKkd1QyE3wPbRcSwiFgO2A34bcXw54CPRUSU3bsAD1exPJKkdlQtEDLzFeBk4B7gUWBiWTV0W0SMyswZwFjg5oj4C3AgcEC1yiNJal9Vn0PIzInAxFb9dqj4+3bg9mqWQZLUOT6pLEkCDARJUslAkCQBBoIkqWQgSJIAA0GSVDIQJEmAgSBJKlX1wTRJ+qAbNHgZlhnQr+rLmTP3XWa+Nafqy1kSBoKkpdoyA/qx9/E3Vn05Ey8Yw0w+2IFglZEkCTAQJEklA0GSBBgIkqSSgSBJAgwESVLJQJAkAQaCJKlkIEiSAANBklQyECRJgIEgSSoZCJIkwECQJJUMBEkSYCBIkkoGgiQJMBAkSSUDQZIEGAiSpJKBIEkCDARJUslAkCQBBoIkqWQgSJIAA0GSVDIQJEmAgSBJKhkIkiTAQJAklQwESRJgIEiSSgaCJAkwECRJpb7dXQBJWho0NbzLsGGDarKshnlzmfHmvMWezkCQpBqo79uPyRccXJNlbXz8BGDxA8EqI0kSYCBIkkpVrTKKiL2BU4B+wCWZeUWr4QFcDQwBXgP2zMwZ1SyTJKltVTtDiIhVgHOALYCRwKERsU7F8DrgFuD8zNwAmAKcWK3ySJLaV80qo+2BuzPzjcycDfwM2L1i+EbA7Mz8bdl9LnAFkqRu0W6VUUTs197wzPxxO4NHAFMruqcCm1Z0rwG8FhHXAhsCTwHfaLe0kqSq6egawh7l/ysDawN3Aw3ANhRVPO0FQj3QXNFdBzS1WvbWwH9m5qSIOAv4PjC2k2VnxRWX7+yovUKt7mHuCdwW87kt5nNbzPd+tkW7gZCZOwNExG8oLvj+rexeFbimg3m/DGxZ0b0y8GpF92vAs5k5qey+iaJaqdOmT59FU1PzQv1765di2rSZiz2N22I+t8V8bov5lqZtUV9f1+6BdGevIazaEgYAmfkP4KMdTPN7YLuIGBYRywG7Ab+tGH4/MCwiNii7dwYmd7I8kqQu1tnbTqdGxBnA9RRVP4cCf29vgsx8JSJOBu4B+gMTMvOhiLgNOLWsJvoKcE1EDKQ4o9j3fa6HJGkJdTYQ9gf+C3iM4rrA7cABHU2UmROBia367VDx94MseKFZktRNOhUImTkV+EqVyyJJ6kYd3Xb6OAveKbSAzFy/y0skSeoWHZ0hjKtJKSRJ3a6j207/0PJ3RIwGvkDRLtHvKodJknq+Tt12GhH7UjwjMAQYDEyMiEOqWTBJUm119i6jY4BNy4vLRMT5wJ10/HCaJKmH6OyDafUtYQCQma8CjdUpkiSpO3Q2EKZHxC4tHeUDZb63QJJ6kc5WGY0DbomIyyluQ30X+HK1CiVJqr0OAyEiPkpRPRTAzcAKFE1VP1vdokmSaqndKqOI2BR4BBiVmY3A+sAfKcLhyOoXT5JUKx1dQzgL+Fpm3lh2z8zMM4BDgD2rWjJJUk11FAifyMx7KrrrADLzReDDVSuVJKnmOgqEua26K1948++uLYokqTt1FAizyovKAGTmLICI+BjwdjULJkmqrY4C4YcUzVR8pKVHRAwB/pvi/QiSpF6io8btrouINYDnI+JJimcQ1gYuzcybalFASVJtdPgcQmZ+OyIuAT5NcVH5wcpmLCRJvUNn35j2L+DXVS6LJKkbdbYtI0lSL2cgSJIAA0GSVDIQJEmAgSBJKhkIkiTAQJAklQwESRJgIEiSSgaCJAkwECRJJQNBkgQYCJKkkoEgSQIMBElSyUCQJAEGgiSpZCBIkgADQZJUMhAkSYCBIEkqGQiSJMBAkCSVDARJEmAgSJJKBoIkCTAQJEklA0GSBBgIkqRSVQMhIvaOiCcj4tmIOLKd8XaMiOerWRZJUvuqFggRsQpwDrAFMBI4NCLWaWO8lYALgbpqlUWS1LFqniFsD9ydmW9k5mzgZ8DubYw3ATijiuWQJHVCNQNhBDC1onsq8NHKESJiPPAI8EAVyyFJ6oS+VZx3PdBc0V0HNLV0RMS6wG7AdrQKis5accXll6R8Pc6wYYO6uwgfGG6L+dwW87kt5ns/26KagfAysGVF98rAqxXdewDDgUlAf2BERPwxMyunadf06bNoampeqH9v/VJMmzZzsadxW8zntpjPbTHf0rQt6uvr2j2QrmYg/B44PSKGAbMpzgYObRmYmacBpwFExOrAvYsTBpKkrlW1awiZ+QpwMnAP8CgwMTMfiojbImJUtZYrSXp/qnmGQGZOBCa26rdDG+O9AKxezbJIktrnk8qSJMBAkCSVDARJEmAgSJJKBoIkCTAQJEklA0GSBBgIkqSSgSBJAgwESVLJQJAkAQaCJKlkIEiSAANBklQyECRJgIEgSSoZCJIkwECQJJUMBEkSYCBIkkoGgiQJMBAkSSUDQZIEGAiSpJKBIEkCDARJUslAkCQBBoIkqWQgSJIAA0GSVDIQJEmAgSBJKhkIkiTAQJAklQwESRJgIEiSSgaCJAkwECRJJQNBkgQYCJKkkoEgSQIMBElSyUCQJAEGgiSpZCBIkgADQZJUMhAkSYCBIEkqGQiSJAD6VnPmEbE3cArQD7gkM69oNXwX4AygDngeOCAzZ1SzTJKktlXtDCEiVgHOAbYARgKHRsQ6FcMHA1cCO2bmBsBfgNOrVR5JUvuqWWW0PXB3Zr6RmbOBnwG7VwzvBxyZma+U3X8BVq1ieSRJ7ahmldEIYGpF91Rg05aOzJwO/BIgIpYFTgR+sDgLWHHF5Ze8lD3IsGGDursIHxhui/ncFvO5LeZ7P9uimoFQDzRXdNcBTa1HiogVKILhscz80eIsYPr0WTQ1NS/Uv7d+KaZNm7nY07gt5nNbzOe2mG9p2hb19XXtHkhXs8roZWB4RffKwKuVI0TEcOCPFNVFB1exLJKkDlTzDOH3wOkRMQyYDewGHNoyMCL6ALcCN2fm2VUshySpE6oWCJn5SkScDNwD9AcmZOZDEXEbcCrwMWAjoG9EtFxsnpSZnilIUjeo6nMImTkRmNiq3w7ln5PwwThJ+sBwhyxJAgwESVLJQJAkAQaCJKlkIEiSAANBklQyECRJgIEgSSoZCJIkwECQJJUMBEkSYCBIkkoGgiQJMBAkSSUDQZIEGAiSpJKBIEkCDARJUslAkCQBBoIkqWQgSJIAA0GSVDIQJEmAgSBJKhkIkiTAQJAklQwESRJgIEiSSgaCJAkwECRJJQNBkgQYCJKkkoEgSQIMBElSyUCQJAEGgiSpZCBIkgADQZJUMhAkSYCBIEkqGQiSJMBAkCSVDARJEmAgSJJKBoIkCTAQJEklA0GSBBgIkqRS32rOPCL2Bk4B+gGXZOYVrYaPBCYAg4H7gMMzs6GaZZIkta1qZwgRsQpwDrAFMBI4NCLWaTXaT4BxmbkWUAccUq3ySJLaV80zhO2BuzPzDYCI+BmwO3Bm2b0asGxmPlCOfz1wBnBlJ+bdB6C+vm6RIwwdMvD9lnux9R+8Yk2W0976tsdtMV+ttkWttgO4LSq5LeZra1tU9OvT1jR1zc3NVSlMRJwEDMzMU8rug4FNM/PQsvvTwPcyc4uyew3gtvJsoSNbAH+sSsElqffbEvhT657VPEOoByrTpg5oWozh7XmYYoWmAo1LUEZJWpr0AYZT7EMXUs1AeJlip91iZeDVVsOHtzO8PXNpI90kSR3626IGVPO2098D20XEsIhYDtgN+G3LwMx8EZgTEZ8pe+0L3F7F8kiS2lG1QMjMV4CTgXuAR4GJmflQRNwWEaPK0cYAF0fE08DywGXVKo8kqX1Vu6gsSepZfFJZkgQYCJKkkoEgSQIMBElSqaqN2/VkEbE7cBLFNqoHfpyZ34uIF4CtM/OFcrzjgLHAtsAd5eQrl/+/Vv6/XWZOr03Ju1Y722FV4ApgtbL/kxTtUv2rnG4ocD6wNfAu8A5wembeUvOVqIGI2Jpi/bau6HcIMCszb+quctVCRIyl+E2MLbt/DqyZmeu3Gm8gRfM0u1B8J5qBizNzQk0L3MUiYnXgGYrfQKXJFM9ibZCZ75Tjbk3F9yQiNqNo820oxUNj9wHHtoxfa54htKFsmO8i4HOZuQHwaWDPiPhSq/GOpnh+YpvM/GdmjszMkcBVwFUt3T04DNrbDldT3Eq8fmauC0yhWG8iYgDF7cb/ACIzPwnsBfwgItZvY1G91WeAAd1diFoqDwQ2BGZFxOatBv8CGASsl5nrULR3Nj4idqxxMavh1Yrfe8t+4CWKA6Zz25qg/C38Evh2+fsaSdFiww9rU+SFGQhtG0rRZPdyAJk5C9ifiiOAiBgP7Ads23JU3Au1tx1Wbulfurz8B8VDiO9k5pmZ2VhOm8DXWQrOSiPiqIj4E/Al4MyI+Hx3l6mGxlAc5f4cOLylZxkOn6I4i5wDkJlTgcMozh57qx8CX4uILdoYdhxwbWY+CFA2/X8C8KvaFW9Bvf7H+X5k5mMR8Wvg7xExheJod2JmPhcRAEcA3wIOyszXu7GoVdXBdjgJuDEizgDuonjK/KflpJtR7BRaz++2GhW925TVJ7sBX6AIyHsz8452J+pdDgC+DTwOnBUR3yxbPN4MeCAz360cOTP/rxvKWA0jIuLRiu4by/+nU+wvrouIDVpNsyHFGcJ7MvMtijDtFp4hLEJmfh1YnaI57tWAByJi13LwNsBOQEtdeq+1qO2Qmb8FVgEOBqYBF7DgF/m9Jx4j4vyIeDQiMiIurVnha29d4Brg0vJsaqlSvvDqo8DvMvMlimrE/StGqfxOjC+/E09GxC9qW9KqaF1l9L2WAZn5K2ASC1cdNQFzaljGDhkIbYiIHSPia5n5Smb+d2buCYwHDipHGVMe7V4NTIyINtsW7+na2Q6HRMTFmTknM3+bmd8C1gM+FxHDKFpSbGmjisw8saxTPQ9YoRtWpVZmArtSHCjU7iUU3SAitoyIEWVnHdAAHEhxzeTZ8uaLtSmqhKD4Toxu+a1k5mXld+II4MM1LHp3+QbwNYqm+1tMAkZVjhQRgyPi1ojoX8vCtTAQ2vY2cF559wARUUdxwWdKOXxe+f/pwLLAqbUtXs0sajs8CnwpIvarGHcd4J/AG8DNwHIRcXJE9CunXYHizKo3N1f+YmbeCtxL8SKoBnpvteyBwJfLv9enuIFgb2D7zFw9M1cHPg4ML++s+RPwV4obC5YFKP//Ar37OwFAeWPJEcB3KnpfDBwREZsClL+Vi4A3M3PewnOpPgOhDZl5D8Xtcf8bEQk8TfGlPavVeO8C+wDHRsR/1rygVdbOdjgd2IHiYtmLEfEUcDawc2Y2ZuZcip3/CODRiPgr8CBFk+fH1H5Nau44iourfwe+Xd6629ucB+xffvbrAk9RBOKDLSOU9eETKN6V3gx8BZgBPBQRj1NcZ1iO4jfU65VVRz+r6H6cYt0vjYjHgL9QVCF126uEbdxOkgR4hiBJKhkIkiTAQJAklQwESRJgIEiSSr31HmnpfYmIy4CWW4jXAZ5nfls7n+6uViilWvC2U2kRyqdtd8/MSd1dFqkWPEOQOiEiDqJ40rSeosGycZn5dESsRfFeiEHAcIqnuL+WmXMiYg7wfYpmnpeneKBvD4pmPl6leJBvdtlA4FconoCfDowtWwKVasprCFIHImIrikbatszMDSka8mtppfIQ4EeZuRmwBkVzDS3t+w8AXsvMTYEfUTy1+02KqqgVgF0i4mNlv00ycxRwJzC6BqslLcQzBKljO1Ls7O8vmz8HGBIRH6Zov/6zEXE8sBZFcx3LV0zb0gLs34DHM/MVgIh4nqJRt1eAx4BHIuJ24PbMvKvK6yO1yTMEqWN9gBsq3oS1EUUrlTOAm4BDgRcpGit7hKL1zxZzK/5e4F0AAJnZBGxF8RrW6cDFEXFB16+C1DEDQerYHcBeETG87D6c4qVAAJ8HzszM/1d2j6YIkE4pX5ryBPBUZp5HESqbdEmppcVklZHUgcy8MyK+C/wuIpqAt4BdM7M5Ir4N/DIiZgNvAn+gqF7q7Lwfi4ibgUkRMYviFtfxXb8WUse87VSSBFhlJEkqGQiSJMBAkCSVDARJEmAgSJJKBoIkCTAQJEklA0GSBMD/Bzedb9ocg6SwAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(6,6))\n",
    "\n",
    "sns.set_theme(style=\"darkgrid\")\n",
    "\n",
    "sns.barplot(x=\"Teams\", y=\"Gold\",hue=\"side\",data=g1)\n",
    "plt.title('5 Teams Gold Diff. for Red vs. Blue Side\\n')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It seems that out of top 5 team who earned the most gold when on the blue side, **SKT** and **JAG** team are the only one who turned out to be earning more gold on the red side. Let's see how many teams are actually earning more gold on the red side compared to blue."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "comp = lol1.groupBy('blueTeamTag').sum(\"goldblue\")\\\n",
    "            .orderBy('sum(goldblue)', ascending=False)\\\n",
    "            .withColumnRenamed(\"sum(goldblue)\", \"bGold\")\\\n",
    "            .withColumnRenamed(\"blueTeamTag\", \"Teams\")\n",
    "\n",
    "comp1 = lol1.groupBy('redTeamTag').sum(\"goldred\")\\\n",
    "                .orderBy('sum(goldred)', ascending=False)\\\n",
    "                .withColumnRenamed(\"sum(goldred)\", \"rGold\")\\\n",
    "                .withColumnRenamed(\"redTeamTag\", \"Teams\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "compare_gold = comp.join(comp1, on=['Teams'], how='outer')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "244 Total Teams, and 108 teams earned more gold on red side\n"
     ]
    }
   ],
   "source": [
    "rg = compare_gold.filter('bGold < rGold').count()\n",
    "bg = compare_gold.filter('bGold > rGold').count()\n",
    "a = compare_gold.select(\"Teams\").distinct().count()\n",
    "\n",
    "print(f\"{a} Total Teams, and {rg} teams earned more gold on red side\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, out of **244** teams, **108** teams have actually earned more gold on red side of the map than compared to the blue side of the map."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data=[rg,bg]\n",
    "\n",
    "labels=['Blue Team Gold', 'Red Team Gold']\n",
    "\n",
    "plt.pie(data, autopct = '%0.0f%%',labels=labels)\n",
    "# plt.legend()\n",
    "plt.title('Team Gold Blue vs. Red Side')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 4\n",
    "Total Kills and Total Objective taken. \n",
    "\n",
    "Objectives include Turrets, Inhibitors, Dragons, Barons and Heralds\n",
    "\n",
    "- Dragons, Barons and Heralds are Giant Monster which grants special rewards\n",
    "- Turrets and Inhibitors are structures defending your respective team side."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "blue_side_kills = lol1.groupBy().sum('bKills').withColumnRenamed(\"sum(bKills)\",\"Kills\").toPandas()\n",
    "red_side_kills = lol1.groupBy().sum('rKills').withColumnRenamed(\"sum(rKills)\",\"Kills\").toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = pd.concat([blue_side_kills,red_side_kills],0).reset_index(drop=True).set_index(pd.Index(['Blue','Red']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "blue_obj = lol1.withColumn(\"Total Objective\", lol1.bTowers + lol1.bInhibs + lol1.bDragons \n",
    "                           + lol1.bBarons + lol1.bHeralds)\\\n",
    "                            .select('Total Objective')\n",
    "\n",
    "red_obj = lol1.withColumn(\"Total Objective\", lol1.rTowers + lol1.rInhibs + lol1.rDragons \n",
    "                          + lol1.rBarons + lol1.rHeralds)\\\n",
    "                            .select('Total Objective')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "bObj = blue_obj.groupBy().sum('Total Objective').withColumnRenamed('sum(Total Objective)','Objective').toPandas()\n",
    "rObj = red_obj.groupBy().sum('Total Objective').withColumnRenamed('sum(Total Objective)','Objective').toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = pd.concat([bObj,rObj],0).reset_index(drop=True).set_index(pd.Index(['Blue','Red']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set_style(\"darkgrid\")\n",
    "# fig, axes = plt.subplots(1, 2, figsize=(12,5))\n",
    "sns.barplot(x=c.index, y='Kills',data=c).set(title='Kills Count for Blue and Red')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set_style(\"darkgrid\")\n",
    "\n",
    "sns.barplot(x=d.index, y='Objective',data=d).set(title='# of Objectives Taken for Blue and Red')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Both Blue and red side are about equal in number kills and objectives taken. This also proves that both red and blue side of the map are designed equally for the team to play. It's just the players preference on their play style that shows little advantage for the blue side."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task  5\n",
    "Compute CDF for the game length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':'Game Length CDF'}, xlabel='gamelength', ylabel='Proportion'>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 8))\n",
    "cdf = lol.select('gamelength').toPandas()\n",
    "g = sns.ecdfplot(data=cdf, x=\"gamelength\")\n",
    "g.set_yticks(np.arange(0, 1.2, .1))\n",
    "g.set(title='Game Length CDF')\n",
    "g"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Things to note from the graph above:\n",
    "\n",
    "    - 90% of the game lasts for about 50 minutes or less in game time\n",
    "    - 10% of games that lasts for more than 50 minutes\n",
    "    - 10% of games end before 30 minutes\n",
    "    \n",
    "It's a good thing that we only kept data for games that lasted for 30 minutes or more, because that's when we get to see the players full potential with champions and team plays. Games ending before 30 minutes are usually result of one team dominating early game."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 6\n",
    "\n",
    "What is number of Wins and Losses for each League?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "lost = lol1.groupby('League','Winner').count().filter('Winner != 0').select('League','count').toPandas()\n",
    "won = lol1.groupby('League','Winner').count().filter('Winner == 0').select('League','count').toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "bar = won.merge(lost,on='League')\n",
    "bar['total']=bar['count_x']+bar['count_y']\n",
    "bar = bar.sort_values('total',ascending=False).reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(6, 6))\n",
    "\n",
    "sns.set_theme(style=\"darkgrid\")\n",
    "sns.set_color_codes(\"pastel\")\n",
    "g = sns.barplot(x=\"count_x\", y=\"League\", data=bar, label=\"Winners\", color=\"b\")\n",
    "\n",
    "# Plot the crashes where alcohol was involved\n",
    "sns.set_color_codes(\"muted\")\n",
    "g = sns.barplot(x=\"count_y\", y=\"League\", data=bar, label=\"Losers\", color=\"b\")\n",
    "\n",
    "g.set_xlabel(\"Count\")\n",
    "\n",
    "plt.title('Number of Wins vs. Loss for Each League')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Based on the graph above, it looks like that LCK had the most number of games played and won the most number of Tournaments, followed by NALCS and EULCS. Why is that? Maybe they have stronger teams compared to other Leagues. Let's see the teams who have won the most number of games."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "blue_t = lol1.groupby('League','blueTeamTag','Winner')\\\n",
    "            .count()\\\n",
    "            .filter('Winner == 0')\\\n",
    "            .orderBy('count',ascending=False)\\\n",
    "            .withColumnRenamed('blueTeamTag','Team')\\\n",
    "            .withColumnRenamed('count','bCount')\\\n",
    "            .select('League','Team','bCount')\\\n",
    "            .toPandas()\n",
    "\n",
    "red_t = lol1.groupby('League','redTeamTag','Winner')\\\n",
    "            .count()\\\n",
    "            .filter('Winner == 0')\\\n",
    "            .orderBy('count',ascending=False)\\\n",
    "            .withColumnRenamed('redTeamTag','Team')\\\n",
    "            .withColumnRenamed('count','rCount')\\\n",
    "            .select('League','Team','rCount')\\\n",
    "            .toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "win_count = blue_t.merge(red_t).head(10)\n",
    "win_count['total'] = win_count['bCount'] + win_count['rCount']\n",
    "win_count = win_count.sort_values('total',ascending=False).reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>League</th>\n",
       "      <th>Team</th>\n",
       "      <th>bCount</th>\n",
       "      <th>rCount</th>\n",
       "      <th>total</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>LCK</td>\n",
       "      <td>JAG</td>\n",
       "      <td>63</td>\n",
       "      <td>69</td>\n",
       "      <td>132</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>LCK</td>\n",
       "      <td>kt</td>\n",
       "      <td>76</td>\n",
       "      <td>52</td>\n",
       "      <td>128</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>LCK</td>\n",
       "      <td>SKT</td>\n",
       "      <td>77</td>\n",
       "      <td>39</td>\n",
       "      <td>116</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>LCK</td>\n",
       "      <td>SSG</td>\n",
       "      <td>55</td>\n",
       "      <td>54</td>\n",
       "      <td>109</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>NALCS</td>\n",
       "      <td>CLG</td>\n",
       "      <td>53</td>\n",
       "      <td>42</td>\n",
       "      <td>95</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>EULCS</td>\n",
       "      <td>FNC</td>\n",
       "      <td>56</td>\n",
       "      <td>36</td>\n",
       "      <td>92</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>NALCS</td>\n",
       "      <td>C9</td>\n",
       "      <td>55</td>\n",
       "      <td>37</td>\n",
       "      <td>92</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>NALCS</td>\n",
       "      <td>TSM</td>\n",
       "      <td>52</td>\n",
       "      <td>33</td>\n",
       "      <td>85</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>EULCS</td>\n",
       "      <td>H2K</td>\n",
       "      <td>49</td>\n",
       "      <td>30</td>\n",
       "      <td>79</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>LMS</td>\n",
       "      <td>ahq</td>\n",
       "      <td>52</td>\n",
       "      <td>19</td>\n",
       "      <td>71</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  League Team  bCount  rCount  total\n",
       "0    LCK  JAG      63      69    132\n",
       "1    LCK   kt      76      52    128\n",
       "2    LCK  SKT      77      39    116\n",
       "3    LCK  SSG      55      54    109\n",
       "4  NALCS  CLG      53      42     95\n",
       "5  EULCS  FNC      56      36     92\n",
       "6  NALCS   C9      55      37     92\n",
       "7  NALCS  TSM      52      33     85\n",
       "8  EULCS  H2K      49      30     79\n",
       "9    LMS  ahq      52      19     71"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "win_count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Top 10 Team by Win Count')"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "g = sns.barplot('Team','total',data=win_count,hue='League',\n",
    "                dodge=False)\n",
    "\n",
    "g.set_xlabel(\"Teams\")\n",
    "g.set_ylabel(\"# of Wins\")\n",
    "plt.title('Top 10 Team by Win Count')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Based on the graph above, Out of 10 teams, top 4 Teams are from LCK, 3 teams are from NALCS and 2 teams are from EULCS. This would explain why LCK was on top with number of Wins. \n",
    "\n",
    "SKT, and SSG have both been world Champions. SKT has been world Champion 3 times, thanks to their Star Player, Lee Sang-hyeok, better known as **Faker**, who is considered as the best player that LOL community has ever seen in the history of LOL."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Machine Learning\n",
    "\n",
    "Let's do so machine learning work now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "# drop these columns since they aren't useful in predicting game outcomes.\n",
    "final_df = lol1.drop('League','blueTeamTag','redTeamTag')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.ml.feature import VectorAssembler\n",
    "feature_assembler=VectorAssembler(inputCols=final_df.drop('winner').columns,\n",
    "                                  outputCol='all_features')\n",
    "new_df=feature_assembler.transform(final_df)\n",
    "new_df=new_df.select(['all_features','Winner'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------------+------+\n",
      "|        all_features|Winner|\n",
      "+--------------------+------+\n",
      "|[40.0,59940.0,9.0...|     0|\n",
      "|[38.0,56911.0,8.0...|     1|\n",
      "|(15,[0,1,2,3,5,8,...|     0|\n",
      "|(15,[0,1,2,3,8,9,...|     1|\n",
      "|[35.0,57109.0,14....|     0|\n",
      "|[39.0,64893.0,17....|     0|\n",
      "|(15,[0,1,2,3,5,8,...|     0|\n",
      "|(15,[0,1,2,3,8,9,...|     1|\n",
      "|[32.0,53299.0,13....|     0|\n",
      "|[52.0,76820.0,2.0...|     0|\n",
      "|(15,[0,1,2,3,8,9,...|     0|\n",
      "|(15,[0,1,2,3,5,8,...|     0|\n",
      "|[33.0,53136.0,8.0...|     0|\n",
      "|(15,[0,1,2,3,5,8,...|     0|\n",
      "|(15,[0,1,2,3,8,9,...|     1|\n",
      "|(15,[0,1,2,3,5,8,...|     0|\n",
      "|[40.0,59954.0,12....|     0|\n",
      "|[39.0,59653.0,10....|     1|\n",
      "|[49.0,70466.0,6.0...|     1|\n",
      "|[35.0,53338.0,10....|     0|\n",
      "+--------------------+------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "new_df.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "# split the dataset and set the seed to 42\n",
    "train, test = new_df.randomSplit([0.8, 0.2],seed=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------------------------------------------------------------------+------+\n",
      "|all_features                                                       |Winner|\n",
      "+-------------------------------------------------------------------+------+\n",
      "|(15,[0,1,2,3,4,5,8,9],[32.0,58555.0,13.0,7.0,1.0,3.0,45369.0,5.0]) |0     |\n",
      "|(15,[0,1,2,3,4,5,8,9],[33.0,60882.0,13.0,7.0,1.0,4.0,49966.0,4.0]) |0     |\n",
      "|(15,[0,1,2,3,4,5,8,9],[35.0,60445.0,13.0,7.0,1.0,4.0,45392.0,4.0]) |0     |\n",
      "|(15,[0,1,2,3,4,5,8,9],[37.0,68653.0,7.0,7.0,1.0,3.0,52971.0,1.0])  |0     |\n",
      "|(15,[0,1,2,3,4,5,8,10],[33.0,59805.0,13.0,7.0,2.0,4.0,47264.0,1.0])|0     |\n",
      "|(15,[0,1,2,3,4,8,10,12],[33.0,58455.0,8.0,6.0,1.0,49132.0,2.0,2.0])|0     |\n",
      "|(15,[0,1,2,3,5,6,8,9],[35.0,61029.0,15.0,6.0,3.0,1.0,53461.0,7.0]) |0     |\n",
      "|(15,[0,1,2,3,5,7,8,10],[34.0,60014.0,10.0,6.0,3.0,1.0,46303.0,2.0])|0     |\n",
      "|(15,[0,1,2,3,5,8,9],[32.0,56212.0,2.0,6.0,3.0,44007.0,1.0])        |0     |\n",
      "|(15,[0,1,2,3,5,8,9],[35.0,59620.0,4.0,5.0,3.0,50874.0,4.0])        |0     |\n",
      "+-------------------------------------------------------------------+------+\n",
      "only showing top 10 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "train.show(10,truncate=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Since its Classification Problem, we'll do Logistic Regression, Decision tree, and Random forest classifier.\n",
    "from pyspark.ml.classification import LogisticRegression\n",
    "from pyspark.ml.classification import RandomForestClassifier\n",
    "from pyspark.ml.classification import DecisionTreeClassifier\n",
    "\n",
    "# module to calculate accuracy\n",
    "from pyspark.mllib.evaluation import MulticlassMetrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "win_actual = test.select('Winner').toPandas()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr = LogisticRegression(featuresCol = 'all_features', labelCol = 'Winner')\n",
    "lrModel = lr.fit(train)\n",
    "\n",
    "predictions = lrModel.transform(test)\n",
    "\n",
    "# graphing purpooses\n",
    "preds = predictions.select('prediction').withColumnRenamed('prediction','LR_prediction').toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Accuracy of Logistic Regression is 91.50%\n"
     ]
    }
   ],
   "source": [
    "preds_and_labels = predictions.select(['prediction','Winner'])\\\n",
    "                    .withColumn('label', F.col('Winner').cast(FloatType())).orderBy('prediction')\n",
    "\n",
    "#select only prediction and label columns\n",
    "preds_and_labels = preds_and_labels.select(['prediction', 'label'])\n",
    "\n",
    "metrics = MulticlassMetrics(preds_and_labels.rdd.map(tuple))\n",
    "\n",
    "conf_matr = metrics.confusionMatrix().toArray()\n",
    "ACC = (conf_matr[0][0] + conf_matr[1][1]) / np.sum(conf_matr)\n",
    "\n",
    "print(f'The Accuracy of Logistic Regression is {ACC*100:.2f}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "confusion_matrix = pd.crosstab(win_actual['Winner'], preds['LR_prediction'], \n",
    "                               rownames=['Actual'], colnames=['Predicted'])\n",
    "sns.heatmap(confusion_matrix, annot=True,fmt='.2f')\n",
    "plt.title('Logistic Regression')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random Forest Classifier "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "rf = RandomForestClassifier(featuresCol = 'all_features', labelCol = 'Winner',numTrees=10)\n",
    "rfModel = rf.fit(train)\n",
    "predictions1 = rfModel.transform(test)\n",
    "\n",
    "# graphing purpooses\n",
    "preds1 = predictions1.select('prediction').withColumnRenamed('prediction','RF_prediction').toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Accuracy of Random Forest is 84.94%\n"
     ]
    }
   ],
   "source": [
    "preds_and_labels1 = predictions1.select(['prediction','Winner'])\\\n",
    "                    .withColumn('label', F.col('Winner').cast(FloatType())).orderBy('prediction')\n",
    "\n",
    "#select only prediction and label columns\n",
    "preds_and_labels1 = preds_and_labels1.select(['prediction', 'label'])\n",
    "\n",
    "metrics1 = MulticlassMetrics(preds_and_labels1.rdd.map(tuple))\n",
    "\n",
    "conf_matr1 = metrics1.confusionMatrix().toArray()\n",
    "ACC1 = (conf_matr1[0][0] + conf_matr1[1][1]) / np.sum(conf_matr1)\n",
    "\n",
    "print(f'The Accuracy of Random Forest is {ACC1*100:.2f}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "confusion_matrix = pd.crosstab(win_actual['Winner'], preds1['RF_prediction'], \n",
    "                               rownames=['Actual'], colnames=['Predicted'])\n",
    "sns.heatmap(confusion_matrix, annot=True,fmt='.2f')\n",
    "plt.title('Random Forest')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decision Tree Classifier "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "dt = DecisionTreeClassifier(featuresCol = 'all_features', labelCol = 'Winner')\n",
    "dtModel = dt.fit(train)\n",
    "predictions2 = dtModel.transform(test)\n",
    "\n",
    "# graphing purpooses\n",
    "preds2 = predictions2.select('prediction').withColumnRenamed('prediction','DT_prediction').toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Accuracy of Decision Tree is 87.43%\n"
     ]
    }
   ],
   "source": [
    "preds_and_labels2 = predictions2.select(['prediction','Winner'])\\\n",
    "                    .withColumn('label', F.col('Winner').cast(FloatType())).orderBy('prediction')\n",
    "\n",
    "#select only prediction and label columns\n",
    "preds_and_labels2 = preds_and_labels2.select(['prediction', 'label'])\n",
    "\n",
    "metrics2 = MulticlassMetrics(preds_and_labels2.rdd.map(tuple))\n",
    "\n",
    "conf_matr2 = metrics2.confusionMatrix().toArray()\n",
    "ACC2 = (conf_matr2[0][0] + conf_matr2[1][1]) / np.sum(conf_matr2)\n",
    "\n",
    "print(f'The Accuracy of Decision Tree is {ACC2*100:.2f}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "confusion_matrix = pd.crosstab(win_actual['Winner'], preds2['DT_prediction'], \n",
    "                               rownames=['Actual'], colnames=['Predicted'])\n",
    "\n",
    "sns.heatmap(confusion_matrix, annot=True,fmt='.2f')\n",
    "plt.title('Decision Tree')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.mllib.evaluation import BinaryClassificationMetrics\n",
    "\n",
    "# Thanks tot Alex Ross for this handy function to help us plot ROC curve\n",
    "# https://stackoverflow.com/questions/52847408/pyspark-extract-roc-curve\n",
    "\n",
    "class CurveMetrics(BinaryClassificationMetrics):\n",
    "    def __init__(self, *args):\n",
    "        super(CurveMetrics, self).__init__(*args)\n",
    "\n",
    "    def _to_list(self, rdd):\n",
    "        points = []\n",
    "        for row in rdd.collect():\n",
    "            points += [(float(row._1()), float(row._2()))]\n",
    "        return points\n",
    "\n",
    "    def get_curve(self, method):\n",
    "        rdd = getattr(self._java_model, method)().toJavaRDD()\n",
    "        return self._to_list(rdd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds = predictions.select('Winner','probability').rdd.map(lambda row: (float(row['probability'][1]), float(row['Winner'])))\n",
    "preds1 = predictions1.select('Winner','probability').rdd.map(lambda row: (float(row['probability'][1]), float(row['Winner'])))\n",
    "preds2 = predictions2.select('Winner','probability').rdd.map(lambda row: (float(row['probability'][1]), float(row['Winner'])))\n",
    "\n",
    "points = CurveMetrics(preds).get_curve('roc')\n",
    "points1 = CurveMetrics(preds1).get_curve('roc')\n",
    "points2 = CurveMetrics(preds2).get_curve('roc')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fe1de7fbfd0>"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x_val = [x[0] for x in points]\n",
    "y_val = [x[1] for x in points]\n",
    "\n",
    "x_val1 = [x[0] for x in points1]\n",
    "y_val1 = [x[1] for x in points1]\n",
    "\n",
    "x_val2 = [x[0] for x in points2]\n",
    "y_val2 = [x[1] for x in points2]\n",
    "\n",
    "plt.title('ROC')\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.plot(x_val, y_val, label='LR')\n",
    "plt.plot(x_val1, y_val1,label='RF')\n",
    "plt.plot(x_val2, y_val2,label='DT')\n",
    "plt.legend()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, out of the three models that we picked. **Logistic Regression** Is the Best Performing model with **91.50%** accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ML with GridSearch in SkLearn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.model_selection import GridSearchCV,train_test_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [],
   "source": [
    "grid_df = lol1.drop('League','blueTeamTag','redTeamTag')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----------+--------+------+-------+-------+--------+-------+--------+-------+------+-------+-------+--------+-------+--------+------+\n",
      "|gamelength|goldblue|bKills|bTowers|bInhibs|bDragons|bBarons|bHeralds|goldred|rKills|rTowers|rInhibs|rDragons|rBarons|rHeralds|Winner|\n",
      "+----------+--------+------+-------+-------+--------+-------+--------+-------+------+-------+-------+--------+-------+--------+------+\n",
      "|        40|   59940|     9|      6|      1|       0|      0|       0|  55254|     5|      3|      0|       2|      0|       0|     0|\n",
      "|        38|   56911|     8|      5|      0|       2|      0|       0|  53185|     7|      5|      0|       1|      0|       0|     1|\n",
      "|        40|   68928|    15|      6|      0|       2|      0|       0|  55004|     7|      1|      0|       0|      0|       0|     0|\n",
      "+----------+--------+------+-------+-------+--------+-------+--------+-------+------+-------+-------+--------+-------+--------+------+\n",
      "only showing top 3 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "grid_df.show(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To do GridSearch with PySpark DataFrame, we have to create multiple copies of same data, hence the code below with replication_df dataframe. Currently, I don't have access to a cluster, so we won't see much speed advantage but the speedup factor certainly depends on how many nodes you have in your cluster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [],
   "source": [
    "replication_df = spark.createDataFrame(pd.DataFrame(list(range(1,50)),columns=['replication_id']))\n",
    "replicated_train_df = grid_df.crossJoin(replication_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.sql.types import *\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.tree import DecisionTreeClassifier\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Funciton was adapted from \n",
    "# https://towardsdatascience.com/100x-faster-randomized-hyperparameter-searching-framework-with-pyspark-4de19e44f5e6\n",
    "# 0. Declare the schema for the output of our function\n",
    "\n",
    "outSchema = StructType([StructField('replication_id',IntegerType(),True),\n",
    "                        StructField('classifier',StringType(),True),\n",
    "                        StructField('means',FloatType(),True),\n",
    "                        StructField('stds',FloatType(),True)\n",
    "                       ])\n",
    "\n",
    "\n",
    "# decorate our function with pandas_udf decorator\n",
    "@F.pandas_udf(outSchema, F.PandasUDFType.GROUPED_MAP)\n",
    "def run_model(pdf):\n",
    "    \n",
    "    # 1. Get randomized hyperparam values\n",
    "    pipe = Pipeline(steps=[('classifier',LogisticRegression())])\n",
    "    param_grid=[\n",
    "       {\n",
    "\n",
    "           'classifier':[LogisticRegression()]\n",
    "        },\n",
    "        {\n",
    "            'classifier':[RandomForestClassifier()],\n",
    "            'classifier__n_estimators':[10,20],\n",
    "            'classifier__criterion':['gini','entropy'],\n",
    "            'classifier__max_features':['auto','sqrt','log2']\n",
    "        },\n",
    "        {\n",
    "            'classifier':[DecisionTreeClassifier()],\n",
    "            'classifier__criterion':['gini','entropy'],\n",
    "            'classifier__max_features':['auto','sqrt','log2']       \n",
    "        }\n",
    "    ]\n",
    "    \n",
    "    # 2. Train test split\n",
    "    X = pdf[['gamelength',\n",
    "             'goldblue','bKills','bTowers','bInhibs','bDragons','bBarons','bHeralds',\n",
    "             'goldred','rKills','rTowers','rInhibs','rDragons','rBarons','rHeralds'\n",
    "            ]]\n",
    "    y = pdf['Winner']\n",
    "    Xtrain,Xcv,ytrain,ycv = train_test_split(X, y, test_size=0.33, random_state=42)\n",
    "    \n",
    "    # 3. Create model using the pandas dataframe\n",
    "    clf = GridSearchCV(pipe,param_grid=param_grid,n_jobs=-1)\n",
    "    best = clf.fit(Xtrain,ytrain)\n",
    "    \n",
    "    # 4. Evaluate the model\n",
    "    means = best.cv_results_['mean_test_score']\n",
    "    stds = best.cv_results_['std_test_score']\n",
    "    \n",
    "    classes=[]\n",
    "    for j in best.cv_results_['params']:\n",
    "        print(str(j['classifier']).split('(')[0]+\"()\")\n",
    "        classes.append(str(j['classifier']).split('(')[0]+\"()\")\n",
    "        \n",
    "     # 5. return results as pandas DF\n",
    "    replication_id = pdf.replication_id.values[0]\n",
    "\n",
    "    res = pd.DataFrame({'replication_id':replication_id,'classifier':classes,'means':means,'stds':stds})\n",
    "    \n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [],
   "source": [
    "results = replicated_train_df.groupby(\"replication_id\").apply(run_model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------+--------------------+---------+-----------+\n",
      "|replication_id|          classifier|    means|       stds|\n",
      "+--------------+--------------------+---------+-----------+\n",
      "|            26|LogisticRegression()|0.9150267|0.009259326|\n",
      "|            26|RandomForestClass...| 0.865637|0.008664461|\n",
      "|            26|RandomForestClass...|0.8770541|0.012563881|\n",
      "|            26|RandomForestClass...|0.8656349|0.014884358|\n",
      "|            26|RandomForestClass...|0.8767864|0.012346954|\n",
      "+--------------+--------------------+---------+-----------+\n",
      "only showing top 5 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "results.show(5)#sort(F.desc(\"means\")).show(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------+--------------------+---------+-----------+\n",
      "|replication_id|          classifier|    means|       stds|\n",
      "+--------------+--------------------+---------+-----------+\n",
      "|            31|LogisticRegression()|0.9150267|0.009259326|\n",
      "|            34|LogisticRegression()|0.9150267|0.009259326|\n",
      "|            19|LogisticRegression()|0.9150267|0.009259326|\n",
      "|            22|LogisticRegression()|0.9150267|0.009259326|\n",
      "|             7|LogisticRegression()|0.9150267|0.009259326|\n",
      "+--------------+--------------------+---------+-----------+\n",
      "only showing top 5 rows\n",
      "\n",
      "CPU times: user 25.7 ms, sys: 22.8 ms, total: 48.4 ms\n",
      "Wall time: 2min 37s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "results.sort(F.desc(\"means\")).show(5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 50.3 ms, sys: 56.5 ms, total: 107 ms\n",
      "Wall time: 2min 13s\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>replication_id</th>\n",
       "      <th>classifier</th>\n",
       "      <th>means</th>\n",
       "      <th>stds</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>26</td>\n",
       "      <td>LogisticRegression()</td>\n",
       "      <td>0.915027</td>\n",
       "      <td>0.009259</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>26</td>\n",
       "      <td>RandomForestClassifier()</td>\n",
       "      <td>0.870421</td>\n",
       "      <td>0.010956</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>26</td>\n",
       "      <td>RandomForestClassifier()</td>\n",
       "      <td>0.878380</td>\n",
       "      <td>0.015171</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>26</td>\n",
       "      <td>RandomForestClassifier()</td>\n",
       "      <td>0.865634</td>\n",
       "      <td>0.014676</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>26</td>\n",
       "      <td>RandomForestClassifier()</td>\n",
       "      <td>0.873865</td>\n",
       "      <td>0.014493</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   replication_id                classifier     means      stds\n",
       "0              26      LogisticRegression()  0.915027  0.009259\n",
       "1              26  RandomForestClassifier()  0.870421  0.010956\n",
       "2              26  RandomForestClassifier()  0.878380  0.015171\n",
       "3              26  RandomForestClassifier()  0.865634  0.014676\n",
       "4              26  RandomForestClassifier()  0.873865  0.014493"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "grid_pand = results.toPandas()\n",
    "grid_pand.head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fe1de9c6ca0>"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.lineplot(data=grid_pand, x=range(1,len(grid_pand)+1), y=\"means\", hue=\"classifier\")\n",
    "\n",
    "plt.legend(['LR','RF','DT'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, Logistic Regression was steady at around 91% for accuracy score with all the replication_id, Random Forest was second in performance and Decision Tree was the last one but it looks like graph output was similar to the one with Random Forest"
   ]
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}