recommendation-system.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark import SparkContext\n",
    "from pyspark.sql import SQLContext\n",
    "from pyspark.sql import SparkSession\n",
    "from pyspark.sql.types import *\n",
    "from pyspark.sql.functions import udf\n",
    "from pyspark.ml.stat import Correlation\n",
    "from pyspark.ml.linalg import Vectors\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from collections import Counter\n",
    "import re\n",
    "import time\n",
    "from pathos.pools import ProcessPool as Pool\n",
    "\n",
    "num_partitions = 10\n",
    "num_cores = 2\n",
    "\n",
    "spark = SparkSession.builder.appName('FootballManager').getOrCreate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def readCSV(path):\n",
    "    return spark.read.format(\"csv\").options(header=\"true\", inferSchema=\"true\")\\\n",
    "    .load(path)\n",
    "\n",
    "teams_df = readCSV(\"./team_feat.csv\")\n",
    "players_df = readCSV(\"./data_clean.csv\")\n",
    "_teams_df = pd.read_csv('./team_feat.csv')\n",
    "_players_df = pd.read_csv('./data_clean.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def single_workflow(features):\n",
    "    def foo(teams_df, input):\n",
    "        \"\"\"\n",
    "        Get 3 features-teams matrixs , transfer the features' score into weights(use Reciprocal Function) and thus we have 3 weighted-teams matrixs.\n",
    "\n",
    "        :param: input, a dic of features vectors\n",
    "        :return a tuple of weighted-teams matrixs\n",
    "        \"\"\"\n",
    "        features = input\n",
    "\n",
    "        teams_columns = dict(zip(range(0,teams_df['Club'].size), teams_df['Club']))\n",
    "\n",
    "        features_teams = teams_df.loc[:, features].T\n",
    "        features_teams = features_teams.rename(columns=teams_columns)\n",
    "\n",
    "        weights_teams = features_teams.applymap(lambda x: 1./float(x))\n",
    "\n",
    "        return weights_teams\n",
    "\n",
    "    def getPlayersTeamsMatrix_parallel(players_df, teams_df, input):\n",
    "        \"\"\"\n",
    "        Create three sections, each section has a m*n and n*k matrix,\n",
    "        where m is the number of players, n is the number of features' weights,\n",
    "        and k is the number of teams. For all these three pairs of matrices,\n",
    "        do the matrix multiplication. Then we can get 3 MxK matrices for DEF, MID and ATK positions.\n",
    "\n",
    "        :params: input, a dict \n",
    "        : return: a tuple of three players_teams matrixs\n",
    "        \"\"\"\n",
    "\n",
    "        features = input['features']\n",
    "        weights_teams = input['weights_teams']\n",
    "\n",
    "        players_rows = dict(zip(range(0, players_df['Name'].size), players_df['Name']))\n",
    "\n",
    "        # DEF\n",
    "        players_features = players_df.loc[:, features]\n",
    "        players_features = players_features.rename(index=players_rows)\n",
    "        players_teams = players_features.dot(weights_teams)\n",
    "\n",
    "        return players_teams\n",
    "\n",
    "    weights_teams = foo(\n",
    "      _teams_df,\n",
    "      features\n",
    "    )\n",
    "    players_teams = getPlayersTeamsMatrix_parallel(\n",
    "      _players_df,\n",
    "      _teams_df,\n",
    "      {\n",
    "          'features': features,\n",
    "          'weights_teams': weights_teams\n",
    "      }\n",
    "    )\n",
    "    return players_teams"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RecommendationEngine(object):\n",
    "    def __init__(self, players_df, teams_df, _players_df, _teams_df):\n",
    "        self.players_df = players_df\n",
    "        self.teams_df = teams_df\n",
    "        self._teams_df = _teams_df\n",
    "        self._players_df = _players_df\n",
    "        self.result = {}\n",
    "    \n",
    "    def readCSVToSparksql(self, path):\n",
    "        return spark.read.format(\"csv\").options(header=\"true\", inferSchema=\"true\")\\\n",
    "            .load(path)\n",
    "\n",
    "    def __convertDFtoRDD(self, df):\n",
    "        rdd = df.rdd\n",
    "        return rdd\n",
    "    \n",
    "#     def __groupPosition(self, players_df):\n",
    "#         \"\"\"\n",
    "#         Function to group the players' positions into three main groups: DEF, MID, FWD\n",
    "        \n",
    "#         :param: players_df\n",
    "#         :return: Dataframe\n",
    "#         \"\"\"\n",
    "        \n",
    "#         def _classify(position):\n",
    "#             \"\"\"\n",
    "#             Classify Position\n",
    "            \n",
    "#             :param: position\n",
    "#             :return: string\n",
    "#             \"\"\"\n",
    "#             # Regex to group\n",
    "#             defs = r'\\w*B$'\n",
    "#             mids = r'\\w*M$'\n",
    "#             fwds = r'\\w*[FSTW]$'\n",
    "            \n",
    "#             if re.match(defs, position):\n",
    "#                 return \"DEF\"\n",
    "#             elif re.match(mids, position):\n",
    "#                 return \"MID\"\n",
    "#             elif re.match(fwds, position):\n",
    "#                 return \"FWD\"\n",
    "#             else:\n",
    "#                 return None\n",
    "        \n",
    "#         # Write an UDF for withColumn\n",
    "#         _classify_udf = udf(_classify, StringType())\n",
    "        \n",
    "#         # groupPosition list\n",
    "#         return players_df\\\n",
    "#           .withColumn('GroupPosition', _classify_udf(players_df['Position']))\n",
    "\n",
    "    def __groupPosition(self, players_df):\n",
    "        # Regex to group\n",
    "        defs = r'\\w*B$'\n",
    "        mids = r'\\w*M$'\n",
    "        fwds = r'\\w*[FSTW]$'\n",
    "\n",
    "        # groupPosition list\n",
    "        groupPositions = []\n",
    "        for index, row in players_df.iterrows():\n",
    "            position = row['Position']\n",
    "            if re.match(defs, position):\n",
    "                groupPositions.append('DEF')\n",
    "            if re.match(mids, position):\n",
    "                groupPositions.append('MID')\n",
    "            if re.match(fwds, position):\n",
    "                groupPositions.append('FWD')\n",
    "        series = pd.Series(groupPositions)\n",
    "        players_df['GroupPosition'] = series\n",
    "        return players_df\n",
    "        \n",
    "    def __findTopRelatedPosition(self, players_df):\n",
    "        \"\"\"\n",
    "        Calculate the Pearson Correlation between each specific position,\n",
    "        and specific featuresFind out top characteristics for different position\n",
    "        \n",
    "        :param: players_df, Pandas Dataframe\n",
    "        :return: \n",
    "        \"\"\"\n",
    "        player_characteristics = ['Crossing','Finishing', 'HeadingAccuracy', \n",
    "                                  'ShortPassing', 'Volleys', 'Dribbling', 'Curve',\n",
    "                                  'FKAccuracy', 'LongPassing', 'BallControl', \n",
    "                                  'Acceleration', 'SprintSpeed', 'Agility', 'Reactions', \n",
    "                                  'Balance', 'ShotPower', 'Jumping', 'Stamina', \n",
    "                                  'Strength', 'LongShots', 'Aggression',\n",
    "                                  'Interceptions', 'Positioning', 'Vision', \n",
    "                                  'Penalties', 'Composure', 'Marking', 'StandingTackle', \n",
    "                                  'SlidingTackle']\n",
    "\n",
    "        ## Top characteristics for  positions\n",
    "        corr_matrix = players_df.corr() # default is pearson\n",
    "        counter_DEF = Counter()\n",
    "        counter_MID = Counter()\n",
    "        counter_ATK = Counter()\n",
    "        defs = r'\\w*B$'\n",
    "        mids = r'\\w*M$'\n",
    "        fwds = r'\\w*[FSTW]$'\n",
    "        for index, row in corr_matrix.loc[player_characteristics, \"LS\":\"RB\"].T.iterrows():\n",
    "\n",
    "            largests = tuple(row.nlargest(12).index)\n",
    "        #     print('Position {}: {}, {}, {}, {}, {}, {}, {}, {}'.format(index, *tuple(row.nlargest(8).index)))\n",
    "\n",
    "            if re.match(defs, index): # DEF\n",
    "                for feature in largests:\n",
    "                    counter_DEF[feature] += 1\n",
    "            if re.match(mids, index): # MID\n",
    "                for feature in largests:\n",
    "                    counter_MID[feature] += 1\n",
    "            if re.match(fwds, index): # FWD\n",
    "                for feature in largests:\n",
    "                    counter_ATK[feature] += 1\n",
    "\n",
    "        # 3. Group all positions together into only three, ATK, MID and DEF, thus we get the three 1 * 8 vector for three main groups.\n",
    "        features_DEF = [kv[0] for kv in counter_DEF.most_common(12)]\n",
    "        features_MID = [kv[0] for kv in counter_MID.most_common(12)]\n",
    "        features_ATK = [kv[0] for kv in counter_ATK.most_common(12)]\n",
    "        features_ALL = player_characteristics\n",
    "        \n",
    "        return features_DEF, features_MID, features_ATK, features_ALL\n",
    "    \n",
    "    def _getWeightedMatrix(self, teams_df, input):\n",
    "        \"\"\"\n",
    "        Get 3 features-teams matrixs , transfer the features' score into weights(use Reciprocal Function) and thus we have 3 weighted-teams matrixs.\n",
    "        \n",
    "        :param: input, a dic of features vectors\n",
    "        :return a tuple of weighted-teams matrixs\n",
    "        \"\"\"\n",
    "        features_DEF = input['features_DEF']\n",
    "        features_MID = input['features_MID']\n",
    "        features_ATK = input['features_ATK']\n",
    "        features_ALL = input['features_ALL']\n",
    "                \n",
    "        teams_columns = dict(zip(range(0,teams_df['Club'].size), teams_df['Club']))\n",
    "\n",
    "        features_teams_DEF = teams_df.loc[:, features_DEF].T\n",
    "        features_teams_DEF = features_teams_DEF.rename(columns=teams_columns)\n",
    "        features_teams_MID = teams_df.loc[:, features_MID].T\n",
    "        features_teams_MID = features_teams_MID.rename(columns=teams_columns)\n",
    "        features_teams_ATK = teams_df.loc[:, features_ATK].T\n",
    "        features_teams_ATK = features_teams_ATK.rename(columns=teams_columns)\n",
    "        features_teams_ALL = teams_df.loc[:, features_ALL].T\n",
    "        features_teams_ALL = features_teams_ALL.rename(columns=teams_columns)\n",
    "        \n",
    "        weights_teams_DEF = features_teams_DEF.applymap(lambda x: 1./float(x))\n",
    "        weights_teams_MID = features_teams_MID.applymap(lambda x: 1./float(x))\n",
    "        weights_teams_ATK = features_teams_ATK.applymap(lambda x: 1./float(x))\n",
    "        weights_teams_ALL = features_teams_ALL.applymap(lambda x: 1./float(x))\n",
    "        \n",
    "        return weights_teams_DEF, weights_teams_MID, weights_teams_ATK, weights_teams_ALL\n",
    "        \n",
    "    def _getPlayersTeamsMatrix(self, players_df, teams_df, input):\n",
    "        \"\"\"\n",
    "        Create three sections, each section has a m*n and n*k matrix,\n",
    "        where m is the number of players, n is the number of features' weights,\n",
    "        and k is the number of teams. For all these three pairs of matrices,\n",
    "        do the matrix multiplication. Then we can get 3 MxK matrices for DEF, MID and ATK positions.\n",
    "        \n",
    "        :params: input, a dict \n",
    "        : return: a tuple of three players_teams matrixs\n",
    "        \"\"\"\n",
    "        \n",
    "        features_DEF = input['features_DEF']\n",
    "        features_MID = input['features_MID']\n",
    "        features_ATK = input['features_ATK']\n",
    "        features_ALL = input['features_ALL']\n",
    "        weights_teams_DEF = input['weights_teams_DEF']\n",
    "        weights_teams_MID = input['weights_teams_MID']\n",
    "        weights_teams_ATK = input['weights_teams_ATK']\n",
    "        weights_teams_ALL = input['weights_teams_ALL']\n",
    "        \n",
    "        players_rows_Name = dict(zip(range(0, players_df['Name'].size), players_df['Name']))\n",
    "        players_rows_ID = dict(zip(range(0, players_df['ID'].size), players_df['ID']))\n",
    "\n",
    "        # DEF\n",
    "        players_features_DEF = players_df.loc[:, features_DEF]\n",
    "        players_features_DEF = players_features_DEF.rename(index=players_rows_Name)\n",
    "        players_teams_DEF = players_features_DEF.dot(weights_teams_DEF)\n",
    "\n",
    "        # MID\n",
    "        players_features_MID = players_df.loc[:, features_MID]\n",
    "        players_features_MID = players_features_MID.rename(index=players_rows_Name)\n",
    "        players_teams_MID = players_features_MID.dot(weights_teams_MID)\n",
    "\n",
    "        # ATK\n",
    "        players_features_ATK = players_df.loc[:, features_ATK]\n",
    "        players_features_ATK = players_features_ATK.rename(index=players_rows_Name)\n",
    "        players_teams_ATK = players_features_ATK.dot(weights_teams_ATK)\n",
    "        \n",
    "        # ALL, row index is ID\n",
    "        players_features_ALL = players_df.loc[:, features_ALL]\n",
    "        players_features_ALL = players_features_ALL.rename(index=players_rows_ID)\n",
    "        players_teams_ALL = players_features_ALL.dot(weights_teams_ALL)\n",
    "        \n",
    "        return players_teams_DEF, players_teams_MID, players_teams_ATK, players_teams_ALL\n",
    "\n",
    "    def _run(self):\n",
    "        \"\"\"\n",
    "        Run the recommendation engine\n",
    "        \n",
    "        :return: a tuple of three players_teams matrixs\n",
    "        \"\"\"\n",
    "        start=time.time()\n",
    "        self._players_df = self.__groupPosition(self._players_df)\n",
    "        features_DEF, features_MID, features_ATK, features_ALL = self.__findTopRelatedPosition(self._players_df)\n",
    "        weights_teams_DEF, weights_teams_MID, weights_teams_ATK, weights_teams_ALL = self._getWeightedMatrix(\n",
    "            self._teams_df,\n",
    "            {'features_DEF': features_DEF,\n",
    "             'features_MID': features_MID,\n",
    "             'features_ATK': features_ATK,\n",
    "             'features_ALL': features_ALL\n",
    "            }\n",
    "        )\n",
    "        players_teams_DEF, players_teams_MID, players_teams_ATK, players_teams_ALL = self._getPlayersTeamsMatrix(\n",
    "            self._players_df,\n",
    "            self._teams_df,\n",
    "            {'features_DEF': features_DEF,\n",
    "             'features_MID': features_MID,\n",
    "             'features_ATK': features_ATK,\n",
    "             'features_ALL': features_ALL,\n",
    "             'weights_teams_DEF': weights_teams_DEF,\n",
    "             'weights_teams_MID': weights_teams_MID,\n",
    "             'weights_teams_ATK': weights_teams_ATK,\n",
    "             'weights_teams_ALL': weights_teams_ALL\n",
    "            }\n",
    "        )\n",
    "        end=time.time()\n",
    "        print(\"The recommendation running time is: {:.2f} seconds in Serial Mode\".format(end-start))\n",
    "        return players_teams_DEF, players_teams_MID, players_teams_ATK, players_teams_ALL\n",
    "    \n",
    "    def _run_parallel(self):\n",
    "        \"\"\"\n",
    "        Run the recommendation engine\n",
    "        \n",
    "        :return: a tuple of three players_teams matrixs\n",
    "        \"\"\"\n",
    "        \n",
    "        start=time.time()\n",
    "        with Pool(num_cores) as pool:\n",
    "            self._players_df = self.__groupPosition(self._players_df)\n",
    "            features_array = list(self.__findTopRelatedPosition(self._players_df))\n",
    "            players_teams_array = pool.map(single_workflow, features_array)\n",
    "            pool.close()\n",
    "            pool.join()\n",
    "        end=time.time()\n",
    "        \n",
    "        print(\"The recommendation running time is: {:.2f} seconds in Parallel mode\".format(end-start))\n",
    "        players_teams_DEF = players_teams_array[0]\n",
    "        players_teams_MID = players_teams_array[1]\n",
    "        players_teams_ATK = players_teams_array[2]\n",
    "        return players_teams_DEF, players_teams_MID, players_teams_ATK\n",
    "    \n",
    "    def getRecommendation(self, mode=0):\n",
    "        \"\"\"\n",
    "        Get the recommendation result, use lazy load mode\n",
    "        \n",
    "        :param: mode, 0 means serial, 1 means parallel, defualt is 0\n",
    "        :return: a tuple of three players_teams matrixs\n",
    "        \"\"\"\n",
    "        if len(self.result) == 0:\n",
    "            if mode == 1:\n",
    "                players_teams_DEF, players_teams_MID, players_teams_ATK = self._run_parallel()\n",
    "            else:\n",
    "                players_teams_DEF, players_teams_MID, players_teams_ATK, players_teams_ALL = self._run()\n",
    "            self.result['players_teams_DEF'] = players_teams_DEF\n",
    "            self.result['players_teams_MID'] = players_teams_MID\n",
    "            self.result['players_teams_ATK'] = players_teams_ATK\n",
    "            self.result['players_teams_ALL'] = players_teams_ALL\n",
    "        return self.result\n",
    "\n",
    "class RecommendationSystem(object):\n",
    "    def __init__(self, recommendation_engine, players_df, teams_df, _players_df, _teams_df):\n",
    "        self.players_df = players_df\n",
    "        self.teams_df = teams_df\n",
    "        self._teams_df = _teams_df\n",
    "        self._players_df = _players_df\n",
    "        self._recommendation_engine = recommendation_engine\n",
    "        self.players_teams_matrixs = self._recommendation_engine.getRecommendation()\n",
    "    \n",
    "    def getMVPForTeam(self, team, position, K, isReverse=False):\n",
    "        \"\"\"\n",
    "        To recommend K Most Valued People in specific position for specific team if ascending is False,\n",
    "        otherwise show Worst Valued People if ascending is True\n",
    "        \n",
    "        :param: team\n",
    "        :param: position\n",
    "        :param: K\n",
    "        :param: isReverse, default False\n",
    "        :return: players -> List[]\n",
    "        \"\"\"\n",
    "        if position == 'DEF':\n",
    "            players = self.players_teams_matrixs['players_teams_DEF'][team]\\\n",
    "                       .sort_values(ascending=isReverse)\\\n",
    "                       .head(K)\n",
    "            return players\n",
    "        elif position == 'MID':\n",
    "            players = self.players_teams_matrixs['players_teams_MID'][team]\\\n",
    "                       .sort_values(ascending=isReverse)\\\n",
    "                       .head(K)\n",
    "            return players\n",
    "        elif position == 'ATK':\n",
    "            players = self.players_teams_matrixs['players_teams_ATK'][team]\\\n",
    "                       .sort_values(ascending=isReverse)\\\n",
    "                       .head(K)\n",
    "            return players\n",
    "        else:\n",
    "            raise RuntimeError('Invalid position argument')\n",
    "    \n",
    "    def getMVTForPlayer(self, player, position, K, isReverse=False):\n",
    "        \"\"\"\n",
    "        To recommend Most Valued Teams in specific position for specific palyer if ascending is False,\n",
    "        otherwise show Worst Valued Teams if ascending is True\n",
    "        \n",
    "        :param: player\n",
    "        :param: position\n",
    "        :param: K\n",
    "        :param: isReverse, default False\n",
    "        :return: teams -> List[]\n",
    "        \"\"\"\n",
    "        if position == 'DEF':\n",
    "            teams = self.players_teams_matrixs['players_teams_DEF']\\\n",
    "                       .loc[player, :]\\\n",
    "                       .sort_values(ascending=isReverse)\\\n",
    "                       .head(K)\n",
    "            return teams\n",
    "        elif position == 'MID':\n",
    "            teams = self.players_teams_matrixs['players_teams_MID']\\\n",
    "                       .loc[player, :]\\\n",
    "                       .sort_values(ascending=isReverse)\\\n",
    "                       .head(K)\n",
    "            return teams\n",
    "        elif position == 'ATK':\n",
    "            teams = self.players_teams_matrixs['players_teams_ATK']\\\n",
    "                       .loc[player, :]\\\n",
    "                       .sort_values(ascending=isReverse)\\\n",
    "                       .head(K)\n",
    "            return teams\n",
    "        else:\n",
    "            raise RuntimeError('Invalid position argument')\n",
    "    \n",
    "    def searchWorstPlayersInPosByTeam(self, position, team):\n",
    "        \"\"\"\n",
    "        To find out the Least Valued Players in specific position for specific team,\n",
    "        thus in the future we can replace them with better players.\n",
    "        \n",
    "        :params: position\n",
    "        :params: team\n",
    "        :return:\n",
    "        \"\"\"\n",
    "        players_df = self._players_df\n",
    "        players_teams_matrix = None\n",
    "        if position == 'DEF':\n",
    "            players_teams_matrix = self.players_teams_matrixs['players_teams_DEF']\n",
    "        elif position == 'MID':\n",
    "            players_teams_matrix = self.players_teams_matrixs['players_teams_MID']\n",
    "        elif position == 'ATK':\n",
    "            players_teams_matrix = self.players_teams_matrixs['players_teams_ATK']\n",
    "        else:\n",
    "            raise RuntimeError('Invalid position argument')\n",
    "        for index, value in players_teams_matrix[team].sort_values(ascending=True).iteritems():\n",
    "            if players_df.loc[(players_df.loc[:, 'Name'] == index), :]['Club'].values[0] == team and players_df.loc[(players_df.loc[:, 'Name'] == index), :]['GroupPosition'].values[0] == position:\n",
    "                print(\"{}\\t\\t{}\".format(index, value))\n",
    "    \n",
    "    def getLVPFromWeakPlayers(self, weak_players, team):\n",
    "        \"\"\"\n",
    "        :params: weak_players, list[int]\n",
    "        :params: team, str\n",
    "        :return: LVP in ID, str\n",
    "        \"\"\"\n",
    "        players_teams_matrix = self.players_teams_matrixs['players_teams_ALL']\n",
    "        if len(weak_players) == 0:\n",
    "            LVP = players_teams_matrix[team]\\\n",
    "                    .sort_values(ascending=True)\\\n",
    "                    .head(1)\n",
    "        else:\n",
    "            LVP = players_teams_matrix.loc[weak_players, team]\\\n",
    "                .sort_values(ascending=True)\\\n",
    "                .head(1)\n",
    "        return LVP.index[0]\n",
    "        \n",
    "class FootballManager(object):\n",
    "    def __init__(self, recommendation_system):\n",
    "        self.players_df = self.readCSVToSparksql(\"./data_clean.csv\")\n",
    "        self.teams_df = self.readCSVToSparksql(\"./team_feat.csv\")\n",
    "        self._teams_df = pd.read_csv('./team_feat.csv')\n",
    "        self._players_df = pd.read_csv('./data_clean.csv')\n",
    "        self.recommendation_system = recommendation_system\n",
    "    \n",
    "    def readCSVToSparksql(self, path):\n",
    "        return spark.read.format(\"csv\").options(header=\"true\", inferSchema=\"true\")\\\n",
    "            .load(path)\n",
    "\n",
    "    def matrix_weighted_recommandation(self, input_player=None, input_team=None):\n",
    "        if input_player is None and input_team is None:\n",
    "            raise RuntimeError('No player or team is found, please at least offer one argument')\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "recommendation_engine = RecommendationEngine(players_df, teams_df, _players_df, _teams_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The recommendation running time is: 2.80 seconds in Serial Mode\n"
     ]
    }
   ],
   "source": [
    "recommendationSystem = RecommendationSystem(recommendation_engine, players_df, teams_df, _players_df, _teams_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "237522\n"
     ]
    }
   ],
   "source": [
    "# Test, find the least valued person in a given list in specific team\n",
    "LVP = recommendationSystem.getLVPFromWeakPlayers(\n",
    "        [152729, 205600, 157304, 241810, 237522, 220440],\n",
    "#         [],\n",
    "        'FC Barcelona'\n",
    "      )\n",
    "print(LVP)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N. Kanté           14.717360\n",
      "R. Nainggolan      14.472113\n",
      "Marcelo            14.421730\n",
      "Sergio Busquets    14.351996\n",
      "Azpilicueta        14.319815\n",
      "M. Verratti        14.285216\n",
      "Sergio Ramos       14.274165\n",
      "Fabinho            14.229531\n",
      "B. Matuidi         14.205642\n",
      "Filipe Luís        14.201602\n",
      "Name: LA Galaxy, dtype: float64\n",
      "Bray Wanderers            14.245963\n",
      "Derry City                14.087554\n",
      "Limerick FC               14.031793\n",
      "Bohemian FC               13.772407\n",
      "Sligo Rovers              13.653418\n",
      "St. Patrick's Athletic    13.225427\n",
      "Crewe Alexandra           13.055256\n",
      "Macclesfield Town         13.031334\n",
      "Cambridge United          13.022933\n",
      "Tranmere Rovers           12.966512\n",
      "Name: L. Messi, dtype: float64\n",
      "H. Arellano\t\t8.97079925367392\n",
      "T. Hilliard-Arce\t\t9.223502050321217\n",
      "M. Ciani\t\t9.976406834536851\n",
      "D. Steres\t\t10.551107689009902\n",
      "J. Skjelvik\t\t10.92070937026635\n",
      "D. Romney\t\t11.039057865252092\n",
      "R. Feltscher\t\t11.35446079266311\n",
      "A. Cole\t\t12.014221027871123\n"
     ]
    }
   ],
   "source": [
    "players = recommendationSystem.getMVPForTeam('LA Galaxy', 'DEF', 10)\n",
    "print(players)\n",
    "teams = recommendationSystem.getMVTForPlayer('L. Messi', 'DEF', 10)\n",
    "print(teams)\n",
    "recommendationSystem.searchWorstPlayersInPosByTeam('DEF', 'LA Galaxy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}