nlp/NLP_project.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SsVTf5y5eeO3",
        "outputId": "01f591f7-8e50-4030-9611-d7f435358aad"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n",
            "/content/drive/MyDrive/CMPS6730/project\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "import os\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import PIL\n",
        "import gensim\n",
        "\n",
        "drive.mount('/content/drive')\n",
        "%cd /content/drive/MyDrive/CMPS6730/project"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import gensim\n",
        "from gensim.models import Word2Vec, KeyedVectors\n",
        "from sklearn.decomposition import PCA\n",
        "from collections import defaultdict\n",
        "from nltk.stem.wordnet import WordNetLemmatizer\n",
        "from sklearn.metrics.pairwise import cosine_similarity\n",
        "from nltk.corpus import wordnet\n",
        "import nltk\n",
        "import gzip\n",
        "\n",
        "\n",
        "f_in = gzip.open('GoogleNews-vectors-negative300.bin.gz', 'rb')\n",
        "f_out = open('GoogleNews-vectors-negative300.bin', 'wb')\n",
        "f_out.writelines(f_in)"
      ],
      "metadata": {
        "id": "E4UBF8RcexSF"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import itertools\n",
        "from sklearn.manifold import TSNE\n",
        "from sklearn.decomposition import PCA\n",
        "import pandas as pd\n",
        "import matplotlib.cm as cm\n",
        "import numpy as np\n",
        "class Agent:\n",
        "  def __init__(self, board):\n",
        "    self.model = KeyedVectors.load_word2vec_format('GoogleNews-vectors-negative300.bin', binary=True, limit=500000)\n",
        "\n",
        "    nltk.download('wordnet')\n",
        "    self.past_clues = []\n",
        "    self.embedding_clusters = []\n",
        "    self.word_clusters = []\n",
        "\n",
        "  def generate_clue(self, board):\n",
        "    new_cands = self.get_neighbors(board)\n",
        "    final_clues = self.get_clue(new_cands)\n",
        "    clue = final_clues.pop(0)\n",
        "    i = 0\n",
        "\n",
        "    #try to give different clues each time\n",
        "    while clue in self.past_clues and i < len(final_clues):\n",
        "      i += 1\n",
        "      clue = final_clues.pop(i)\n",
        "      self.past_clues.append(clue)\n",
        "\n",
        "    return clue\n",
        "\n",
        "  def get_neighbors(self, board, n_words=15):\n",
        "    candidate_words = []\n",
        "    new_cands = []\n",
        "    syn_dict = {}\n",
        "\n",
        "    # get neighbors for individual words\n",
        "\n",
        "    for word in board[\"Red\"]:\n",
        "      synonyms = self.generate_synonyms(word)\n",
        "      syn_dict[word] = synonyms\n",
        "\n",
        "    for words in syn_dict:\n",
        "      for synonyms in syn_dict[words]:\n",
        "\n",
        "        try:\n",
        "          neighbors = self.model.most_similar([synonyms], topn=n_words)\n",
        "          for word in board[\"Red\"]:\n",
        "            embeddings = []\n",
        "            words = []\n",
        "            for similar_word, _ in neighbors:\n",
        "                words.append(similar_word)\n",
        "                embeddings.append(self.model[similar_word])\n",
        "            self.embedding_clusters.append(embeddings)\n",
        "            self.word_clusters.append(words)\n",
        "          candidate_words.extend(neighbors)\n",
        "        except KeyError:\n",
        "          pass\n",
        "\n",
        "    for word, score in candidate_words:\n",
        "      if any(not c.isalnum() for c in word) or word.upper() in board[\"Red\"]:\n",
        "        continue\n",
        "      else:\n",
        "        new_cands.append((word.lower(), score))\n",
        "\n",
        "\n",
        "    return sorted(list(set((new_cands))), key=lambda x: x[1], reverse = True)\n",
        "\n",
        "  def generate_synonyms(self, word):\n",
        "    synonyms = []\n",
        "    altered_syn = []\n",
        "    for syn in wordnet.synsets(word):\n",
        "        for i in syn.lemmas():\n",
        "            synonyms.append(i.name().lower())\n",
        "    for i in synonyms:\n",
        "      if word.lower() in i or i in word.lower() or \"_\" in i or \"-\" in i:\n",
        "        continue\n",
        "      else:\n",
        "        altered_syn.append(i)\n",
        "    return list(set(altered_syn))\n",
        "\n",
        "  def get_clue(self, new_cands):\n",
        "\n",
        "    final_clues = []\n",
        "    for word, score in new_cands:\n",
        "      if score >= 0.90:\n",
        "        final_clues.append((word, 3))\n",
        "      elif score <= 0.88 and score >= 0.83:\n",
        "        final_clues.append((word, 2))\n",
        "      elif score <= 0.83:\n",
        "        final_clues.append((word,1))\n",
        "\n",
        "    return final_clues\n",
        "\n",
        "  def create_embeddings(self):\n",
        "    embedding_clusters = np.array(self.embedding_clusters)\n",
        "    n, m, k = embedding_clusters.shape\n",
        "    tsne_model_en_2d = TSNE(perplexity=45, n_components=2, init='pca', n_iter=3500, random_state=32)\n",
        "    embeddings_en_2d = np.array(tsne_model_en_2d.fit_transform(embedding_clusters.reshape(n * m, k))).reshape(n, m, 2)\n",
        "    return embeddings_en_2d\n",
        "\n",
        "  def tsne_plot_similar_words(self, title, labels, a, filename=None):\n",
        "    embedding_clusters = self.create_embeddings()\n",
        "    word_clusters = self.word_clusters\n",
        "    plt.figure(figsize=(16, 9))\n",
        "    colors = cm.rainbow(np.linspace(0, 1, len(labels)))\n",
        "    for label, embeddings, words, color in zip(labels, embedding_clusters, word_clusters, colors):\n",
        "        x = embeddings[:, 0]\n",
        "        y = embeddings[:, 1]\n",
        "\n",
        "        plt.scatter(x, y, c=color, alpha=a, label=label)\n",
        "        for i, word in enumerate(words):\n",
        "            plt.annotate(word, alpha=0.5, xy=(x[i], y[i]), xytext=(5, 2),\n",
        "                         textcoords='offset points', ha='right', va='bottom', size=8)\n",
        "\n",
        "    plt.legend(loc=4)\n",
        "    plt.title(title)\n",
        "    plt.grid(True)\n",
        "\n",
        "    plt.savefig(\"plot.pdf\")\n",
        "    plt.show()\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "0z8nn5_6ATQw"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import random\n",
        "\n",
        "#import pdb\n",
        "import copy\n",
        "\n",
        "class Game:\n",
        "    def __init__(self, words_file):\n",
        "      self.words_file = words_file\n",
        "      def gen_board(words_file):\n",
        "          f = open(words_file, \"r\")\n",
        "          board = {}\n",
        "          temp_array = f.read().splitlines()\n",
        "          random.shuffle(temp_array)\n",
        "\n",
        "          board[\"Red\"] = temp_array[:8]\n",
        "          board[\"Blue\"] = temp_array[8:15]\n",
        "          board[\"Civillian\"] = temp_array[15:24]\n",
        "          board[\"Assasin\"]= [temp_array[24]]\n",
        "          return board\n",
        "\n",
        "      self.board = gen_board(self.words_file)\n",
        "      print(self.board)\n",
        "      self.player = 'red'\n",
        "      self.blue = self.board[\"Blue\"]\n",
        "      self.red = self.board[\"Red\"]\n",
        "      #print(self.red)\n",
        "      self.assassin = self.board[\"Assasin\"]\n",
        "      self.neutral = self.board[\"Civillian\"]\n",
        "      ###agent is red\n",
        "      self.spymaster = Agent(self.board)\n",
        "      if self.player == 'blue':\n",
        "          self.turn_toggle = True\n",
        "      else:\n",
        "          self.turn_toggle = False\n",
        "      return\n",
        "\n",
        "    #executes the game\n",
        "    def execute(self):\n",
        "        print('Let\\'s play Codenames')\n",
        "        print('Your color is: ' + self.player)\n",
        "        print('the board is:')\n",
        "\n",
        "        self.show_board()\n",
        "        while self.blue and self.red and self.assassin:\n",
        "            if self.turn_toggle:\n",
        "                print('It\\'s your turn; type \\\"PASS\\\" to end your turn.')\n",
        "                self.show_board()\n",
        "                self.turn()\n",
        "            else:\n",
        "                print('It\\'s the computer\\'s turn:')\n",
        "                self.opp_turn()\n",
        "                print('the computer has gone.')\n",
        "\n",
        "            self.turn_toggle = not self.turn_toggle\n",
        "\n",
        "        if not self.red:\n",
        "            print('Red identified all their agents!! They win!!')\n",
        "        elif not self.blue:\n",
        "            print('Blue identified all their agents!! They win!!')\n",
        "        else:\n",
        "            print('Assassin!! Game over!  ', end = '')\n",
        "            if self.turn_toggle:\n",
        "                print('You win!!')\n",
        "            else:\n",
        "                print('Computer wins!')\n",
        "        self.show_board()\n",
        "\n",
        "    #shows the game board as a dictionary\n",
        "    def show_board(self):\n",
        "        board = self.red + self.blue + self.assassin + self.neutral\n",
        "        random.shuffle(board)\n",
        "        print(board)\n",
        "\n",
        "\n",
        "    #execute a full turn for the player\n",
        "    def turn(self):\n",
        "        print('Spymaster is generating a clue...')\n",
        "        print(self.board)\n",
        "        clue = self.spymaster.generate_clue(self.board)\n",
        "        print(\"Your clue is: \" + clue[0] + ', ' + str(clue[1]))\n",
        "\n",
        "        num_guesses = clue[1]\n",
        "        end = False\n",
        "        i = 0\n",
        "        word = ''\n",
        "\n",
        "        while i < num_guesses and not end and word != 'PASS':\n",
        "            word = self.guess()\n",
        "            if word == 'PASS':\n",
        "                return\n",
        "            if (word not in self.red):\n",
        "                print('Your guess was incorrect.  Your turn is over.')\n",
        "                print()\n",
        "                end = True\n",
        "            else:\n",
        "                print('Correct. You have ' + str(num_guesses-i-1) + ' more guess(es).')\n",
        "            self.remove_word(word)\n",
        "            i += 1\n",
        "        return\n",
        "\n",
        "    #query a guess from the user\n",
        "    def guess(self):\n",
        "        query = input('Guess a word: ')\n",
        "        print(f\"q: {query}\")\n",
        "        if query == 'PASS':\n",
        "            return query\n",
        "        while (query not in self.red) and (query not in self.blue) and (query not in self.neutral) and (query not in self.assassin):\n",
        "            query = input('error: query not in game board. Try again: ')\n",
        "        return query\n",
        "\n",
        "    #choose words for the opponent\n",
        "    def opp_turn(self):\n",
        "        num = np.random.choice([0,1,2,3], p=[0.2, 0.6, 0.1, 0.1])\n",
        "        if num == 0:\n",
        "            self.remove_word(np.random.choice(self.neutral + self.assassin))\n",
        "            for w in np.random.choice(self.blue, size=min(num, len(self.blue)), replace=False):\n",
        "                self.remove_word(w)\n",
        "\n",
        "    #removes a word from the game once it's guessed\n",
        "    def remove_word(self, word):\n",
        "        if word in self.blue:\n",
        "            self.board[\"Blue\"] = [i if i != word else 'BLUE' for i in self.board[\"Blue\"]]\n",
        "            self.blue.remove(word)\n",
        "        elif word in self.red:\n",
        "            self.board[\"Red\"] = [i if i != word else 'RED' for i in self.board[\"Red\"]]\n",
        "            self.red.remove(word)\n",
        "        elif word in self.neutral:\n",
        "            self.board[\"Civillian\"] = [i if i != word else 'NEUTRAL' for i in self.board[\"Civillian\"]]\n",
        "            self.neutral.remove(word)\n",
        "        elif word in self.assassin:\n",
        "            self.board[\"Assasin\"] = [i if i != word else 'ASSASSIN' for i in self.board[\"Assasin\"]]\n",
        "            self.assassin.remove(word)\n",
        "        return\n",
        "    def create_plot(self):\n",
        "      self.spymaster.generate_clue(self.board)\n",
        "      self.spymaster.tsne_plot_similar_words('Similar words from Google News', self.red,  0.7)"
      ],
      "metadata": {
        "id": "cXU-q1-YWd2f"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "game = Game(\"game_wordpool.txt\")\n",
        "game.create_plot()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 885
        },
        "id": "r78c0rTKf04R",
        "outputId": "cc7ce8a8-9365-4961-bdc7-534a007b0cd4"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'Red': ['SINK', 'HOOD', 'KETCHUP', 'ROBIN', 'TELESCOPE', 'SUB', 'CRASH', 'SPOT'], 'Blue': ['CROSS', 'NOVEL', 'CRICKET', 'POISON', 'GERMANY', 'CHARGE', 'PIT'], 'Civillian': ['YARD', 'SCREEN', 'PITCH', 'CLUB', 'BACK', 'CENTER', 'HEAD', 'NET', 'APPLE'], 'Assasin': ['NAIL']}\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "[nltk_data] Downloading package wordnet to /root/nltk_data...\n",
            "[nltk_data]   Package wordnet is already up-to-date!\n",
            "<ipython-input-11-142320922b42>:109: UserWarning: *c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*.  Please use the *color* keyword-argument or provide a 2D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n",
            "  plt.scatter(x, y, c=color, alpha=a, label=label)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1600x900 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "game2 = Game(\"game_wordpool.txt\")\n",
        "game2.execute()"
      ],
      "metadata": {
        "id": "MRcwSEbtglxR"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}