Node2Vec.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r-PESV7StzvU"
      },
      "source": [
        "# Node2Vec  and Embeddings - Part 2"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oVK_ox1iBk8K"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/joerg84/Graph_Powered_ML_Workshop/blob/master/Node2Vec.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E6Dd86LgtzvV"
      },
      "source": [
        "In this nodebook we will explore Node Embeddings and Node2Vec. \n",
        "The second part, a more in-depth use case of Node Embeddings is adapted from [Medium post](https://medium.com/@eliorcohen/node2vec-embeddings-for-graph-data-32a866340fef) and with data is taken from https://www.kaggle.com/artimous/complete-fifa-2017-player-dataset-global"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X6ajLzNUCF6z"
      },
      "source": [
        "As usual, setup and install everything required."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "W9U_WoQWBk8K"
      },
      "outputs": [],
      "source": [
        "%%capture\n",
        "!git clone https://github.com/joerg84/Graph_Powered_ML_Workshop.git\n",
        "!rsync -av Graph_Powered_ML_Workshop/ ./ --exclude=.git\n",
        "!pip3 install node2vec==0.4.4\n",
        "!pip3 install gensim==3.6\n",
        "!pip3 install sklearn==0.24.1\n",
        "!pip3 install text_unidecode\n",
        "!pip3 install seaborn\n",
        "!pip3 install networkx\n",
        "!pip3 install matplotlib\n",
        "!pip3 install pandas\n",
        "!pip3 install nodevectors "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "n-xwWGnAtzvW"
      },
      "outputs": [],
      "source": [
        "%matplotlib inline\n",
        "\n",
        "import warnings\n",
        "from text_unidecode import unidecode\n",
        "from collections import deque\n",
        "warnings.filterwarnings('ignore')\n",
        "\n",
        "\n",
        "import pandas as pd\n",
        "from sklearn.manifold import TSNE\n",
        "import numpy as np\n",
        "import networkx as nx\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.patches as mpatches\n",
        "import seaborn as sns\n",
        "from node2vec import Node2Vec as n2v\n",
        "from nodevectors import Node2Vec as n2\n",
        "%matplotlib inline\n",
        "\n",
        "sns.set_style('whitegrid')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vv6pDy5iBk8M"
      },
      "source": [
        "# Fifa Graph\n",
        "\n",
        "![image.png](https://github.com/joerg84/Graph_Powered_ML_Workshop/blob/master/img/fifa.jpeg?raw=1)"
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "9aZlMmzVrmCL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mb9BOI79Bk8M"
      },
      "source": [
        "1. Nodes will be players, team names and positions\n",
        "2. For each team, create a separate graph where each player node is connected to his team name node, connected to his teammates nodes and connected to his teammate position nodes."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Bp6HlvrBtzva"
      },
      "source": [
        "### Data loading and pre processing"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "upNJI7oltzva"
      },
      "outputs": [],
      "source": [
        "# Load data \n",
        "data = pd.read_csv('./data/Fifa.csv', usecols=['Name', 'Club', 'Club_Position', 'Rating'])\n",
        "\n",
        "# Lowercase columns for convenience\n",
        "data.columns = list(map(str.lower, data.columns))\n",
        "\n",
        "# Reformat strings: lowercase, ' ' -> '_' and é, ô etc. -> e, o\n",
        "reformat_string = lambda x: unidecode(str.lower(x).replace(' ', '_'))\n",
        "    \n",
        "data['name'] = data['name'].apply(reformat_string)\n",
        "data['club'] = data['club'].apply(reformat_string)\n",
        "\n",
        "# Lowercase position\n",
        "data['club_position'] = data['club_position'].str.lower()\n",
        "\n",
        "# Ignore substitutes and reserves \n",
        "data = data[(data['club_position'] != 'sub') & (data['club_position'] != 'res')]\n",
        "\n",
        "# Fix lcm rcm -> cm cm\n",
        "fix_positions = {'rcm' : 'cm', 'lcm': 'cm', 'rcb': 'cb', 'lcb': 'cb', 'ldm': 'cdm', 'rdm': 'cdm'}\n",
        "data['club_position'] = data['club_position'].apply(lambda x: fix_positions.get(x, x))\n",
        "\n",
        "# For example sake we will keep only 7 clubs\n",
        "clubs = {'real_madrid', 'manchester_utd', \n",
        "         'manchester_city', 'chelsea', 'juventus', \n",
        "         'fc_bayern', 'napoli'}\n",
        "\n",
        "data = data[data['club'].isin(clubs)]\n",
        "\n",
        "\n",
        "# Verify we have 11 player for each team\n",
        "assert all(n_players == 11 for n_players in data.groupby('club')['name'].nunique())\n",
        "\n",
        "data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wn833D45tzvf"
      },
      "source": [
        "Here comes the ugly part.\n",
        "Since we want to put each team of a graph of nodes and edges, we had to hard-code the relationship between the different FIFA 17 formations.\n",
        "\n",
        "Also since some formations have the same role (CB for example) in different positions connected to different players, I first use a distinct name for each role which after the learning process I will trim so the positions will be the same.\n",
        "\n",
        "Finally since position are connected differently in each formation we will add a suffix for the graph presentation and we will trim it also before the Word2vec process\n",
        "\n",
        "Example:\n",
        "\n",
        "`'cb'` will become `'cb_1_real_madrid'` because it is the first CB, in Real Madrid's formation, and before running the Word2Vec algorithm it will be trimmed to `cb` again\n",
        "\n",
        "### Formations"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XgAGbboVtzvf"
      },
      "outputs": [],
      "source": [
        "FORMATIONS = {'4-3-3_4': {'gk': ['cb_1', 'cb_2'],                           # Real madrid\n",
        "                          'lb': ['lw', 'cb_1', 'cm_1'],\n",
        "                          'cb_1': ['lb', 'cb_2', 'gk'],\n",
        "                          'cb_2': ['rb', 'cb_1', 'gk'],\n",
        "                          'rb': ['rw', 'cb_2', 'cm_2'],\n",
        "                          'cm_1': ['cam', 'lw', 'cb_1', 'lb'],\n",
        "                          'cm_2': ['cam', 'rw', 'cb_2', 'rb'],\n",
        "                          'cam': ['cm_1', 'cm_2', 'st'],\n",
        "                          'lw': ['cm_1', 'lb', 'st'],\n",
        "                          'rw': ['cm_2', 'rb', 'st'],\n",
        "                          'st': ['cam', 'lw', 'rw']},\n",
        "              '5-2-2-1': {'gk': ['cb_1', 'cb_2', 'cb_3'],                   # Chelsea\n",
        "                          'cb_1': ['gk', 'cb_2', 'lwb'],\n",
        "                          'cb_2': ['gk', 'cb_1', 'cb_3', 'cm_1', 'cb_2'],\n",
        "                          'cb_3': ['gk', 'cb_2', 'rwb'],\n",
        "                          'lwb': ['cb_1', 'cm_1', 'lw'],\n",
        "                          'cm_1': ['lwb', 'cb_2', 'cm_2', 'lw', 'st'],\n",
        "                          'cm_2': ['rwb', 'cb_2', 'cm_1', 'rw', 'st'],\n",
        "                          'rwb': ['cb_3', 'cm_2', 'rw'],\n",
        "                          'lw': ['lwb', 'cm_1', 'st'],\n",
        "                          'st': ['lw', 'cm_1', 'cm_2', 'rw'],\n",
        "                          'rw': ['st', 'rwb', 'cm_2']},\n",
        "              '4-3-3_2': {'gk': ['cb_1', 'cb_2'],                           # Man UTD / CITY\n",
        "                          'lb': ['cb_1', 'cm_1'],\n",
        "                          'cb_1': ['lb', 'cb_2', 'gk', 'cdm'],\n",
        "                          'cb_2': ['rb', 'cb_1', 'gk', 'cdm'],\n",
        "                          'rb': ['cb_2', 'cm_2'],\n",
        "                          'cm_1': ['cdm', 'lw', 'lb', 'st'],\n",
        "                          'cm_2': ['cdm', 'rw', 'st', 'rb'],\n",
        "                          'cdm': ['cm_1', 'cm_2', 'cb_1', 'cb_2'],\n",
        "                          'lw': ['cm_1', 'st'],\n",
        "                          'rw': ['cm_2', 'st'],\n",
        "                          'st': ['cm_1', 'cm_2', 'lw', 'rw']},              # Juventus, Bayern\n",
        "              '4-2-3-1_2': {'gk': ['cb_1', 'cb_2'],\n",
        "                            'lb': ['lm', 'cdm_1', 'cb_1'],\n",
        "                            'cb_1': ['lb', 'cdm_1', 'gk', 'cb_2'],\n",
        "                            'cb_2': ['rb', 'cdm_2', 'gk', 'cb_1'],\n",
        "                            'rb': ['cb_2', 'rm', 'cdm_2'],\n",
        "                            'lm': ['lb', 'cdm_1', 'st', 'cam'],\n",
        "                            'rm': ['rb', 'cdm_2', 'st', 'cam'],\n",
        "                            'cdm_1': ['lm', 'cb_1', 'rb', 'cam'],\n",
        "                            'cdm_2': ['rm', 'cb_2', 'lb', 'cam'],\n",
        "                            'cam': ['cdm_1', 'cdm_2', 'rm', 'lm', 'st'],\n",
        "                            'st': ['lm', 'rm', 'cam']},\n",
        "              '4-3-3': {'gk': ['cb_1', 'cb_2'],                             # Napoli\n",
        "                        'lb': ['cb_1', 'cm_1'],\n",
        "                        'cb_1': ['lb', 'cb_2', 'gk', 'cm_2'],\n",
        "                        'cb_2': ['rb', 'cb_1', 'gk', 'cm_2'],\n",
        "                        'rb': ['cb_2', 'cm_3'],\n",
        "                        'cm_1': ['cm_2', 'lw', 'lb'],\n",
        "                        'cm_3': ['cm_2', 'rw', 'rb'],\n",
        "                        'cm_2': ['cm_1', 'cm_3', 'st', 'cb_1', 'cb_2'],\n",
        "                        'lw': ['cm_1', 'st'],\n",
        "                        'rw': ['cm_3', 'st'],\n",
        "                        'st': ['cm_2', 'lw', 'rw']}}\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fUEfMuG-tzvi"
      },
      "source": [
        "### Creating the graphs for each team"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gugy8_Qbtzvi"
      },
      "outputs": [],
      "source": [
        "add_club_suffix = lambda x, c: x + '_{}'.format(c)\n",
        "\n",
        "graph = nx.Graph()\n",
        "formatted_positions = set()\n",
        "\n",
        "def club2graph(club_name, formation, graph):\n",
        "    club_data = data[data['club'] == club_name]\n",
        "    \n",
        "    club_formation = FORMATIONS[formation]\n",
        "    \n",
        "    club_positions = dict()\n",
        "    \n",
        "    # Assign positions to players\n",
        "    available_positions = deque(club_formation)\n",
        "    available_players = set(zip(club_data['name'], club_data['club_position']))\n",
        "    \n",
        "    roster = dict()  # Here we will store the assigned players and positions\n",
        "    \n",
        "    while available_positions:\n",
        "        position = available_positions.pop()\n",
        "        name, pos = [(name, position) for name, p in available_players if position.startswith(p)][0]        \n",
        "        \n",
        "        roster[name] = pos\n",
        "        \n",
        "        available_players.remove((name, pos.split('_')[0]))\n",
        "        \n",
        "    reverse_roster = {v: k for k, v in roster.items()}\n",
        "        \n",
        "    # Build the graph\n",
        "    for name, position in roster.items():\n",
        "        # Connect to team name\n",
        "        graph.add_edge(name, club_name)\n",
        "        \n",
        "        # Inter team connections\n",
        "        for teammate_position in club_formation[position]:\n",
        "            # Connect positions\n",
        "            graph.add_edge(add_club_suffix(position, club_name),\n",
        "                           add_club_suffix(teammate_position, club_name))\n",
        "            \n",
        "            # Connect player to teammate positions\n",
        "            graph.add_edge(name,\n",
        "                           add_club_suffix(teammate_position, club_name))\n",
        "            \n",
        "            # Connect player to teammates\n",
        "            graph.add_edge(name, reverse_roster[teammate_position])\n",
        "            \n",
        "            # Save for later trimming\n",
        "            formatted_positions.add(add_club_suffix(position, club_name))\n",
        "            formatted_positions.add(add_club_suffix(teammate_position, club_name))\n",
        "            \n",
        "    return graph"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sE4vKc9ttzvl"
      },
      "outputs": [],
      "source": [
        "teams = [('real_madrid', '4-3-3_4'), \n",
        "         ('chelsea', '5-2-2-1'),\n",
        "         ('manchester_utd', '4-3-3_2'),\n",
        "         ('manchester_city', '4-3-3_2'),\n",
        "         ('juventus', '4-2-3-1_2'),\n",
        "         ('fc_bayern', '4-2-3-1_2'),\n",
        "         ('napoli', '4-3-3')]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "H3BgSySHtzvo"
      },
      "outputs": [],
      "source": [
        "graph = club2graph('real_madrid', '4-3-3_4', graph)\n",
        "\n",
        "# Let us look at read madrid\n",
        "# for edge in graph.edges:\n",
        "#     print(edge)\n",
        "#nx.draw(graph, with_labels=True)\n",
        "\n",
        "for team, formation in teams:\n",
        "    graph = club2graph(team, formation, graph)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EP0E8Q6-tzvr"
      },
      "source": [
        "### Node2Vec algorithm"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LgM2gGojtzvs"
      },
      "outputs": [],
      "source": [
        "node2vec = Node2Vec(graph, dimensions=20, walk_length=10, num_walks=100, workers=2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "K6o2poxqtzvv"
      },
      "outputs": [],
      "source": [
        "fix_formatted_positions = lambda x: x.split('_')[0] if x in formatted_positions else x\n",
        "reformatted_walks = [list(map(fix_formatted_positions, walk)) for walk in node2vec.walks]\n",
        "node2vec.walks = reformatted_walks"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iHapSYu2tzvy"
      },
      "outputs": [],
      "source": [
        "model = node2vec.fit(window=10, min_count=1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l-RvQ0fGtzv0"
      },
      "source": [
        "#### Most similar nodes"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oAeRt_V7Bk8Q"
      },
      "outputs": [],
      "source": [
        "for node, _ in model.most_similar('real_madrid'):\n",
        "    print(node)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "j2h9pcFntzv1"
      },
      "outputs": [],
      "source": [
        "for node, _ in model.most_similar('rw'):\n",
        "    # Show only players\n",
        "    if len(node) > 3:\n",
        "        print(node)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "omwxy675tzv4"
      },
      "outputs": [],
      "source": [
        "for node, _ in model.most_similar('gk'):\n",
        "    # Show only players\n",
        "    if len(node) > 3:\n",
        "        print(node)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IHL0C1j4Bk8R"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "esdNdCuctzv9"
      },
      "outputs": [],
      "source": [
        "for node, _ in model.most_similar('paulo_dybala'):\n",
        "    print(node)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5SO8Ft9ytzv_"
      },
      "source": [
        "#### Visualization"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DC6i_3kktzwA"
      },
      "outputs": [],
      "source": [
        "player_nodes = [x for x in model.wv.vocab if len(x) > 3 and x not in clubs]\n",
        "embeddings = np.array([model.wv[x] for x in player_nodes])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kImuW67FtzwC"
      },
      "outputs": [],
      "source": [
        "tsne = TSNE(n_components=2, random_state=7, perplexity=15)\n",
        "embeddings_2d = tsne.fit_transform(embeddings)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tSIuTG21tzwE"
      },
      "outputs": [],
      "source": [
        "# Assign colors to players\n",
        "team_colors = {\n",
        "    'real_madrid': 'lightblue',\n",
        "    'chelsea': 'b',\n",
        "    'manchester_utd': 'r',\n",
        "    'manchester_city': 'teal',\n",
        "    'juventus': 'gainsboro',\n",
        "    'napoli': 'deepskyblue',\n",
        "    'fc_bayern': 'tomato' \n",
        "}\n",
        "\n",
        "data['color'] = data['club'].apply(lambda x: team_colors[x])\n",
        "player_colors = dict(zip(data['name'], data['color']))\n",
        "colors = [player_colors[x] for x in player_nodes]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "paMe3NvDtzwH"
      },
      "outputs": [],
      "source": [
        "figure = plt.figure(figsize=(11, 9))\n",
        "\n",
        "ax = figure.add_subplot(111)\n",
        "\n",
        "ax.scatter(embeddings_2d[:, 0], embeddings_2d[:, 1], c=colors)\n",
        "\n",
        "# Create team patches for legend\n",
        "team_patches = [mpatches.Patch(color=color, label=team) for team, color in team_colors.items()]\n",
        "ax.legend(handles=team_patches);"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "name": "Node2Vec.ipynb",
      "provenance": []
    },
    "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.7"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}