CRAFT_fine_tuning_2022

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "CRAFT fine-tuning demo using ConvoKit",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/RenaGao/2022PairedSpeakingTestData/blob/main/CRAFT_fine_tuning_2022\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t5JqrpJWoNaB"
      },
      "source": [
        "# CRAFT demo (fine-tuning and inference) using ConvoKit\n",
        "\n",
        "This example notebook shows how to fine-tune a pretrained CRAFT conversational model for the task of forecasting conversational derailment, as shown in the \"Trouble on the Horizon\" paper (note however that due to nondeterminism in the training process, the results will not exactly reproduce the ones shown in the paper; if you need the exact inference results from the paper, see the inference-only version of this notebook)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tWGZ1Wc0n7BR"
      },
      "source": [
        "# start by installing ConvoKit on the colab VM\n",
        "!pip install -q convokit"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RHkNojY7tzAh",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 74
        },
        "outputId": "a9d10e05-c6db-401f-a651-20bb60a3c095"
      },
      "source": [
        "# import necessary libraries, including convokit\n",
        "import torch\n",
        "from torch.jit import script, trace\n",
        "import torch.nn as nn\n",
        "from torch import optim\n",
        "import torch.nn.functional as F\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import nltk\n",
        "import requests\n",
        "import os\n",
        "import sys\n",
        "import random\n",
        "import unicodedata\n",
        "import itertools\n",
        "from urllib.request import urlretrieve\n",
        "from convokit import download, Corpus\n",
        "%matplotlib inline"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/sklearn/externals/joblib/__init__.py:15: DeprecationWarning: sklearn.externals.joblib is deprecated in 0.21 and will be removed in 0.23. Please import this functionality directly from joblib, which can be installed with: pip install joblib. If this warning is raised when loading pickled models, you may need to re-serialize those models with scikit-learn 0.21+.\n",
            "  warnings.warn(msg, category=DeprecationWarning)\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6sA5pzI7LRtz"
      },
      "source": [
        "# define globals and constants\n",
        "\n",
        "MAX_LENGTH = 80  # Maximum sentence length (number of tokens) to consider\n",
        "\n",
        "# configure model\n",
        "hidden_size = 500\n",
        "encoder_n_layers = 2\n",
        "context_encoder_n_layers = 2\n",
        "decoder_n_layers = 2\n",
        "dropout = 0.1\n",
        "batch_size = 64\n",
        "# Configure training/optimization\n",
        "clip = 50.0\n",
        "teacher_forcing_ratio = 1.0\n",
        "learning_rate = 1e-5\n",
        "decoder_learning_ratio = 5.0\n",
        "print_every = 10\n",
        "train_epochs = 30\n",
        "\n",
        "# Default word tokens\n",
        "PAD_token = 0  # Used for padding short sentences\n",
        "SOS_token = 1  # Start-of-sentence token\n",
        "EOS_token = 2  # End-of-sentence token\n",
        "UNK_token = 3  # Unknown word token\n",
        "\n",
        "# model download paths\n",
        "WORD2INDEX_URL = \"http://zissou.infosci.cornell.edu/convokit/models/craft_wikiconv/word2index.json\"\n",
        "INDEX2WORD_URL = \"http://zissou.infosci.cornell.edu/convokit/models/craft_wikiconv/index2word.json\"\n",
        "MODEL_URL = \"http://zissou.infosci.cornell.edu/convokit/models/craft_wikiconv/craft_pretrained.tar\"\n",
        "\n",
        "# confidence score threshold for declaring a positive prediction.\n",
        "# this value was previously learned on the validation set.\n",
        "FORECAST_THRESH = 0.570617"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L_w8yFiXuCpg"
      },
      "source": [
        "## Part 1: set up data conversion utilities\n",
        "\n",
        "We begin by setting up some helper functions and classes for converting conversational text data into a torch-friendly Tensor format. Note that these low-level routines are largely taken from the [PyTorch seq2seq chatbot tutorial](https://pytorch.org/tutorials/beginner/chatbot_tutorial.html)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QM8PeUAduAhq"
      },
      "source": [
        "class Voc:\n",
        "    \"\"\"A class for representing the vocabulary used by a CRAFT model\"\"\"\n",
        "\n",
        "    def __init__(self, name, word2index=None, index2word=None):\n",
        "        self.name = name\n",
        "        self.trimmed = False if not word2index else True # if a precomputed vocab is specified assume the user wants to use it as-is\n",
        "        self.word2index = word2index if word2index else {\"UNK\": UNK_token}\n",
        "        self.word2count = {}\n",
        "        self.index2word = index2word if index2word else {PAD_token: \"PAD\", SOS_token: \"SOS\", EOS_token: \"EOS\", UNK_token: \"UNK\"}\n",
        "        self.num_words = 4 if not index2word else len(index2word)  # Count SOS, EOS, PAD, UNK\n",
        "\n",
        "    def addSentence(self, sentence):\n",
        "        for word in sentence.split(' '):\n",
        "            self.addWord(word)\n",
        "\n",
        "    def addWord(self, word):\n",
        "        if word not in self.word2index:\n",
        "            self.word2index[word] = self.num_words\n",
        "            self.word2count[word] = 1\n",
        "            self.index2word[self.num_words] = word\n",
        "            self.num_words += 1\n",
        "        else:\n",
        "            self.word2count[word] += 1\n",
        "\n",
        "    # Remove words below a certain count threshold\n",
        "    def trim(self, min_count):\n",
        "        if self.trimmed:\n",
        "            return\n",
        "        self.trimmed = True\n",
        "\n",
        "        keep_words = []\n",
        "\n",
        "        for k, v in self.word2count.items():\n",
        "            if v >= min_count:\n",
        "                keep_words.append(k)\n",
        "\n",
        "        print('keep_words {} / {} = {:.4f}'.format(\n",
        "            len(keep_words), len(self.word2index), len(keep_words) / len(self.word2index)\n",
        "        ))\n",
        "\n",
        "        # Reinitialize dictionaries\n",
        "        self.word2index = {\"UNK\": UNK_token}\n",
        "        self.word2count = {}\n",
        "        self.index2word = {PAD_token: \"PAD\", SOS_token: \"SOS\", EOS_token: \"EOS\", UNK_token: \"UNK\"}\n",
        "        self.num_words = 4 # Count default tokens\n",
        "\n",
        "        for word in keep_words:\n",
        "            self.addWord(word)\n",
        "\n",
        "# Create a Voc object from precomputed data structures\n",
        "def loadPrecomputedVoc(corpus_name, word2index_url, index2word_url):\n",
        "    # load the word-to-index lookup map\n",
        "    r = requests.get(word2index_url)\n",
        "    word2index = r.json()\n",
        "    # load the index-to-word lookup map\n",
        "    r = requests.get(index2word_url)\n",
        "    index2word = r.json()\n",
        "    return Voc(corpus_name, word2index, index2word)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0SazSyux7KFS"
      },
      "source": [
        "# Helper functions for preprocessing and tokenizing text\n",
        "\n",
        "# Turn a Unicode string to plain ASCII, thanks to\n",
        "# https://stackoverflow.com/a/518232/2809427\n",
        "def unicodeToAscii(s):\n",
        "    return ''.join(\n",
        "        c for c in unicodedata.normalize('NFD', s)\n",
        "        if unicodedata.category(c) != 'Mn'\n",
        "    )\n",
        "\n",
        "# Tokenize the string using NLTK\n",
        "def tokenize(text):\n",
        "    tokenizer = nltk.tokenize.RegexpTokenizer(pattern=r'\\w+|[^\\w\\s]')\n",
        "    # simplify the problem space by considering only ASCII data\n",
        "    cleaned_text = unicodeToAscii(text.lower())\n",
        "\n",
        "    # if the resulting string is empty, nothing else to do\n",
        "    if not cleaned_text.strip():\n",
        "        return []\n",
        "    \n",
        "    return tokenizer.tokenize(cleaned_text)\n",
        "\n",
        "# Given a ConvoKit conversation, preprocess each utterance's text by tokenizing and truncating.\n",
        "# Returns the processed dialog entry where text has been replaced with a list of\n",
        "# tokens, each no longer than MAX_LENGTH - 1 (to leave space for the EOS token)\n",
        "def processDialog(voc, dialog):\n",
        "    processed = []\n",
        "    for utterance in dialog.iter_utterances():\n",
        "        # skip the section header, which does not contain conversational content\n",
        "        if utterance.meta['is_section_header']:\n",
        "            continue\n",
        "        tokens = tokenize(utterance.text)\n",
        "        # replace out-of-vocabulary tokens\n",
        "        for i in range(len(tokens)):\n",
        "            if tokens[i] not in voc.word2index:\n",
        "                tokens[i] = \"UNK\"\n",
        "        processed.append({\"tokens\": tokens, \"is_attack\": int(utterance.meta['comment_has_personal_attack']), \"id\": utterance.id})\n",
        "    return processed\n",
        "\n",
        "# Load context-reply pairs from the Corpus, optionally filtering to only conversations\n",
        "# from the specified split (train, val, or test).\n",
        "# Each conversation, which has N comments (not including the section header) will\n",
        "# get converted into N-1 comment-reply pairs, one pair for each reply \n",
        "# (the first comment does not reply to anything).\n",
        "# Each comment-reply pair is a tuple consisting of the conversational context\n",
        "# (that is, all comments prior to the reply), the reply itself, the label (that\n",
        "# is, whether the reply contained a derailment event), and the comment ID of the\n",
        "# reply (for later use in re-joining with the ConvoKit corpus).\n",
        "# The function returns a list of such pairs.\n",
        "def loadPairs(voc, corpus, split=None, last_only=False):\n",
        "    pairs = []\n",
        "    for convo in corpus.iter_conversations():\n",
        "        # consider only conversations in the specified split of the data\n",
        "        if split is None or convo.meta['split'] == split:\n",
        "            dialog = processDialog(voc, convo)\n",
        "            iter_range = range(1, len(dialog)) if not last_only else [len(dialog)-1]\n",
        "            for idx in iter_range:\n",
        "                reply = dialog[idx][\"tokens\"][:(MAX_LENGTH-1)]\n",
        "                label = dialog[idx][\"is_attack\"]\n",
        "                comment_id = dialog[idx][\"id\"]\n",
        "                # gather as context all utterances preceding the reply\n",
        "                context = [u[\"tokens\"][:(MAX_LENGTH-1)] for u in dialog[:idx]]\n",
        "                pairs.append((context, reply, label, comment_id))\n",
        "    return pairs"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zo4Mg7AEK-0Q"
      },
      "source": [
        "# Helper functions for turning dialog and text sequences into tensors, and manipulating those tensors\n",
        "\n",
        "def indexesFromSentence(voc, sentence):\n",
        "    return [voc.word2index[word] for word in sentence] + [EOS_token]\n",
        "\n",
        "def zeroPadding(l, fillvalue=PAD_token):\n",
        "    return list(itertools.zip_longest(*l, fillvalue=fillvalue))\n",
        "\n",
        "def binaryMatrix(l, value=PAD_token):\n",
        "    m = []\n",
        "    for i, seq in enumerate(l):\n",
        "        m.append([])\n",
        "        for token in seq:\n",
        "            if token == PAD_token:\n",
        "                m[i].append(0)\n",
        "            else:\n",
        "                m[i].append(1)\n",
        "    return m\n",
        "\n",
        "# Takes a batch of dialogs (lists of lists of tokens) and converts it into a\n",
        "# batch of utterances (lists of tokens) sorted by length, while keeping track of\n",
        "# the information needed to reconstruct the original batch of dialogs\n",
        "def dialogBatch2UtteranceBatch(dialog_batch):\n",
        "    utt_tuples = [] # will store tuples of (utterance, original position in batch, original position in dialog)\n",
        "    for batch_idx in range(len(dialog_batch)):\n",
        "        dialog = dialog_batch[batch_idx]\n",
        "        for dialog_idx in range(len(dialog)):\n",
        "            utterance = dialog[dialog_idx]\n",
        "            utt_tuples.append((utterance, batch_idx, dialog_idx))\n",
        "    # sort the utterances in descending order of length, to remain consistent with pytorch padding requirements\n",
        "    utt_tuples.sort(key=lambda x: len(x[0]), reverse=True)\n",
        "    # return the utterances, original batch indices, and original dialog indices as separate lists\n",
        "    utt_batch = [u[0] for u in utt_tuples]\n",
        "    batch_indices = [u[1] for u in utt_tuples]\n",
        "    dialog_indices = [u[2] for u in utt_tuples]\n",
        "    return utt_batch, batch_indices, dialog_indices\n",
        "\n",
        "# Returns padded input sequence tensor and lengths\n",
        "def inputVar(l, voc):\n",
        "    indexes_batch = [indexesFromSentence(voc, sentence) for sentence in l]\n",
        "    lengths = torch.tensor([len(indexes) for indexes in indexes_batch])\n",
        "    padList = zeroPadding(indexes_batch)\n",
        "    padVar = torch.LongTensor(padList)\n",
        "    return padVar, lengths\n",
        "\n",
        "# Returns padded target sequence tensor, padding mask, and max target length\n",
        "def outputVar(l, voc):\n",
        "    indexes_batch = [indexesFromSentence(voc, sentence) for sentence in l]\n",
        "    max_target_len = max([len(indexes) for indexes in indexes_batch])\n",
        "    padList = zeroPadding(indexes_batch)\n",
        "    mask = binaryMatrix(padList)\n",
        "    mask = torch.ByteTensor(mask)\n",
        "    padVar = torch.LongTensor(padList)\n",
        "    return padVar, mask, max_target_len\n",
        "\n",
        "# Returns all items for a given batch of pairs\n",
        "def batch2TrainData(voc, pair_batch, already_sorted=False):\n",
        "    if not already_sorted:\n",
        "        pair_batch.sort(key=lambda x: len(x[0]), reverse=True)\n",
        "    input_batch, output_batch, label_batch, id_batch = [], [], [], []\n",
        "    for pair in pair_batch:\n",
        "        input_batch.append(pair[0])\n",
        "        output_batch.append(pair[1])\n",
        "        label_batch.append(pair[2])\n",
        "        id_batch.append(pair[3])\n",
        "    dialog_lengths = torch.tensor([len(x) for x in input_batch])\n",
        "    input_utterances, batch_indices, dialog_indices = dialogBatch2UtteranceBatch(input_batch)\n",
        "    inp, utt_lengths = inputVar(input_utterances, voc)\n",
        "    output, mask, max_target_len = outputVar(output_batch, voc)\n",
        "    label_batch = torch.FloatTensor(label_batch) if label_batch[0] is not None else None\n",
        "    return inp, dialog_lengths, utt_lengths, batch_indices, dialog_indices, label_batch, id_batch, output, mask, max_target_len\n",
        "\n",
        "def batchIterator(voc, source_data, batch_size, shuffle=True):\n",
        "    cur_idx = 0\n",
        "    if shuffle:\n",
        "        random.shuffle(source_data)\n",
        "    while True:\n",
        "        if cur_idx >= len(source_data):\n",
        "            cur_idx = 0\n",
        "            if shuffle:\n",
        "                random.shuffle(source_data)\n",
        "        batch = source_data[cur_idx:(cur_idx+batch_size)]\n",
        "        # the true batch size may be smaller than the given batch size if there is not enough data left\n",
        "        true_batch_size = len(batch)\n",
        "        # ensure that the dialogs in this batch are sorted by length, as expected by the padding module\n",
        "        batch.sort(key=lambda x: len(x[0]), reverse=True)\n",
        "        # for analysis purposes, get the source dialogs and labels associated with this batch\n",
        "        batch_dialogs = [x[0] for x in batch]\n",
        "        batch_labels = [x[2] for x in batch]\n",
        "        # convert batch to tensors\n",
        "        batch_tensors = batch2TrainData(voc, batch, already_sorted=True)\n",
        "        yield (batch_tensors, batch_dialogs, batch_labels, true_batch_size) \n",
        "        cur_idx += batch_size"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o_ev-7g-xsGQ"
      },
      "source": [
        "## Part 2: load the data\n",
        "\n",
        "Now we load the labeled Wikiconv corpus from ConvoKit, and run some transformations to prepare it for use with PyTorch"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y96SXcp4x1yj",
        "outputId": "64557a00-453c-44c0-f334-b5ae83508231",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "corpus = Corpus(filename=download(\"conversations-gone-awry-corpus\"))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Dataset already exists at /root/.convokit/downloads/conversations-gone-awry-corpus\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fPySt5a4yLId",
        "outputId": "18931f88-572d-4c39-e5da-df3eca9c078c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        }
      },
      "source": [
        "# let's check some quick stats to verify that the corpus loaded correctly\n",
        "print(len(corpus.get_utterance_ids()))\n",
        "print(len(corpus.get_usernames()))\n",
        "print(len(corpus.get_conversation_ids()))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "30021\n",
            "8069\n",
            "4188\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eeNfs0A-yosu",
        "outputId": "61b9f041-d59f-4f5a-a65b-ce9631c02336",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 74
        }
      },
      "source": [
        "# Let's also take a look at some example data to see what kinds of information/metadata are available to us\n",
        "print(list(corpus.iter_conversations())[0].__dict__)\n",
        "print(list(corpus.iter_utterances())[0])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'_owner': <convokit.model.corpus.Corpus object at 0x7f6424d21358>, '_id': '146743638.12652.12652', '_utterance_ids': ['146743638.12652.12652', '146743638.12667.12652', '146842219.12874.12874', '146860774.13072.13072'], '_usernames': None, '_meta': {'page_title': 'User talk:2005', 'page_id': 1003212, 'pair_id': '143890867.11926.11926', 'conversation_has_personal_attack': False, 'verified': True, 'pair_verified': True, 'annotation_year': '2018', 'split': 'train'}}\n",
            "Utterance({'id': '146743638.12652.12652', 'user': User([('name', 'Sirex98')]), 'root': '146743638.12652.12652', 'reply_to': None, 'timestamp': 1185295934.0, 'text': '== [WIKI_LINK: WP:COMMONNAME] ==\\n', 'meta': {'is_section_header': True, 'comment_has_personal_attack': False, 'toxicity': 0}})\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v3QIoTtbzOfY"
      },
      "source": [
        "Now we can use the utilities defined in Part 1 to convert the ConvoKit conversational data into a tokenized form that can be straightforwardly turned into Tensors later."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WlpbT72FxK8W"
      },
      "source": [
        "# First, we need to build the vocabulary so that we know how to map tokens to tensor indicies.\n",
        "# For the sake of replicating the paper results, we will load the pre-computed vocabulary objects used in the paper.\n",
        "voc = loadPrecomputedVoc(\"wikiconv\", WORD2INDEX_URL, INDEX2WORD_URL)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eRSAVrgSxhmD",
        "outputId": "a682ac56-5ec9-4a88-fdce-fc9fb08aa104",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        }
      },
      "source": [
        "# Inspect the Voc object to make sure it loaded correctly\n",
        "print(voc.num_words) # expected vocab size is 50004: it was built using a fixed vocab size of 50k plus 4 spots for special tokens PAD, SOS, EOS, and UNK.\n",
        "print(list(voc.word2index.items())[:10])\n",
        "print(list(voc.index2word.items())[:10])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "50004\n",
            "[('UNK', 3), ('.', 4), ('the', 5), (\"'\", 6), (',', 7), ('to', 8), ('i', 9), ('of', 10), ('a', 11), ('and', 12)]\n",
            "[('0', 'PAD'), ('1', 'SOS'), ('2', 'EOS'), ('3', 'UNK'), ('4', '.'), ('5', 'the'), ('6', \"'\"), ('7', ','), ('8', 'to'), ('9', 'i')]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pmaWfn7vyTjy"
      },
      "source": [
        "# Convert the test set data into a list of input/label pairs. Each input will represent the conversation as a list of lists of tokens.\n",
        "train_pairs = loadPairs(voc, corpus, \"train\", last_only=True)\n",
        "val_pairs = loadPairs(voc, corpus, \"val\", last_only=True)\n",
        "test_pairs = loadPairs(voc, corpus, \"test\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RIiQNvg4zBEi",
        "outputId": "11d7b50b-bc00-4080-d4ce-9294b3988194",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 184
        }
      },
      "source": [
        "# Validate the conversion by checking data size and some samples\n",
        "print(len(train_pairs))\n",
        "print(len(val_pairs))\n",
        "print(len(test_pairs))\n",
        "for p in train_pairs[:5]:\n",
        "    print(p)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2508\n",
            "840\n",
            "4365\n",
            "([['i', 'notice', 'that', 'UNK', 'that', 'moved', 'UNK', 'to', 'bill', 'chen', 'citing', 'UNK', ',', 'then', 'you', 'reverted', 'this', 'change', ',', 'bill', 'chen', 'doesn', \"'\", 't', 'commonly', 'go', 'by', 'william', ',', 'his', 'book', 'is', 'even', 'penned', 'as', 'bill', 'chen', '.', 'from', 'what', 'i', 'read', 'in', 'wp', ':', 'commonname', 'UNK', 'seems', 'to', 'be', 'correct', ',', 'examples', 'given', 'are', 'names', 'such', 'as', ':', '*', 'UNK', '(', 'not', 'UNK', ')', '*', 'UNK', '(', 'not', 'UNK', ')', 'i', 'think', 'this', 'revert', 'may', 'have', 'been', 'a'], ['chen', 'was', 'known', 'in', 'the', 'poker', 'world', 'as', '\"', 'william', '\"', 'for', 'years', 'before', 'he', 'became', 'commonly', 'known', 'as', '\"', 'bill', '\"', '.', 'i', 'changed', 'it', 'back', 'because', 'incidences', 'online', 'including', 'usenet', 'are', 'roughly', 'equal', ',', 'nothing', 'at', 'all', 'like', 'bill', 'clinton', 'and', 'william', 'clinton', ',', 'and', 'in', 'equal', 'cases', 'using', 'the', 'real', 'name', 'seems', 'the', 'best', 'choice', '.', '(', 'the', 'UNK', 'page', 'is', 'especially', 'UNK', '.', '.', '.', 'UNK', 'in', 'the', 'page', 'title', ',', 'bill', 'in', 'the', 'page']], ['i', 'see', 'what', 'you', 'saying', 'i', 'just', 'read', 'his', 'UNK', 'profile', ',', 'it', 'struck', 'me', 'when', 'i', 'saw', 'the', 'change', 'because', 'i', 'remember', 'him', 'being', 'called', 'bill', 'when', 'i', 'watched', 'the', 'last', 'season', 'of', 'high', 'stakes', 'poker', ',', 'but', 'you', 'seem', 'to', 'have', 'many', 'more', 'years', 'experience', 'in', 'the', 'poker', '/', 'gambling', 'world', 'then', 'i', 'do', '(', 'i', \"'\", 'm', 'still', 'a', 'bit', 'of', 'a', 'newbie', ')', ',', 'so', 'i', 'wanted', 'to', 'check', 'with', 'you', 'first', '.', 'btw', 'as'], 0, '146860774.13072.13072')\n",
            "([['no', 'more', 'than', 'two', 'editors', 'advocated', 'deletion', '.', 'UNK', 'and', 'maybe', 'UNK', '.', 'that', \"'\", 's', 'not', 'a', 'clear', 'consensus', 'for', 'deletion', '.', 'cheers', ','], ['in', 'the', 'future', 'please', 'don', \"'\", 't', 'close', 'afds', 'when', 'you', 'don', \"'\", 't', 'have', 'the', 'courtesy', 'of', 'reading', 'the', 'comments', '.', 'all', 'comments', 'favored', 'deletion', 'except', 'two', '.', 'please', 'don', \"'\", 't', 'be', 'so', 'careless', 'in', 'the', 'future', '.'], ['that', 'simply', 'isn', \"'\", 't', 'true', '.', 'if', 'you', 'read', 'the', 'comments', ',', 'you', \"'\", 'll', 'find', 'it', \"'\", 's', 'actually', '2', 'keep', ',', '4', 'transwiki', ',', '2', 'delete', '(', 'more', 'or', 'less', ')', '.', 'the', \"'\", \"'\", 'comments', \"'\", \"'\", 'favour', 'no', 'consensus', '/', 'transwiki', '.', 'the', '\"', 'votes', '\"', 'favour', 'delete', ',', 'but', 'voting', 'is', 'evil', ',', 'of', 'course', '.', '.', '.'], ['somehow', ',', 'i', 'suspect', 'you', 'may', 'wish', 'to', 'participate', 'in', 'UNK', 'discussion', '.', 'cheers', ',']], ['i', 'assume', 'your', 'deliberate', 'lying', 'has', 'a', 'point', ',', 'but', 'get', 'over', 'it', '.', 'stop', 'bizarrely', 'goin', 'on', 'about', 'UNK', '.', 'that', 'has', 'nothing', 'to', 'do', 'with', 'the', 'afd', '.', 'there', 'was', 'a', 'plain', 'consensus', 'for', 'deleting', 'the', 'article', '.', 'UNK', 'is', 'completely', 'unrelated', '.', 'please', 'don', \"'\", 't', 'be', 'so', 'deliberately', 'obtuse', 'in', 'the', 'future', '.', 'wasting', 'other', 'people', \"'\", 's', 'time', 'is', 'simply', 'rude', '.'], 1, '144065917.12226.12226')\n",
            "([['if', 'you', 'have', 'problems', 'with', 'my', 'edits', 'to', 'the', 'UNK', 'page', 'please', 'let', 'me', 'know', ',', 'do', 'not', 'just', 'revert', 'the', 'edits', '.', 'although', 'the', 'UNK', 'article', 'is', 'very', 'accurate', 'the', 'introduction', 'is', 'riddled', 'with', 'errors', ',', 'which', 'i', 'corrected', '.', 'i', 'think', 'it', 'is', 'everyone', \"'\", 's', 'best', 'interests', 'to', 'make', 'wiki', 'pages', 'as', 'accurate', 'as', 'possible', 'and', 'the', 'four', 'wheel', 'drive', 'article', 'is', 'not', 'a', 'UNK', 'example', 'of', 'this', '.', 'i', '.', 'e', '.', 'all', '-', 'wheel'], ['*', 'shrug', '*', 'it', '*', 'is', '*', 'just', 'a', 'marketing', 'term', '.', 'i', 'wish', 'you', 'lot', 'would', 'stop', 'editing', 'it', 'otherwise', '.', 'UNK', '.']], ['although', 'UNK', 'can', 'be', 'considered', 'a', 'form', 'of', 'UNK', 'it', 'is', 'not', 'the', 'same', 'drive', 'train', 'type', 'as', 'part', '-', 'time', 'UNK', '.', 'so', 'i', 'would', 'have', 'to', 'say', 'calling', 'it', 'just', 'a', 'marketing', 'term', 'is', 'a', 'narrow', 'minded', 'and', 'inaccurate', 'statement', '.', 'even', 'though', 'they', 'are', 'similar', 'you', 'can', \"'\", 't', 'just', 'UNK', 'them', 'into', 'the', 'same', 'group', '.', 'if', ',', 'as', 'you', 'say', ',', 'UNK', 'is', 'just', 'a', 'marketing', 'term', 'then', 'taking', 'a', 'turn', 'in', 'a', 'audi'], 0, '127772860.903.903')\n",
            "([['please', 'stop', 'removing', 'and', 'altering', 'other', 'editors', \"'\", 'comments', '.', 'what', 'appeared', 'to', 'be', 'valid', 'concern', 'is', 'quickly', 'descending', 'into', 'trolling', ',', 'and', 'if', 'you', 'continue', ',', 'you', 'may', 'be', 'blocked', 'from', 'editing', '.', 'stop', 'it', '.', '-'], ['well', 'please', 'stop', 'posting', 'incorrect', 'information', '.', 'if', 'you', 'were', 'right', 'i', \"'\", 'd', 'agree', 'with', 'you', ',', 'and', 'i', 'am', 'not', 'trolling', '.'], ['UNK', 'is', 'trolling', ',', 'as', 'is', 'removing', 'other', 'people', \"'\", 's', 'comments', '.', 'look', ',', 'wikipedia', 'is', 'built', 'on', 'consensus', ',', 'and', 'consensus', 'has', 'it', 'that', 'we', 'use', 'american', 'style', 'for', 'american', 'subjects', '.', 'end', 'of', 'story', '.', 'any', 'more', 'complaint', 'about', 'trolling', 'about', 'this', 'topic', 'and', 'i', \"'\", 'll', 'report', 'you', 'myself', '.']], ['bullshit', '.', 'i', 'am', 'correcting', 'a', 'simple', 'mistake', '.', 'if', 'i', 'was', 'trolling', 'i', \"'\", 'd', 'be', 'doing', 'damage', 'to', 'the', 'page', ',', 'yet', 'i', 'am', 'not', '.', 'what', 'was', 'written', 'is', 'wrong', ',', 'simple', 'as', 'that', '.', 'all', 'i', 'have', 'done', 'is', 'disagree', 'with', 'what', 'was', 'written', 'and', 'written', 'as', 'such', '.', 'if', 'that', \"'\", 's', 'trolling', 'then', 'you', 'are', 'guilty', 'as', 'well', '.', 'and', 'stop', 'UNK', 'my', 'page', 'dickhead', '.', 'UNK', '.'], 1, '144645449.1479.1479')\n",
            "([['please', 'stop', 'including', 'disreputable', 'sources', 'for', 'this', 'article', '.', 'wikipedia', 'policy', 'is', 'quite', 'clear', 'on', 'this', 'matter', 'blogs', 'and', 'other', 'websites', 'which', 'do', 'not', 'employ', 'editorial', 'oversight', 'of', 'authors', \"'\", 'work', 'are', 'not', 'permitted', 'as', 'sources', 'here', '.', 'please', 'stop', 'adding', 'blogs', '.'], ['please', 'stop', 'deleting', 'reputable', 'sources', 'from', 'this', 'article', '.', 'you', 'have', 'deleted', 'joe', 'wilson', \"'\", 's', 'nyt', 'article', 'that', 'is', 'a', 'key', 'factor', 'in', 'this', 'whole', 'controversy', '!', 'among', 'others', '.', 'simply', 'because', 'the', 'article', 'is', 'printed', 'on', 'a', 'different', 'site', 'does', 'not', 'mean', 'it', 'is', 'sourced', 'to', 'a', '\"', 'heinous', 'blog', '\"', '(', 'which', 'the', 'site', 'is', 'not', 'anyway', ')', '.', 'if', 'you', 'find', 'a', 'better', 'place', 'that', 'the', 'article', 'exists', ',', 'put', 'it', 'there', '.', 'or', 'if'], ['the', 'american', 'prospect', 'article', 'should', 'stay', '-', 'american', 'prospect', 'easily', 'meets', 'UNK', '.', 'the', 'cooperative', 'research', 'project', 'link', 'should', 'be', 'nuked', 'and', 'should', 'stay', 'nuked', '-', 'i', 'see', 'no', 'evidence', 'that', 'it', \"'\", 's', 'a', 'reliable', 'source', '.', 'factcheck', '.', 'org', 'is', 'reliable', 'enough', 'that', 'the', 'vice', 'president', 'of', 'the', 'united', 'states', '(', 'incorrectly', ')', 'cited', 'it', 'in', 'his', 'debate', 'as', 'an', 'authoritative', 'source', ';', 'they', 'have', 'a', 'good', 'reputation', ',', 'and', 'their', 'very', \"'\", \"'\", 'purpose', \"'\", \"'\"], ['agreed', 'UNK', 'cooperative', 'research', 'but', 'not', 'the', 'alternet', 'citation', '-', 'they', 'are', 'transcribing', 'an', 'interview', 'on', 'a', 'well', 'known', 'radio', 'show', 'with', 'a', 'well', 'known', 'source', 'with', 'expertise', 'on', 'this', 'topic', 'whose', 'comments', 'are', 'cited', 'in', 'numerous', 'mainstream', 'sources', '.', 'if', 'you', 'have', 'a', 'better', 'source', 'for', 'the', 'transcript', 'that', 'is', 'fine', 'but', 'you', 'cannot', 'just', 'delete', 'it', 'because', 'it', 'is', '\"', 'edited', '\"', '-', 'unless', 'you', 'have', 'evidence', 'that', 'they', 'are', 'making', 'stuff', 'up', ',', 'we', 'must', 'presume'], ['actually', ',', 'especially', 'with', 'alternet', ',', 'we', \"'\", \"'\", 'can', \"'\", 't', \"'\", \"'\", 'assume', 'good', 'faith', ';', 'we', 'need', 'to', 'do', 'exactly', 'the', 'opposite', '.', 'we', 'need', 'to', 'examine', 'sources', 'critically', ',', 'according', 'to', 'the', 'guidelines', 'on', 'UNK', '.', 'were', 'it', 'to', 'be', 'a', 'verbatim', 'copy', ',', 'perhaps', 'we', 'could', 'accept', 'it', 'as', 'a', 'source', '(', \"'\", \"'\", 'perhaps', \"'\", \"'\", 'being', 'absolutely', 'critical', ')', ',', 'but', 'because', 'it', \"'\", 's', 'edited', 'and', 'doesn', \"'\", 't', 'contain', 'information']], ['(', '1', ')', 'please', 'substantiate', 'that', 'the', 'source', 'is', '\"', 'notoriously', 'unreliable', '.', '\"', '(', '2', ')', 'please', 'indicate', 'where', 'it', 'says', 'we', 'should', 'assume', 'bad', 'faith', 'with', 'sources', 'that', 'are', 'transcripts', 'of', 'interviews', '(', 'i', 'know', 'the', 'quote', 'in', 'the', 'article', 'is', 'directly', 'from', 'the', 'interview', 'as', 'i', 'listened', 'to', 'the', 'interview', 'myself', ';', 'i', 'also', 'have', 'looked', 'at', 'the', 'transcript', 'and', 'do', 'not', 'see', 'anything', 'that', 'is', 'different', 'from', 'what', 'i', 'heard', ';', 'but', 'apparently', 'i', 'should'], 0, '67176052.25110.25110')\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ghTVeRFK0CUe"
      },
      "source": [
        "## Part 3: define the model\n",
        "\n",
        "Next, we need to set up the individual components of the CRAFT framework: the utterance encoder, the context encoder, and the classification head (since we are fine-tuning a pretrained model, we do not need to define the decoder here). Each component will be defined as a PyTorch `nn.Module`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZzAgSRKi0p_I"
      },
      "source": [
        "class EncoderRNN(nn.Module):\n",
        "    \"\"\"This module represents the utterance encoder component of CRAFT, responsible for creating vector representations of utterances\"\"\"\n",
        "    def __init__(self, hidden_size, embedding, n_layers=1, dropout=0):\n",
        "        super(EncoderRNN, self).__init__()\n",
        "        self.n_layers = n_layers\n",
        "        self.hidden_size = hidden_size\n",
        "        self.embedding = embedding\n",
        "\n",
        "        # Initialize GRU; the input_size and hidden_size params are both set to 'hidden_size'\n",
        "        #   because our input size is a word embedding with number of features == hidden_size\n",
        "        self.gru = nn.GRU(hidden_size, hidden_size, n_layers,\n",
        "                          dropout=(0 if n_layers == 1 else dropout), bidirectional=True)\n",
        "\n",
        "    def forward(self, input_seq, input_lengths, hidden=None):\n",
        "        # Convert word indexes to embeddings\n",
        "        embedded = self.embedding(input_seq)\n",
        "        # Pack padded batch of sequences for RNN module\n",
        "        packed = torch.nn.utils.rnn.pack_padded_sequence(embedded, input_lengths)\n",
        "        # Forward pass through GRU\n",
        "        outputs, hidden = self.gru(packed, hidden)\n",
        "        # Unpack padding\n",
        "        outputs, _ = torch.nn.utils.rnn.pad_packed_sequence(outputs)\n",
        "        # Sum bidirectional GRU outputs\n",
        "        outputs = outputs[:, :, :self.hidden_size] + outputs[:, : ,self.hidden_size:]\n",
        "        # Return output and final hidden state\n",
        "        return outputs, hidden\n",
        "\n",
        "class ContextEncoderRNN(nn.Module):\n",
        "    \"\"\"This module represents the context encoder component of CRAFT, responsible for creating an order-sensitive vector representation of conversation context\"\"\"\n",
        "    def __init__(self, hidden_size, n_layers=1, dropout=0):\n",
        "        super(ContextEncoderRNN, self).__init__()\n",
        "        self.n_layers = n_layers\n",
        "        self.hidden_size = hidden_size\n",
        "        \n",
        "        # only unidirectional GRU for context encoding\n",
        "        self.gru = nn.GRU(hidden_size, hidden_size, n_layers,\n",
        "                          dropout=(0 if n_layers == 1 else dropout), bidirectional=False)\n",
        "        \n",
        "    def forward(self, input_seq, input_lengths, hidden=None):\n",
        "        # Pack padded batch of sequences for RNN module\n",
        "        packed = torch.nn.utils.rnn.pack_padded_sequence(input_seq, input_lengths)\n",
        "        # Forward pass through GRU\n",
        "        outputs, hidden = self.gru(packed, hidden)\n",
        "        # Unpack padding\n",
        "        outputs, _ = torch.nn.utils.rnn.pad_packed_sequence(outputs)\n",
        "        # return output and final hidden state\n",
        "        return outputs, hidden\n",
        "\n",
        "class SingleTargetClf(nn.Module):\n",
        "    \"\"\"This module represents the CRAFT classifier head, which takes the context encoding and uses it to make a forecast\"\"\"\n",
        "    def __init__(self, hidden_size, dropout=0.1):\n",
        "        super(SingleTargetClf, self).__init__()\n",
        "        \n",
        "        self.hidden_size = hidden_size\n",
        "        \n",
        "        # initialize classifier\n",
        "        self.layer1 = nn.Linear(hidden_size, hidden_size)\n",
        "        self.layer1_act = nn.LeakyReLU()\n",
        "        self.layer2 = nn.Linear(hidden_size, hidden_size // 2)\n",
        "        self.layer2_act = nn.LeakyReLU()\n",
        "        self.clf = nn.Linear(hidden_size // 2, 1)\n",
        "        self.dropout = nn.Dropout(p=dropout)\n",
        "        \n",
        "    def forward(self, encoder_outputs, encoder_input_lengths):\n",
        "        # from stackoverflow (https://stackoverflow.com/questions/50856936/taking-the-last-state-from-bilstm-bigru-in-pytorch)\n",
        "        # First we unsqueeze seqlengths two times so it has the same number of\n",
        "        # of dimensions as output_forward\n",
        "        # (batch_size) -> (1, batch_size, 1)\n",
        "        lengths = encoder_input_lengths.unsqueeze(0).unsqueeze(2)\n",
        "        # Then we expand it accordingly\n",
        "        # (1, batch_size, 1) -> (1, batch_size, hidden_size) \n",
        "        lengths = lengths.expand((1, -1, encoder_outputs.size(2)))\n",
        "\n",
        "        # take only the last state of the encoder for each batch\n",
        "        last_outputs = torch.gather(encoder_outputs, 0, lengths-1).squeeze()\n",
        "        # forward pass through hidden layers\n",
        "        layer1_out = self.layer1_act(self.layer1(self.dropout(last_outputs)))\n",
        "        layer2_out = self.layer2_act(self.layer2(self.dropout(layer1_out)))\n",
        "        # compute and return logits\n",
        "        logits = self.clf(self.dropout(layer2_out)).squeeze()\n",
        "        return logits\n",
        "\n",
        "class Predictor(nn.Module):\n",
        "    \"\"\"This helper module encapsulates the CRAFT pipeline, defining the logic of passing an input through each consecutive sub-module.\"\"\"\n",
        "    def __init__(self, encoder, context_encoder, classifier):\n",
        "        super(Predictor, self).__init__()\n",
        "        self.encoder = encoder\n",
        "        self.context_encoder = context_encoder\n",
        "        self.classifier = classifier\n",
        "        \n",
        "    def forward(self, input_batch, dialog_lengths, dialog_lengths_list, utt_lengths, batch_indices, dialog_indices, batch_size, max_length):\n",
        "        # Forward input through encoder model\n",
        "        _, utt_encoder_hidden = self.encoder(input_batch, utt_lengths)\n",
        "        \n",
        "        # Convert utterance encoder final states to batched dialogs for use by context encoder\n",
        "        context_encoder_input = makeContextEncoderInput(utt_encoder_hidden, dialog_lengths_list, batch_size, batch_indices, dialog_indices)\n",
        "        \n",
        "        # Forward pass through context encoder\n",
        "        context_encoder_outputs, context_encoder_hidden = self.context_encoder(context_encoder_input, dialog_lengths)\n",
        "        \n",
        "        # Forward pass through classifier to get prediction logits\n",
        "        logits = self.classifier(context_encoder_outputs, dialog_lengths)\n",
        "        \n",
        "        # Apply sigmoid activation\n",
        "        predictions = F.sigmoid(logits)\n",
        "        return predictions\n",
        "\n",
        "def makeContextEncoderInput(utt_encoder_hidden, dialog_lengths, batch_size, batch_indices, dialog_indices):\n",
        "    \"\"\"The utterance encoder takes in utterances in combined batches, with no knowledge of which ones go where in which conversation.\n",
        "       Its output is therefore also unordered. We correct this by using the information computed during tensor conversion to regroup\n",
        "       the utterance vectors into their proper conversational order.\"\"\"\n",
        "    # first, sum the forward and backward encoder states\n",
        "    utt_encoder_summed = utt_encoder_hidden[-2,:,:] + utt_encoder_hidden[-1,:,:]\n",
        "    # we now have hidden state of shape [utterance_batch_size, hidden_size]\n",
        "    # split it into a list of [hidden_size,] x utterance_batch_size\n",
        "    last_states = [t.squeeze() for t in utt_encoder_summed.split(1, dim=0)]\n",
        "    \n",
        "    # create a placeholder list of tensors to group the states by source dialog\n",
        "    states_dialog_batched = [[None for _ in range(dialog_lengths[i])] for i in range(batch_size)]\n",
        "    \n",
        "    # group the states by source dialog\n",
        "    for hidden_state, batch_idx, dialog_idx in zip(last_states, batch_indices, dialog_indices):\n",
        "        states_dialog_batched[batch_idx][dialog_idx] = hidden_state\n",
        "        \n",
        "    # stack each dialog into a tensor of shape [dialog_length, hidden_size]\n",
        "    states_dialog_batched = [torch.stack(d) for d in states_dialog_batched]\n",
        "    \n",
        "    # finally, condense all the dialog tensors into a single zero-padded tensor\n",
        "    # of shape [max_dialog_length, batch_size, hidden_size]\n",
        "    return torch.nn.utils.rnn.pad_sequence(states_dialog_batched)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BjC1hgIWGl7g"
      },
      "source": [
        "## Part 4: define training loop\n",
        "\n",
        "Now that we have all the model components defined, we need to define the actual training procedure. This will be a fairly standard neural network training loop, iterating over batches of labeled dialogs and computing cross-entropy loss on the predicted label. We will also define evaluation functions so that we can compute accuracy on the validation set after every epoch, allowing us to keep the model with the best validation performance. Note that for the sake of simpler code, validation accuracy is computed in the \"unfair\" manner using a single run of CRAFT over the full context preceding the actual personal attack, rather than the more realistic (and complicated) iterated evaluation that is used for final evaluation of the test set (in practice the two metrics track each other fairly well, making this a reasonable simplification for the sake of easy validation)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zIAHOvcdHR_h"
      },
      "source": [
        "def train(input_variable, dialog_lengths, dialog_lengths_list, utt_lengths, batch_indices, dialog_indices, labels, # input/output arguments\n",
        "          encoder, context_encoder, attack_clf,                                                                    # network arguments\n",
        "          encoder_optimizer, context_encoder_optimizer, attack_clf_optimizer,                                      # optimization arguments\n",
        "          batch_size, clip, max_length=MAX_LENGTH):                                                                # misc arguments\n",
        "\n",
        "    # Zero gradients\n",
        "    encoder_optimizer.zero_grad()\n",
        "    context_encoder_optimizer.zero_grad()\n",
        "    attack_clf_optimizer.zero_grad()\n",
        "\n",
        "    # Set device options\n",
        "    input_variable = input_variable.to(device)\n",
        "    dialog_lengths = dialog_lengths.to(device)\n",
        "    utt_lengths = utt_lengths.to(device)\n",
        "    labels = labels.to(device)\n",
        "\n",
        "    # Forward pass through utterance encoder\n",
        "    _, utt_encoder_hidden = encoder(input_variable, utt_lengths)\n",
        "    \n",
        "    # Convert utterance encoder final states to batched dialogs for use by context encoder\n",
        "    context_encoder_input = makeContextEncoderInput(utt_encoder_hidden, dialog_lengths_list, batch_size, batch_indices, dialog_indices)\n",
        "    \n",
        "    # Forward pass through context encoder\n",
        "    context_encoder_outputs, _ = context_encoder(context_encoder_input, dialog_lengths)\n",
        "\n",
        "    # Forward pass through classifier to get prediction logits\n",
        "    logits = attack_clf(context_encoder_outputs, dialog_lengths)\n",
        "    \n",
        "    # Calculate loss\n",
        "    loss = F.binary_cross_entropy_with_logits(logits, labels)\n",
        "\n",
        "    # Perform backpropatation\n",
        "    loss.backward()\n",
        "\n",
        "    # Clip gradients: gradients are modified in place\n",
        "    _ = torch.nn.utils.clip_grad_norm_(encoder.parameters(), clip)\n",
        "    _ = torch.nn.utils.clip_grad_norm_(context_encoder.parameters(), clip)\n",
        "    _ = torch.nn.utils.clip_grad_norm_(attack_clf.parameters(), clip)\n",
        "\n",
        "    # Adjust model weights\n",
        "    encoder_optimizer.step()\n",
        "    context_encoder_optimizer.step()\n",
        "    attack_clf_optimizer.step()\n",
        "\n",
        "    return loss.item()\n",
        "\n",
        "def evaluateBatch(encoder, context_encoder, predictor, voc, input_batch, dialog_lengths, \n",
        "                  dialog_lengths_list, utt_lengths, batch_indices, dialog_indices, batch_size, device, max_length=MAX_LENGTH):\n",
        "    # Set device options\n",
        "    input_batch = input_batch.to(device)\n",
        "    dialog_lengths = dialog_lengths.to(device)\n",
        "    utt_lengths = utt_lengths.to(device)\n",
        "    # Predict future attack using predictor\n",
        "    scores = predictor(input_batch, dialog_lengths, dialog_lengths_list, utt_lengths, batch_indices, dialog_indices, batch_size, max_length)\n",
        "    predictions = (scores > 0.5).float()\n",
        "    return predictions, scores\n",
        "\n",
        "def validate(dataset, encoder, context_encoder, predictor, voc, batch_size, device):\n",
        "    # create a batch iterator for the given data\n",
        "    batch_iterator = batchIterator(voc, dataset, batch_size, shuffle=False)\n",
        "    # find out how many iterations we will need to cover the whole dataset\n",
        "    n_iters = len(dataset) // batch_size + int(len(dataset) % batch_size > 0)\n",
        "    # containers for full prediction results so we can compute accuracy at the end\n",
        "    all_preds = []\n",
        "    all_labels = []\n",
        "    for iteration in range(1, n_iters+1):\n",
        "        batch, batch_dialogs, _, true_batch_size = next(batch_iterator)\n",
        "        # Extract fields from batch\n",
        "        input_variable, dialog_lengths, utt_lengths, batch_indices, dialog_indices, labels, convo_ids, target_variable, mask, max_target_len = batch\n",
        "        dialog_lengths_list = [len(x) for x in batch_dialogs]\n",
        "        # run the model\n",
        "        predictions, scores = evaluateBatch(encoder, context_encoder, predictor, voc, input_variable,\n",
        "                                            dialog_lengths, dialog_lengths_list, utt_lengths, batch_indices, dialog_indices,\n",
        "                                            true_batch_size, device)\n",
        "        # aggregate results for computing accuracy at the end\n",
        "        all_preds += [p.item() for p in predictions]\n",
        "        all_labels += [l.item() for l in labels]\n",
        "        print(\"Iteration: {}; Percent complete: {:.1f}%\".format(iteration, iteration / n_iters * 100))\n",
        "\n",
        "    # compute and return the accuracy\n",
        "    return (np.asarray(all_preds) == np.asarray(all_labels)).mean()\n",
        "\n",
        "def trainIters(voc, pairs, val_pairs, encoder, context_encoder, attack_clf,\n",
        "               encoder_optimizer, context_encoder_optimizer, attack_clf_optimizer, embedding,\n",
        "               n_iteration, batch_size, print_every, validate_every, clip):\n",
        "    \n",
        "    # create a batch iterator for training data\n",
        "    batch_iterator = batchIterator(voc, pairs, batch_size)\n",
        "    \n",
        "    # Initializations\n",
        "    print('Initializing ...')\n",
        "    start_iteration = 1\n",
        "    print_loss = 0\n",
        "\n",
        "    # Training loop\n",
        "    print(\"Training...\")\n",
        "    # keep track of best validation accuracy - only save when we have a model that beats the current best\n",
        "    best_acc = 0\n",
        "    for iteration in range(start_iteration, n_iteration + 1):\n",
        "        training_batch, training_dialogs, _, true_batch_size = next(batch_iterator)\n",
        "        # Extract fields from batch\n",
        "        input_variable, dialog_lengths, utt_lengths, batch_indices, dialog_indices, labels, _, target_variable, mask, max_target_len = training_batch\n",
        "        dialog_lengths_list = [len(x) for x in training_dialogs]\n",
        "\n",
        "        # Run a training iteration with batch\n",
        "        loss = train(input_variable, dialog_lengths, dialog_lengths_list, utt_lengths, batch_indices, dialog_indices, labels, # input/output arguments\n",
        "                     encoder, context_encoder, attack_clf,                                                                    # network arguments\n",
        "                     encoder_optimizer, context_encoder_optimizer, attack_clf_optimizer,                                      # optimization arguments\n",
        "                     true_batch_size, clip)                                                                                   # misc arguments\n",
        "        print_loss += loss\n",
        "        \n",
        "        # Print progress\n",
        "        if iteration % print_every == 0:\n",
        "            print_loss_avg = print_loss / print_every\n",
        "            print(\"Iteration: {}; Percent complete: {:.1f}%; Average loss: {:.4f}\".format(iteration, iteration / n_iteration * 100, print_loss_avg))\n",
        "            print_loss = 0\n",
        "\n",
        "        # Evaluate on validation set\n",
        "        if (iteration % validate_every == 0):\n",
        "            print(\"Validating!\")\n",
        "            # put the network components into evaluation mode\n",
        "            encoder.eval()\n",
        "            context_encoder.eval()\n",
        "            attack_clf.eval()\n",
        "            \n",
        "            predictor = Predictor(encoder, context_encoder, attack_clf)\n",
        "            accuracy = validate(val_pairs, encoder, context_encoder, predictor, voc, batch_size, device)\n",
        "            print(\"Validation set accuracy: {:.2f}%\".format(accuracy * 100))\n",
        "\n",
        "            # keep track of our best model so far\n",
        "            if accuracy > best_acc:\n",
        "                print(\"Validation accuracy better than current best; saving model...\")\n",
        "                best_acc = accuracy\n",
        "                torch.save({\n",
        "                    'iteration': iteration,\n",
        "                    'en': encoder.state_dict(),\n",
        "                    'ctx': context_encoder.state_dict(),\n",
        "                    'atk_clf': attack_clf.state_dict(),\n",
        "                    'en_opt': encoder_optimizer.state_dict(),\n",
        "                    'ctx_opt': context_encoder_optimizer.state_dict(),\n",
        "                    'atk_clf_opt': attack_clf_optimizer.state_dict(),\n",
        "                    'loss': loss,\n",
        "                    'voc_dict': voc.__dict__,\n",
        "                    'embedding': embedding.state_dict()\n",
        "                }, \"finetuned_model.tar\")\n",
        "            \n",
        "            # put the network components back into training mode\n",
        "            encoder.train()\n",
        "            context_encoder.train()\n",
        "            attack_clf.train()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9eG1p_cH5fw9"
      },
      "source": [
        "## Part 5: define the evaluation procedure\n",
        "\n",
        "We're almost ready to run! The last component we need is some code to evaluate performance on the test set after fine-tuning is completed. This evaluation should use the full iterative procedure described in the paper, replicating how a system might be deployed in practice, without knowledge of where the personal attack occurs"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yZqEcwEJ5bqn"
      },
      "source": [
        "def evaluateDataset(dataset, encoder, context_encoder, predictor, voc, batch_size, device):\n",
        "    # create a batch iterator for the given data\n",
        "    batch_iterator = batchIterator(voc, dataset, batch_size, shuffle=False)\n",
        "    # find out how many iterations we will need to cover the whole dataset\n",
        "    n_iters = len(dataset) // batch_size + int(len(dataset) % batch_size > 0)\n",
        "    output_df = {\n",
        "        \"id\": [],\n",
        "        \"prediction\": [],\n",
        "        \"score\": []\n",
        "    }\n",
        "    for iteration in range(1, n_iters+1):\n",
        "        batch, batch_dialogs, _, true_batch_size = next(batch_iterator)\n",
        "        # Extract fields from batch\n",
        "        input_variable, dialog_lengths, utt_lengths, batch_indices, dialog_indices, labels, convo_ids, target_variable, mask, max_target_len = batch\n",
        "        dialog_lengths_list = [len(x) for x in batch_dialogs]\n",
        "        # run the model\n",
        "        predictions, scores = evaluateBatch(encoder, context_encoder, predictor, voc, input_variable,\n",
        "                                            dialog_lengths, dialog_lengths_list, utt_lengths, batch_indices, dialog_indices,\n",
        "                                            true_batch_size, device)\n",
        "\n",
        "        # format the output as a dataframe (which we can later re-join with the corpus)\n",
        "        for i in range(true_batch_size):\n",
        "            convo_id = convo_ids[i]\n",
        "            pred = predictions[i].item()\n",
        "            score = scores[i].item()\n",
        "            output_df[\"id\"].append(convo_id)\n",
        "            output_df[\"prediction\"].append(pred)\n",
        "            output_df[\"score\"].append(score)\n",
        "                \n",
        "        print(\"Iteration: {}; Percent complete: {:.1f}%\".format(iteration, iteration / n_iters * 100))\n",
        "\n",
        "    return pd.DataFrame(output_df).set_index(\"id\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N0VIv8sbOaB6"
      },
      "source": [
        "## Part 6: build and fine-tune the model\n",
        "\n",
        "We finally have all the components we need! Now we can instantiate the CRAFT model components, load the pre-trained weights, and run fine-tuning."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4QRinW10Oo_G",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "99df8b29-f6cb-4fab-80db-611e73ab3869"
      },
      "source": [
        "# Fix random state (affect native Python code only, does not affect PyTorch and hence does not guarantee reproducibility)\n",
        "random.seed(2019)\n",
        "\n",
        "# Tell torch to use GPU. Note that if you are running this notebook in a non-GPU environment, you can change 'cuda' to 'cpu' to get the code to run.\n",
        "device = torch.device('cuda')\n",
        "\n",
        "print(\"Loading saved parameters...\")\n",
        "if not os.path.isfile(\"pretrained_model.tar\"):\n",
        "    print(\"\\tDownloading pre-trained CRAFT...\")\n",
        "    urlretrieve(MODEL_URL, \"pretrained_model.tar\")\n",
        "    print(\"\\t...Done!\")\n",
        "checkpoint = torch.load(\"pretrained_model.tar\")\n",
        "# If running in a non-GPU environment, you need to tell PyTorch to convert the parameters to CPU tensor format.\n",
        "# To do so, replace the previous line with the following:\n",
        "#checkpoint = torch.load(\"model.tar\", map_location=torch.device('cpu'))\n",
        "encoder_sd = checkpoint['en']\n",
        "context_sd = checkpoint['ctx']\n",
        "embedding_sd = checkpoint['embedding']\n",
        "voc.__dict__ = checkpoint['voc_dict']\n",
        "\n",
        "print('Building encoders, decoder, and classifier...')\n",
        "# Initialize word embeddings\n",
        "embedding = nn.Embedding(voc.num_words, hidden_size)\n",
        "embedding.load_state_dict(embedding_sd)\n",
        "# Initialize utterance and context encoders\n",
        "encoder = EncoderRNN(hidden_size, embedding, encoder_n_layers, dropout)\n",
        "context_encoder = ContextEncoderRNN(hidden_size, context_encoder_n_layers, dropout)\n",
        "encoder.load_state_dict(encoder_sd)\n",
        "context_encoder.load_state_dict(context_sd)\n",
        "# Initialize classifier\n",
        "attack_clf = SingleTargetClf(hidden_size, dropout)\n",
        "# Use appropriate device\n",
        "encoder = encoder.to(device)\n",
        "context_encoder = context_encoder.to(device)\n",
        "attack_clf = attack_clf.to(device)\n",
        "print('Models built and ready to go!')\n",
        "\n",
        "# Compute the number of training iterations we will need in order to achieve the number of epochs specified in the settings at the start of the notebook\n",
        "n_iter_per_epoch = len(train_pairs) // batch_size + int(len(train_pairs) % batch_size == 1)\n",
        "n_iteration = n_iter_per_epoch * train_epochs\n",
        "\n",
        "# Put dropout layers in train mode\n",
        "encoder.train()\n",
        "context_encoder.train()\n",
        "attack_clf.train()\n",
        "\n",
        "# Initialize optimizers\n",
        "print('Building optimizers...')\n",
        "encoder_optimizer = optim.Adam(encoder.parameters(), lr=learning_rate)\n",
        "context_encoder_optimizer = optim.Adam(context_encoder.parameters(), lr=learning_rate)\n",
        "attack_clf_optimizer = optim.Adam(attack_clf.parameters(), lr=learning_rate)\n",
        "\n",
        "# Run training iterations, validating after every epoch\n",
        "print(\"Starting Training!\")\n",
        "print(\"Will train for {} iterations\".format(n_iteration))\n",
        "trainIters(voc, train_pairs, val_pairs, encoder, context_encoder, attack_clf,\n",
        "           encoder_optimizer, context_encoder_optimizer, attack_clf_optimizer, embedding,\n",
        "           n_iteration, batch_size, print_every, n_iter_per_epoch, clip)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Loading saved parameters...\n",
            "Building encoders, decoder, and classifier...\n",
            "Models built and ready to go!\n",
            "Building optimizers...\n",
            "Starting Training!\n",
            "Will train for 1170 iterations\n",
            "Initializing ...\n",
            "Training...\n",
            "Iteration: 10; Percent complete: 0.9%; Average loss: 0.6931\n",
            "Iteration: 20; Percent complete: 1.7%; Average loss: 0.6928\n",
            "Iteration: 30; Percent complete: 2.6%; Average loss: 0.6932\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:1351: UserWarning: nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\n",
            "  warnings.warn(\"nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\")\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 52.98%\n",
            "Validation accuracy better than current best; saving model...\n",
            "Iteration: 40; Percent complete: 3.4%; Average loss: 0.6932\n",
            "Iteration: 50; Percent complete: 4.3%; Average loss: 0.6929\n",
            "Iteration: 60; Percent complete: 5.1%; Average loss: 0.6928\n",
            "Iteration: 70; Percent complete: 6.0%; Average loss: 0.6925\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 55.95%\n",
            "Validation accuracy better than current best; saving model...\n",
            "Iteration: 80; Percent complete: 6.8%; Average loss: 0.6921\n",
            "Iteration: 90; Percent complete: 7.7%; Average loss: 0.6925\n",
            "Iteration: 100; Percent complete: 8.5%; Average loss: 0.6921\n",
            "Iteration: 110; Percent complete: 9.4%; Average loss: 0.6923\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 56.07%\n",
            "Validation accuracy better than current best; saving model...\n",
            "Iteration: 120; Percent complete: 10.3%; Average loss: 0.6918\n",
            "Iteration: 130; Percent complete: 11.1%; Average loss: 0.6917\n",
            "Iteration: 140; Percent complete: 12.0%; Average loss: 0.6914\n",
            "Iteration: 150; Percent complete: 12.8%; Average loss: 0.6912\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 58.21%\n",
            "Validation accuracy better than current best; saving model...\n",
            "Iteration: 160; Percent complete: 13.7%; Average loss: 0.6906\n",
            "Iteration: 170; Percent complete: 14.5%; Average loss: 0.6910\n",
            "Iteration: 180; Percent complete: 15.4%; Average loss: 0.6908\n",
            "Iteration: 190; Percent complete: 16.2%; Average loss: 0.6903\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 58.57%\n",
            "Validation accuracy better than current best; saving model...\n",
            "Iteration: 200; Percent complete: 17.1%; Average loss: 0.6901\n",
            "Iteration: 210; Percent complete: 17.9%; Average loss: 0.6894\n",
            "Iteration: 220; Percent complete: 18.8%; Average loss: 0.6895\n",
            "Iteration: 230; Percent complete: 19.7%; Average loss: 0.6893\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 58.21%\n",
            "Iteration: 240; Percent complete: 20.5%; Average loss: 0.6885\n",
            "Iteration: 250; Percent complete: 21.4%; Average loss: 0.6878\n",
            "Iteration: 260; Percent complete: 22.2%; Average loss: 0.6878\n",
            "Iteration: 270; Percent complete: 23.1%; Average loss: 0.6877\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 59.64%\n",
            "Validation accuracy better than current best; saving model...\n",
            "Iteration: 280; Percent complete: 23.9%; Average loss: 0.6875\n",
            "Iteration: 290; Percent complete: 24.8%; Average loss: 0.6864\n",
            "Iteration: 300; Percent complete: 25.6%; Average loss: 0.6854\n",
            "Iteration: 310; Percent complete: 26.5%; Average loss: 0.6850\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 60.24%\n",
            "Validation accuracy better than current best; saving model...\n",
            "Iteration: 320; Percent complete: 27.4%; Average loss: 0.6832\n",
            "Iteration: 330; Percent complete: 28.2%; Average loss: 0.6822\n",
            "Iteration: 340; Percent complete: 29.1%; Average loss: 0.6811\n",
            "Iteration: 350; Percent complete: 29.9%; Average loss: 0.6811\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 60.24%\n",
            "Iteration: 360; Percent complete: 30.8%; Average loss: 0.6828\n",
            "Iteration: 370; Percent complete: 31.6%; Average loss: 0.6757\n",
            "Iteration: 380; Percent complete: 32.5%; Average loss: 0.6757\n",
            "Iteration: 390; Percent complete: 33.3%; Average loss: 0.6710\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 62.14%\n",
            "Validation accuracy better than current best; saving model...\n",
            "Iteration: 400; Percent complete: 34.2%; Average loss: 0.6723\n",
            "Iteration: 410; Percent complete: 35.0%; Average loss: 0.6672\n",
            "Iteration: 420; Percent complete: 35.9%; Average loss: 0.6620\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 62.14%\n",
            "Iteration: 430; Percent complete: 36.8%; Average loss: 0.6573\n",
            "Iteration: 440; Percent complete: 37.6%; Average loss: 0.6551\n",
            "Iteration: 450; Percent complete: 38.5%; Average loss: 0.6458\n",
            "Iteration: 460; Percent complete: 39.3%; Average loss: 0.6489\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 62.86%\n",
            "Validation accuracy better than current best; saving model...\n",
            "Iteration: 470; Percent complete: 40.2%; Average loss: 0.6323\n",
            "Iteration: 480; Percent complete: 41.0%; Average loss: 0.6192\n",
            "Iteration: 490; Percent complete: 41.9%; Average loss: 0.6178\n",
            "Iteration: 500; Percent complete: 42.7%; Average loss: 0.6014\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 64.76%\n",
            "Validation accuracy better than current best; saving model...\n",
            "Iteration: 510; Percent complete: 43.6%; Average loss: 0.5925\n",
            "Iteration: 520; Percent complete: 44.4%; Average loss: 0.5889\n",
            "Iteration: 530; Percent complete: 45.3%; Average loss: 0.5653\n",
            "Iteration: 540; Percent complete: 46.2%; Average loss: 0.5628\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 64.52%\n",
            "Iteration: 550; Percent complete: 47.0%; Average loss: 0.5631\n",
            "Iteration: 560; Percent complete: 47.9%; Average loss: 0.5645\n",
            "Iteration: 570; Percent complete: 48.7%; Average loss: 0.5232\n",
            "Iteration: 580; Percent complete: 49.6%; Average loss: 0.5292\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 64.17%\n",
            "Iteration: 590; Percent complete: 50.4%; Average loss: 0.5362\n",
            "Iteration: 600; Percent complete: 51.3%; Average loss: 0.5371\n",
            "Iteration: 610; Percent complete: 52.1%; Average loss: 0.5146\n",
            "Iteration: 620; Percent complete: 53.0%; Average loss: 0.5136\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 64.88%\n",
            "Validation accuracy better than current best; saving model...\n",
            "Iteration: 630; Percent complete: 53.8%; Average loss: 0.4756\n",
            "Iteration: 640; Percent complete: 54.7%; Average loss: 0.4970\n",
            "Iteration: 650; Percent complete: 55.6%; Average loss: 0.4534\n",
            "Iteration: 660; Percent complete: 56.4%; Average loss: 0.4884\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 64.52%\n",
            "Iteration: 670; Percent complete: 57.3%; Average loss: 0.4638\n",
            "Iteration: 680; Percent complete: 58.1%; Average loss: 0.4493\n",
            "Iteration: 690; Percent complete: 59.0%; Average loss: 0.4276\n",
            "Iteration: 700; Percent complete: 59.8%; Average loss: 0.4350\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 64.40%\n",
            "Iteration: 710; Percent complete: 60.7%; Average loss: 0.4465\n",
            "Iteration: 720; Percent complete: 61.5%; Average loss: 0.4442\n",
            "Iteration: 730; Percent complete: 62.4%; Average loss: 0.3888\n",
            "Iteration: 740; Percent complete: 63.2%; Average loss: 0.3680\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 64.52%\n",
            "Iteration: 750; Percent complete: 64.1%; Average loss: 0.4093\n",
            "Iteration: 760; Percent complete: 65.0%; Average loss: 0.4613\n",
            "Iteration: 770; Percent complete: 65.8%; Average loss: 0.3405\n",
            "Iteration: 780; Percent complete: 66.7%; Average loss: 0.3864\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 65.24%\n",
            "Validation accuracy better than current best; saving model...\n",
            "Iteration: 790; Percent complete: 67.5%; Average loss: 0.3877\n",
            "Iteration: 800; Percent complete: 68.4%; Average loss: 0.3566\n",
            "Iteration: 810; Percent complete: 69.2%; Average loss: 0.3338\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 64.64%\n",
            "Iteration: 820; Percent complete: 70.1%; Average loss: 0.3410\n",
            "Iteration: 830; Percent complete: 70.9%; Average loss: 0.3472\n",
            "Iteration: 840; Percent complete: 71.8%; Average loss: 0.3186\n",
            "Iteration: 850; Percent complete: 72.6%; Average loss: 0.3243\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 65.36%\n",
            "Validation accuracy better than current best; saving model...\n",
            "Iteration: 860; Percent complete: 73.5%; Average loss: 0.3046\n",
            "Iteration: 870; Percent complete: 74.4%; Average loss: 0.2941\n",
            "Iteration: 880; Percent complete: 75.2%; Average loss: 0.3040\n",
            "Iteration: 890; Percent complete: 76.1%; Average loss: 0.2523\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 65.36%\n",
            "Iteration: 900; Percent complete: 76.9%; Average loss: 0.2909\n",
            "Iteration: 910; Percent complete: 77.8%; Average loss: 0.2636\n",
            "Iteration: 920; Percent complete: 78.6%; Average loss: 0.3216\n",
            "Iteration: 930; Percent complete: 79.5%; Average loss: 0.2464\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 65.83%\n",
            "Validation accuracy better than current best; saving model...\n",
            "Iteration: 940; Percent complete: 80.3%; Average loss: 0.2263\n",
            "Iteration: 950; Percent complete: 81.2%; Average loss: 0.2287\n",
            "Iteration: 960; Percent complete: 82.1%; Average loss: 0.2494\n",
            "Iteration: 970; Percent complete: 82.9%; Average loss: 0.2394\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 65.71%\n",
            "Iteration: 980; Percent complete: 83.8%; Average loss: 0.2072\n",
            "Iteration: 990; Percent complete: 84.6%; Average loss: 0.1860\n",
            "Iteration: 1000; Percent complete: 85.5%; Average loss: 0.2065\n",
            "Iteration: 1010; Percent complete: 86.3%; Average loss: 0.1825\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 65.71%\n",
            "Iteration: 1020; Percent complete: 87.2%; Average loss: 0.1563\n",
            "Iteration: 1030; Percent complete: 88.0%; Average loss: 0.1951\n",
            "Iteration: 1040; Percent complete: 88.9%; Average loss: 0.1809\n",
            "Iteration: 1050; Percent complete: 89.7%; Average loss: 0.1757\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 65.71%\n",
            "Iteration: 1060; Percent complete: 90.6%; Average loss: 0.1550\n",
            "Iteration: 1070; Percent complete: 91.5%; Average loss: 0.1622\n",
            "Iteration: 1080; Percent complete: 92.3%; Average loss: 0.1301\n",
            "Iteration: 1090; Percent complete: 93.2%; Average loss: 0.1117\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 65.71%\n",
            "Iteration: 1100; Percent complete: 94.0%; Average loss: 0.1553\n",
            "Iteration: 1110; Percent complete: 94.9%; Average loss: 0.1188\n",
            "Iteration: 1120; Percent complete: 95.7%; Average loss: 0.1326\n",
            "Iteration: 1130; Percent complete: 96.6%; Average loss: 0.1339\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 65.60%\n",
            "Iteration: 1140; Percent complete: 97.4%; Average loss: 0.1078\n",
            "Iteration: 1150; Percent complete: 98.3%; Average loss: 0.1155\n",
            "Iteration: 1160; Percent complete: 99.1%; Average loss: 0.1010\n",
            "Iteration: 1170; Percent complete: 100.0%; Average loss: 0.0923\n",
            "Validating!\n",
            "Iteration: 1; Percent complete: 7.1%\n",
            "Iteration: 2; Percent complete: 14.3%\n",
            "Iteration: 3; Percent complete: 21.4%\n",
            "Iteration: 4; Percent complete: 28.6%\n",
            "Iteration: 5; Percent complete: 35.7%\n",
            "Iteration: 6; Percent complete: 42.9%\n",
            "Iteration: 7; Percent complete: 50.0%\n",
            "Iteration: 8; Percent complete: 57.1%\n",
            "Iteration: 9; Percent complete: 64.3%\n",
            "Iteration: 10; Percent complete: 71.4%\n",
            "Iteration: 11; Percent complete: 78.6%\n",
            "Iteration: 12; Percent complete: 85.7%\n",
            "Iteration: 13; Percent complete: 92.9%\n",
            "Iteration: 14; Percent complete: 100.0%\n",
            "Validation set accuracy: 65.12%\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Na5gjZGE-KA0"
      },
      "source": [
        "## Part 7: run test set evaluation\n",
        "\n",
        "Now that we have successfully fine-tuned the model, we run it on the test set so that we can evaluate performance."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2551GR65-Wm5",
        "outputId": "154d7581-37a7-48e7-c203-9d3a97c472ed",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "source": [
        "# Fix random state for reproducibility\n",
        "random.seed(2019)\n",
        "\n",
        "# Tell torch to use GPU. Note that if you are running this notebook in a non-GPU environment, you can change 'cuda' to 'cpu' to get the code to run.\n",
        "device = torch.device('cuda')\n",
        "\n",
        "print(\"Loading saved parameters...\")\n",
        "checkpoint = torch.load(\"finetuned_model.tar\")\n",
        "# If running in a non-GPU environment, you need to tell PyTorch to convert the parameters to CPU tensor format.\n",
        "# To do so, replace the previous line with the following:\n",
        "#checkpoint = torch.load(\"model.tar\", map_location=torch.device('cpu'))\n",
        "encoder_sd = checkpoint['en']\n",
        "context_sd = checkpoint['ctx']\n",
        "attack_clf_sd = checkpoint['atk_clf']\n",
        "embedding_sd = checkpoint['embedding']\n",
        "voc.__dict__ = checkpoint['voc_dict']\n",
        "\n",
        "print('Building encoders, decoder, and classifier...')\n",
        "# Initialize word embeddings\n",
        "embedding = nn.Embedding(voc.num_words, hidden_size)\n",
        "embedding.load_state_dict(embedding_sd)\n",
        "# Initialize utterance and context encoders\n",
        "encoder = EncoderRNN(hidden_size, embedding, encoder_n_layers, dropout)\n",
        "context_encoder = ContextEncoderRNN(hidden_size, context_encoder_n_layers, dropout)\n",
        "encoder.load_state_dict(encoder_sd)\n",
        "context_encoder.load_state_dict(context_sd)\n",
        "# Initialize classifier\n",
        "attack_clf = SingleTargetClf(hidden_size, dropout)\n",
        "attack_clf.load_state_dict(attack_clf_sd)\n",
        "# Use appropriate device\n",
        "encoder = encoder.to(device)\n",
        "context_encoder = context_encoder.to(device)\n",
        "attack_clf = attack_clf.to(device)\n",
        "print('Models built and ready to go!')\n",
        "\n",
        "# Set dropout layers to eval mode\n",
        "encoder.eval()\n",
        "context_encoder.eval()\n",
        "attack_clf.eval()\n",
        "\n",
        "# Initialize the pipeline\n",
        "predictor = Predictor(encoder, context_encoder, attack_clf)\n",
        "\n",
        "# Run the pipeline!\n",
        "forecasts_df = evaluateDataset(test_pairs, encoder, context_encoder, predictor, voc, batch_size, device)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Loading saved parameters...\n",
            "Building encoders, decoder, and classifier...\n",
            "Models built and ready to go!\n",
            "Iteration: 1; Percent complete: 1.4%\n",
            "Iteration: 2; Percent complete: 2.9%\n",
            "Iteration: 3; Percent complete: 4.3%\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:1351: UserWarning: nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\n",
            "  warnings.warn(\"nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\")\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "Iteration: 4; Percent complete: 5.8%\n",
            "Iteration: 5; Percent complete: 7.2%\n",
            "Iteration: 6; Percent complete: 8.7%\n",
            "Iteration: 7; Percent complete: 10.1%\n",
            "Iteration: 8; Percent complete: 11.6%\n",
            "Iteration: 9; Percent complete: 13.0%\n",
            "Iteration: 10; Percent complete: 14.5%\n",
            "Iteration: 11; Percent complete: 15.9%\n",
            "Iteration: 12; Percent complete: 17.4%\n",
            "Iteration: 13; Percent complete: 18.8%\n",
            "Iteration: 14; Percent complete: 20.3%\n",
            "Iteration: 15; Percent complete: 21.7%\n",
            "Iteration: 16; Percent complete: 23.2%\n",
            "Iteration: 17; Percent complete: 24.6%\n",
            "Iteration: 18; Percent complete: 26.1%\n",
            "Iteration: 19; Percent complete: 27.5%\n",
            "Iteration: 20; Percent complete: 29.0%\n",
            "Iteration: 21; Percent complete: 30.4%\n",
            "Iteration: 22; Percent complete: 31.9%\n",
            "Iteration: 23; Percent complete: 33.3%\n",
            "Iteration: 24; Percent complete: 34.8%\n",
            "Iteration: 25; Percent complete: 36.2%\n",
            "Iteration: 26; Percent complete: 37.7%\n",
            "Iteration: 27; Percent complete: 39.1%\n",
            "Iteration: 28; Percent complete: 40.6%\n",
            "Iteration: 29; Percent complete: 42.0%\n",
            "Iteration: 30; Percent complete: 43.5%\n",
            "Iteration: 31; Percent complete: 44.9%\n",
            "Iteration: 32; Percent complete: 46.4%\n",
            "Iteration: 33; Percent complete: 47.8%\n",
            "Iteration: 34; Percent complete: 49.3%\n",
            "Iteration: 35; Percent complete: 50.7%\n",
            "Iteration: 36; Percent complete: 52.2%\n",
            "Iteration: 37; Percent complete: 53.6%\n",
            "Iteration: 38; Percent complete: 55.1%\n",
            "Iteration: 39; Percent complete: 56.5%\n",
            "Iteration: 40; Percent complete: 58.0%\n",
            "Iteration: 41; Percent complete: 59.4%\n",
            "Iteration: 42; Percent complete: 60.9%\n",
            "Iteration: 43; Percent complete: 62.3%\n",
            "Iteration: 44; Percent complete: 63.8%\n",
            "Iteration: 45; Percent complete: 65.2%\n",
            "Iteration: 46; Percent complete: 66.7%\n",
            "Iteration: 47; Percent complete: 68.1%\n",
            "Iteration: 48; Percent complete: 69.6%\n",
            "Iteration: 49; Percent complete: 71.0%\n",
            "Iteration: 50; Percent complete: 72.5%\n",
            "Iteration: 51; Percent complete: 73.9%\n",
            "Iteration: 52; Percent complete: 75.4%\n",
            "Iteration: 53; Percent complete: 76.8%\n",
            "Iteration: 54; Percent complete: 78.3%\n",
            "Iteration: 55; Percent complete: 79.7%\n",
            "Iteration: 56; Percent complete: 81.2%\n",
            "Iteration: 57; Percent complete: 82.6%\n",
            "Iteration: 58; Percent complete: 84.1%\n",
            "Iteration: 59; Percent complete: 85.5%\n",
            "Iteration: 60; Percent complete: 87.0%\n",
            "Iteration: 61; Percent complete: 88.4%\n",
            "Iteration: 62; Percent complete: 89.9%\n",
            "Iteration: 63; Percent complete: 91.3%\n",
            "Iteration: 64; Percent complete: 92.8%\n",
            "Iteration: 65; Percent complete: 94.2%\n",
            "Iteration: 66; Percent complete: 95.7%\n",
            "Iteration: 67; Percent complete: 97.1%\n",
            "Iteration: 68; Percent complete: 98.6%\n",
            "Iteration: 69; Percent complete: 100.0%\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lVK-1NWHEy7l",
        "outputId": "8b208593-4f96-444f-ad6c-cb84c0ffd88b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 708
        }
      },
      "source": [
        "# Inspect some of the outputs as a sanity-check\n",
        "forecasts_df.head(20)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>prediction</th>\n",
              "      <th>score</th>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>id</th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>191681310.17214.17214</th>\n",
              "      <td>0.0</td>\n",
              "      <td>0.300737</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>193088419.20001.20001</th>\n",
              "      <td>1.0</td>\n",
              "      <td>0.945930</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>191149920.17102.17102</th>\n",
              "      <td>0.0</td>\n",
              "      <td>0.347532</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>192892110.19259.19259</th>\n",
              "      <td>1.0</td>\n",
              "      <td>0.813790</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>190192199.17060.17060</th>\n",
              "      <td>0.0</td>\n",
              "      <td>0.045523</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>192890095.19227.19227</th>\n",
              "      <td>1.0</td>\n",
              "      <td>0.941272</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>190192005.17004.17004</th>\n",
              "      <td>0.0</td>\n",
              "      <td>0.043127</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>192885632.19156.19156</th>\n",
              "      <td>0.0</td>\n",
              "      <td>0.473514</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>190191827.16918.16918</th>\n",
              "      <td>0.0</td>\n",
              "      <td>0.126330</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>192882222.19129.19129</th>\n",
              "      <td>1.0</td>\n",
              "      <td>0.569842</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>190191097.16843.16843</th>\n",
              "      <td>0.0</td>\n",
              "      <td>0.260226</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>192642615.19074.19074</th>\n",
              "      <td>0.0</td>\n",
              "      <td>0.332530</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>190190570.16705.16705</th>\n",
              "      <td>1.0</td>\n",
              "      <td>0.758276</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>203899060.13359.13359</th>\n",
              "      <td>1.0</td>\n",
              "      <td>0.989039</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>15869198.3976.3976</th>\n",
              "      <td>0.0</td>\n",
              "      <td>0.340487</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>192640416.19036.19036</th>\n",
              "      <td>0.0</td>\n",
              "      <td>0.224283</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>190189346.16645.16645</th>\n",
              "      <td>0.0</td>\n",
              "      <td>0.124451</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>203898053.13222.13222</th>\n",
              "      <td>1.0</td>\n",
              "      <td>0.986863</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>390066809.29445.29445</th>\n",
              "      <td>1.0</td>\n",
              "      <td>0.804826</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>434001261.9906.9906</th>\n",
              "      <td>0.0</td>\n",
              "      <td>0.440444</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                       prediction     score\n",
              "id                                         \n",
              "191681310.17214.17214         0.0  0.300737\n",
              "193088419.20001.20001         1.0  0.945930\n",
              "191149920.17102.17102         0.0  0.347532\n",
              "192892110.19259.19259         1.0  0.813790\n",
              "190192199.17060.17060         0.0  0.045523\n",
              "192890095.19227.19227         1.0  0.941272\n",
              "190192005.17004.17004         0.0  0.043127\n",
              "192885632.19156.19156         0.0  0.473514\n",
              "190191827.16918.16918         0.0  0.126330\n",
              "192882222.19129.19129         1.0  0.569842\n",
              "190191097.16843.16843         0.0  0.260226\n",
              "192642615.19074.19074         0.0  0.332530\n",
              "190190570.16705.16705         1.0  0.758276\n",
              "203899060.13359.13359         1.0  0.989039\n",
              "15869198.3976.3976            0.0  0.340487\n",
              "192640416.19036.19036         0.0  0.224283\n",
              "190189346.16645.16645         0.0  0.124451\n",
              "203898053.13222.13222         1.0  0.986863\n",
              "390066809.29445.29445         1.0  0.804826\n",
              "434001261.9906.9906           0.0  0.440444"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m_EMZ7-SKtEP"
      },
      "source": [
        "## Part 8: merge predictions back into corpus and evaluate\n",
        "\n",
        "Now that the hard part is done, all that is left to do is to evaluate the predictions. Since the predictions are in no particular order, we will first merge each prediction back into the source corpus, and then evaluate each conversation according to the order of utterances within that conversation."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Vnjmtu-QLDVo"
      },
      "source": [
        "# We will add a metadata entry to each test-set utterance signifying whether it was FORECAST to be a derailment.\n",
        "# Note that there is an important subtlety in how this metadata field is to be interpreted - the forecast for a given\n",
        "# utterance is made BEFORE the model actually sees the utterance. That is, the forecast does not mean \"the model thinks\n",
        "# this utterance *is* a derailment\" but rather that \"based on the context of all preceding utterances, the model predicted,\n",
        "# prior to actually seeing this utterance, that this utterance *would be* a derailment\".\n",
        "for convo in corpus.iter_conversations():\n",
        "    # only consider test set conversations (we did not make predictions for the other ones)\n",
        "    if convo.meta['split'] == \"test\":\n",
        "        for utt in convo.iter_utterances():\n",
        "            if utt.id in forecasts_df.index:\n",
        "                utt.meta['forecast_score'] = forecasts_df.loc[utt.id].score"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FYxW_AuWszqX",
        "outputId": "d478288b-55ae-4bc9-cb8c-f294a80f3174",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Finally, we can use the forecast-annotated corpus to compute the forecast accuracy.\n",
        "# Though we have an individual forecast per utterance, ground truth is at the conversation level:\n",
        "# either a conversation derails or it does not. Thus, forecast accuracy is computed as follows:\n",
        "#   - True positives are cases that actually derail, for which the model made at least one positive forecast ANYTIME prior to derailment\n",
        "#   - False positives are cases that don't derail but for which the model made at least one positive forecast\n",
        "#   - False negatives are cases that derail but for which the model made no positive forecasts prior to derailment\n",
        "#   - True negatives are cases that don't derail, for which the model made no positive forecasts\n",
        "# Note that by construction, the last comment of each conversation is the one marked as derailment, and that our earlier code was therefore\n",
        "# set up to not look at the last comment, meaning that all forecasts we obtained are forecasts made prior to derailment. This simplifies\n",
        "# the computation of forecast accuracy as we now do not need to explicitly consider when a forecast was made.\n",
        "\n",
        "conversational_forecasts_df = {\n",
        "    \"convo_id\": [],\n",
        "    \"label\": [],\n",
        "    \"score\": [],\n",
        "    \"prediction\": []\n",
        "}\n",
        "\n",
        "for convo in corpus.iter_conversations():\n",
        "    if convo.meta['split'] == \"test\":\n",
        "        conversational_forecasts_df['convo_id'].append(convo.id)\n",
        "        conversational_forecasts_df['label'].append(int(convo.meta['conversation_has_personal_attack']))\n",
        "        forecast_scores = [utt.meta['forecast_score'] for utt in convo.iter_utterances() if 'forecast_score' in utt.meta]\n",
        "        conversational_forecasts_df['score'] = np.max(forecast_scores)\n",
        "        conversational_forecasts_df['prediction'].append(int(np.max(forecast_scores) > FORECAST_THRESH))\n",
        "\n",
        "conversational_forecasts_df = pd.DataFrame(conversational_forecasts_df).set_index(\"convo_id\")\n",
        "print((conversational_forecasts_df.label == conversational_forecasts_df.prediction).mean())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.6547619047619048\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_49Yaz2FIo9S",
        "outputId": "d1ae7b87-6973-41a1-e7aa-806d57990c01",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 72
        }
      },
      "source": [
        "# in addition to accuracy, we can also consider applying other metrics at the conversation level, such as precision/recall\n",
        "def get_pr_stats(preds, labels):\n",
        "    tp = ((labels==1)&(preds==1)).sum()\n",
        "    fp = ((labels==0)&(preds==1)).sum()\n",
        "    tn = ((labels==0)&(preds==0)).sum()\n",
        "    fn = ((labels==1)&(preds==0)).sum()\n",
        "    print(\"Precision = {0:.4f}, recall = {1:.4f}\".format(tp / (tp + fp), tp / (tp + fn)))\n",
        "    print(\"False positive rate =\", fp / (fp + tn))\n",
        "    print(\"F1 =\", 2 / (((tp + fp) / tp) + ((tp + fn) / tp)))\n",
        "\n",
        "get_pr_stats(conversational_forecasts_df.prediction, conversational_forecasts_df.label)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Precision = 0.6354, recall = 0.7262\n",
            "False positive rate = 0.4166666666666667\n",
            "F1 = 0.6777777777777778\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WzBiI0dsW7WZ"
      },
      "source": [
        "## Part 9: model analysis: how early is early warning?\n",
        "\n",
        "The goal of CRAFT is to forecast outcomes in advance, but how far in advance does it typically make its prediction? Following the paper, we measure this in two ways: the number of *comments* between the first prediction and the actual derailment, and how much *elapsed time* that gap actually translates to."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8Qfvl9k8Xesh"
      },
      "source": [
        "comments_until_derail = {} # store the \"number of comments until derailment\" metric for each conversation\n",
        "time_until_derail = {} # store the \"time until derailment\" metric for each conversation\n",
        "\n",
        "for convo in corpus.iter_conversations():\n",
        "    if convo.meta['split'] == \"test\" and convo.meta['conversation_has_personal_attack']:\n",
        "        # filter out the section header as usual\n",
        "        utts = [utt for utt in convo.iter_utterances() if not utt.meta['is_section_header']]\n",
        "        # by construction, the last comment is the one with the personal attack\n",
        "        derail_idx = len(utts) - 1\n",
        "        # now scan the utterances in order until we find the first derailment prediction (if any)\n",
        "        for idx in range(1, len(utts)):\n",
        "            if utts[idx].meta['forecast_score'] > FORECAST_THRESH:\n",
        "                # recall that the forecast_score meta field specifies what CRAFT thought this comment would look like BEFORE it\n",
        "                # saw this comment. So the actual CRAFT forecast is made during the previous comment; we account for this by \n",
        "                # subtracting 1 from idx\n",
        "                comments_until_derail[convo.id] = derail_idx - (idx-1)\n",
        "                time_until_derail[convo.id] = utts[derail_idx].timestamp - utts[(idx-1)].timestamp\n",
        "                break"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IFXn4LrMhJ8W",
        "outputId": "26611644-8c44-4380-8897-b0de6eece0cd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# compute some quick statistics about the distribution of the \"number of comments until derailment\" metric\n",
        "comments_until_derail_vals = np.asarray(list(comments_until_derail.values()))\n",
        "print(np.min(comments_until_derail_vals), np.max(comments_until_derail_vals), np.median(comments_until_derail_vals), np.mean(comments_until_derail_vals))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1 12 3.0 3.2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7cTdzAuLhuHF",
        "outputId": "85df20c5-62e1-4d2c-8736-8432a65f55ac",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# compute some quick statistics about the distribution of the \"time until derailment\" metric\n",
        "# note that since timestamps are in seconds, we convert to hours by dividing by 3600, to make it more human readable\n",
        "time_until_derail_vals = np.asarray(list(time_until_derail.values())) / 3600\n",
        "print(np.min(time_until_derail_vals), np.max(time_until_derail_vals), np.median(time_until_derail_vals), np.mean(time_until_derail_vals))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0.0 25575.071111111112 3.4491666666666667 277.8502741347906\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_w3l6UxDiDAz",
        "outputId": "7de51fb0-dbb9-42f2-8d5f-18fcda28ab00",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 362
        }
      },
      "source": [
        "# visualize the distribution of \"number of comments until derailment\" as a histogram (reproducing Figure 4 from the paper)\n",
        "plt.rcParams['figure.figsize'] = (10.0, 5.0)\n",
        "plt.rcParams['font.size'] = 24\n",
        "plt.hist(comments_until_derail_vals, bins=range(1, np.max(comments_until_derail_vals)), density=True)\n",
        "plt.xlim(1,10)\n",
        "plt.xticks(np.arange(1,10)+0.5, np.arange(1,10))\n",
        "plt.yticks(np.arange(0,0.25,0.05), np.arange(0,25,5))\n",
        "plt.xlabel(\"Number of comments elapsed\")\n",
        "plt.ylabel(\"% of conversations\")\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAn4AAAFZCAYAAAAGkSJzAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nZtYn/j+lq/z3SAehrwAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 720x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    }
  ]
}