RNN.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "RNN.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "PevhD9fJAq38",
        "vgo41H4VRgL7",
        "VtwKvEKsnA-F"
      ]
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PevhD9fJAq38",
        "colab_type": "text"
      },
      "source": [
        "# Installations, Imports, and Drive Setup"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "axcDNnqgBI-s",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "    !pip install PyDrive"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9xzbTBIDBLJk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import os\n",
        "from pydrive.auth import GoogleAuth\n",
        "from pydrive.drive import GoogleDrive\n",
        "from google.colab import auth\n",
        "from oauth2client.client import GoogleCredentials\n",
        "from google.colab import files"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ekGVY5MOCi1k",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "auth.authenticate_user()\n",
        "gauth = GoogleAuth()\n",
        "gauth.credentials = GoogleCredentials.get_application_default()\n",
        "drive = GoogleDrive(gauth)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JZUohabTD1SQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "download = drive.CreateFile({'id': '1Bwd_Ma8mqCho0diPLoqPrLhsrAA77oEi'})\n",
        "download.GetContentFile('games.zip')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jomEcoIdI3fk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/gdrive')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eQUoHbtcJT9l",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!unzip \"/content/gdrive/My Drive/AlphaHitler/games.zip\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vgo41H4VRgL7",
        "colab_type": "text"
      },
      "source": [
        "# Network Training"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WT4hhuetKL2V",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import json\n",
        "\n",
        "def populate_inputs(game_number_start, game_number_end, max_num_govs):\n",
        "    \"\"\"\n",
        "    Populates the input nodes with game information.\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    game_number_start : int\n",
        "        Start game parsing at game_number_start.json\n",
        "    game_number_end : int\n",
        "        End game parsing at game_number_end.json\n",
        "    max_num_govs : int\n",
        "        Truncate elements of games greater than length max_num_govs\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    games : list\n",
        "        List of size num_valid_games X max_num_govs X num_input_nodes containing the input layers created for each valid game\n",
        "    results : list\n",
        "        List of size num_valid_games X 7 containing fascist results for each valid game (1 = fascist, 0 = liberal)\n",
        "    game_numbers : list\n",
        "        List of length num_valid_games containing game numbers for all valid games\n",
        "    game_lengths : list\n",
        "        List of length num_valid_games containing game lengths for all valid games for use by torch.nn.utils.rnn.pack_padded_sequence to keep forward() parallelizable\n",
        "    outed : list\n",
        "        List of size num_valid_games X 7 storing who is \"outed\" fascist for each valid game (1 = outed, 0 = not outed) for use in calculation of \"conflict confidence\" metric\n",
        "    \"\"\"\n",
        "\n",
        "    games = []\n",
        "    num_valid_games = 0\n",
        "    game_lengths = []\n",
        "    results = []\n",
        "    game_numbers = []\n",
        "    outed = []\n",
        "    num_input_nodes = 89\n",
        "\n",
        "    # Treat each lib seat POV as a different game to augment data\n",
        "    for lib_number in range(0, 4):\n",
        "        for game_number in range(game_number_start, game_number_end):\n",
        "            # Is the game valid\n",
        "            game_valid = True\n",
        "            # Contains all the data for this game\n",
        "            game_data = []\n",
        "            # Who is \"outed\" as a fascist\n",
        "            game_outed = [0] * 7\n",
        "            # Who is \"confirmed\" as a liberal\n",
        "            confirmed = [0] * 7\n",
        "            # Who is \"outed\" as hitler\n",
        "            game_hitler = [0] * 7\n",
        "            # Who is confirmed not hitler (cnh)\n",
        "            game_cnh = [0] * 7\n",
        "            # Number of played (majority vote \"Ja\") governments\n",
        "            num_played_govs = 0\n",
        "            # Roles of the players in the game (1 = fascist, 0 = liberal)\n",
        "            roles = []\n",
        "\n",
        "            file_name = \"games/\" + str(game_number) + \".json\"\n",
        "\n",
        "            # Number of lib and fas cards on the board\n",
        "            lib_cards_played = 0\n",
        "            fas_cards_played = 0\n",
        "\n",
        "            with open(file_name) as f:\n",
        "                data = json.load(f)\n",
        "\n",
        "                # Check not custom\n",
        "                if data[\"customGameSettings\"][\"enabled\"]:\n",
        "                    continue\n",
        "                # Check if the game is 7 players\n",
        "                if len(data[\"players\"]) != 7:\n",
        "                    continue\n",
        "                # Check not rebalanced 7p\n",
        "                if data[\"gameSetting\"][\"rebalance7p\"]:\n",
        "                    continue\n",
        "\n",
        "                # Fill roles\n",
        "                for seat in range(0, 7):\n",
        "                    roles.append(1 if (data[\"players\"][seat][\"role\"] == \"fascist\" or data[\"players\"][seat][\"role\"] == \"hitler\") else 0)\n",
        "\n",
        "                # Pick one of the lib seats to play as\n",
        "                lib_count = 0\n",
        "                confirmed_seat = 0\n",
        "                for seat in range(7):\n",
        "                    if data[\"players\"][seat][\"role\"] == \"liberal\":\n",
        "                        if lib_count == lib_number:\n",
        "                            confirmed_seat = seat\n",
        "                        lib_count = lib_count + 1\n",
        "\n",
        "                # One-hot encode which seat the network is playing\n",
        "                confirmed[confirmed_seat] = 1\n",
        "\n",
        "                if len(data[\"logs\"]) <= 0:\n",
        "                    game_valid = False\n",
        "\n",
        "                # Length 8 (1-7 - chancellor seat number) (8 - result)\n",
        "                investigation_data = [0] * 8\n",
        "                # Length 7 (1-7 - chosen seat number)\n",
        "                special_election_data = [0] * 7\n",
        "                # Length 14 (1-7 - shot seat number)\n",
        "                bullet_data_1 = [0] * 7\n",
        "                # Length 14 (1-7 - shot seat number)\n",
        "                bullet_data_2 = [0] * 7\n",
        "\n",
        "                # For each government\n",
        "                for gov in range(0, len(data[\"logs\"])):\n",
        "                    # Is this government valid\n",
        "                    gov_valid = False\n",
        "                    # Did a veto force a td\n",
        "                    veto_and_td = False\n",
        "                    # Lenth 31 (1-7 - pres, 8-14 chanc, 15-18 pres claim, 19-21 chanc claim, 22 veto, 23 blue, 24 red, 25-31 vote data)\n",
        "                    gov_data = []\n",
        "                    # Contains topdeck data\n",
        "                    topdeck = []\n",
        "\n",
        "                    # If the government was played\n",
        "                    if len(data[\"logs\"][gov]) >= 7:\n",
        "                        num_played_govs += 1\n",
        "                        gov_valid = True\n",
        "\n",
        "                        # President seat number\n",
        "                        for pres in range(0, 7):\n",
        "                            gov_data.append(1 if data[\"logs\"][gov][\"presidentId\"] == pres else 0)\n",
        "\n",
        "                        # Chancellor seat number\n",
        "                        for chan in range(0, 7):\n",
        "                            gov_data.append(1 if data[\"logs\"][gov][\"chancellorId\"] == chan else 0)\n",
        "\n",
        "                        pres_claim = (data[\"logs\"][gov][\"presidentClaim\"][\"reds\"] if \"presidentClaim\" in data[\"logs\"][gov] else -1) if data[\"logs\"][gov][\"presidentId\"] != confirmed_seat else data[\"logs\"][gov][\"presidentHand\"][\"reds\"]\n",
        "                        chanc_claim = (data[\"logs\"][gov][\"chancellorClaim\"][\"reds\"] if \"chancellorClaim\" in data[\"logs\"][gov] else -1) if data[\"logs\"][gov][\"chancellorId\"] != confirmed_seat else data[\"logs\"][gov][\"chancellorHand\"][\"reds\"]          \n",
        "\n",
        "                        # President number of reds claimed\n",
        "                        if \"presidentClaim\" in data[\"logs\"][gov]:\n",
        "                            gov_data.append(1 if pres_claim == 0 else 0)\n",
        "                            gov_data.append(1 if pres_claim == 1 else 0)\n",
        "                            gov_data.append(1 if pres_claim == 2 else 0)\n",
        "                            gov_data.append(1 if pres_claim == 3 else 0)\n",
        "                        elif \"chancellorClaim\" in data[\"logs\"][gov]:\n",
        "                            pres_claim = chanc_claim + 1\n",
        "                            gov_data.append(0)\n",
        "                            gov_data.append(1 if chanc_claim == 0 else 0)\n",
        "                            gov_data.append(1 if chanc_claim == 1 else 0)\n",
        "                            gov_data.append(1 if chanc_claim == 2 else 0)\n",
        "                        elif \"enactedPolicy\" in data[\"logs\"][gov]:\n",
        "                            gov_data.append(0)\n",
        "                            gov_data.append(0)\n",
        "                            gov_data.append(0 if data[\"logs\"][gov][\"enactedPolicy\"] == \"fascist\" else 1)\n",
        "                            gov_data.append(1 if data[\"logs\"][gov][\"enactedPolicy\"] == \"fascist\" else 0)\n",
        "                        else:\n",
        "                            game_valid = False\n",
        "\n",
        "                        # Chancellor number of reds claimed\n",
        "                        if \"chancellorClaim\" in data[\"logs\"][gov]:\n",
        "                            gov_data.append(1 if chanc_claim == 0 else 0)\n",
        "                            gov_data.append(1 if chanc_claim == 1 else 0)\n",
        "                            gov_data.append(1 if chanc_claim == 2 else 0)\n",
        "                        elif \"presidentClaim\" in data[\"logs\"][gov]:\n",
        "                            if \"enactedPolicy\" in data[\"logs\"][gov] and data[\"logs\"][gov][\"enactedPolicy\"] == \"fascist\":\n",
        "                                chanc_claim = 2\n",
        "                                gov_data.append(0)\n",
        "                                gov_data.append(0)\n",
        "                                gov_data.append(1)\n",
        "                            else:\n",
        "                                chanc_claim = min(0, pres_claim - 1)\n",
        "                                gov_data.append(1 if chanc_claim == 0 else 0)\n",
        "                                gov_data.append(1 if chanc_claim == 1 else 0)\n",
        "                                gov_data.append(0)\n",
        "                        elif \"enactedPolicy\" in data[\"logs\"][gov]:\n",
        "                            gov_data.append(0)\n",
        "                            gov_data.append(0 if data[\"logs\"][gov][\"enactedPolicy\"] == \"fascist\" else 1)\n",
        "                            gov_data.append(1 if data[\"logs\"][gov][\"enactedPolicy\"] == \"fascist\" else 0)\n",
        "                        else:\n",
        "                            game_valid = False\n",
        "\n",
        "                        # Encode card outed\n",
        "                        if (confirmed_seat == data[\"logs\"][gov][\"presidentId\"] or confirmed_seat == data[\"logs\"][gov][\"chancellorId\"]) and (pres_claim - chanc_claim != 1 and pres_claim != 0) and \"enactedPolicy\" in data[\"logs\"][gov] and data[\"logs\"][gov][\"enactedPolicy\"] == \"fascist\":\n",
        "                            game_outed[data[\"logs\"][gov][\"chancellorId\" if confirmed_seat == data[\"logs\"][gov][\"presidentId\"] else \"presidentId\"]] = 1\n",
        "                            \n",
        "                        # Veto\n",
        "                        gov_data.append(1 if (\"presidentVeto\" in data[\"logs\"][gov] and \"chancellorVeto\" in data[\"logs\"][gov] and data[\"logs\"][gov][\"presidentVeto\"] and data[\"logs\"][gov][\"chancellorVeto\"]) else 0)\n",
        "\n",
        "                        # Enacted policy\n",
        "                        if \"enactedPolicy\" in data[\"logs\"][gov]:\n",
        "                            gov_data.append(0 if data[\"logs\"][gov][\"enactedPolicy\"] == \"fascist\" else 1)\n",
        "                            gov_data.append(1 if data[\"logs\"][gov][\"enactedPolicy\"] == \"fascist\" else 0)\n",
        "                        else:\n",
        "                            gov_data.append(0)\n",
        "                            gov_data.append(0)\n",
        "\n",
        "                        # Vote data\n",
        "                        for seat in range(0, 7):\n",
        "                          gov_data.append(1 if data[\"logs\"][gov][\"votes\"][seat] else 0)\n",
        "                        \n",
        "                        # If investigation\n",
        "                        if \"investigationId\" in data[\"logs\"][gov]:\n",
        "                            investigation_data[data[\"logs\"][gov][\"investigationId\"]] = 1\n",
        "                            if not \"investigationClaim\" in data[\"logs\"][gov]:\n",
        "                                game_valid = False\n",
        "                            else:\n",
        "                                investigation_data[7] = 1 if data[\"logs\"][gov][\"investigationClaim\"] == \"fascist\" else 0\n",
        "\n",
        "                        # Encode inv outed\n",
        "                        if \"investigationId\" in data[\"logs\"][gov] and (confirmed_seat == data[\"logs\"][gov][\"presidentId\"] or confirmed_seat == data[\"logs\"][gov][\"investigationId\"]) and \"investigationClaim\" in data[\"logs\"][gov] and data[\"logs\"][gov][\"investigationClaim\"] == \"fascist\":\n",
        "                            game_outed[data[\"logs\"][gov][\"investigationId\" if confirmed_seat == data[\"logs\"][gov][\"presidentId\"] else \"presidentId\"]] = 1\n",
        "\n",
        "                        # Encode inv confirmed\n",
        "                        if \"investigationId\" in data[\"logs\"][gov] and confirmed_seat == data[\"logs\"][gov][\"presidentId\"] and roles[data[\"logs\"][gov][\"investigationId\"]] == 0:\n",
        "                            confirmed[data[\"logs\"][gov][\"investigationId\"]] = 1\n",
        "\n",
        "                        # Did a veto force a topdeck\n",
        "                        if \"presidentVeto\" in data[\"logs\"][gov] and \"chancellorVeto\" in data[\"logs\"][gov] and data[\"logs\"][gov][\"presidentVeto\"] and data[\"logs\"][gov][\"chancellorVeto\"] and \"enactedPolicy\" in data[\"logs\"][gov]:\n",
        "                            veto_and_td = True\n",
        "  \n",
        "                        # If Special Election\n",
        "                        if \"specialElection\" in data[\"logs\"][gov]:\n",
        "                            special_election_data[data[\"logs\"][gov][\"specialElection\"]] = 1\n",
        "                            \n",
        "                        # If bullet\n",
        "                        if \"execution\" in data[\"logs\"][gov]:\n",
        "                            # If first bullet\n",
        "                            if not 1 in bullet_data_1:\n",
        "                                bullet_data_1[data[\"logs\"][gov][\"execution\"]] = 1\n",
        "                            # If second bullet\n",
        "                            else:\n",
        "                                bullet_data_2[data[\"logs\"][gov][\"execution\"]] = 1\n",
        "\n",
        "                    # Neined government\n",
        "                    elif \"presidentId\" in data[\"logs\"][gov] and \"chancellorId\" in data[\"logs\"][gov] and \"votes\" in data[\"logs\"][gov] and len(data[\"logs\"][gov][\"votes\"]) == 7:\n",
        "                        gov_valid = True\n",
        "                        # President seat number\n",
        "                        for pres in range(0, 7):\n",
        "                            gov_data.append(1 if data[\"logs\"][gov][\"presidentId\"] == pres else 0)\n",
        "\n",
        "                        # Chancellor seat number\n",
        "                        for chan in range(0, 7):\n",
        "                            gov_data.append(1 if data[\"logs\"][gov][\"chancellorId\"] == chan else 0)\n",
        "\n",
        "                        # Empty data\n",
        "                        for fill in range(8):\n",
        "                            gov_data.append(0)\n",
        "\n",
        "                        # Encode enacted policy if topdecked\n",
        "                        if \"enactedPolicy\" in data[\"logs\"][gov]:\n",
        "                            gov_data.append(0 if data[\"logs\"][gov][\"enactedPolicy\"] == \"fascist\" else 1)\n",
        "                            gov_data.append(1 if data[\"logs\"][gov][\"enactedPolicy\"] == \"fascist\" else 0)\n",
        "                        else:\n",
        "                            gov_data.append(0)\n",
        "                            gov_data.append(0)\n",
        "\n",
        "                        # Vote data\n",
        "                        for seat in range(0, 7):\n",
        "                            gov_data.append(1 if data[\"logs\"][gov][\"votes\"][seat] else 0)\n",
        "\n",
        "                    else:\n",
        "                        game_valid = False\n",
        "\n",
        "                    # If the government was a topdeck\n",
        "                    if (len(data[\"logs\"][gov]) == 4 and (\"enactedPolicy\" in data[\"logs\"][gov])) or veto_and_td:\n",
        "                        gov_valid = True\n",
        "                        topdeck.append(1)\n",
        "                    else:\n",
        "                        topdeck.append(0)\n",
        "\n",
        "                    # If Hitler was elected in HZ\n",
        "                    if \"chancellorId\" in data[\"logs\"][gov] and len(data[\"logs\"][gov]) == 3 and gov == len(data[\"logs\"]) - 1 and data[\"players\"][data[\"logs\"][gov][\"chancellorId\"]][\"role\"] == \"hitler\" and fas_cards_played >= 3:\n",
        "                        game_outed[data[\"logs\"][gov][\"chancellorId\"]] = 1\n",
        "                        game_hitler[data[\"logs\"][gov][\"chancellorId\"]] = 1\n",
        "\n",
        "                    # If Hitler was shot at any point\n",
        "                    if \"execution\" in data[\"logs\"][gov] and gov == len(data[\"logs\"]) - 1 and data[\"players\"][data[\"logs\"][gov][\"execution\"]][\"role\"] == \"hitler\":\n",
        "                        game_outed[data[\"logs\"][gov][\"execution\"]] = 1\n",
        "                        game_hitler[data[\"logs\"][gov][\"execution\"]] = 1\n",
        "\n",
        "                    # Encode chancellors in HZ being CNH\n",
        "                    if \"chancellorId\" in data[\"logs\"][gov] and len(data[\"logs\"][gov]) >= 7 and fas_cards_played >= 3:\n",
        "                        game_cnh[data[\"logs\"][gov][\"chancellorId\"]] = 1\n",
        "\n",
        "                    # All the people confirmed lib are also CNH, for example after inv\n",
        "                    for seat in range(7):\n",
        "                        game_cnh[seat] = game_cnh[seat] | confirmed[seat]\n",
        "\n",
        "                    # If a policy was enacted, updated board fas and lib card counts\n",
        "                    if \"enactedPolicy\" in data[\"logs\"][gov]:\n",
        "                        if data[\"logs\"][gov][\"enactedPolicy\"] == \"fascist\":\n",
        "                            fas_cards_played += 1\n",
        "                        else:\n",
        "                            lib_cards_played += 1\n",
        "\n",
        "                    # Fill empty data with 0s\n",
        "                    for i in range(len(gov_data), 31):\n",
        "                        gov_data.append(0)\n",
        "                    for i in range(len(investigation_data), 8):\n",
        "                        investigation_data.append(0)\n",
        "                    for i in range(len(special_election_data), 7):\n",
        "                        special_election_data.append(0)\n",
        "                    for i in range(len(bullet_data_1), 7):\n",
        "                        bullet_data_1.append(0)\n",
        "                    for i in range(len(bullet_data_2), 7):\n",
        "                        bullet_data_2.append(0)\n",
        "\n",
        "                    game_data.append(gov_data + investigation_data + special_election_data + bullet_data_1 + bullet_data_2 + topdeck + confirmed + game_outed + game_hitler + game_cnh)\n",
        "                    \n",
        "                    # If some misclaim / troll play will mess up training\n",
        "                    for seat in range(7):\n",
        "                        if confirmed[seat] == 1 and roles[seat] == 1:\n",
        "                            game_valid = False\n",
        "\n",
        "                if num_played_govs < 3:\n",
        "                    game_valid = False\n",
        "\n",
        "                if game_valid:\n",
        "                    game_lengths.append(min(max_num_govs, len(game_data)))\n",
        "\n",
        "                for i in range(len(game_data), max_num_govs):\n",
        "                    game_data.append([0] * num_input_nodes)\n",
        "\n",
        "                if game_valid:\n",
        "                    num_valid_games += 1\n",
        "                    games.append(game_data[:max_num_govs])\n",
        "                    results.append(roles)\n",
        "                    game_numbers.append(game_number)\n",
        "                    outed.append(game_outed)\n",
        "\n",
        "\n",
        "    # Remove games with fake conflicts\n",
        "    for t in range(len(games) - 1, -1, -1):\n",
        "        for seat in range(7):\n",
        "            if outed[t][seat] == 1 and results[t][seat] == 0:\n",
        "                del games[t]\n",
        "                del results[t]\n",
        "                del game_numbers[t]\n",
        "                del game_lengths[t]\n",
        "                del outed[t]\n",
        "                break\n",
        "\n",
        "    return games, results, game_numbers, game_lengths, outed"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wMKFsTgySToR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "import os\n",
        "import numpy as np\n",
        "from torch.autograd import Variable\n",
        "import matplotlib.pyplot as plt\n",
        "import gc\n",
        "import sys\n",
        "\n",
        "# Prints the entire numpy array\n",
        "np.set_printoptions(threshold=sys.maxsize)\n",
        "\n",
        "# Deterministic randomness\n",
        "torch.manual_seed(0)\n",
        "\n",
        "# Garbage collect\n",
        "gc.collect()\n",
        "\n",
        "# Enables device agnostic tensor creation\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "\n",
        "# Empty the CUDA cache\n",
        "with torch.no_grad():\n",
        "    torch.cuda.empty_cache()\n",
        "torch.cuda.empty_cache()\n",
        "\n",
        "# Recurrent Neural Network\n",
        "class RNN(nn.Module):\n",
        "    def __init__(self, n_inputs, n_hidden, X_in, seq_lengths):\n",
        "        super(RNN, self).__init__()\n",
        "        self.rnn = nn.LSTM(n_inputs, n_hidden, batch_first=True, num_layers=1, dropout=0.0)\n",
        "        self.n_hidden = n_hidden\n",
        "        self.X = X_in\n",
        "        self.seq_lengths = seq_lengths\n",
        "        self.FC = nn.Linear(self.n_hidden, 7)\n",
        "    def forward(self):\n",
        "        # Initialize the hidden state with all zeroes\n",
        "        self.init_hidden()\n",
        "        # Pack X\n",
        "        self.X_packed = torch.nn.utils.rnn.pack_padded_sequence(Variable(self.X), self.seq_lengths, batch_first=True, enforce_sorted=False)\n",
        "        # Calculate values of hidden states\n",
        "        _, self.hx = self.rnn(self.X_packed)\n",
        "        # Run the states through the sigmoid function\n",
        "        sigmoid = nn.Sigmoid()\n",
        "        out = sigmoid(self.FC(self.hx[0][0])).to(device)\n",
        "\n",
        "        return out\n",
        "    def init_hidden(self):\n",
        "        self.hx = Variable(torch.zeros(1, len(self.X), self.n_hidden).to(device))\n",
        "\n",
        "# Hyperparameters\n",
        "# N_EPOCHS determined at runtime based on training_length\n",
        "LEARNING_RATE = 0.0015\n",
        "LAMBDA_ = .0004\n",
        "N_HIDDEN = 17\n",
        "\n",
        "# Training lengths\n",
        "training_lengths = []\n",
        "for length in range(1, 30):\n",
        "    training_lengths.append(length)\n",
        "\n",
        "# Number of nodes in input layer\n",
        "N_INPUT = 89\n",
        "\n",
        "# Number of games\n",
        "N_GAMES = 25000\n",
        "\n",
        "# Train a model for each game_length\n",
        "for training_length in training_lengths:\n",
        "\n",
        "    # Training set\n",
        "    X, Y, train_game_numbers, train_seq_lengths, train_outed = populate_inputs(2, int(N_GAMES * 0.8), training_length)\n",
        "\n",
        "    # Validation set\n",
        "    validation_X, validation_Y, validation_game_numbers, validation_seq_lengths, validation_outed = populate_inputs(int(N_GAMES * 0.8), int(N_GAMES * 1), training_length)\n",
        "\n",
        "    # Convert to tensors\n",
        "    X = torch.as_tensor(X, dtype=torch.float32).to(device)\n",
        "    Y = torch.as_tensor(Y).to(device)\n",
        "    train_game_numbers = torch.as_tensor(train_game_numbers).to(device)\n",
        "    train_seq_lengths = torch.as_tensor(train_seq_lengths).to(device)\n",
        "    train_outed = torch.as_tensor(train_outed).to(device)\n",
        "\n",
        "    validation_X = torch.as_tensor(validation_X, dtype=torch.float32).to(device)\n",
        "    validation_Y = torch.as_tensor(validation_Y).to(device)\n",
        "    validation_game_numbers = torch.as_tensor(validation_game_numbers).to(device)\n",
        "    validation_seq_lengths = torch.as_tensor(validation_seq_lengths).to(device)\n",
        "    validation_outed = torch.as_tensor(validation_outed).to(device)\n",
        "\n",
        "    # Training model\n",
        "    train_model = RNN(N_INPUT, N_HIDDEN, X, train_seq_lengths).to(device)\n",
        "\n",
        "    # Validation model\n",
        "    validation_model = RNN(N_INPUT, N_HIDDEN, validation_X, validation_seq_lengths).to(device)\n",
        "\n",
        "    # Set the loss function to binary cross entropy and use Adam optimizer\n",
        "    criterion = nn.BCELoss().to(device)\n",
        "    optimizer = optim.Adam(train_model.parameters(), lr=LEARNING_RATE, weight_decay=LAMBDA_)\n",
        "\n",
        "    # Training metrics\n",
        "    train_seat_errors = []\n",
        "\n",
        "    # Validation metrics\n",
        "    validation_seat_errors = []\n",
        "    rounded_validation_seat_errors = []\n",
        "    sorted_validation_seat_errors = []\n",
        "    threshold_validation_seat_errors = []\n",
        "\n",
        "    # The longer game lengths need more epochs to be fit\n",
        "    N_EPOCHS = 5000 if training_length < 15 else 10000\n",
        "\n",
        "    for epoch in range(N_EPOCHS):\n",
        "        # Print the epoch number every 100 epochs\n",
        "        if epoch % 100 == 0:\n",
        "            print(\"Epoch \" + str(epoch))\n",
        "\n",
        "        train_model.train()\n",
        "        validation_model.train()\n",
        "\n",
        "        # zero the parameter gradients\n",
        "        optimizer.zero_grad()\n",
        "\n",
        "        # reset hidden states\n",
        "        train_model.init_hidden()\n",
        "        validation_model.init_hidden()\n",
        "\n",
        "        # Run the model, collect states (store them)\n",
        "        last_states = train_model()\n",
        "\n",
        "        # Calculate loss and backpropogate\n",
        "        loss = criterion(last_states.float(), Y.float())\n",
        "\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        # Evaluate the training set errors and store them\n",
        "        train_seat_error = torch.sum(torch.abs(Y - last_states)) / len(Y)\n",
        "        train_seat_errors.append(train_seat_error.detach().item())\n",
        "        \n",
        "        train_model.eval()\n",
        "\n",
        "        # Transfer weights of training model to the validation model for validation\n",
        "        torch.save(train_model.state_dict(), 'parameters-transfer')\n",
        "        validation_model.load_state_dict(torch.load('parameters-transfer'))\n",
        "        \n",
        "        # Run the validation model on the validation data set and store predictions\n",
        "        prediction = validation_model()\n",
        "\n",
        "        # Store the errors for the validation set\n",
        "        validation_seat_error = torch.sum(torch.abs(validation_Y - prediction)) / len(validation_Y)\n",
        "        validation_seat_errors.append(validation_seat_error.detach().item())\n",
        "\n",
        "        # Store the errors for the validation set, but round to either 0 or 1\n",
        "        rounded_validation_seat_error = torch.sum(torch.abs(validation_Y - torch.round(prediction))) / len(validation_Y)\n",
        "        rounded_validation_seat_errors.append(rounded_validation_seat_error.detach().item())\n",
        "\n",
        "        # If this is the middle or last epoch\n",
        "        if (epoch + 1) % (N_EPOCHS / 2) == 0:\n",
        "\n",
        "            # Assume the 3 highest values are fascist and the rest are lib\n",
        "            _, sorted_validation_seat_indices = torch.sort(prediction)\n",
        "            sorted_prediction = torch.zeros(prediction.size()).to(device)\n",
        "            for i in range(4, 7):\n",
        "                for game in range(len(validation_X)):\n",
        "                    sorted_prediction[game][sorted_validation_seat_indices[game][i]] = 1\n",
        "            sorted_validation_seat_error = torch.sum(torch.abs(validation_Y - sorted_prediction)) / len(validation_Y)\n",
        "            sorted_validation_seat_errors.append(sorted_validation_seat_error.detach().item())\n",
        "\n",
        "        validation_model.eval()\n",
        "\n",
        "    # Save the parameters for this model\n",
        "    save_name = \"parameters-\" + str(training_length) + \".pt\"\n",
        "    torch.save(train_model.state_dict(), save_name)\n",
        "\n",
        "    # Print validation set results\n",
        "    print(\"\\nValidation Set Data\")\n",
        "    print(\"Game #\" + str(validation_game_numbers[-1]))\n",
        "    print(\"Pred: \" + str(prediction[-1]) + \"\\nReal: \" + str(validation_Y[-1]))\n",
        "\n",
        "    # Data after all epochs\n",
        "    print(\"\\n\" + '\\033[1m' + \"End\")\n",
        "    print('\\033[21m' + \"Train error: \" + \"                      %.4f\" % train_seat_errors[-1])\n",
        "    print(\"Validation error: \" + \"                 %.4f\" % validation_seat_errors[-1])\n",
        "    print(\"Validation error with threshold: \" + \"  %.4f\" % rounded_validation_seat_errors[-1])\n",
        "    print(\"Validation error with sort: \" + \"       %.4f\" % sorted_validation_seat_errors[-1])\n",
        "\n",
        "    # Graph Train Error\n",
        "    plt.subplot(3, 1, 1)\n",
        "    plt.title(\"Raw Seat Errors\")\n",
        "    plt.plot(train_seat_errors)\n",
        "    plt.plot(validation_seat_errors)\n",
        "\n",
        "    # Graph validation set error\n",
        "    plt.subplot(3, 1, 2)\n",
        "    plt.title(\"Threshold Validation Error\")\n",
        "    plt.plot(rounded_validation_seat_errors)\n",
        "\n",
        "    # Pad graphs so the titles and graphs don't overlap\n",
        "    plt.tight_layout()\n",
        "\n",
        "    # Show plot\n",
        "    plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VtwKvEKsnA-F",
        "colab_type": "text"
      },
      "source": [
        "# Live Game Prediction"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F-0bwpSceKec",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import json\n",
        "\n",
        "def load_game(file_name):\n",
        "    \"\"\"\n",
        "    Loads game information from a json file and populates the input layer of the LSTM\n",
        "\n",
        "    Parameters\n",
        "    ----------\n",
        "    file_name : str\n",
        "        Parse json file file_name\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    list\n",
        "        List of containing one element: the data for this game\n",
        "    \"\"\"\n",
        "\n",
        "    game_data = []\n",
        "    game_outed = [0] * 7\n",
        "    game_hitler = [0] * 7\n",
        "    game_cnh = [0] * 7\n",
        "    confirmed = [0] * 7\n",
        "\n",
        "    lib_cards_played = 0\n",
        "    fas_cards_played = 0\n",
        "\n",
        "    with open(file_name) as file_in:\n",
        "        data = json.load(file_in)\n",
        "\n",
        "        # Encode network's seat\n",
        "        for seat in range(0, 7):\n",
        "            if data[\"players\"][seat][\"role\"] == \"liberal\":\n",
        "                confirmed[seat] = 1\n",
        "                confirmed_seat = seat\n",
        "\n",
        "        # Length 8 (1-7 - investigated seat number) (8 - result)\n",
        "        investigation_data = [0] * 8\n",
        "        # Length 7 (1-7 - chosen seat number)\n",
        "        special_election_data = [0] * 7\n",
        "        # Length 7 (1-7 - shot seat number)\n",
        "        bullet_data_1 = [0] * 7\n",
        "        # Length 7 (1-7 - shot seat number)\n",
        "        bullet_data_2 = [0] * 7\n",
        "\n",
        "        # For each government\n",
        "        for gov in range(0, len(data[\"logs\"])):\n",
        "\n",
        "            # If a veto forces a td\n",
        "            veto_and_td = False\n",
        "            # Lenth 31 (1-7 - pres, 8-14 chanc, 15-18 pres claim, 19-21 chanc claim, 22 veto, 23 blue, 24 red, 25-31 vote data)\n",
        "            gov_data = []\n",
        "            # Topdeck data\n",
        "            topdeck = []\n",
        "\n",
        "            # If the government was played\n",
        "            if len(data[\"logs\"][gov]) >= 5:\n",
        "\n",
        "                # President seat number\n",
        "                for pres in range(0, 7):\n",
        "                    gov_data.append(1 if data[\"logs\"][gov][\"presidentId\"] == pres else 0)\n",
        "\n",
        "                # Chancellor seat number\n",
        "                for chan in range(0, 7):\n",
        "                    gov_data.append(1 if data[\"logs\"][gov][\"chancellorId\"] == chan else 0)\n",
        "\n",
        "                pres_claim = data[\"logs\"][gov][\"presidentClaim\"][\"reds\"]\n",
        "                chanc_claim = data[\"logs\"][gov][\"chancellorClaim\"][\"reds\"]\n",
        "\n",
        "                # President number of reds claimed\n",
        "                if \"presidentClaim\" in data[\"logs\"][gov]:\n",
        "                    gov_data.append(1 if pres_claim == 0 else 0)\n",
        "                    gov_data.append(1 if pres_claim == 1 else 0)\n",
        "                    gov_data.append(1 if pres_claim == 2 else 0)\n",
        "                    gov_data.append(1 if pres_claim == 3 else 0)\n",
        "\n",
        "                # Chancellor number of reds claimed\n",
        "                if \"chancellorClaim\" in data[\"logs\"][gov]:\n",
        "                    gov_data.append(1 if chanc_claim == 0 else 0)\n",
        "                    gov_data.append(1 if chanc_claim == 1 else 0)\n",
        "                    gov_data.append(1 if chanc_claim == 2 else 0)\n",
        "\n",
        "                # Encode card outed\n",
        "                if (confirmed_seat == data[\"logs\"][gov][\"presidentId\"] or confirmed_seat == data[\"logs\"][gov][\"chancellorId\"]) and (pres_claim - chanc_claim != 1 and pres_claim != 0) and \"enactedPolicy\" in data[\"logs\"][gov] and data[\"logs\"][gov][\"enactedPolicy\"] == \"fascist\":\n",
        "                    game_outed[data[\"logs\"][gov][\"chancellorId\" if confirmed_seat == data[\"logs\"][gov][\"presidentId\"] else \"presidentId\"]] = 1\n",
        "                    \n",
        "                # Veto\n",
        "                gov_data.append(1 if (\"presidentVeto\" in data[\"logs\"][gov] and \"chancellorVeto\" in data[\"logs\"][gov] and data[\"logs\"][gov][\"presidentVeto\"] and data[\"logs\"][gov][\"chancellorVeto\"]) else 0)\n",
        "\n",
        "                # Enacted policy\n",
        "                if \"enactedPolicy\" in data[\"logs\"][gov]:\n",
        "                    gov_data.append(0 if data[\"logs\"][gov][\"enactedPolicy\"] == \"fascist\" else 1)\n",
        "                    gov_data.append(1 if data[\"logs\"][gov][\"enactedPolicy\"] == \"fascist\" else 0)\n",
        "                else:\n",
        "                    gov_data.append(0)\n",
        "                    gov_data.append(0)\n",
        "\n",
        "                # Vote data\n",
        "                for seat in range(0, 7):\n",
        "                    gov_data.append(1 if data[\"logs\"][gov][\"votes\"][seat] else 0)\n",
        "                \n",
        "                # If investigation\n",
        "                if \"investigationId\" in data[\"logs\"][gov]:\n",
        "                    investigation_data[data[\"logs\"][gov][\"investigationId\"]] = 1\n",
        "                    investigation_data[7] = 1 if data[\"logs\"][gov][\"investigationClaim\"] == \"fascist\" else 0\n",
        "\n",
        "                # Encode inv outed\n",
        "                if \"investigationId\" in data[\"logs\"][gov] and (confirmed_seat == data[\"logs\"][gov][\"presidentId\"] or confirmed_seat == data[\"logs\"][gov][\"investigationId\"]) and data[\"logs\"][gov][\"investigationClaim\"] == \"fascist\":\n",
        "                    game_outed[data[\"logs\"][gov][\"investigationId\" if confirmed_seat == data[\"logs\"][gov][\"presidentId\"] else \"presidentId\"]] = 1\n",
        "\n",
        "                # Encode inv confirmed\n",
        "                if \"investigationId\" in data[\"logs\"][gov] and confirmed_seat == data[\"logs\"][gov][\"presidentId\"] and data[\"logs\"][gov][\"investigationClaim\"] == \"liberal\": \n",
        "                    confirmed[data[\"logs\"][gov][\"investigationId\"]] = 1\n",
        "\n",
        "                # Did a veto force a topdeck\n",
        "                if \"presidentVeto\" in data[\"logs\"][gov] and \"chancellorVeto\" in data[\"logs\"][gov] and data[\"logs\"][gov][\"presidentVeto\"] and data[\"logs\"][gov][\"chancellorVeto\"] and \"enactedPolicy\" in data[\"logs\"][gov]:\n",
        "                    veto_and_td = True\n",
        "\n",
        "                # If Special Election\n",
        "                if \"specialElection\" in data[\"logs\"][gov]:\n",
        "                    special_election_data[data[\"logs\"][gov][\"specialElection\"]] = 1\n",
        "\n",
        "                # If bullet\n",
        "                if \"execution\" in data[\"logs\"][gov]:\n",
        "                    # If first bullet\n",
        "                    if not 1 in bullet_data_1:\n",
        "                        bullet_data_1[data[\"logs\"][gov][\"execution\"]] = 1\n",
        "                    # If second bullet\n",
        "                    else:\n",
        "                        bullet_data_2[data[\"logs\"][gov][\"execution\"]] = 1\n",
        "\n",
        "            # Neined government\n",
        "            else:\n",
        "                # President seat number\n",
        "                for pres in range(0, 7):\n",
        "                    gov_data.append(1 if data[\"logs\"][gov][\"presidentId\"] == pres else 0)\n",
        "\n",
        "                # Chancellor seat number\n",
        "                for chan in range(0, 7):\n",
        "                    gov_data.append(1 if data[\"logs\"][gov][\"chancellorId\"] == chan else 0)\n",
        "\n",
        "                # Empty data\n",
        "                for fill in range(8):\n",
        "                    gov_data.append(0)\n",
        "\n",
        "                # Encode enacted policy if topdecked\n",
        "                if \"enactedPolicy\" in data[\"logs\"][gov]:\n",
        "                    gov_data.append(0 if data[\"logs\"][gov][\"enactedPolicy\"] == \"fascist\" else 1)\n",
        "                    gov_data.append(1 if data[\"logs\"][gov][\"enactedPolicy\"] == \"fascist\" else 0)\n",
        "                else:\n",
        "                    gov_data.append(0)\n",
        "                    gov_data.append(0)\n",
        "\n",
        "                # Vote data\n",
        "                for seat in range(0, 7):\n",
        "                    gov_data.append(1 if data[\"logs\"][gov][\"votes\"][seat] else 0)\n",
        "\n",
        "            # If the government was a topdeck\n",
        "            if (len(data[\"logs\"][gov]) == 4 and (\"enactedPolicy\" in data[\"logs\"][gov])) or veto_and_td:\n",
        "                topdeck.append(1)\n",
        "            else:\n",
        "                topdeck.append(0)\n",
        "\n",
        "            # If Hitler was elected in HZ\n",
        "            if len(data[\"logs\"][gov]) == 4 and \"hitler\" in data[\"logs\"][gov] and fas_cards_played >= 3:\n",
        "                game_outed[data[\"logs\"][gov][\"chancellorId\"]] = 1\n",
        "                game_hitler[data[\"logs\"][gov][\"chancellorId\"]] = 1\n",
        "\n",
        "            # If Hitler was shot at any point\n",
        "            if \"execution\" in data[\"logs\"][gov] and \"hitler\" in data[\"logs\"][gov]:\n",
        "                game_outed[data[\"logs\"][gov][\"execution\"]] = 1\n",
        "                game_hitler[data[\"logs\"][gov][\"execution\"]] = 1\n",
        "\n",
        "            # Encode chancellors in HZ being CNH\n",
        "            if len(data[\"logs\"][gov]) >= 5 and fas_cards_played >= 3:\n",
        "                game_cnh[data[\"logs\"][gov][\"chancellorId\"]] = 1\n",
        "\n",
        "            # All the people confirmed lib are also CNH, for example after inv\n",
        "            for seat in range(7):\n",
        "                game_cnh[seat] = game_cnh[seat] | confirmed[seat]\n",
        "\n",
        "            if \"enactedPolicy\" in data[\"logs\"][gov]:\n",
        "                if data[\"logs\"][gov][\"enactedPolicy\"] == \"fascist\":\n",
        "                    fas_cards_played += 1\n",
        "                else:\n",
        "                    lib_cards_played += 1\n",
        "\n",
        "            # Fill empty data with 0s\n",
        "            for i in range(len(gov_data), 31):\n",
        "                gov_data.append(0)\n",
        "\n",
        "            game_data.append(gov_data + investigation_data + special_election_data + bullet_data_1 + bullet_data_2 + topdeck + confirmed + game_outed + game_hitler + game_cnh)\n",
        "\n",
        "    return [game_data]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Hc_I593qe4ai",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import json\n",
        "import re\n",
        "\n",
        "def convert_to_json(file_name):\n",
        "    \"\"\"\n",
        "    Takes a file containing plaintext game notation and converts it to a json file that can then be interpreted by load_game()\n",
        "     \n",
        "    Example: file_name is the name of a file with the following plaintext game notation:\n",
        "\n",
        "    SEAT 1\n",
        "    1111111 - 15 RRB RB B\n",
        "\n",
        "    This method will take that game notation and convert it to a json file containing the following, which can be interpreted by load_game()\n",
        "\n",
        "    {\"logs\": [{\"votes\": [true, true, true, true, true, true, true], \"presidentId\": 0, \"chancellorId\": 4, \"presidentClaim\": {\"reds\": 2, \"blues\": 1}, \"chancellorClaim\": {\"reds\": 1, \"blues\": 1}, \"enactedPolicy\": \"liberal\"}], \n",
        "    \"players\": [{\"role\": \"liberal\"}, {\"role\": \"not_me\"}, {\"role\": \"not_me\"}, {\"role\": \"not_me\"}, {\"role\": \"not_me\"}, {\"role\": \"not_me\"}, {\"role\": \"not_me\"}]}\n",
        "    \n",
        "    Parameters\n",
        "    ----------\n",
        "    file_name : str\n",
        "        Parse plaintext file file_name\n",
        "\n",
        "    Returns\n",
        "    -------\n",
        "    new_file_name : str\n",
        "        String containing the name of a new file containing game information encoded in json format\n",
        "    \"\"\"\n",
        "    \n",
        "    data = {}\n",
        "    data[\"logs\"] = []\n",
        "\n",
        "    with open(file_name) as file_in:\n",
        "        lines = file_in.readlines()\n",
        "\n",
        "    # Create players list that stores my_seat as liberal\n",
        "    my_seat_index = int(re.split('SEAT', lines[0])[1]) - 1\n",
        "    data[\"players\"] = []\n",
        "    for seat in range(7):\n",
        "        seat_data = {}\n",
        "        seat_data[\"role\"] = \"liberal\" if seat == my_seat_index else \"not_me\"\n",
        "        data[\"players\"].append(seat_data)\n",
        "\n",
        "    # Create government logs\n",
        "    for line in lines[1:]:\n",
        "\n",
        "        # Create dict to represent this government\n",
        "        gov = {}\n",
        "        # Votes list\n",
        "        gov[\"votes\"] = (list(re.split(' - ', line)[0]))\n",
        "        # Convert to boolean\n",
        "        for seat in range(7):\n",
        "            gov[\"votes\"][seat] = gov[\"votes\"][seat] == \"1\"\n",
        "\n",
        "        # President and chancellor Ids\n",
        "        gov[\"presidentId\"] = int(re.split(' - ', line)[1][0]) - 1\n",
        "        gov[\"chancellorId\"] = int(re.split(' - ', line)[1][1]) - 1\n",
        "\n",
        "        # If the gov was played\n",
        "        if len(line) > 15:\n",
        "\n",
        "            # President claim\n",
        "            reds = re.split(' - ', line)[1].split()[1].count('R')\n",
        "            # Create dict\n",
        "            gov[\"presidentClaim\"] = {}\n",
        "            # Number of reds and blues claimed\n",
        "            gov[\"presidentClaim\"][\"reds\"] = reds\n",
        "            gov[\"presidentClaim\"][\"blues\"] = 3 - reds\n",
        "\n",
        "            # Chancellor claim\n",
        "            reds = re.split(' - ', line)[1].split()[2].count('R')\n",
        "            # Create dict\n",
        "            gov[\"chancellorClaim\"] = {}\n",
        "            # Number of reds and blues claimed\n",
        "            gov[\"chancellorClaim\"][\"reds\"] = reds\n",
        "            gov[\"chancellorClaim\"][\"blues\"] = 2 - reds\n",
        "\n",
        "            # Enacted policy\n",
        "            policy = re.split(' - ', line)[1].split()[3]\n",
        "            gov[\"enactedPolicy\"] = \"fascist\" if policy == 'R' else \"liberal\"\n",
        "\n",
        "            # If a special action (inv, se, bullet) was taken or veto took place\n",
        "            if line.count('-') == 2:\n",
        "                # If investigation\n",
        "                if \"INV\" in line:\n",
        "                    gov[\"investigationId\"] = int(re.split(' - ', line)[2].split()[1]) - 1\n",
        "                    gov[\"investigationClaim\"] = \"liberal\" if re.split(' - ', line)[2].split()[2] == \"LIB\" else \"fascist\"\n",
        "                \n",
        "                # If special election\n",
        "                if \"SE\" in line:\n",
        "                    gov[\"specialElection\"] = int(re.split(' - ', line)[2].split()[1]) - 1\n",
        "                \n",
        "                # If bullet\n",
        "                if \"KILL\" in line:\n",
        "                    gov[\"execution\"] = int(re.split(' - ', line)[2].split()[1]) - 1\n",
        "\n",
        "                if \"VETO\" in line:\n",
        "                    gov[\"presidentVeto\"] = True\n",
        "                    gov[\"chancellorVeto\"] = True\n",
        "        \n",
        "        # Check if this gov was a topdeck\n",
        "        elif len(line) == 15:\n",
        "            policy = re.split(' - ', line)[1].split()[1]\n",
        "            gov[\"enactedPolicy\"] = \"fascist\" if policy == 'R' else \"liberal\"\n",
        "\n",
        "        if \"H\" in line:\n",
        "            gov[\"hitler\"] = True\n",
        "\n",
        "        # Append this gov to the data\n",
        "        data[\"logs\"].append(gov)\n",
        "\n",
        "    new_file_name = \"game_out.json\"\n",
        "    with open(new_file_name, 'w') as file_out:\n",
        "        json.dump(data, file_out)\n",
        "\n",
        "    return new_file_name"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iXb-a5hlYV7U",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "import os\n",
        "import numpy as np\n",
        "from torch.autograd import Variable\n",
        "import matplotlib.pyplot as plt\n",
        "import gc\n",
        "import sys\n",
        "\n",
        "# Prints the entire numpy array\n",
        "np.set_printoptions(threshold=sys.maxsize)\n",
        "\n",
        "# Deterministic randomness\n",
        "torch.manual_seed(0)\n",
        "\n",
        "# Garbage collect\n",
        "gc.collect()\n",
        "\n",
        "# Enables device agnostic tensor creation\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "\n",
        "# Empty the CUDA cache\n",
        "with torch.no_grad():\n",
        "    torch.cuda.empty_cache()\n",
        "torch.cuda.empty_cache()\n",
        "\n",
        "# Recurrent Neural Network\n",
        "class RNN(nn.Module):\n",
        "    def __init__(self, n_inputs, n_hidden, X_in, seq_lengths):\n",
        "        super(RNN, self).__init__()\n",
        "        self.rnn = nn.LSTM(n_inputs, n_hidden, batch_first=True, num_layers=1, dropout=0.0)\n",
        "        self.n_hidden = n_hidden\n",
        "        self.X = X_in\n",
        "        self.seq_lengths = seq_lengths\n",
        "        self.FC = nn.Linear(self.n_hidden, 7)\n",
        "    def forward(self):\n",
        "        # Initialize the hidden state with all zeroes\n",
        "        self.init_hidden()\n",
        "        # Pack X\n",
        "        self.X_packed = torch.nn.utils.rnn.pack_padded_sequence(Variable(self.X), self.seq_lengths, batch_first=True, enforce_sorted=False)\n",
        "        # Calculate values of hidden states\n",
        "        _, self.hx = self.rnn(self.X_packed)\n",
        "        # Run the states through the sigmoid function\n",
        "        sigmoid = nn.Sigmoid()\n",
        "        out = sigmoid(self.FC(self.hx[0][0])).to(device)\n",
        "\n",
        "        return out\n",
        "    def init_hidden(self):\n",
        "        self.hx = Variable(torch.zeros(1, len(self.X), self.n_hidden).to(device))\n",
        "\n",
        "# Size of input layer\n",
        "N_INPUT = 89\n",
        "# Size of hidden layer\n",
        "N_HIDDEN = 17\n",
        "\n",
        "# Name of game file\n",
        "file_name = \"game_in.txt\"\n",
        "\n",
        "# Training set\n",
        "X = load_game(convert_to_json(file_name))\n",
        "\n",
        "game_length = len(X[0])\n",
        "\n",
        "# Convert to tensor\n",
        "X = torch.as_tensor(X, dtype=torch.float32).to(device)\n",
        "\n",
        "# Create model\n",
        "model = RNN(N_INPUT, N_HIDDEN, X, [game_length]).to(device)\n",
        "\n",
        "# Load the correct model parameters\n",
        "parameter_file_name = \"parameters-\" + str(game_length) + \".pt\"\n",
        "model.load_state_dict(torch.load(parameter_file_name))\n",
        "\n",
        "# Get prediction\n",
        "prediction = model()\n",
        "\n",
        "print(prediction)"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}