python/nn_readable.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get embeddings\n",
    "\n",
    "We have generated embeddings (number vectors) for both tags and class names. This was done in the notebook [analyze_classnames](./analyze_classnames.ipynb). The results of that have also been uploaded. We'll use the result of that notebook, or fetch it, and load the JSON file..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n",
      "Creating directory data/\n",
      "Reading 21132kb into data/html-vectors.json... done.\n",
      "Class example: ('-comment-item-option-tool', [0.267649, 0.060728, 0.372383, -0.167402, -0.42405, -0.213464, -0.18574, 0.22672, 0.159343, 0.14346, 0.225321, 0.350789, 0.218112, 0.276691, 0.447376, -0.192947, -0.290775, -0.259949, 0.388473, -0.310735, -0.424629, -0.472496, 0.188353, 0.150703, 0.112088, 0.265407, 0.222766, -0.08162, 0.402486, 0.190056, 0.430345, -0.476926, 0.11799, -0.422889, 0.111582, 0.288491, 0.013147, -0.005348, -0.018681, -0.291235, -0.016522, 0.251612, -0.322645, 0.318849, -0.48921, -0.307299, 0.004299, -0.581498, 0.13047, -0.641503])\n",
      "Tag example: ('nobr', [1.215299, 0.857834, 0.162706, 0.966696, 0.232542, 1.218955, 0.733365, 0.797194, -0.145894, -0.231142, -0.262402, -0.961403, -0.097864, -1.0834, 0.766679, 0.968583, 1.385928, 0.209797, -0.425753, -1.923545])\n"
     ]
    }
   ],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload\n",
    "import json\n",
    "from pha.notebooktools import lazyget\n",
    "lazyget(\"https://raw.githubusercontent.com/ianb/personal-history-data/master/html-vectors.json\", \"data/html-vectors.json\")\n",
    "data = json.load(open(\"data/html-vectors.json\"))\n",
    "classname_vectors = data[\"classes\"]\n",
    "tag_vectors = data[\"tags\"]\n",
    "print(\"Class example:\", list(classname_vectors.items())[0])\n",
    "print(\"Tag example:\", list(tag_vectors.items())[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create vectors for elements\n",
    "\n",
    "Now, given an element, we need to make a vector. \n",
    "\n",
    "A tag has a few properties:\n",
    "* One tag name\n",
    "* Zero or more class names\n",
    "* A number of immediate children\n",
    "* A number of descendants (including grandchildren, etc)\n",
    "* A number of words\n",
    "* Number of links\n",
    "\n",
    "We'll turn these into several vectors, all of which are concatenated. Several use a parameter `min(n / range, 1.0)` which we'll call `trunc_count(n, range)`\n",
    "\n",
    "* The tag vector\n",
    "* The sum of the class name vectors (or the vector for `no-class`)\n",
    "* `trunc_count(children, 10)`\n",
    "* `trunc_count(desc, 100)`\n",
    "* `trunc_count(words, 250)`\n",
    "* `links / words` or 0 if there are no words\n",
    "\n",
    "FIXME: add `display` property (i.e., block, block-ish like inline-block, or not-block)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from pha import htmltools\n",
    "\n",
    "def trunc_count(n, max_count):\n",
    "    return min(n / max_count, 1.0)\n",
    "\n",
    "def get_classnames_vector(el):\n",
    "    classnames = htmltools.normalize_classes(el)\n",
    "    classnames = [classname_vectors[c] for c in classnames if c in classname_vectors] or [classname_vectors['no-class']]\n",
    "    return np.sum(classnames, axis=0)\n",
    "\n",
    "def get_tag_vector(el):\n",
    "    return tag_vectors.get(el.tag) or tag_vectors[\"div\"]\n",
    "\n",
    "def element_to_vector(el):\n",
    "    children = len(el)\n",
    "    desc = len(list(el.iter()))\n",
    "    words = len(el.text_content().split())\n",
    "    links = len(el.cssselect('a'))\n",
    "    classname_sum = get_classnames_vector(el)\n",
    "    tag_vector = get_tag_vector(el)\n",
    "    word_links = links / words if words else 0.0\n",
    "    vector = np.concatenate([\n",
    "        tag_vector,\n",
    "        classname_sum,\n",
    "        [trunc_count(children, 10), trunc_count(desc, 100), trunc_count(words, 250), word_links],\n",
    "    ])\n",
    "    return vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1.342614e+00 -9.486100e-02  4.825000e-02 -2.420997e+00  1.879200e-01\n",
      "  1.059590e+00  2.564651e+00  4.462840e-01  6.541920e-01 -8.095740e-01\n",
      " -6.323590e-01 -3.787137e+00  1.598670e-01 -2.616020e-01  3.036870e-01\n",
      " -1.347139e+00  1.822867e+00 -1.205438e+00  9.460170e-01 -1.036174e+00\n",
      " -2.597010e-01 -3.733580e-01  1.566220e-01  1.588957e+00  1.118785e+00\n",
      " -1.518593e+00 -7.373980e-01  6.349290e-01  5.760940e-01  2.792740e-01\n",
      " -1.000190e-01 -3.212480e-01 -1.515810e-01  1.517445e+00 -4.100120e-01\n",
      "  4.545120e-01 -1.409812e+00  2.038540e-01 -7.124000e-02 -1.194100e-02\n",
      " -4.407500e-01 -7.227330e-01  1.052250e+00 -8.168990e-01  1.433370e-01\n",
      " -1.351080e-01  2.169070e-01 -8.799660e-01  2.570460e-01 -4.959670e-01\n",
      " -4.564300e-02 -6.928400e-02  1.093841e+00 -1.262750e-01  9.825410e-01\n",
      " -1.089900e-01 -3.273710e-01  1.234727e+00 -1.384890e-01  1.434000e-03\n",
      "  3.838530e-01 -1.019180e-01  8.018710e-01  7.520770e-01 -1.827950e-01\n",
      "  4.175690e-01 -5.354360e-01  7.710520e-01 -4.671780e-01 -2.141180e-01\n",
      "  0.000000e+00  1.000000e-02  1.600000e-02  0.000000e+00] (74,)\n"
     ]
    }
   ],
   "source": [
    "# Let's test it out:\n",
    "import lxml.html\n",
    "\n",
    "example_el = lxml.html.fromstring('<div class=\"login\">this is an element</div>')\n",
    "print(element_to_vector(example_el), element_to_vector(example_el).shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training data\n",
    "\n",
    "The training (Y) data is fairly simple: is the element readable or not? We'll use a vector of `[is_not_readable, is_readable]` for each item (so always `[1, 0]` for non-readable elements, and `[0, 1]` for readable elements.\n",
    "\n",
    "But not all elements are either! Specifically elements *inside* a readable element are readable, but aren't what we are selecting. These elements will be filtered out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [],
   "source": [
    "def iter_testable_elements(doc):\n",
    "    body = list(doc.iter(\"body\"))[0]\n",
    "    def iter_children(el):\n",
    "        for child in el:\n",
    "            if \"data-isreadable\" in child:\n",
    "                print(\"found\", child)\n",
    "                assert 0\n",
    "            if child.get(\"data-isreadable\"):\n",
    "                yield True, child\n",
    "            else:\n",
    "                yield False, child\n",
    "                yield from iter_children(child)\n",
    "    return iter_children(body)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(False, <Element div at 0x496f5eae8>), (True, <Element ul at 0x496f5e458>), (False, <Element ol at 0x496f5eea8>), (False, <Element li at 0x496f5e098>), (False, <Element li at 0x496f5eb88>)]\n"
     ]
    }
   ],
   "source": [
    "example_doc = lxml.html.document_fromstring(\"\"\"\n",
    "<html><head><title>Test</title></head>\n",
    "<body><div><ul data-isreadable=\"1\"><li>1<li>2</ul>\n",
    "<ol><li>3<li>4</ol>\n",
    "</div></body></html>\n",
    "\"\"\")\n",
    "print(list(iter_testable_elements(example_doc)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Actual training data\n",
    "\n",
    "To get real training data we have to load the history, get all the elements, convert them to vectors, and construct results along the way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Archive at '/Users/ianbicking/src/personal-history-archive' 20978/54826 fetched, 32647 errored>\n",
      "16100\n"
     ]
    }
   ],
   "source": [
    "import pha\n",
    "import pha.htmltools\n",
    "import random\n",
    "archive = pha.Archive.default_location()\n",
    "print(archive)\n",
    "histories = archive.histories_with_page()\n",
    "random.shuffle(histories)\n",
    "print(len(histories))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_X_Y(element_to_vector, histories, select_unreadable=0.02):\n",
    "    X = []\n",
    "    Y = []\n",
    "    total = 0\n",
    "    with_readable = 0\n",
    "    for h in histories:\n",
    "        for is_readable, el in iter_testable_elements(h.page.lxml):\n",
    "            if not is_readable and random.random() > select_unreadable:\n",
    "                continue\n",
    "            total += 1\n",
    "            X.append(element_to_vector(el))\n",
    "            if is_readable:\n",
    "                with_readable += 1\n",
    "            Y.append([0., 1.] if is_readable else [1., 0.])\n",
    "    X = np.array(X)\n",
    "    Y = np.array(Y)\n",
    "    print(\"Total:\", total, \"with readable:\", with_readable)\n",
    "    return X, Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X, Y = generate_X_Y(element_to_vector, histories)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "import h5py\n",
    "h5f = h5py.File('readable-training-data.h5', 'w')\n",
    "h5f.create_dataset('X_1', data=X, dtype=np.float32, compression=\"gzip\")\n",
    "h5f.create_dataset('Y_1', data=Y, dtype=np.int8, compression=\"gzip\")\n",
    "h5f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X: <class 'numpy.ndarray'> <class 'numpy.ndarray'> 256890 (74,) sub-length: 74 size: 19 Y: 256890\n"
     ]
    }
   ],
   "source": [
    "print(\"X:\", type(X), type(X[0]), len(X), X[0].shape, \"sub-length:\", len(X[0]), \"size:\", len(X) * len(X[0]) // 1000000, \"Y:\", len(Y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14996243 14996243\n"
     ]
    }
   ],
   "source": [
    "h5f = h5py.File('readable-training-data.h5', 'r')\n",
    "print(len(h5f['X_1']), len(h5f['Y_1']))\n",
    "h5f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [],
   "source": [
    "def split_training(X, Y):\n",
    "    split = 8 * len(X) // 10\n",
    "    X_train, X_test = X[:split], X[split:]\n",
    "    Y_train, Y_test = Y[:split], Y[split:]\n",
    "    return X_train, X_test, Y_train, Y_test\n",
    "\n",
    "X_train, X_test, Y_train, Y_test = split_training(X, Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Dropout\n",
    "\n",
    "def make_model(input_shape):\n",
    "    model = Sequential()\n",
    "    model.add(Dense(input_shape[0], input_shape=input_shape))\n",
    "    model.add(Dropout(0.2))\n",
    "    model.add(Dense(256, input_shape=input_shape))\n",
    "    model.add(Dense(2, activation='softmax')) # is readable, or is not readable\n",
    "    model.compile(\n",
    "        optimizer='rmsprop', \n",
    "        loss='categorical_crossentropy',\n",
    "        metrics=['accuracy'])\n",
    "    return model\n",
    "\n",
    "model = make_model(X[0].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 00001: val_loss improved from inf to 0.05133, saving model to readable-model-best.h5\n",
      "\n",
      "Epoch 00002: val_loss did not improve\n",
      "\n",
      "Epoch 00003: val_loss did not improve\n",
      "\n",
      "Epoch 00004: val_loss did not improve\n",
      "\n",
      "Epoch 00005: val_loss did not improve\n",
      "\n",
      "Epoch 00006: val_loss did not improve\n",
      "\n",
      "Epoch 00007: val_loss did not improve\n",
      "\n",
      "Epoch 00008: val_loss did not improve\n",
      "\n",
      "Epoch 00009: val_loss did not improve\n",
      "\n",
      "Epoch 00010: val_loss improved from 0.05133 to 0.05114, saving model to readable-model-best.h5\n",
      "\n",
      "Epoch 00011: val_loss did not improve\n",
      "\n",
      "Epoch 00012: val_loss did not improve\n",
      "\n",
      "Epoch 00013: val_loss did not improve\n",
      "\n",
      "Epoch 00014: val_loss did not improve\n",
      "\n",
      "Epoch 00015: val_loss did not improve\n",
      "\n",
      "Epoch 00016: val_loss did not improve\n",
      "\n",
      "Epoch 00017: val_loss did not improve\n",
      "\n",
      "Epoch 00018: val_loss improved from 0.05114 to 0.05059, saving model to readable-model-best.h5\n",
      "\n",
      "Epoch 00019: val_loss did not improve\n",
      "\n",
      "Epoch 00020: val_loss did not improve\n",
      "\n",
      "Epoch 00021: val_loss did not improve\n",
      "\n",
      "Epoch 00022: val_loss did not improve\n",
      "\n",
      "Epoch 00023: val_loss did not improve\n",
      "\n",
      "Epoch 00024: val_loss did not improve\n",
      "\n",
      "Epoch 00025: val_loss did not improve\n",
      "\n",
      "Epoch 00026: val_loss did not improve\n",
      "\n",
      "Epoch 00027: val_loss did not improve\n",
      "\n",
      "Epoch 00028: val_loss did not improve\n",
      "\n",
      "Epoch 00029: val_loss did not improve\n",
      "\n",
      "Epoch 00030: val_loss did not improve\n",
      "\n",
      "Epoch 00031: val_loss did not improve\n",
      "\n",
      "Epoch 00032: val_loss did not improve\n",
      "\n",
      "Epoch 00033: val_loss did not improve\n",
      "\n",
      "Epoch 00034: val_loss did not improve\n",
      "\n",
      "Epoch 00035: val_loss did not improve\n",
      "\n",
      "Epoch 00036: val_loss did not improve\n",
      "\n",
      "Epoch 00037: val_loss did not improve\n",
      "\n",
      "Epoch 00038: val_loss did not improve\n",
      "\n",
      "Epoch 00039: val_loss did not improve\n",
      "\n",
      "Epoch 00040: val_loss did not improve\n",
      "\n",
      "Epoch 00041: val_loss did not improve\n",
      "\n",
      "Epoch 00042: val_loss did not improve\n",
      "\n",
      "Epoch 00043: val_loss did not improve\n",
      "\n",
      "Epoch 00044: val_loss did not improve\n",
      "\n",
      "Epoch 00045: val_loss did not improve\n",
      "\n",
      "Epoch 00046: val_loss did not improve\n",
      "\n",
      "Epoch 00047: val_loss did not improve\n",
      "\n",
      "Epoch 00048: val_loss improved from 0.05059 to 0.05006, saving model to readable-model-best.h5\n",
      "\n",
      "Epoch 00049: val_loss did not improve\n",
      "\n",
      "Epoch 00050: val_loss did not improve\n",
      "Accuracy: [0.06527374820363409, 0.9771497528124878] ['loss', 'acc']\n"
     ]
    }
   ],
   "source": [
    "from keras.callbacks import ModelCheckpoint\n",
    "\n",
    "checkpointer = ModelCheckpoint(\n",
    "    filepath='readable-model-best.h5', \n",
    "    verbose=1, save_best_only=True)\n",
    "hist = model.fit(\n",
    "    np.array(X_train), np.array(Y_train), \n",
    "    batch_size=128, epochs=50,\n",
    "    validation_split=0.2, \n",
    "    callbacks=[checkpointer],\n",
    "    verbose=0, shuffle=True)\n",
    "model.load_weights('readable-model-best.h5')\n",
    "score = model.evaluate(np.array(X_test), np.array(Y_test), verbose=0)\n",
    "print(\"Accuracy:\", score, model.metrics_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Got readable right 826 and wrong 977 0.5418746533555185\n",
      "Got unreadable right 49378 and wrong 197 0.003973777105395865\n"
     ]
    }
   ],
   "source": [
    "def evaluate_model(model, X_test, Y_test):\n",
    "    right_readable = wrong_readable = right_unreadable = wrong_unreadable = 0\n",
    "    for el, result in list(zip(X_test, Y_test)):\n",
    "        predict = model.predict(numpy.array([el]))\n",
    "        predict_readable = predict[0][0] < predict[0][1]\n",
    "        is_readable = result[0] < result[1]\n",
    "        if is_readable:\n",
    "            if predict_readable:\n",
    "                right_readable += 1\n",
    "            else:\n",
    "                wrong_readable += 1\n",
    "        elif predict_readable:\n",
    "            wrong_unreadable += 1\n",
    "        else:\n",
    "            right_unreadable += 1\n",
    "    print(\"Got readable right\", right_readable, \"and wrong\", wrong_readable, \n",
    "          wrong_readable / (right_readable + wrong_readable))\n",
    "    print(\"Got unreadable right\", right_unreadable, \"and wrong\", wrong_unreadable,\n",
    "          wrong_unreadable / (right_unreadable + wrong_unreadable))\n",
    "    \n",
    "evaluate_model(model, X_test, Y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A new vector representation\n",
    "\n",
    "Let's try giving the model a bit more information, essentially a sort of \"window\" for the element.\n",
    "\n",
    "We'll use the previous vector representation, but add in:\n",
    "\n",
    "- The tag and classname vectors for the parent node\n",
    "- The sum of all the tag and classname vectors for the child node (but not descendants)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [],
   "source": [
    "def contextualized_element_to_vector(el):\n",
    "    parent = el.getparent()\n",
    "    if not len(el):\n",
    "        children_tags = tag_vectors[\"span\"]\n",
    "        children_classnames = classname_vectors[\"no-class\"]\n",
    "    else:\n",
    "        children_tags = np.sum([get_tag_vector(child) for child in el], axis=0)\n",
    "        children_classnames = np.sum([get_classnames_vector(child) for child in el], axis=0)\n",
    "    return np.concatenate([\n",
    "        element_to_vector(el),\n",
    "        children_tags,\n",
    "        children_classnames,\n",
    "        get_tag_vector(parent),\n",
    "        get_classnames_vector(parent),\n",
    "    ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total: 35661 with readable: 9052\n"
     ]
    }
   ],
   "source": [
    "context_X, context_Y = generate_X_Y(contextualized_element_to_vector, histories, select_unreadable=0.0007 * 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "readable 9052 unreadable 12713809 ratio 1404.5303800265135 or 0.0007119817514955589\n"
     ]
    }
   ],
   "source": [
    "## For reasons I do not understand, this doesn't work:\n",
    "# from collections import Counter\n",
    "# c = Counter([result[0] for result in iter_testable_elements(h.page.lxml) for h in histories])\n",
    "# print(c)\n",
    "## But this does:\n",
    "readable = unreadable = 0\n",
    "for h in histories:\n",
    "    for r, el in iter_testable_elements(h.page.lxml):\n",
    "        if r:\n",
    "            readable += 1\n",
    "        else:\n",
    "            unreadable += 1\n",
    "print(\"readable\", readable, \"unreadable\", unreadable, \"ratio\", unreadable / readable, \"or\", readable / unreadable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [],
   "source": [
    "context_X_train, context_X_test, context_Y_train, context_Y_test = split_training(context_X, context_Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 00001: val_loss did not improve\n",
      "\n",
      "Epoch 00002: val_loss did not improve\n",
      "\n",
      "Epoch 00003: val_loss did not improve\n",
      "\n",
      "Epoch 00004: val_loss did not improve\n",
      "\n",
      "Epoch 00005: val_loss did not improve\n",
      "\n",
      "Epoch 00006: val_loss did not improve\n",
      "\n",
      "Epoch 00007: val_loss improved from 0.11298 to 0.09876, saving model to readable-model2-best.h5\n",
      "\n",
      "Epoch 00008: val_loss did not improve\n",
      "\n",
      "Epoch 00009: val_loss improved from 0.09876 to 0.09309, saving model to readable-model2-best.h5\n",
      "\n",
      "Epoch 00010: val_loss improved from 0.09309 to 0.08839, saving model to readable-model2-best.h5\n",
      "\n",
      "Epoch 00011: val_loss did not improve\n",
      "\n",
      "Epoch 00012: val_loss did not improve\n",
      "\n",
      "Epoch 00013: val_loss did not improve\n",
      "\n",
      "Epoch 00014: val_loss improved from 0.08839 to 0.08524, saving model to readable-model2-best.h5\n",
      "\n",
      "Epoch 00015: val_loss did not improve\n",
      "\n",
      "Epoch 00016: val_loss did not improve\n",
      "\n",
      "Epoch 00017: val_loss did not improve\n",
      "\n",
      "Epoch 00018: val_loss did not improve\n",
      "\n",
      "Epoch 00019: val_loss did not improve\n",
      "\n",
      "Epoch 00020: val_loss improved from 0.08524 to 0.08315, saving model to readable-model2-best.h5\n",
      "\n",
      "Epoch 00021: val_loss did not improve\n",
      "\n",
      "Epoch 00022: val_loss did not improve\n",
      "\n",
      "Epoch 00023: val_loss did not improve\n",
      "\n",
      "Epoch 00024: val_loss did not improve\n",
      "\n",
      "Epoch 00025: val_loss did not improve\n",
      "\n",
      "Epoch 00026: val_loss did not improve\n",
      "\n",
      "Epoch 00027: val_loss did not improve\n",
      "\n",
      "Epoch 00028: val_loss did not improve\n",
      "\n",
      "Epoch 00029: val_loss did not improve\n",
      "\n",
      "Epoch 00030: val_loss did not improve\n",
      "\n",
      "Epoch 00031: val_loss did not improve\n",
      "\n",
      "Epoch 00032: val_loss did not improve\n",
      "\n",
      "Epoch 00033: val_loss did not improve\n",
      "\n",
      "Epoch 00034: val_loss did not improve\n",
      "\n",
      "Epoch 00035: val_loss did not improve\n",
      "\n",
      "Epoch 00036: val_loss did not improve\n",
      "\n",
      "Epoch 00037: val_loss did not improve\n",
      "\n",
      "Epoch 00038: val_loss did not improve\n",
      "\n",
      "Epoch 00039: val_loss did not improve\n",
      "\n",
      "Epoch 00040: val_loss did not improve\n",
      "\n",
      "Epoch 00041: val_loss did not improve\n",
      "\n",
      "Epoch 00042: val_loss did not improve\n",
      "\n",
      "Epoch 00043: val_loss did not improve\n",
      "\n",
      "Epoch 00044: val_loss did not improve\n",
      "\n",
      "Epoch 00045: val_loss did not improve\n",
      "\n",
      "Epoch 00046: val_loss did not improve\n",
      "\n",
      "Epoch 00047: val_loss did not improve\n",
      "\n",
      "Epoch 00048: val_loss did not improve\n",
      "\n",
      "Epoch 00049: val_loss did not improve\n",
      "\n",
      "Epoch 00050: val_loss did not improve\n"
     ]
    }
   ],
   "source": [
    "from keras.callbacks import ModelCheckpoint\n",
    "\n",
    "context_model = make_model(context_X[0].shape)\n",
    "\n",
    "context_checkpointer = ModelCheckpoint(\n",
    "    filepath='readable-model2-best.h5', \n",
    "    verbose=1, save_best_only=True)\n",
    "context_hist = context_model.fit(\n",
    "    np.array(context_X_train), np.array(context_Y_train), \n",
    "    batch_size=128, epochs=50,\n",
    "    validation_split=0.2, \n",
    "    callbacks=[checkpointer],\n",
    "    verbose=0, shuffle=True)\n",
    "context_model.load_weights('readable-model2-best.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: [0.10461074322854823, 0.9733632411977511] ['loss', 'acc']\n",
      "Got readable right 1781 and wrong 79 0.04247311827956989\n",
      "Got unreadable right 5162 and wrong 111 0.02105063531196662\n"
     ]
    }
   ],
   "source": [
    "score = context_model.evaluate(np.array(context_X_test), np.array(context_Y_test), verbose=0)\n",
    "print(\"Accuracy:\", score, context_model.metrics_names)\n",
    "evaluate_model(context_model, context_X_test, context_Y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "metadata": {},
   "outputs": [],
   "source": [
    "%autoreload\n",
    "import pha\n",
    "import pha.htmltools\n",
    "from pha.notebooktools import display_html\n",
    "import lxml.html\n",
    "from IPython.core.display import display, HTML\n",
    "\n",
    "def create_readable(page):\n",
    "    body = page.lxml.find(\"body\")\n",
    "    readable = lxml.html.fragment_fromstring(\"<div></div>\")\n",
    "    for el in body.iter():\n",
    "        el_vector = contextualized_element_to_vector(el)\n",
    "        predict = context_model.predict(numpy.array([el_vector]))\n",
    "        if predict[0][0] < predict[0][1]:\n",
    "            readable.append(el)\n",
    "    if not len(readable):\n",
    "        return None\n",
    "    return readable\n",
    "\n",
    "def show_readable(page):\n",
    "    if isinstance(page, pha.Page) or hasattr(page, \"lxml\"):\n",
    "        page = create_readable(page)\n",
    "    if page is None:\n",
    "        print(\"No readable version to show\")\n",
    "    display_html(page)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "      \n",
       "      <iframe style=\"width: 100%; height: 12em; overflow: scroll\" scrolling=\"yes\" src=\"data:text/html;base64,<div><body class="">
    <div id="cta-lightbox-placeholder"></div>

        
    

    

            

        
    

        <div id="upload-global"><div data-reactroot="" class="upload-global-layout"><div class="total-upload-progress" style="transform: scaleX(0); transform-origin: 100% 100% 0px;"></div><span data-hidden="true"></span><span data-hidden="true"></span></div></div>
    <div id="upload-album"></div>

    
    

    <div id="inside">
        <div id="report-bad-ads-modal"></div>

        <div class="left post-pad">
            <div id="promoted-spotlight"></div>
            <div class="post-container">
                <div class="post-header"><div data-reactroot=""><div class="next-prev"><div data-hidden="true" class="btn navPrev icon icon-arrow-left disabled"></div><div class="btn btn-action navNext"><div class="text">Next Post</div><span data-display="block" class="icon icon-arrow-right"></span></div></div><div class="post-title-container"><h1 class="post-title">Expectation vs. Reality: My wife made a dragon cake for her mother's birthday</h1></div><div class="post-title-meta font-opensans-semibold"><span> by </span><a data-display="inline-block" href="https://imgur.com/user/lemurvomit" title="view account of lemurvomit" class="post-account">lemurvomit</a><span title="Sat Jul 01 2017 21:02:34 GMT-0500 (CDT)">Jul 1</span></div></div></div>

                <div class="post-images">

                                    
                    
                    

                    <div id="eVnCxIi" class="post-image-container" itemscope="" itemtype="http://schema.org/ImageObject">
                        <div class="post-image">
    

                        <a href="https://i.imgur.com/eVnCxIi.jpg" class="zoom">
                                    <img data-width="728" data-height="980" data-display="block" src="https://i.imgur.com/eVnCxIi.jpg" alt="Expectation vs. Reality: My wife made a dragon cake for her mother's birthday" itemprop="contentURL">
                
            </a>
        
    
</div>


                        <div>
                            
                        </div>

                                                    <meta itemprop="datePublished" content="2017-07-02">
                        

                                                    <span itemprop="author" itemscope="" itemtype="http://schema.org/Person">
                                <link itemprop="url" href="https://imgur.com/user/lemurvomit">
                            </span>
                        
                    </div>
                

                

                

                
                <div class="post-action"><div data-reactroot="" class=""><div class="post-action-actions"><button class="post-action-icon post-action-upvote icon-upvote-outline" style="transform: scale(1);"></button><button class="post-action-icon post-action-downvote icon-downvote-outline" style="transform: scale(1);"></button><button class="post-action-icon post-action-favorite icon-favorite-outline" style="transform: scale(1);"></button><a class="Open-Save-To-Folder-Button">+</a><div class="post-action-options pointer right"><span data-hidden="true" class="icon-ellipses"></span><ul data-hidden="true" class="post-action-options-items"><li><a class="post-action-option" href="https://imgur.com/eVnCxIi#"><span data-hidden="true" class="icon-report-outline post-action-options-items-icon"></span><span class="post-action-link-text">Report Post</span></a></li><li><a class="post-action-option" href="https://imgur.com/eVnCxIi#"><span data-hidden="true" class="icon-download post-action-options-items-icon"></span><span class="post-action-link-text">Download Post</span></a></li><li><a class="post-action-option" href="https://imgur.com/eVnCxIi#"><span data-hidden="true" class="icon-embed post-action-options-items-icon"></span><span class="post-action-link-text">Embed Post</span></a></li><li><a class="post-action-option" href="https://imgur.com/memegen/create/eVnCxIi"><span data-hidden="true" class="icon-meme post-action-options-items-icon"></span><span class="post-action-link-text">Make Meme</span></a></li></ul></div><div class="right"><span data-hidden="true" class="social-icon icon-f"></span><span data-hidden="true" class="social-icon icon-twttr"></span><span data-hidden="true" class="social-icon icon-pin"></span><span data-hidden="true" class="social-icon icon-reddit"></span></div></div><div class="post-action-meta"><span class="post-action-stats pointer"><span class="post-action-stats-points">24 Points</span><span class="">24,575 Views</span></span><div data-hidden="true" class="right post-action-tags"></div><div class="cf"></div></div></div></div>

                </div>
            </div>

                            <div id="comments-container" class="comments-initialized"><div data-reactroot="" id="comments" class="comments-loaded"><div id="captions" class="root-caption-container"><form class="caption-create"><span data-hidden="true" class="icon-x right pointer"></span><textarea data-display="block" placeholder="Write a comment" style="resize: none; overflow-y: hidden; position: absolute; top: 0px; left: -9999px; height: 22px; width: 694px; line-height: 22.5px; text-decoration: none; letter-spacing: 0.3px;" tabindex="-1"></textarea><textarea data-display="block" placeholder="Write a comment" style="resize: none; overflow-y: hidden;"></textarea><div class="summary"><input data-display="block" value="Post" id="submit-comment" class="right btn btn-main" disabled type="submit"><a data-display="block" class="rules left" href="https://imgur.com/rules" target="_blank">remember the community rules</a><div class="counter right">140</div></div></form><div class="comments-info"><div class="left"><div class="inline"><span class="comments-count">8</span> COMMENTS</div></div><div class="comments-sort right like-combobox-but-not "><span>best</span><span data-hidden="true" class="icon-arrow-down"></span><div data-hidden="true" class="options"><div><div class="item selected">best</div><div class="item">new</div><div class="item">top</div></div></div></div><span data-display="block" class="icon-expand comments-expand right pointer" href="undefined">Expand All</span><div class="clear"></div></div><div class="children"><span data-hidden="true"></span><span><div data-level="0" class="comment"><div class="caption" data-id="1066821303"><div class="usertext cf"><div class="author"><a data-display="inline-block" class="comment-username" href="https://imgur.com/user/orbit919" title="orbit919">orbit919</a><span class="via"> via <a href="https://imgur.com/apps" target="_blank">Android<span data-hidden="true" class="icon icon-mobile"></span></a></span><span class="comment-meta-spacer">3 pts</span><span title="Sat Jul 01 2017 22:31:34 GMT-0500 (CDT)" class="comment-meta-spacer">Jul 1</span><div data-display="inline" class="icon-ellipses caption-toolbar edit-button comment-meta-spacer like-combobox-but-not "><span data-hidden="true"></span><span data-hidden="true"></span><div data-hidden="true" class="options"><div><div class="addthis_button item share-caption-link">share</div><div class="item report-caption-link">report</div><a data-display="block" class="item permalink-caption-link" href="https://imgur.com/gallery/eVnCxIi/comment/1066821303">permalink</a></div></div></div></div><span data-display="block"><span>be strong for mother</span></span><div data-hidden="true" class="comment-create-reply"><div class="comment-create-reply-wrapper"><div data-hidden="true" class="icon-reply"></div><div>Reply</div></div></div></div><div class="comment-votes"><div class="comment-votes-wrapper"><button data-display="block" class="comment-vote icon-upvote-fill" style="transform: scale(1);"></button><button data-display="block" class="comment-vote icon-downvote-fill" style="transform: scale(1);"></button></div></div></div><span data-hidden="true"></span></div><div data-level="0" class="comment"><div class="caption" data-id="1107255915"><div class="usertext cf"><div class="author"><a data-display="inline-block" class="comment-username" href="https://imgur.com/user/smtel" title="smtel">smtel</a><span class="comment-meta-spacer">1 pt</span><span title="Mon Aug 28 2017 05:03:29 GMT-0500 (CDT)" class="comment-meta-spacer">Aug 28</span><div data-display="inline" class="icon-ellipses caption-toolbar edit-button comment-meta-spacer like-combobox-but-not "><span data-hidden="true"></span><span data-hidden="true"></span><div data-hidden="true" class="options"><div><div class="addthis_button item share-caption-link">share</div><div class="item report-caption-link">report</div><a data-display="block" class="item permalink-caption-link" href="https://imgur.com/gallery/eVnCxIi/comment/1107255915">permalink</a></div></div></div></div><span data-display="block"><span>it looks more like a snail</span></span><div data-hidden="true" class="comment-create-reply"><div class="comment-create-reply-wrapper"><div data-hidden="true" class="icon-reply"></div><div>Reply</div></div></div></div><div class="comment-votes"><div class="comment-votes-wrapper"><button data-display="block" class="comment-vote icon-upvote-fill" style="transform: scale(1);"></button><button data-display="block" class="comment-vote icon-downvote-fill" style="transform: scale(1);"></button></div></div></div><span data-hidden="true"></span></div><div data-level="0" class="comment"><div class="caption" data-id="1067470523"><div class="usertext cf"><div class="author"><a data-display="inline-block" class="comment-username" href="https://imgur.com/user/somebadplankton" title="somebadplankton">somebadplankton</a><span class="comment-meta-spacer">1 pt</span><span title="Sun Jul 02 2017 22:17:56 GMT-0500 (CDT)" class="comment-meta-spacer">Jul 2</span><div data-display="inline" class="icon-ellipses caption-toolbar edit-button comment-meta-spacer like-combobox-but-not "><span data-hidden="true"></span><span data-hidden="true"></span><div data-hidden="true" class="options"><div><div class="addthis_button item share-caption-link">share</div><div class="item report-caption-link">report</div><a data-display="block" class="item permalink-caption-link" href="https://imgur.com/gallery/eVnCxIi/comment/1067470523">permalink</a></div></div></div></div><span data-display="block"><span>i enjoy the randomly placed horn candles</span></span><div data-hidden="true" class="comment-create-reply"><div class="comment-create-reply-wrapper"><div data-hidden="true" class="icon-reply"></div><div>Reply</div></div></div></div><div class="comment-votes"><div class="comment-votes-wrapper"><button data-display="block" class="comment-vote icon-upvote-fill" style="transform: scale(1);"></button><button data-display="block" class="comment-vote icon-downvote-fill" style="transform: scale(1);"></button></div></div></div><span data-hidden="true"></span></div><div data-level="0" class="comment"><div class="caption" data-id="1066826411"><div class="usertext cf"><div class="author"><a data-display="inline-block" class="comment-username" href="https://imgur.com/user/gillotte" title="gillotte">gillotte</a><span class="comment-meta-spacer">1 pt</span><span title="Sat Jul 01 2017 22:41:31 GMT-0500 (CDT)" class="comment-meta-spacer">Jul 1</span><div data-display="inline" class="icon-ellipses caption-toolbar edit-button comment-meta-spacer like-combobox-but-not "><span data-hidden="true"></span><span data-hidden="true"></span><div data-hidden="true" class="options"><div><div class="addthis_button item share-caption-link">share</div><div class="item report-caption-link">report</div><a data-display="block" class="item permalink-caption-link" href="https://imgur.com/gallery/eVnCxIi/comment/1066826411">permalink</a></div></div></div></div><span data-display="block"><span>To be honest neither cake looks that good or appetizing.</span></span><div data-hidden="true" class="comment-create-reply"><div class="comment-create-reply-wrapper"><div data-hidden="true" class="icon-reply"></div><div>Reply</div></div></div></div><div class="comment-votes"><div class="comment-votes-wrapper"><button data-display="block" class="comment-vote icon-upvote-fill" style="transform: scale(1);"></button><button data-display="block" class="comment-vote icon-downvote-fill" style="transform: scale(1);"></button></div></div></div><span data-hidden="true"></span></div><div data-level="0" class="comment"><div class="caption" data-id="1066798827"><div class="usertext cf"><div class="author"><a data-display="inline-block" class="comment-username" href="https://imgur.com/user/MeredithHasBeenExposedToRabies" title="MeredithHasBeenExposedToRabies">MeredithHasBeenExposedToRabies</a><span class="via"> via <a href="https://imgur.com/apps" target="_blank">Android<span data-hidden="true" class="icon icon-mobile"></span></a></span><span class="comment-meta-spacer">1 pt</span><span title="Sat Jul 01 2017 21:48:03 GMT-0500 (CDT)" class="comment-meta-spacer">Jul 1</span><div data-display="inline" class="icon-ellipses caption-toolbar edit-button comment-meta-spacer like-combobox-but-not "><span data-hidden="true"></span><span data-hidden="true"></span><div data-hidden="true" class="options"><div><div class="addthis_button item share-caption-link">share</div><div class="item report-caption-link">report</div><a data-display="block" class="item permalink-caption-link" href="https://imgur.com/gallery/eVnCxIi/comment/1066798827">permalink</a></div></div></div></div><span data-display="block"><span>Nailed it.</span></span><div data-hidden="true" class="comment-create-reply"><div class="comment-create-reply-wrapper"><div data-hidden="true" class="icon-reply"></div><div>Reply</div></div></div></div><div class="comment-votes"><div class="comment-votes-wrapper"><button data-display="block" class="comment-vote icon-upvote-fill" style="transform: scale(1);"></button><button data-display="block" class="comment-vote icon-downvote-fill" style="transform: scale(1);"></button></div></div></div><span data-hidden="true"></span></div><div data-hidden="true" class="bad-captions nodisplay"><a data-display="block" href="#" class="link">show bad replies</a><div data-hidden="true" class="nodisplay"></div></div></span></div></div></div></div>
            

            <div id="recommendations"></div>
        </div>

        <div id="right-content" class="right post-unification">

            <div id="post-options"></div>

            <div id="side-gallery"><div data-reactroot=""><div class="sg-header"><a data-display="block" class="sg-title-container" href="https://imgur.com/gallery"><h2 class="sg-title">Most Viral Images</h2><h3 class="sg-subtitle">sorted by popularity</h3></a><div class="layout-options"><a data-display="inline-block" class="layout-button selected"><span data-hidden="true" class="icon-right-list"></span></a><a data-display="inline-block" class="layout-button"><span data-hidden="true" class="icon-grid"></span></a></div></div><div class="nano"><div class="content scroll-content cf" tabindex="0" data-isreadable="1"><div class="items list"><a data-display="block" class="sg-item selected base list" id="item-eVnCxIi" href="https://imgur.com/gallery/eVnCxIi"><div class="sg-list-image" style='background-image: url("//i.imgur.com/eVnCxIib.jpg");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Expectation vs. Reality: My wife made a dragon cake for her mother's birthday</div></div></a><a data-display="block" class="sg-item base list" id="item-pDFFo" href="https://imgur.com/gallery/pDFFo"><div class="sg-list-image" style='background-image: url("//i.imgur.com/Oz8rh53b.jpg");'><div class="sg-item-tag">49</div></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Funny Random Meme Dump</div></div></a><a data-display="block" class="sg-item base list" id="item-gsZua" href="https://imgur.com/gallery/gsZua"><div class="sg-list-image" style='background-image: url("//i.imgur.com/PX0RvJlb.jpg");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Black Panther</div></div></a><a data-display="block" class="sg-item base list" id="item-T8G3t" href="https://imgur.com/gallery/T8G3t"><div class="sg-list-image" style='background-image: url("//i.imgur.com/uO2dOQeb.jpg");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">A night encounter in the Yellowstone National Park.</div></div></a><a data-display="block" class="sg-item base list" id="item-wbayCmc" href="https://imgur.com/gallery/wbayCmc"><div class="sg-list-image" style='background-image: url("//i.imgur.com/wbayCmcb.jpg");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">People that do these "prank" videos all deserve to get their asses kicked.</div></div></a><a data-display="block" class="sg-item base list" id="item-aRQrA" href="https://imgur.com/gallery/aRQrA"><div class="sg-list-image" style='background-image: url("//i.imgur.com/ilN4Ofob.jpg");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">There's still hope</div></div></a><a data-display="block" class="sg-item base list" id="item-78kQ0" href="https://imgur.com/gallery/78kQ0"><div class="sg-list-image" style='background-image: url("//i.imgur.com/yjxme0wb.jpg");'><div class="sg-item-tag">50</div></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Here's a meme dump for everyone</div></div></a><a data-display="block" class="sg-item base list" id="item-GkTLGEk" href="https://imgur.com/gallery/GkTLGEk"><div class="sg-list-image" style='background-image: url("//i.imgur.com/GkTLGEkb.jpg");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">being black in china vol.2</div></div></a><a data-display="block" class="sg-item base list" id="item-OmT8O" href="https://imgur.com/gallery/OmT8O"><div class="sg-list-image" style='background-image: url("//i.imgur.com/HnaNFlYb.jpg");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Wtf</div></div></a><a data-display="block" class="sg-item base list" id="item-EGM1bcn" href="https://imgur.com/gallery/EGM1bcn"><div class="sg-list-image" style='background-image: url("//i.imgur.com/EGM1bcnb.jpg");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">need a ride?</div></div></a><a data-display="block" class="sg-item base list" id="item-yvVf4" href="https://imgur.com/gallery/yvVf4"><div class="sg-list-image" style='background-image: url("//i.imgur.com/hRHrL0kb.jpg");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Disney Isn't Always Gospel</div></div></a><a data-display="block" class="sg-item base list" id="item-K0SSIzv" href="https://imgur.com/gallery/K0SSIzv"><div class="sg-list-image" style='background-image: url("//i.imgur.com/K0SSIzvb.jpg");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">What..who's touching me! Oh it's you!</div></div></a><a data-display="block" class="sg-item base list" id="item-tESlR" href="https://imgur.com/gallery/tESlR"><div class="sg-list-image" style='background-image: url("//i.imgur.com/vzuk53Cb.jpg");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Pure Happiness</div></div></a><a data-display="block" class="sg-item base list" id="item-yElCL" href="https://imgur.com/gallery/yElCL"><div class="sg-list-image" style='background-image: url("//i.imgur.com/8WU5Kgub.jpg");'><div class="sg-item-tag">4</div></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">I got my own sewing machine...</div></div></a><a data-display="block" class="sg-item base list" id="item-csBvC" href="https://imgur.com/gallery/csBvC"><div class="sg-list-image" style='background-image: url("//i.imgur.com/xTEmFByb.jpg");'><div class="sg-item-tag">7</div></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">He's doing the helicopter again
</div></div></a><a data-display="block" class="sg-item base list" id="item-mqJLN41" href="https://imgur.com/gallery/mqJLN41"><div class="sg-list-image" style='background-image: url("//i.imgur.com/mqJLN41b.jpg");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">I golfed once, this was not my experience.&#160;</div></div></a><a data-display="block" class="sg-item base list" id="item-CD5mytb" href="https://imgur.com/gallery/CD5mytb"><div class="sg-list-image" style='background-image: url("//i.imgur.com/CD5mytbb.jpg");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">anybody remembers police squad?</div></div></a><a data-display="block" class="sg-item base list" id="item-8NwAhgK" href="https://imgur.com/gallery/8NwAhgK"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">This is what happens to aluminium when a 1/2 oz piece of plastic hits it at 15,000 mph in space</div></div></a><a data-display="block" class="sg-item base list" id="item-76oUY" href="https://imgur.com/gallery/76oUY"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Unnecessary Maps</div></div></a><a data-display="block" class="sg-item base list" id="item-aZAek" href="https://imgur.com/gallery/aZAek"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Elon you listining?</div></div></a><a data-display="block" class="sg-item base list" id="item-F6ebl" href="https://imgur.com/gallery/F6ebl"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">This is true.</div></div></a><a data-display="block" class="sg-item base list" id="item-5bwyn" href="https://imgur.com/gallery/5bwyn"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">hold my beer for a sec...</div></div></a><a data-display="block" class="sg-item base list" id="item-RXQZ3" href="https://imgur.com/gallery/RXQZ3"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Oh show me, the way, to the next, whiskey bar</div></div></a><a data-display="block" class="sg-item base list" id="item-zINJC" href="https://imgur.com/gallery/zINJC"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Enjoy These Awesome Mostly HD Response Gifs I Haven't Seen On Imgur Part 4</div></div></a><a data-display="block" class="sg-item base list" id="item-5Yq5Y" href="https://imgur.com/gallery/5Yq5Y"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Difference between an impact fused shell and an airburst mortar shell</div></div></a><a data-display="block" class="sg-item base list" id="item-x3TLt" href="https://imgur.com/gallery/x3TLt"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Having your dad at your cooking contest comes in very handy.......</div></div></a><a data-display="block" class="sg-item base list" id="item-SWVwJ" href="https://imgur.com/gallery/SWVwJ"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">I am a burger fraud</div></div></a><a data-display="block" class="sg-item base list" id="item-i8Waq" href="https://imgur.com/gallery/i8Waq"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Oh! There's cake! It's ok everything is fine!</div></div></a><a data-display="block" class="sg-item base list" id="item-1vMTA" href="https://imgur.com/gallery/1vMTA"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Cat is booting up.</div></div></a><a data-display="block" class="sg-item base list" id="item-RCZO5" href="https://imgur.com/gallery/RCZO5"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Pussy get wet surprise</div></div></a><a data-display="block" class="sg-item base list" id="item-XPRi6Ye" href="https://imgur.com/gallery/XPRi6Ye"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Julia Louis-Dreyfus - Real &amp; Spectacular</div></div></a><a data-display="block" class="sg-item base list" id="item-l2OU8" href="https://imgur.com/gallery/l2OU8"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Stranger Things Barb visits Starbucks</div></div></a><a data-display="block" class="sg-item base list" id="item-jVe1E" href="https://imgur.com/gallery/jVe1E"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">They&#8217;ve upgraded</div></div></a><a data-display="block" class="sg-item base list" id="item-MvnNs" href="https://imgur.com/gallery/MvnNs"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">They never stop being adorable</div></div></a><a data-display="block" class="sg-item base list" id="item-Y1Qsg" href="https://imgur.com/gallery/Y1Qsg"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Judgmental?</div></div></a><a data-display="block" class="sg-item base list" id="item-MXPcd" href="https://imgur.com/gallery/MXPcd"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Tommy Wiseau is an alien trying his very best to act like a human being.</div></div></a><a data-display="block" class="sg-item base list" id="item-ro2Ma" href="https://imgur.com/gallery/ro2Ma"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">You have reached a neutral post. Take a break.&#160;</div></div></a><a data-display="block" class="sg-item base list" id="item-IJZjb" href="https://imgur.com/gallery/IJZjb"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Countries, Personified by Anastasia Bulgakova</div></div></a><a data-display="block" class="sg-item base list" id="item-eCxYh" href="https://imgur.com/gallery/eCxYh"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Without modern tech it takes longer to heat up, but the Amish burn leaves scars.</div></div></a><a data-display="block" class="sg-item base list" id="item-t4nNIOT" href="https://imgur.com/gallery/t4nNIOT"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Monkey Wrench Fan Shreds.</div></div></a><a data-display="block" class="sg-item base list" id="item-A6mD4" href="https://imgur.com/gallery/A6mD4"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Mesmerizing&#160;</div></div></a><a data-display="block" class="sg-item base list" id="item-Y7EP2" href="https://imgur.com/gallery/Y7EP2"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">*Pokemon theme playing in the background*</div></div></a><a data-display="block" class="sg-item base list" id="item-8voJV" href="https://imgur.com/gallery/8voJV"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Yes officer</div></div></a><a data-display="block" class="sg-item base list" id="item-coPHV" href="https://imgur.com/gallery/coPHV"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">He's had steady work though. Nothing like the good ol' days.</div></div></a><a data-display="block" class="sg-item base list" id="item-AgDZ5" href="https://imgur.com/gallery/AgDZ5"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">90&#8217;s kids will know what set this belongs to! Absolutely love and miss this show.</div></div></a><a data-display="block" class="sg-item base list" id="item-E6cgP" href="https://imgur.com/gallery/E6cgP"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">A crisis</div></div></a><a data-display="block" class="sg-item base list" id="item-nZnps" href="https://imgur.com/gallery/nZnps"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Poor guy...</div></div></a><a data-display="block" class="sg-item base list" id="item-BInJC5N" href="https://imgur.com/gallery/BInJC5N"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Milwaukee bus driver helps a man get back on his feet</div></div></a><a data-display="block" class="sg-item base list" id="item-hP3Ho4r" href="https://imgur.com/gallery/hP3Ho4r"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Every ducking time</div></div></a><a data-display="block" class="sg-item base list" id="item-XeAtc" href="https://imgur.com/gallery/XeAtc"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">I had to read it twice</div></div></a><a data-display="block" class="sg-item base list" id="item-sB3PK" href="https://imgur.com/gallery/sB3PK"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Pete!</div></div></a><a data-display="block" class="sg-item base list" id="item-n0T8E" href="https://imgur.com/gallery/n0T8E"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">This made my day </div></div></a><a data-display="block" class="sg-item base list" id="item-eBiAq" href="https://imgur.com/gallery/eBiAq"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">So, it's My cakeday! Here's my second favorite cause my first wouldn't load.</div></div></a><a data-display="block" class="sg-item base list" id="item-Bsmvh" href="https://imgur.com/gallery/Bsmvh"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Cuteness is justice.</div></div></a><a data-display="block" class="sg-item base list" id="item-IpXAC" href="https://imgur.com/gallery/IpXAC"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Smh kids</div></div></a><a data-display="block" class="sg-item base list" id="item-FJfgR" href="https://imgur.com/gallery/FJfgR"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Very oddly satisfying...</div></div></a><a data-display="block" class="sg-item base list" id="item-9qhJP" href="https://imgur.com/gallery/9qhJP"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">The Tesla was cool and all but if you're looking for a vehicle that will survive re-entry...</div></div></a><a data-display="block" class="sg-item base list" id="item-Ns9fZ" href="https://imgur.com/gallery/Ns9fZ"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Minor inconvienence man to the not rescue!</div></div></a><a data-display="block" class="sg-item base list" id="item-JTwoM" href="https://imgur.com/gallery/JTwoM"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">When you think you've won but it's only just begun</div></div></a><a data-display="block" class="sg-item base list" id="item-sZvyHeE" href="https://imgur.com/gallery/sZvyHeE"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">Your first instinct is usually right.&#160;</div></div></a><a data-display="block" class="sg-item base list" id="item-9Fb6fXX" href="https://imgur.com/gallery/9Fb6fXX"><div class="sg-list-image" style='background-image: url("data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==");'></div><div class="sg-list-metadata"><div data-display="-webkit-box" class="sg-list-title">How much for the doggy in the window?</div></div></a></div><div class="sidegallery-end loading"></div></div><div class="pane"><div class="slider" style="height: 23px; top: 0px;"></div></div></div><div class="fade-out"></div></div></div>

                            
                
            

            

                            <div data-hidden="true" class="advertisement " id="under-sidebar-parent">
                    <div data-hidden="true" class="panel-ad"></div>
                </div>
            

                            <div id="fixed-side-footer-links" class="side-footer-links">
    <div class="jobs-divider"><span id="jobs-sidefooter">Love Imgur? <a href="https://imgur.com/jobs" class="title join-callout" data-jafo="{@@event@@:@@sideFooter@@,@@meta@@:{@@link@@:@@jobs@@}}" original-title="">Join our team!</a></span></div>
    <ul class="links">
        <li><a href="https://imgur.com/about" title="about Imgur" data-jafo="{@@event@@:@@sideFooter@@,@@meta@@:{@@link@@:@@about@@}}">about</a></li>
        <li><a href="https://store.imgur.com/" title="the official Imgur store" data-jafo="{@@event@@:@@sideFooter@@,@@meta@@:{@@link@@:@@store@@}}">store</a></li>
        <li><a href="https://help.imgur.com/" title="answers to your questions" data-jafo="{@@event@@:@@sideFooter@@,@@meta@@:{@@link@@:@@help@@}}">help</a></li>
        <li><a href="https://imgur.com/blog" title="the most magical blog on the Internet" data-jafo="{@@event@@:@@sideFooter@@,@@meta@@:{@@link@@:@@blog@@}}">blog</a></li>
        <li><a href="https://imgur.com/tos" title="terms of service" data-jafo="{@@event@@:@@sideFooter@@,@@meta@@:{@@link@@:@@terms@@}}">terms</a></li>
        <li><a href="https://imgur.com/privacy" title="privacy policy" data-jafo="{@@event@@:@@sideFooter@@,@@meta@@:{@@link@@:@@privacy@@}}">privacy</a></li>
        <li><a href="https://imgur.com/apps" title="official apps" data-jafo="{@@event@@:@@sideFooter@@,@@meta@@:{@@link@@:@@apps@@}}">apps</a></li>
        <li><a href="https://apidocs.imgur.com/" title="documentation for the Imgur API" data-jafo="{@@event@@:@@sideFooter@@,@@meta@@:{@@link@@:@@api@@}}">api</a></li>
        <li><a href="https://www.imgurads.com/" title="advertise with us" data-jafo="{@@event@@:@@sideFooter@@,@@meta@@:{@@link@@:@@advertise@@}}">advertise</a></li>
        <li><a href="https://imgur.com/privacy#adchoices" title="ad choices" data-jafo="{@@event@@:@@sideFooter@@,@@meta@@:{@@link@@:@@adchoices@@}}">ad choices</a></li>
        <li class="footerlink-report-ads title" original-title=""><a title="report an ad that violates our advertiser policy">report ad</a></li>
        <li><a href="https://imgur.com/removalrequest" title="request image deletion" data-jafo="{@@event@@:@@sideFooter@@,@@meta@@:{@@link@@:@@deletion@@}}">request deletion</a></li>
        <li><a href="https://imgur.com/rules" title="community rules" data-jafo="{@@event@@:@@sideFooter@@,@@meta@@:{@@link@@:@@communityrules@@}}">community rules</a></li>
        <li><a href="https://community.imgur.com/" title="forum" data-jafo="{@@event@@:@@sideFooter@@,@@meta@@:{@@link@@:@@forum@@}}">forum</a></li>
    </ul>
</div>

            

            <div data-hidden="true" id="post-jump-container">
                <div id="post-jump">
                    <div class="box go-to-comments">
                        <div data-hidden="true" class="icon icon-to-comments-bubbles"></div>
                        <div data-hidden="true" class="icon icon-to-comments"></div>
                    </div>
                    <div class="box take-me-up">
                        <div class="text">TAKE ME UP</div>
                        <div data-hidden="true" class="icon icon-take-me-up"></div>
                    </div>
                </div>
            </div>
        </div>
        </div>

        <div class="clear"></div>
    

    <div class="tag-group-selector-container"></div>

    <input data-hidden="true" id="sid" value="b01bbca5bdbcfab0c7003044819c85b1" type="hidden">

    <div data-hidden="true" class="nodisplay">
	<div id="colorbox-confirm" class="popup">
		<h3 data-hidden="true" id="colorbox-confirm-title"></h3>
		
		<div data-hidden="true" class="textbox" id="colorbox-confirm-message"></div>

		<div class="margin-top">
			<div class="left">
				<a href="#" class="colorbox-no-confirm" id="colorbox-confirm-no">No way!</a>
			</div>
			
			<div class="right">
				<div data-hidden="true" class="small-loader"></div>
				<a href="#" class="colorbox-confirm" id="colorbox-confirm-yes">I'm sure</a>
			</div>
			
			<div data-hidden="true" class="clear"></div>
		</div>
	</div>
</div>

    <div data-hidden="true" class="nodisplay">
    <div id="embed-post" class="embed-popup">
        <div id="new-embed-post">
            <div class="embed-nav">
                <h3>Embed Code</h3>
                <label><input data-hidden="true" name="data-context" id="data-context" type="checkbox">hide post details</label>
            </div>

            <div class="embed-clipboard">
                <div class="clipboard-container" id="new-embedcode-container" title="copy">
                    <div data-hidden="true" class="clipboard" id="new-embedcode-clipboard"></div>
                </div>
                <input data-hidden="true" id="embedcode" value="" type="text">
            </div>
            <div id="embed-preview">
            </div>
            <p id="old-embed-view-wrapper"><a data-hidden="true" class="nodisplay" id="old-embed-view" href="#" target="_blank">Use old embed code</a></p>
        </div>
        <div data-hidden="true" id="embed-album-form" class="nodisplay">
            <div class="textbox">
                Copy and paste the HTML below into your website:
            </div>

            <div>
                <div class="clipboard-container" id="embedcode-container" title="copy">
                    <div data-hidden="true" class="clipboard" id="embedcode-clipboard"></div>
                </div>
                <input data-hidden="true" id="embedcode" value="" type="text">
            </div>

            <div id="themur">
                <div>
                    <label data-display="inline-block" for="tTheme">Theme:</label>
                    <select id="tTheme">
                        <option value="dark" selected>Dark</option>
                        <option value="light">Light</option>
                        <option value="custom">Custom</option>
                    </select>
                    <p id="embedcodePreview"><a href="https://imgur.com/eVnCxIi#" target="_blank">Preview</a></p>
                </div>
                <ul data-hidden="true">
                    <li>
                        <label data-display="inline-block" for="tBackground">Background:</label> # <input data-hidden="true" id="tBackground" name="background" type="text">
                    </li>
                    <li>
                        <label data-display="inline-block" for="tText">Text:</label> # <input data-hidden="true" id="tText" name="text" type="text">
                    </li>
                    <li>
                        <label data-display="inline-block" for="tLink">Link:</label> # <input data-hidden="true" id="tLink" name="link" type="text">
                    </li>
                    <li>
                        <label data-display="inline-block" for="tThumbs">Hide Thumbnails:</label> <input data-hidden="true" id="tThumbs" name="thumbs" type="checkbox">
                    </li>
                </ul>
            </div>
            <p id="new-embed-view-wrapper"><a id="new-embed-view" href="#" target="_blank">Hide old embed code</a></p>
        </div>
    </div>
</div>

        

    

            
    

    

            

        











                    

        
        

        

        

    

            


        

        
        

        
        

    

        

            
    

            
    

            
    

    
    

    

    

            
    

    
        
    

    

            
    

        
    

            

        
        
        

        

        






        





        
        
    

            
    
    

    


<div data-hidden="true" id="humanMsg" class="humanMsg"><p data-hidden="true"></p></div><div data-hidden="true" id="cboxOverlay" style="display: none;"></div><div data-hidden="true" id="colorbox" class="" role="dialog" tabindex="-1" style="display: none;"><div id="cboxWrapper"><div><div data-hidden="true" id="cboxTopLeft" style="float: left;"></div><div data-hidden="true" id="cboxTopCenter" style="float: left;"></div><div data-hidden="true" id="cboxTopRight" style="float: left;"></div></div><div style="clear: left;"><div data-hidden="true" id="cboxMiddleLeft" style="float: left;"></div><div id="cboxContent" style="float: left;"><div data-hidden="true" id="cboxTitle" style="float: left;"></div><div data-hidden="true" id="cboxCurrent" style="float: left;"></div><button data-hidden="true" type="button" id="cboxPrevious"></button><button data-hidden="true" type="button" id="cboxNext"></button><button data-hidden="true" id="cboxSlideshow"></button><div data-hidden="true" id="cboxLoadingOverlay" style="float: left;"></div><div data-hidden="true" id="cboxLoadingGraphic" style="float: left;"></div></div><div data-hidden="true" id="cboxMiddleRight" style="float: left;"></div></div><div style="clear: left;"><div data-hidden="true" id="cboxBottomLeft" style="float: left;"></div><div data-hidden="true" id="cboxBottomCenter" style="float: left;"></div><div data-hidden="true" id="cboxBottomRight" style="float: left;"></div></div></div><div data-hidden="true" style="position: absolute; width: 9999px; visibility: hidden; display: none; max-width: none;"></div></div></body><div data-hidden="true" id="drop-layer"></div>
                        <div id="cta-container-placeholder"></div>
<div id="topbar">
    <div class="header-center">
        <a data-display="block" href="https://imgur.com/" class="topbar-icon logo " data-jafo="{@@event@@:@@header@@,@@meta@@:{@@link@@:@@logo@@}}">
            <div class="logo-icon"></div>
        </a>

        <span data-display="block" class="topbar-icon menu-btn icon-arrow-down">
            <div data-hidden="true" class="link-menu">
                <ul>
                    <li><a data-display="block" href="https://imgur.com/jobs" class="hiring" data-jafo="{@@event@@:@@header@@,@@meta@@:{@@link@@:@@jobs@@}}">we're hiring!</a></li>
                                        <li><a data-display="block" href="https://imgur.com/blog" data-jafo="{@@event@@:@@header@@,@@meta@@:{@@link@@:@@blog@@,@@new@@:false}}">blog</a></li>
                    
                    <li><a data-display="block" href="https://imgur.com/about" data-jafo="{@@event@@:@@header@@,@@meta@@:{@@link@@:@@about@@}}">about imgur</a></li>
                    <li><a data-display="block" href="https://store.imgur.com/" data-jafo="{@@event@@:@@header@@,@@meta@@:{@@link@@:@@store@@}}">imgur store</a></li>
                    <li><a data-display="block" href="https://imgur.com/apps" data-jafo="{@@event@@:@@header@@,@@meta@@:{@@link@@:@@apps@@}}">imgur apps</a></li>
                    <li><a data-display="block" href="https://apidocs.imgur.com/" data-jafo="{@@event@@:@@header@@,@@meta@@:{@@link@@:@@api@@}}">developer api</a></li>
                    <li><a data-display="block" href="http://www.imgurads.com/" data-jafo="{@@event@@:@@header@@,@@meta@@:{@@link@@:@@advertise@@}}">advertise</a></li>
                    <li><a data-display="block" href="https://help.imgur.com/hc/en-us" data-jafo="{@@event@@:@@header@@,@@meta@@:{@@link@@:@@help@@}}">need help?</a></li>
                </ul>
                <div data-hidden="true" class="clear"></div>
                <div class="dropdown-footer hamburger-menu">
                    <div class="terms-footer">
                        <a data-display="inline-block" href="https://imgur.com/tos" data-jafo="{@@event@@:@@header@@,@@meta@@:{@@link@@:@@terms@@}}">terms</a>
                        <a data-display="inline-block" href="https://imgur.com/privacy" data-jafo="{@@event@@:@@header@@,@@meta@@:{@@link@@:@@privacy@@}}">privacy</a>
                        <a data-display="inline-block" class="small-margin-top" href="https://imgur.com/privacy#adchoices" data-jafo="{@@event@@:@@header@@,@@meta@@:{@@link@@:@@adchoices@@}}">ad choices</a>
                    </div>
                     
                    <iframe data-hidden="true" src="data:text/html;base64,PGh0bWw+PGhlYWQ+PG1ldGEgY2hhcnNldD0iVVRGLTgiPjwvaGVhZD48Ym9keT48L2JvZHk+PC9odG1sPg==" scrolling="no" style="display:inline-block; border:none; overflow:hidden; height:20px; width:50px; margin-right:7px;" allowtransparency="true" frameborder="0"></iframe>
                    <a data-hidden="true" href="https://twitter.com/imgur" class="twitter-follow-button" data-show-count="false" data-show-screen-name="false" data-twitter-extracted-i1518090670464945771="true"></a>
                    
                </div>
            </div>
        </span>
        
        <span data-display="block" class="upload-button-container">
            <div id="createDropdown" class="options">
                <ul>
                    <li data-display="block" class="item"><a data-display="block" href="https://imgur.com/upload" class="upload-subitem">Upload Images</a></li>
                    <li data-display="block" class="item"><a data-display="block" href="https://imgur.com/vidgif" data-jafo="{@@event@@:@@vidToGifInvoked@@,@@meta@@:{@@control@@:@@uploadImagesDropdown@@}}">Video to GIF</a></li>
                    <li data-display="block" class="item"><a data-display="block" href="https://imgur.com/memegen" data-jafo="{@@event@@:@@makeAMeme@@,@@meta@@:{@@control@@:@@uploadImagesDropdown@@}}">Make a Meme</a></li>
                </ul>
            </div>
            <a data-display="inline-block" class="upload-button" href="https://imgur.com/upload">
                <span data-hidden="true" class="icon-upload"></span>
                <span class="upload-btn-text">New post</span>
                <span data-hidden="true" id="create-dropdown-button" class="selection icon icon-arrow-down"></span>
            </a>
        </span>
        <div id="secondary-nav">
            <ul class="user-nav">
                <li id="global-search-container"><div data-reactroot="" class="search-container search-closed"><form class="search-form" method="get" action="https://imgur.com/search"><input data-display="inline-block" autocomplete="off" class="search" name="q" type="text"><div class="search-icon-container"><div class="icon-search"></div></div></form></div></li>
                                    <li class="signin-link">
                        <a data-display="block" class="topbar-icon signin-register " href="https://imgur.com/signin?invokedBy=regularSignIn">sign in</a>
                        <div id="FlipInfo-Container"></div>
                    </li>
                    <li id="register"><a data-display="block" class="topbar-icon signin-register " href="https://imgur.com/register?invokedBy=regularSignIn">sign up</a></li>
                
            </ul>
        </div> 
    </div> 
</div> 
</div>\"></iframe>\n",
       "      \n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_readable(histories[1].page)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}