joke_generator.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from collections import Counter\n",
    "from collections import defaultdict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def normalize(counter):\n",
    "    \"\"\" Converts a letter -> count counter to a list of (letter, \n",
    "    frequency) pairs, sorted in descending order of frequency.\n",
    "    \n",
    "        Parameters\n",
    "        -----------\n",
    "        counter : collections.Counter\n",
    "            letter -> count\n",
    "            \n",
    "        Returns\n",
    "        -------\n",
    "        A list of (letter, frequency) pairs, sorted in descending \n",
    "        order of frequency. \"\"\"\n",
    "\n",
    "    total = sum(counter.values())\n",
    "    return [(char, cnt/total) for char, cnt in counter.most_common()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def train_lm(text, n):\n",
    "    \"\"\" Trains a character-based n-gram language model.\n",
    "        \n",
    "        Parameters\n",
    "        -----------\n",
    "        text: str \n",
    "            \n",
    "        n: int\n",
    "            the length of the n-gram to analyze.\n",
    "        \n",
    "        Returns\n",
    "        -------\n",
    "        A dictionary that maps history to a list of tuples that \n",
    "        describes the probability of each following character. \"\"\"\n",
    "    \n",
    "    raw_lm = defaultdict(Counter)\n",
    "    # padding\n",
    "    history = \"~\" * (n - 1)\n",
    "    \n",
    "    for char in text:\n",
    "        raw_lm[history][char] += 1\n",
    "        history = history[1:] + char\n",
    "    \n",
    "    lm = {history : normalize(counter) for history, counter in raw_lm.items()}\n",
    "    return lm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def generate_letter(lm, history):\n",
    "    \"\"\" Randomly generates a letter according to the probability \n",
    "    distribution associated with the specified history.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        lm: Dict[str, List[Tuple[str, float]]] \n",
    "            the n-gram language model. \n",
    "        \n",
    "        history: str\n",
    "            a string of length (n-1) to use as history when generating \n",
    "            the next character.\n",
    "        \n",
    "        Returns\n",
    "        -------\n",
    "        A tuple containing the predicted character and the history. \"\"\"\n",
    "    \n",
    "    if not history in lm:\n",
    "        if history[-1] == '\\n':\n",
    "            return ('A', history)\n",
    "        elif history[-1] == 'A':\n",
    "            return (':', history)\n",
    "        elif history[-1] == ':':\n",
    "            return (' ', history)\n",
    "        else:\n",
    "            # forcibly change history\n",
    "            A_list = [hist for hist in lm.keys() if hist.endswith('\\nA: ')]\n",
    "            A_i = np.random.randint(len(A_list))\n",
    "            history = A_list[A_i]\n",
    "    letters, probs = tuple(zip(*lm[history]))\n",
    "    i = np.random.choice(letters, p=probs)\n",
    "    return (i, history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def generate_text(lm, n, nletters = 200):\n",
    "    \"\"\" Randomly generates text by drawing from the probability \n",
    "    distributions stored in the n-gram language model.\n",
    "    \n",
    "        Parameters\n",
    "        ----------\n",
    "        lm: Dict[str, List[Tuple[str, float]]]\n",
    "            the n-gram language model. \n",
    "            \n",
    "        n: int\n",
    "            order of n-gram model.\n",
    "            \n",
    "        nletters: int\n",
    "            number of letters to randomly generate.\n",
    "        \n",
    "        Returns\n",
    "        -------\n",
    "        Model-generated text. \"\"\"\n",
    "    \n",
    "    history = \"~\" * (n - 1)\n",
    "    text = []\n",
    "    finished = False\n",
    "    for i in range(nletters):\n",
    "        # keeps joke in Q&A format\n",
    "        if history[-1] == '\\n':\n",
    "            c = 'A'\n",
    "            finished = True\n",
    "        else:\n",
    "            c, history = generate_letter(lm, history)\n",
    "        if finished and c == '\\n':\n",
    "            break\n",
    "        text.append(c)\n",
    "        history = history[1:] + c\n",
    "    return \"\".join(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"jokes.txt\", \"r\") as f:\n",
    "    jokes = f.read()\n",
    "\n",
    "lm_jokes = train_lm(jokes, 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "with open(\"lm_jokes.pkl\", mode=\"wb\") as f:\n",
    "    pickle.dump(lm_jokes, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def gen_joke(n):\n",
    "    with open(\"lm_jokes.pkl\", mode=\"rb\") as f:\n",
    "        lm_jokes = pickle.load(f)\n",
    "        \n",
    "    joke = generate_text(lm_jokes, n)\n",
    "    joke = joke.replace('Q: ', '')\n",
    "    joke = joke.replace('A: ', '')\n",
    "    return joke"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What’s red and moves up and down?\n",
      "A stamp \n"
     ]
    }
   ],
   "source": [
    "print(gen_joke(8))"
   ]
  }
 ],
 "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}