corpus-driven-narrative-generation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# A few simple corpus-driven approaches to narrative analysis and generation\n",
    "\n",
    "By [Allison Parrish](http://www.decontextualize.com/)\n",
    "\n",
    "This notebook is a fast introduction to a few techniques for working with narrative corpora. By \"narrative corpora,\" I mean pre-existing bodies of text that mostly contain the texts of narratives. In particular, we're going to use Mark Riedl's [WikiPlots corpus](https://github.com/markriedl/WikiPlots), which has the titles and plot summaries of more than one hundred thousand movies, books, television shows and other media from Wikipedia.\n",
    "\n",
    "The notebook takes you through using [spaCy](http://spacy.io) to extract words, noun chunks, parts of speech and entities from the text and then sew them back together with [Tracery](http://tracery.io). It then shows how to use [Markovify](https://github.com/jsvine/markovify) to create new narratives from existing narrative text, and how to prepare the narratives for use as a training corpus for a large pre-trained language model like GPT-2.\n",
    "\n",
    "The code is written in Python, but you don't really need to know Python in order to use the notebook. Everything's pre-written for you, so you can just execute the cells, making small changes to the code as needed. Even if the notebook itself doesn't end up being useful to you, hopefully it spurs a few ideas that you can take with you into your practice as a storyteller and/or programmer.\n",
    "\n",
    "If you're running this code on Binder, you should be good to go. Just keep on executing the cells below. If you're running this notebook on Google Colab, you'll need to run the following cells to install the necessary libraries and download the data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install markovify\n",
    "!pip install tracery\n",
    "!pip install spacy==2.3.2\n",
    "!python -m spacy download en_core_web_sm\n",
    "!curl -L -O https://github.com/aparrish/corpus-driven-narrative-generation/raw/master/romcom_plot_sentences.tsv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading the corpus\n",
    "\n",
    "The first step is to get the narrative corpus into the program. Because WikiPlots is so big, we're actually going to be working with a smaller subset: only the plot summaries for romantic comedy movies. The subcorpus was made using [this notebook on creating a subcorpus of WikiPlots](https://github.com/aparrish/corpus-driven-narrative-generation/blob/master/creating-a-wikiplots-subcorpus.ipynb), which you can consult if you want to make your own with a different subset of WikiPlots.\n",
    "\n",
    "The corpus we're working with takes the form of a TSV file (\"tab separated values\"), with each line containing the title of the movie, a number indicating where in the plot summary the sentence for this line occurs, the total number of sentences in the summary, and the actual text of the sentence. The following cell loads the data into a list of dictionaries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "sentences = []\n",
    "for line in open(\"romcom_plot_sentences.tsv\"):\n",
    "    line = line.strip()\n",
    "    items = line.split(\"\\t\")\n",
    "    sentences.append(\n",
    "        {'title': items[0],\n",
    "         'index': int(items[1]),\n",
    "         'total': int(items[2]),\n",
    "         'text': items[3]})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just to make sure it worked, we'll print out a random sentence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'title': 'It Should Happen to You',\n",
       " 'index': 49,\n",
       " 'total': 72,\n",
       " 'text': \"That's what you're doing, isn't it.\"}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.choice(sentences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: You can make your own corpus that works with the code in this notebook by exporting your data in TSV format with one line per sentence, with columns for the following:\n",
    "\n",
    "* `title`: the title of the work that the sentence comes from\n",
    "* `index`: the index of the sentence in the work\n",
    "* `total`: the total number of sentences in the work\n",
    "* `text`: the text of the sentence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Natural language processing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get an idea of what's happening in the text of the plots, we can do a bit of Natural Language Processing. I cover just the bare essentials in this notebook. [Here's a more in-depth tutorial that I wrote](https://github.com/aparrish/rwet/blob/master/nlp-concepts-with-spacy.ipynb).\n",
    "\n",
    "Most natural language processing is done with the aid of third-party libraries. We're going to use one called spaCy. To use spaCy, you first need to install it (i.e., download the code and put it in a place where Python can find it) and download the language model. (The language model contains statistical information about a particular language that makes it possible for spaCy to do things like parse sentences into their constituent parts.)\n",
    "\n",
    "Run the following cell to load spaCy's model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import spacy\n",
    "nlp = spacy.load('en_core_web_sm')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(This could also take a while–the model is potentially very large and your computer needs to load it from your hard drive and into memory. When you see a `[*]` next to a cell, that means that your computer is still working on executing the code in the cell.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Right off the bat, the spaCy library gives us access to a number of interesting units of text:\n",
    "\n",
    "* All of the sentences (`doc.sents`)\n",
    "* All of the words (`doc`)\n",
    "* All of the \"named entities,\" like names of places, people, #brands, etc. (`doc.ents`)\n",
    "* All of the \"noun chunks,\" i.e., nouns in the text plus surrounding matter like adjectives and articles\n",
    "\n",
    "The cell below, we extract these into variables so we can play around with them a little bit. (Parsing sentences is hungry work and the following cell will take a while to execute.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 28785\n",
      "100 28785\n",
      "200 28785\n",
      "300 28785\n",
      "400 28785\n",
      "500 28785\n",
      "600 28785\n",
      "700 28785\n",
      "800 28785\n",
      "900 28785\n"
     ]
    }
   ],
   "source": [
    "words = []\n",
    "noun_chunks = []\n",
    "entities = []\n",
    "# only use 1000 sentences sampled at random by default; comment out this `for...`\n",
    "# uncomment the `for...` beneath to use every sentence in the corpus.\n",
    "for i, sent in enumerate(random.sample(sentences, 1000)):\n",
    "#for i, sent in enumerate(sentences):\n",
    "    if i % 100 == 0:\n",
    "        print(i, len(sentences))\n",
    "    doc = nlp(sent['text'])\n",
    "    words.extend([w for w in list(doc) if w.is_alpha])\n",
    "    noun_chunks.extend(list(doc.noun_chunks))\n",
    "    entities.extend(list(doc.ents))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just to make sure it worked, print out ten random words:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "attention\n",
      "are\n",
      "no\n",
      "does\n",
      "and\n",
      "realize\n",
      "to\n",
      "called\n",
      "auto\n",
      "is\n"
     ]
    }
   ],
   "source": [
    "for item in random.sample(words, 10):\n",
    "    print(item.text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ten random noun chunks:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the woman\n",
      "their parents' home\n",
      "him\n",
      "the counter\n",
      "Lanie\n",
      "that night's performance\n",
      "prayers\n",
      "(Eric Blore\n",
      "an accident\n",
      "the wedding\n"
     ]
    }
   ],
   "source": [
    "for item in random.sample(noun_chunks, 10):\n",
    "    print(item.text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ten random entities:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Elizabeth\n",
      "Martha\n",
      "Paul\n",
      "Alison\n",
      "Sam\n",
      "Cathy falls\n",
      "American\n",
      "five\n",
      "Philip\n",
      "Danny\n"
     ]
    }
   ],
   "source": [
    "for item in random.sample(entities, 10):\n",
    "    print(item.text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Grammatical roles\n",
    "\n",
    "The parser included with spaCy can also give us information about the grammatical roles in the sentence. For example, the `.root.dep_` attribute of a noun chunk tells us whether that noun chunk is the subject of the sentence (\"nsubj\") or a direct object (\"dobj\") of the sentence. (See the \"Universal Dependency Labels\" of spaCy's [annotation specs](https://spacy.io/api/annotation) for more possible roles.) Using this information, we can make a list of sentence subjects and sentence objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "subjects = [chunk for chunk in noun_chunks if chunk.root.dep_ == 'nsubj']\n",
    "objects = [chunk for chunk in noun_chunks if chunk.root.dep_ == 'dobj']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[who, who, Clarisse, Casey, he, she, he, they, she, He]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.sample(subjects, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Ese,\n",
       " her affair,\n",
       " them,\n",
       " Mary,\n",
       " sex,\n",
       " himself,\n",
       " the next town,\n",
       " his prior dream,\n",
       " the Rose Bowl's committee,\n",
       " entirely different paths]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.sample(objects, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parts of speech\n",
    "\n",
    "The spaCy parser allows us to check what part of speech a word belongs to. In the cell below, we create four different lists—`nouns`, `verbs`, `adjs` and `advs`—that contain only words of the specified parts of speech. Using the `.tag_` attribute, we can easily get only particular forms of verbs; in this case, I'm just getting verbs that are in the past tense. ([There's a full list of part of speech tags here](https://spacy.io/docs/usage/pos-tagging#pos-tagging-english).)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "nouns = [w for w in words if w.pos_ == \"NOUN\"]\n",
    "verbs = [w for w in words if w.pos_ == \"VERB\"]\n",
    "past_tense_verbs = [w for w in words if w.tag_ == 'VBD']\n",
    "adjs = [w for w in words if w.tag_ == \"JJ\"]\n",
    "advs = [w for w in words if w.pos_ == \"ADV\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now we can print out a random sample of any of these:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kiss\n",
      "glitch\n",
      "veteran\n",
      "friend\n",
      "snare\n",
      "run\n",
      "game\n",
      "approval\n",
      "ship\n",
      "day\n",
      "projects\n",
      "pocket\n"
     ]
    }
   ],
   "source": [
    "for item in random.sample(nouns, 12): # change \"nouns\" to \"verbs\" or \"adjs\" or \"advs\" to sample from those lists!\n",
    "    print(item.text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Entity types\n",
    "\n",
    "The parser in spaCy not only identifies \"entities\" but also assigns them to a particular type. [See a full list of entity types here.](https://spacy.io/docs/usage/entity-recognition#entity-types) Using this information, the following cell builds lists of the people, locations, and times mentioned in the text:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "people = [e for e in entities if e.label_ == \"PERSON\"]\n",
    "locations = [e for e in entities if e.label_ == \"LOC\"]\n",
    "times = [e for e in entities if e.label_ == \"TIME\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And then you can print out a random sample:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the night\n",
      "The next morning\n",
      "One morning\n",
      "night\n",
      "night\n",
      "the night\n",
      "night\n",
      "the night\n",
      "afternoon\n",
      "Later that night\n",
      "One night\n",
      "the next morning\n"
     ]
    }
   ],
   "source": [
    "for item in random.sample(times, 12): # change \"times\" to \"people\" or \"locations\" to sample those lists\n",
    "    print(item.text.strip())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Finding the most common\n",
    "\n",
    "We won't go too deep into text analysis in this tutorial, but it's useful to be able to do the most fundamental task in text analysis: finding the things that are most common. The code to do this task looks like the following, which gives us a way to look up how often any word occurs in the text:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "word_count = Counter([w.text for w in words])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word_count['Meanwhile']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... and also tells us which words are most common:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('the', 896),\n",
       " ('to', 760),\n",
       " ('and', 734),\n",
       " ('a', 588),\n",
       " ('her', 406),\n",
       " ('is', 337),\n",
       " ('of', 321),\n",
       " ('in', 302),\n",
       " ('with', 269),\n",
       " ('his', 267),\n",
       " ('he', 260),\n",
       " ('that', 246)]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "word_count.most_common(12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can make a counter for any of the other lists we've worked with using the same syntax. Just make up a unique variable name on the left of the `=` sign and put the name of the list you want to count in the brackets to the right (replacing `words`). E.g., to find the most common people:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "people_count = Counter([w.text for w in people])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Tom', 18),\n",
       " ('Joe', 18),\n",
       " ('Mary', 14),\n",
       " ('Adam', 10),\n",
       " ('Michael', 10),\n",
       " ('Charlie', 10),\n",
       " ('Andy', 9),\n",
       " ('Max', 9),\n",
       " ('Peter', 9),\n",
       " ('Paul', 8),\n",
       " ('Elizabeth', 8),\n",
       " ('James', 8)]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "people_count.most_common(12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most common past-tense verbs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "vbd_count = Counter([w.text for w in past_tense_verbs])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('was', 50),\n",
       " ('had', 26),\n",
       " ('did', 7),\n",
       " ('were', 7),\n",
       " ('left', 4),\n",
       " ('died', 3),\n",
       " ('came', 3),\n",
       " ('saw', 3),\n",
       " ('took', 3),\n",
       " ('called', 2),\n",
       " ('made', 2),\n",
       " ('put', 2)]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vbd_count.most_common(12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Writing to a file\n",
    "\n",
    "The following cell defines a function for writing data from a `Counter` object to a file. The file is in \"tab-separated values\" format, which you can open using most spreadsheet programs. Execute it before you continue:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_counter_tsv(filename, counter, limit=1000):\n",
    "    with open(filename, \"w\") as outfile:\n",
    "        outfile.write(\"key\\tvalue\\n\")\n",
    "        for item, count in counter.most_common():\n",
    "            outfile.write(item.strip() + \"\\t\" + str(count) + \"\\n\")    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, run the following cell. You'll end up with a file in the same directory as this notebook called `100_common_words.tsv` that has two columns, one for the words and one for their associated counts:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "save_counter_tsv(\"100_common_words.tsv\", word_count, 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try opening this file in Excel or Google Docs or Numbers!\n",
    "\n",
    "If you want to write the data from another `Counter` object to a file:\n",
    "\n",
    "* Change the filename to whatever you want (though you should probably keep the `.tsv` extension)\n",
    "* Replace `word_count` with the name of any of the `Counter` objects we've made in this sheet and use it in place of `word_count`\n",
    "* Change the number to the number of rows you want to include in your spreadsheet."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### When do things happen in this text?\n",
    "\n",
    "Here's another example. Using the `times` entities, we can make a spreadsheet of how often particular \"times\" (durations, times of day, etc.) are mentioned in the text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "time_counter = Counter([e.text.lower().strip() for e in times])\n",
    "save_counter_tsv(\"time_count.tsv\", time_counter, 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Do the same thing, but with people:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "people_counter = Counter([e.text.lower() for e in people])\n",
    "save_counter_tsv(\"people_count.tsv\", people_counter, 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generating stories from a corpus and Tracery grammars\n",
    "\n",
    "Once you've isolated entities and parts of speech, you can recombine them in interesting ways. One is to use a Tracery grammar to write sentences that include the isolated parts. Because the parts have been labelled using spaCy, you can be reasonbly sure that they'll fit into particular slots in the sentence. (I used a similar technique for my [Cheap Space Nine](https://twitter.com/cheapspacenine) bot.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tracery\n",
    "from tracery.modifiers import base_english"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "rules = {\n",
    "    \"subject\": [w.text for w in subjects],\n",
    "    \"object\": [w.text for w in objects],\n",
    "    \"verb\": [w.text for w in past_tense_verbs if w.text not in ('was', 'were', 'went')], # exclude common irregular verbs\n",
    "    \"adj\": [w.text for w in adjs],\n",
    "    \"people\": [w.text for w in people],\n",
    "    \"loc\": [w.text for w in locations],\n",
    "    \"time\": [w.text for w in times],\n",
    "    \"origin\": \"#scene#\\n\\n[charA:#subject#][charB:#subject#][prop:#object#]#sentences#\",\n",
    "    \"scene\": \"SCENE: #loc#, #time.lowercase#\",\n",
    "    \"sentences\": [\n",
    "        \"#sentence#\\n#sentence#\",\n",
    "        \"#sentence#\\n#sentence#\\n#sentence#\",\n",
    "        \"#sentence#\\n#sentence#\\n#sentence#\\n#sentence#\"\n",
    "    ],\n",
    "    \"sentence\": [\n",
    "        \"#charA.capitalize# #verb# #prop#.\",\n",
    "        \"#charB.capitalize# #verb# #prop#.\",\n",
    "        \"#prop.capitalize# became #adj#.\",\n",
    "        \"#charA.capitalize# and #charB# greeted each other.\",\n",
    "        \"'Did you hear about #object.lowercase#?' said #charA#.\",\n",
    "        \"'#subject.capitalize# is #adj#,' said #charB#.\",\n",
    "        \"#charA.capitalize# and #charB# #verb# #object#.\",\n",
    "        \"#charA.capitalize# and #charB# looked at each other.\",\n",
    "        \"#sentence#\\n#sentence#\"\n",
    "    ]\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "grammar = tracery.Grammar(rules)\n",
    "grammar.add_modifiers(base_english)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SCENE: Mars, the next morning\n",
      "\n",
      "'Did you hear about kimmy wallace?' said he.\n",
      "'Aram is aware,' said The conference.\n",
      "'Did you hear about her date?' said he.\n",
      "'Bryce is indispensable,' said The conference.\n",
      "The conference called him.\n",
      "He and The conference looked at each other.\n",
      "\n",
      "SCENE: the Wild West Show, the night\n",
      "\n",
      "The next town became decent.\n",
      "He called the next town.\n",
      "Elizabeth and he looked at each other.\n",
      "'Irene is routine,' said he.\n",
      "Elizabeth and he greeted each other.\n",
      "\n",
      "SCENE: Orient, night\n",
      "\n",
      "The spirited Sarah and Charlie greeted each other.\n",
      "Charlie had school rules.\n",
      "The spirited Sarah had school rules.\n",
      "Charlie buried school rules.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    print(grammar.flatten(\"#origin#\"))\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Markov chain text generation\n",
    "\n",
    "Another way to produce new narratives from existing narrative text is to find statistical patterns in the text itself and then make the computer create new text that follows those statistical patterns. Markov chain text generation has been a pastime of poets and programmers going back [all the way to 1983](https://www.jstor.org/stable/24969024), so it should be no surprise that there are many implementations of the idea in Python that you can download and install. The one we're going to use is [Markovify](https://github.com/jsvine/markovify), a Markov chain text generation library originally developed for BuzzFeed, apparently. Writing [code to implement a Markov chain generator](https://github.com/aparrish/rwet/blob/master/ngrams-and-markov-chains.ipynb) on your own is certainly possible, but Markovify comes with a lot of extra niceties that will make our lives easier."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To install Markovify on your computer, run the cell below. (You can skip this step if you're using this notebook in Binder.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: markovify in /Users/allison/anaconda/lib/python3.6/site-packages (0.7.1)\n",
      "Requirement already satisfied: unidecode in /Users/allison/anaconda/lib/python3.6/site-packages (from markovify) (1.0.22)\n",
      "\u001b[33mWARNING: You are using pip version 19.1.1, however version 19.3.1 is available.\n",
      "You should consider upgrading via the 'pip install --upgrade pip' command.\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "!pip install markovify"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And then run this cell to make the library available in your notebook:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import markovify"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need a list of strings to train the Markov generator. For now, let's just get all of the sentences from any movie in the corpus:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_text = [item['text'] for item in sentences]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code in the following cell creates a new text generator, using the text in the variable specified to build the Markov model, which is then assigned to the variable `all_text_gen`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "all_text_gen = markovify.Text(all_text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can then call the `.make_sentence()` method to generate a sentence from the model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dodge distracts her by helping shovel coal.\n"
     ]
    }
   ],
   "source": [
    "print(all_text_gen.make_sentence())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `.make_short_sentence()` method allows you to specify a maximum length for the generated sentence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "During the date as well.\n"
     ]
    }
   ],
   "source": [
    "print(all_text_gen.make_short_sentence(50))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, Markovify tries to generate a sentence that is significantly different from any existing sentence in the input text. As a consequence, sometimes the `.make_sentence()` or `.make_short_sentence()` methods will return `None`, which means that in ten tries it wasn't able to generate such a sentence. You can work around this by increasing the number of times it tries to generate a sufficiently unique sentence using the `tries` parameter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "He goes to visit next month.\n"
     ]
    }
   ],
   "source": [
    "print(all_text_gen.make_short_sentence(40, tries=100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or by disabling the check altogether with `test_output=False`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "She accepts.\n"
     ]
    }
   ],
   "source": [
    "print(all_text_gen.make_short_sentence(40, test_output=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Changing the order\n",
    "\n",
    "When you create the model, you can specify the order of the model using the `state_size` parameter. It defaults to 2. Let's make two model with different orders and compare:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "gen_1 = markovify.Text(all_text, state_size=1)\n",
    "gen_4 = markovify.Text(all_text, state_size=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "order 1\n",
      "He supports the green.\n",
      "\n",
      "order 4\n",
      "Amanda then finds Harold at the bar where they first met, drunk and surrounded by giggling women.\n"
     ]
    }
   ],
   "source": [
    "print(\"order 1\")\n",
    "print(gen_1.make_sentence(test_output=False))\n",
    "print()\n",
    "print(\"order 4\")\n",
    "print(gen_4.make_sentence(test_output=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In general, the higher the order, the more the sentences will seem \"coherent\" (i.e., more closely resembling the source text). Lower order models will produce more variation. Deciding on the order is usually a matter of taste and trial-and-error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Changing the level\n",
    "\n",
    "Markovify, by default, works with *words* as the individual unit. It doesn't come out-of-the-box with support for character-level models. The following code defines a new kind of Markovify generator that implements character-level models. Execute it before continuing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "class SentencesByChar(markovify.Text):\n",
    "    def word_split(self, sentence):\n",
    "        return list(sentence)\n",
    "    def word_join(self, words):\n",
    "        return \"\".join(words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Any of the parameters you passed to `markovify.Text` you can also pass to `SentencesByChar`. The `state_size` parameter still controls the order of the model, but now the n-grams are characters, not words.\n",
    "\n",
    "The following cell implements a character-level Markov text generator for the word \"condescendences\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "con_model = SentencesByChar(\"condescendences\", state_size=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Execute the cell below to see the output—it'll be a lot like what we implemented by hand earlier!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'condescendencencendes'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "con_model.make_sentence()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, you can use a character-level model on any text of your choice. So, for example, the following cell creates a character-level order-7 Markov chain text generator from text A:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "gen_char = SentencesByChar(all_text, state_size=7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And the cell below prints out a random sentence from this generator. (The `.replace()` is to get rid of any newline characters in the output.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Elizabeth explains that he denies, however, the kissed.\n"
     ]
    }
   ],
   "source": [
    "print(gen_char.make_sentence(test_output=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Thinking about structure\n",
    "\n",
    "It's one thing to be able to produce one plausible sentence of a plot summary using Markov chains, but another to create a sense of overall structure between sentences, and generating narratives with these kinds of long-term dependencies is still an open problem in computational creativity. The approach I'm going to suggest below relies on the intuition that sentences in a plot summary share characteristics based on their position in the summary. First sentences will generally introduce characters and present an initial situation; last sentences will generally describe how the situation was resolved; and sentences in between will describe developing action.\n",
    "\n",
    "Following this intuition, let's create *three different Markov chains*: one for beginning sentences, one for middle sentences, and one for final sentences. We can use the `index` of each sentence in our corpus to give us this information.\n",
    "\n",
    "First, the beginnings are lines whose index is zero (i.e., they're the first sentence for this plot):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "beginnings = [line['text'] for line in sentences if line['index'] == 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Sutter Keely (Miles Teller) is a high school senior, charming and self-possessed.',\n",
       " 'Wealthy Alice Bond (Rosemary Lane), dissatisfied with her dishwater-dull fiance Marshall Winkler (John Eldredge), throws him over in favor of Michael Stevens (George Reeves).',\n",
       " 'Emily \"Jacks\" Jackson, who spent her childhood in America, now lives and works in London, at British Vogue, and shares an apartment with her gay friend Peter Simon, a screenwriter.',\n",
       " 'Dave (Vince Vaughn), a dealer for Guitar Hero, and Ronnie (Malin Åkerman), a stay-at-home mom, are a typical couple raising two young children in the suburbs of Chicago.',\n",
       " 'Andy Stitzer (Steve Carell) is a 40-year-old virgin who lives alone, collects action figures, plays video games, and his social life seems to consist of watching Survivor with his elderly neighbors.']"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.sample(beginnings, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And endings are sentences that come last in the plot (i.e., their index is one less than the total number of sentences):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "endings = [line['text'] for line in sentences if line['index'] == line['total'] - 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['In the end, Debi and Martin leave Grosse Pointe together.',\n",
       " 'Frank and Meredith, along with the other members of the dance class, continue to find friendship and healing in each other.',\n",
       " 'She says that she knew it all along and decides to marry him.',\n",
       " 'The two reunite when Miss Lily returns to the circus.',\n",
       " 'They talk about what to eat for dinner before thinking about running a furniture business.']"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.sample(endings, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And \"middles\" are anything in between:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "middles = [line['text'] for line in sentences if 0 < line['index'] < line['total'] - 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Brian, in his first relationship and out of his depth, does what he believes is the right thing.',\n",
       " 'Laida calls it a night.',\n",
       " 'Accompanied by Willoughby, she drives Herbie onto the window-cleaning machine of Hawk’s skyscraper to reach his 28th-floor office, where mrs Steinmetz overhears a telephoned conversation with Loostgarten about the deal to demolish the firehouse and activates the window cleaning machine to fill the office with foam and water.',\n",
       " 'She goes over there to pick him up, but he is going on and on about his amnesia.',\n",
       " 'His father calls to inform him that he has the ring.']"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.sample(middles, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following cell creates the models:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "beginning_gen = markovify.Text(beginnings)\n",
    "middle_gen = markovify.Text(middles)\n",
    "ending_gen = markovify.Text(endings)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you can generate tiny narratives by producing a beginning sentence, a middle sentence, and an ending sentence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Joan Howell intends to be bride Sophie.\n",
      "Eventually Robin cracks under the guise of an important counterattack.\n",
      "Father thinks it may be yet again pregnant.\n"
     ]
    }
   ],
   "source": [
    "print(beginning_gen.make_short_sentence(100))\n",
    "print(middle_gen.make_short_sentence(100))\n",
    "print(ending_gen.make_short_sentence(100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The narratives still feel disconnected (and there are often jarring mismatches in pronoun antecedents), but the artifacts produced with this method do feel a bit narrative-like? Maybe?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combining models\n",
    "\n",
    "Markovify has a handy feature that allows you to *combine* models, creating a new model that draws on probabilities from both of the source models. You can use this to create hybrid output that mixes the style and content of two (or more!) different source texts. To do this, you need to create the models independently, and then call `.combine()` to combine them.\n",
    "\n",
    "The code below combines models for beginning sentences, middle sentences, and ending sentences into one model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "combo = markovify.combine([beginning_gen, middle_gen, ending_gen], [10, 1, 10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The bit of code `[10, 1, 10]` controls the \"weights\" of the models, i.e., how much to emphasize the probabilities of any model. You can change this to suit your tastes. (E.g., if you want mostly beginnings with but a bit of middles and a *soupçon* of ends, try `[10, 2, 1]`.)\n",
    "\n",
    "Then you can create sentences using the combined model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Afterwards, Tony approaches Amelia in the Whittaker counterfeit ring Agent Rivera who has stolen her heart.\n"
     ]
    }
   ],
   "source": [
    "print(combo.make_short_sentence(120))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepping the corpus for fine-tuning a large language model\n",
    "\n",
    "Markov chains are cheap and fun, but they don't do a great job of the one thing we expect from stories: maintaining coherence over a long stretch of text. Accomplishing this is a more difficult task, and requires making use of more sophisticated machine learning models, belonging to the category of large pre-trained neural networks. These models are fundamentally similar to Markov chains, in that they make a prediction about what will come next in a text, given some stretch of context. Unlike a Markov chain, a large pre-trained neural network can predict what will come next in a text, even if the context you give it has never been seen in the training text. It can also work on contexts of arbitrary and variable length. Handy!\n",
    "\n",
    "These language models are already trained on a large amount of text. Generally, you don't train them from scratch on your own, but instead \"fine-tune\" them to bring their probabilities more in line with a particular source text.\n",
    "\n",
    "One such model, [OpenAI's GPT-2](https://github.com/openai/gpt-2) does a pretty good job of maintaining long-distance coherence, and it's easy to fine-tune the model with Max Woolf's [aitextgen](https://github.com/minimaxir/aitextgen/).  We'll use the [example Colab notebook](https://colab.research.google.com/drive/15qBZx5y9rdaQSyWpsreMDnTiZ5IlN0zD?usp=sharing) from the aitextgen repository. This notebook works best when it's fine-tuned on text in a prose format. The model can also learn ad-hoc markup elements that you add to the text. We'll use this feature of the model to make it possible to generate stories from beginning to end, by adding a `[BEGIN STORY]` marker before each story in the source text, followed by the title of the story."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "out = []\n",
    "last_title = None\n",
    "for sent in sentences[:10000]:\n",
    "    if sent['title'] != last_title:\n",
    "        out.append(\"\")\n",
    "        out.append(\"[BEGIN STORY]\")\n",
    "        out.append(sent['title'])\n",
    "        out.append(\"\")\n",
    "        last_title = sent['title']\n",
    "    out.append(sent['text'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's what the data look like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['',\n",
       " '[BEGIN STORY]',\n",
       " 'Four Weddings and a Funeral',\n",
       " '',\n",
       " 'The film follows the adventures of a group of friends through the eyes of Charles, a good-natured but socially awkward man living in London, who becomes smitten with Carrie, an American whom Charles keeps meeting at four weddings and a funeral.',\n",
       " 'The first wedding is that of Angus and Laura, at which Charles is the best man.',\n",
       " 'Charles and his single friends wonder whether they will ever get married.',\n",
       " 'Charles meets Carrie and spends the night with her.',\n",
       " 'Carrie pretends that, now they have slept together, they will have to get married, to which Charles endeavours to respond before realising she is joking.',\n",
       " 'Carrie observes that they may have missed an opportunity and then returns to America.',\n",
       " 'The second wedding is that of Bernard and Lydia, a couple who became romantically involved at the previous wedding.',\n",
       " 'Charles encounters Carrie again, but she introduces him to her fiancé, Sir Hamish Banks, a wealthy politician.',\n",
       " 'At the reception, Charles finds himself seated with several ex-girlfriends who relate embarrassing stories about his inability to be discreet and afterwards bumps into Henrietta, known among Charles\\' friends as \"Duckface\", with whom he had a particularly difficult relationship.',\n",
       " 'Charles retreats to an empty hotel suite, seeing Carrie and Hamish leave in a taxicab, only to be trapped in a cupboard after the newlyweds stumble into the room to have sex.',\n",
       " 'After Charles awkwardly exits the room, Henrietta confronts him about his habit of \"serial monogamy\", telling him he is afraid of letting anyone get too close to him.',\n",
       " 'Charles then runs into Carrie, and they end up spending another night together.',\n",
       " \"A month later, Charles receives an invitation to Carrie's wedding.\",\n",
       " 'While shopping for a present, he coincidentally encounters Carrie and ends up helping her select her wedding dress.',\n",
       " 'Carrie lists her more than thirty sexual partners.',\n",
       " 'Charles later awkwardly tries confessing his love to her and hinting that he would like to have a relationship with her, to no avail.',\n",
       " 'The third wedding is that of Carrie and Hamish.',\n",
       " 'Charles attends, depressed at the prospect of Carrie marrying Hamish.',\n",
       " \"At the reception, Gareth instructs his friends to seek potential mates; Fiona's brother, Tom, stumbles through an attempt to connect with a woman until she reveals that she is the minister's wife, while Charles's flatmate, Scarlett, strikes up a conversation with an American named Chester.\",\n",
       " 'As Charles watches Carrie and Hamish dance, Fiona deduces his feelings about Carrie.',\n",
       " 'When Charles asks why Fiona is not married, she confesses that she has loved Charles since they first met years earlier.']"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "out[:25]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following cell writes this out to a file, which you can then upload to the aitextgen notebook on Google Colab to train the model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"story_training.txt\", \"w\") as fh:\n",
    "    fh.write(\"\\n\".join(out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the text generation section of that notebook, try prompting the model with `[BEGIN STORY]` followed by the title of a story you'd like to generate!"
   ]
  }
 ],
 "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.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}