ellipses_and_fragments_mini_tests.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import nltk\n",
    "import itertools\n",
    "import argparse\n",
    "from klm.query import slor, LM, get_unigram_probs\n",
    "from collections import defaultdict\n",
    "from nltk.tree import Tree\n",
    "\n",
    "filename = 'corpora/dogs.10k.subreddit.jsonl'\n",
    "\n",
    "with open(filename, \"r\") as inf:\n",
    "    lns = [json.loads(i) for i in inf]\n",
    "    \n",
    "from environments.envs import ENVIRONMENTS\n",
    "\n",
    "env = ENVIRONMENTS[\"DEV\"]\n",
    "LOC = env['klm_model']\n",
    "UG_MODEL = env[\"ug_model\"]\n",
    "\n",
    "lm = LM(loc=LOC)\n",
    "up = get_unigram_probs(UG_MODEL)\n",
    "\n",
    "ROOT = 'ROOT'\n",
    "\n",
    "\n",
    "def get_all_combos_of_constituents(jdoc, b=100, p=.75, max_combo_size=3):\n",
    "    '''\n",
    "    If you assume that the linguistic units are constituents and assume that you want to fill at least \n",
    "    p percent of your budget and that you want no more than K elllipses... this is actually combinatorily\n",
    "    tractable FOR A SINGLE SENTENCE\n",
    "    \n",
    "    You just want all nCk combos of constituents, for 1 .... K + 1.\n",
    "    \n",
    "    - Then you exclude all of the combos w len more than b and less than p * b\n",
    "    - You also exclude cases where one unit is nested in the other. You can exclued these safely I think b/c\n",
    "      if there is a set (x1, x2... xn) s.t xi \\in xj then there will be \n",
    "      another set (x1, x2... xn) that includes all but xi that makes better use of the xi position\n",
    "    '''\n",
    " \n",
    "    out = list()\n",
    "    tree2 = Tree.fromstring(jdoc[\"parse\"])\n",
    "    getNodes(tree2, out)\n",
    "\n",
    "    tm = [p[1] for p in out]\n",
    "\n",
    "    co = 0\n",
    "    opts = list()\n",
    "    def has_overlap(tm):\n",
    "        for a,b in itertools.combinations(tm, r=2):\n",
    "            if a in b or b in a:\n",
    "                return True\n",
    "        return False\n",
    "\n",
    "    for i in range(1,max_combo_size):\n",
    "        for v in itertools.combinations(tm, r=i):\n",
    "            co += 1\n",
    "            if sum([len(i) for i in v]) < b and sum([len(i) for i in v]) > (p * b):\n",
    "                if not has_overlap(v):\n",
    "                    opts.append(list(v))\n",
    "    return opts\n",
    "\n",
    "\n",
    "def combo2snippet(jdoc,combos):\n",
    "    sent = \" \".join([o[\"word\"] for o in jdoc[\"tokens\"]])\n",
    "    combos.sort(key=lambda x:sent.index(x))\n",
    "    return(\"...\".join([c for c in combos]))\n",
    "\n",
    "\n",
    "def getNodes(parent, out):\n",
    "    for node in parent:\n",
    "        if type(node) is nltk.Tree:\n",
    "            if node.label() == ROOT:\n",
    "                print(\"======== Sentence =========\")\n",
    "                print(\"Sentence:\", \" \".join(node.leaves()))\n",
    "            else:\n",
    "                if len(node.leaves()) > 1:\n",
    "                    out.append((node.label(), \" \".join(node.leaves())))\n",
    "\n",
    "            getNodes(node, out)\n",
    "        else:\n",
    "            pass\n",
    "        \n",
    "\n",
    "def find_ngrams(input_list, n):\n",
    "    return zip(*[input_list[i:] for i in range(n)])\n",
    "\n",
    "\n",
    "def insert_all_ellipses(toks, start_index, end_index):\n",
    "    '''\n",
    "    \n",
    "    here is another thing that does not really work. \n",
    "    \n",
    "    assume you have  sequence of tokens. Now you want to insert an elipse somewhere. This returns all of the \n",
    "    places where you can get an ellipse. \n",
    "    \n",
    "    This is quadratic b/c you loop over start and ends of elipses. This cuts\n",
    "    down on the search complexity of compressive summarization problem\n",
    "    \n",
    "    If you made K recursive calls to add more ellipses, I bet you'd find that high ranking cases mapped to constituents, kind of.\n",
    "    \n",
    "    This is something we could use to justify the constituent assumption tho\n",
    "    \n",
    "    More details: \n",
    "\n",
    "    start_index(int): where to start looping, to insert ellipse\n",
    "    end_index(int): where to end looping, to insert ellipse\n",
    "         - If you are looping over the whole sentences then \n",
    "             - start_index = 0 and end_index = len(toks)\n",
    "         - But also you might loop over the last 5 tokens in the sentence\n",
    "    \n",
    "    Returns a list of tuples. \n",
    "        - The first item in the tuple is the tokens included \n",
    "        - The second item in the tuple is the start of ellipse\n",
    "        - The third item in the tuple is the end of ellipse\n",
    "    '''\n",
    "    for start_ellipse in range(start_index, end_index):\n",
    "        for end_ellipse in range(start_ellipse + 1, end_index):\n",
    "            yield(start_ellipse, end_ellipse)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Does SLOR do a good job finding well-formed ngrams? \n",
    "No. Sort of disappointed. I guess the coarse ranking is good but fine-grained is not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('thirty min walks a day .', 0.9980161390218095)\n",
      "('My little couch potato dog needs', 0.6113157377929687)\n",
      "('3 thirty min walks a day', 0.4164939557576499)\n",
      "('little couch potato dog needs 3', 0.3197258045450842)\n",
      "('couch potato dog needs 3 thirty', 0.031799057637532734)\n",
      "('potato dog needs 3 thirty min', 0.03132666356608086)\n",
      "('dog needs 3 thirty min walks', 0)\n",
      "('needs 3 thirty min walks a', 0)\n"
     ]
    }
   ],
   "source": [
    "index = 26\n",
    "all_ = []\n",
    "for o in find_ngrams([o[\"word\"] for o in lns[index]['tokens']], n=6):\n",
    "    str_ = \" \".join(o)\n",
    "    all_.append((str_, max(slor(str_,lm, up), 0)))\n",
    "    \n",
    "all_.sort(key=lambda x:x[1], reverse=True)\n",
    "\n",
    "for o in all_:\n",
    "    print(o)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Does SLOR do a good job finding well-formed constituents? \n",
    "- No. Sort of disappointed. The coarse ranking is good but not the fine-grained ranking, basically. This fits w/ Lau Clarke Lapin who found an approximate correlation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My little couch potato dog needs 3 thirty min walks a day .\n",
      "('My little couch potato dog needs 3 thirty min walks a day .', 0.8180272019343447)\n",
      "('My little couch potato dog needs 3 thirty min', 0.7242806523708762)\n",
      "('My little couch potato dog', 0.6557964061962892)\n",
      "('walks a day', 0.09627045926513667)\n",
      "('3 thirty min', 0.08536011938476544)\n",
      "('a day', -0.09840599101257297)\n",
      "('needs 3 thirty min', -0.1275434680114751)\n",
      "('3 thirty', -1.6068268827514647)\n"
     ]
    }
   ],
   "source": [
    "out = []\n",
    "opts = []\n",
    "K = 20\n",
    "sno = 26\n",
    "tree2 = Tree.fromstring(lns[sno][\"parse\"])\n",
    "getNodes(tree2, out)\n",
    "for o in out:\n",
    "    label, frag = o\n",
    "    if len(frag.split()) < K:\n",
    "        opts.append((frag, slor(frag,lm, up)))\n",
    "\n",
    "opts = list(set(opts))\n",
    "opts.sort(key=lambda x:x[1],reverse=True)\n",
    "\n",
    "print(\" \".join([o[\"word\"] for o in lns[sno][\"tokens\"]]))\n",
    "for o in opts:\n",
    "    print(o)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A method that works\n",
    "\n",
    "Assume you want only a few ellipses (2/3) per sentence. Assume you want to fill your summary budget up to 75%. You can really just enumerate all combos of constituents of size 1,2,3,4, and filter out those that are too long and too short. This is because the number of ellipses will in general be size of combo + 1. There are a manageable number of subsets to just check. If we rank the resullting snippets by SLOR, imagining that the ... are not present, well everything seems to work"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "top 10 snippets, by SLOR\n",
      "('I could see myself re-locating to Toronto or Quebec .', 0.8696897867602538)\n",
      "\n",
      "\n",
      "bottom 10 snippets, by SLOR\n",
      "('I could see myself re-locating to Toronto or Quebec .', 0.8696897867602538)\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "sno = 3\n",
    "combos = get_all_combos_of_constituents(lns[sno], p=.5)\n",
    "\n",
    "ranks = []\n",
    "\n",
    "for c in combos:\n",
    "    snip = combo2snippet(lns[sno], c)\n",
    "    \n",
    "    ranks.append((snip, slor(snip.replace(\"...\", \" \").replace(\"  \", \" \"),lm, up)))\n",
    "    \n",
    "ranks.sort(key=lambda x:x[1], reverse=True)\n",
    "\n",
    "print(\"top 10 snippets, by SLOR\")\n",
    "for r in ranks[0:10]:\n",
    "    print(r)\n",
    "print(\"\\n\")\n",
    "print(\"bottom 10 snippets, by SLOR\")\n",
    "for r in ranks[-10:]:\n",
    "    print(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Tree('ROOT', [Tree('S', [Tree('NP', [Tree('PRP', ['I'])]), Tree('VP', [Tree('MD', ['could']), Tree('VP', [Tree('VB', ['see']), Tree('S', [Tree('NP', [Tree('PRP', ['myself'])]), Tree('VP', [Tree('VBG', ['re-locating']), Tree('PP', [Tree('TO', ['to']), Tree('NP', [Tree('NNP', ['Toronto']), Tree('CC', ['or']), Tree('NNP', ['Quebec'])])])])])])]), Tree('.', ['.'])])])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tree2 = Tree.fromstring(lns[sno][\"parse\"])\n",
    "tree2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### One note\n",
    "\n",
    "if you insert ellipses w/o respecting constituents. The SLOR ranking seems ok-ish to evaluate different summaries of\n",
    "the same size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "(' my little couch potato needs 3 thirty minute ... ', 0.6129066852813718)\n",
      "(' my little couch potato ...  3 thirty minute walks', 0.5386765264556885)\n",
      "(' my little couch potato needs ...  thirty minute walks', 0.5155214225158691)\n",
      "(' my little couch potato needs 3 ...  minute walks', 0.3912193690338137)\n",
      "(' my ...  couch potato needs 3 thirty minute walks', 0.3645562493133543)\n",
      "(' my little couch potato needs 3 thirty ...  walks', 0.3547105074310304)\n",
      "(' my little couch ...  needs 3 thirty minute walks', 0.3040491313323983)\n",
      "(' ...  little couch potato needs 3 thirty minute walks', 0.30112789797973605)\n",
      "(' my little ...  potato needs 3 thirty minute walks', 0.19168549163208048)\n",
      "7\n",
      "(' my little couch potato ...  thirty minute walks', 0.6974210636648996)\n",
      "(' my little couch potato needs 3 ...  walks', 0.5883220816476005)\n",
      "(' my little couch potato needs 3 thirty ... ', 0.37479685377022876)\n",
      "(' my little couch potato needs ...  minute walks', 0.308935251831055)\n",
      "(' ...  couch potato needs 3 thirty minute walks', 0.25427367890276287)\n",
      "(' my little ...  needs 3 thirty minute walks', 0.17288657604282978)\n",
      "(' my little couch ...  3 thirty minute walks', 0.16704978550153474)\n",
      "(' my ...  potato needs 3 thirty minute walks', -0.043912139010183794)\n",
      "6\n",
      "(' my little couch potato needs 3 ... ', 0.6203378686035155)\n",
      "(' my little couch potato ...  minute walks', 0.4867204713907884)\n",
      "(' my little couch potato needs ...  walks', 0.43188343225097664)\n",
      "(' my little couch ...  thirty minute walks', 0.2903142733113609)\n",
      "(' my little ...  3 thirty minute walks', 0.11115881541748014)\n",
      "(' my ...  needs 3 thirty minute walks', 0.014212933605957545)\n",
      "(' ...  potato needs 3 thirty minute walks', -0.2821087892944334)\n",
      "5\n",
      "(' my little couch potato ...  walks', 0.669815331806641)\n",
      "(' my little couch potato needs ... ', 0.6485357496240234)\n",
      "(' my little ...  thirty minute walks', 0.24789762530273407)\n",
      "(' my ...  3 thirty minute walks', -0.04047663839355451)\n",
      "(' my little couch ...  minute walks', -0.04394817695800697)\n",
      "(' ...  needs 3 thirty minute walks', -0.3931149450537106)\n",
      "4\n",
      "(' my little couch potato ... ', 1.1143123881042483)\n",
      "(' my little couch ...  walks', 0.05225323647461)\n",
      "(' my little ...  minute walks', -0.043046234362792646)\n",
      "(' my ...  thirty minute walks', -0.18130813893432585)\n",
      "(' ...  3 thirty minute walks', -0.29982964692993175)\n",
      "3\n",
      "(' my little couch ... ', 0.25370453472493537)\n",
      "(' ...  thirty minute walks', 0.13895671148274738)\n",
      "(' my little ...  walks', -0.09779422003580744)\n",
      "(' my ...  minute walks', -0.8956190576822914)\n",
      "2\n",
      "(' my little ... ', -0.32163596932983385)\n",
      "(' my ...  walks', -0.4901304103454587)\n",
      "(' ...  minute walks', -1.6587574370483402)\n",
      "1\n",
      "(' my ... ', -2.5004181580200195)\n",
      "(' ...  walks', -2.6481871603515623)\n",
      "0\n",
      "(' ... ', 5.1463767799835205)\n"
     ]
    }
   ],
   "source": [
    "from environments.envs import ENVIRONMENTS\n",
    "from collections import defaultdict\n",
    "import argparse\n",
    "import kenlm\n",
    "import json\n",
    "\n",
    "from klm.query import LM\n",
    "from klm.query import get_unigram_probs\n",
    "\n",
    "env = ENVIRONMENTS[\"DEV\"]\n",
    "LOC = env['klm_model']\n",
    "UG_MODEL = env[\"ug_model\"]\n",
    "\n",
    "lm = LM(loc=LOC)\n",
    "up = get_unigram_probs(UG_MODEL)\n",
    "from klm.query import slor\n",
    "\n",
    "\n",
    "toks = \"my little couch potato needs 3 thirty minute walks\".split()\n",
    "\n",
    "opts = []\n",
    "\n",
    "classes = defaultdict(list)\n",
    "\n",
    "for i in insert_all_ellipses(toks, start_index=0, end_index=len(toks) + 1):\n",
    "    ellipse_min, ellipse_max = i\n",
    "    printthis = \"\"\n",
    "    for tno, t in enumerate(toks):\n",
    "        if tno == ellipse_min:\n",
    "            printthis = printthis + \" ... \"\n",
    "        elif tno > ellipse_min and tno < ellipse_max:\n",
    "            pass\n",
    "        else:\n",
    "            printthis = printthis + \" \" + t\n",
    "    str_ = printthis.replace(\" ... \", \" \").strip().replace(\"  \", \" \")\n",
    "    classes[len(str_.split())].append((printthis, slor(str_,lm, up)))\n",
    "    \n",
    "for c in classes:\n",
    "    print(c)\n",
    "    opts = classes[c]\n",
    "    opts.sort(key=lambda x:x[1], reverse=True)\n",
    "    opts[0:20]\n",
    "    for o in opts:\n",
    "        print(o)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9b28347c120d463e9867bc0ada7ca5b0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=41920), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "error\n",
      "error\n",
      "error\n",
      "error\n",
      "error\n",
      "error\n",
      "error\n",
      "error\n",
      "error\n",
      "error\n",
      "error\n",
      "error\n",
      "error\n",
      "error\n",
      "error\n",
      "error\n",
      "error\n",
      "error\n",
      "error\n",
      "error\n",
      "error\n",
      "error\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import os, os.path\n",
    "from whoosh import index\n",
    "\n",
    "from whoosh.fields import Schema, TEXT, ID\n",
    "from whoosh.analysis import StemmingAnalyzer\n",
    "from tqdm import tqdm_notebook as tqdm\n",
    "\n",
    "def index_docs(jdocs, lm, up, b=100, p=.75, min_slor=.3):\n",
    "\n",
    "    schema = Schema(content=TEXT(analyzer=StemmingAnalyzer()), id_=ID(stored=True))\n",
    "\n",
    "    if not os.path.exists(\"indexdir\"):\n",
    "        os.mkdir(\"indexdir\")\n",
    "\n",
    "    ix = index.create_in(\"indexdir\", schema)\n",
    "\n",
    "    writer = ix.writer() \n",
    "    \n",
    "    id2slor = {}\n",
    "    id2frag = {}\n",
    "    for i in tqdm(lns):\n",
    "        for fragno, j in enumerate(get_all_possible_frags(i, lm, up, b=b, p=p)):\n",
    "            frag, slor = j\n",
    "            id2frag[str(i['id'])+ \"-\"+ str(fragno)] = frag\n",
    "            id2slor[str(i['id'])+ \"-\"+ str(fragno)] = slor\n",
    "            if slor > min_slor:\n",
    "                writer.add_document(content=frag.replace(\"...\", \"\"),\n",
    "                                    id_=str(i['id'])+ \"-\"+ str(fragno))\n",
    "\n",
    "    writer.commit()\n",
    "    \n",
    "    return ix, id2slor, id2frag\n",
    "\n",
    "\n",
    "def get_all_possible_frags(jdoc, lm, up, b=200, p=.8):\n",
    "    combos = get_all_combos_of_constituents(jdoc, p=p, b=b)\n",
    "\n",
    "    ranks = []\n",
    "\n",
    "    for c in combos:\n",
    "        try:\n",
    "            snip = combo2snippet(jdoc, c)\n",
    "\n",
    "            ranks.append((snip, slor(snip.replace(\"...\", \" \").replace(\"  \", \" \"),lm, up)))\n",
    "        except ValueError:\n",
    "            print(\"error\")\n",
    "            \n",
    "    for r in ranks:\n",
    "        yield r\n",
    "\n",
    "\n",
    "ix, id2slor, id2frag = index_docs(lns, lm, up, b=100, p=.75)\n",
    "\n",
    "with open(\"metadata/id2slor\" + filename.split(\"/\").pop() , \"w\") as of:\n",
    "    of.write(json.dumps(id2slor))\n",
    "    \n",
    "with open(\"metadata/id2frag\" + filename.split(\"/\").pop() , \"w\") as of:\n",
    "    of.write(json.dumps(id2frag))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from whoosh.qparser import QueryParser\n",
    "\n",
    "import whoosh.index as index\n",
    "\n",
    "ix = index.open_dir(\"indexdir\")\n",
    "\n",
    "with open(\"metadata/id2slor\" + filename.split(\"/\").pop() , \"r\") as inf:\n",
    "    id2slor = json.loads(inf.read())\n",
    "    \n",
    "with open(\"metadata/id2frag\" + filename.split(\"/\").pop() , \"r\") as inf:\n",
    "    id2frags = json.loads(inf.read())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "For clarification...where dogs are supposed to be leashed , not off-leash areas\n",
      "you should be able to control your dog if you choose to have it off leash , hence...on leash\n",
      "`` It 's definitely not a good idea to keep your dog on leash at an off-leash dog park .\n",
      "the OFF LEASH dog...off leash dogs can be confiscated by the city for being off leash in a public area\n",
      "IF YOU ARE NOT IN A SPECIFIED OFF-LEASH ENVIRONMENT , LEASH YOUR DOG , ALWAYS .\n",
      "a \\ `` hiking leash \\ ''...when someone else comes by without fumbling for a leash\n",
      "have a reactive dog on a leash in an area where you can run into off-leash dogs\n",
      "off leash ' or ` on leash ' areas...would obviously use the on leash areas only\n",
      "When I was in the US...being off leash and greeting other off leash dogs in an off leash area\n",
      "I am at the dog beach and we see an on leash dog...do n't bother the leashed dog\n"
     ]
    }
   ],
   "source": [
    "def query(Q, K = 100):\n",
    "    docs2options = []\n",
    "\n",
    "    with ix.searcher() as searcher:\n",
    "        query = QueryParser(\"content\", ix.schema).parse(Q)\n",
    "        results = searcher.search(query, limit=2000)\n",
    "        for o in results[0:2000]:\n",
    "            id_ = o.fields()['id_']\n",
    "            doc_id, frag_id = id_.split('-')\n",
    "            docs2options.append(((o.score + id2slor[id_])/2, doc_id, id2frags[id_]))  \n",
    "\n",
    "    docs2options.sort(key=lambda x:x[0], reverse=True)    \n",
    "    \n",
    "    docs_so_far = set()\n",
    "    for o in docs2options:\n",
    "        score, docid, frag = o\n",
    "        if docid not in docs_so_far and len(docs_so_far) < K:\n",
    "            print(frag)\n",
    "            docs_so_far.add(docid)\n",
    "            \n",
    "query(\"leash\", K = 10)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}