From 078f021c0a0eec142dcb19a5306a9dd65ca3b3c2 Mon Sep 17 00:00:00 2001
From: "sunlok.kim" <skywalker2316@gmail.com>
Date: Tue, 29 Sep 2020 15:46:30 +0900
Subject: [PATCH] Code Release

---
 .gitignore                      |   1 +
 agents/__init__.py              |   0
 agents/history.py               | 333 ++++++++++++++++++++
 agents/modules.py               | 220 +++++++++++++
 agents/selfconscious_blender.py | 543 ++++++++++++++++++++++++++++++++
 environment.yml                 |  30 ++
 eval_dnli.py                    |  21 ++
 eval_personachat.py             |  20 ++
 modules/__init__.py             |   0
 modules/dnli_bert.py            | 214 +++++++++++++
 tasks/__init__.py               |   0
 tasks/build.py                  |  80 +++++
 tasks/teachers.py               | 497 +++++++++++++++++++++++++++++
 tasks/test_persona_map.pkl      | Bin 0 -> 58923 bytes
 tasks/train_persona_map.pkl     | Bin 0 -> 634531 bytes
 tasks/valid_persona_map.pkl     | Bin 0 -> 62668 bytes
 16 files changed, 1959 insertions(+)
 create mode 100644 agents/__init__.py
 create mode 100755 agents/history.py
 create mode 100644 agents/modules.py
 create mode 100644 agents/selfconscious_blender.py
 create mode 100644 environment.yml
 create mode 100644 eval_dnli.py
 create mode 100644 eval_personachat.py
 create mode 100644 modules/__init__.py
 create mode 100644 modules/dnli_bert.py
 create mode 100644 tasks/__init__.py
 create mode 100755 tasks/build.py
 create mode 100644 tasks/teachers.py
 create mode 100644 tasks/test_persona_map.pkl
 create mode 100644 tasks/train_persona_map.pkl
 create mode 100644 tasks/valid_persona_map.pkl

diff --git a/.gitignore b/.gitignore
index b6e4761..b8da8a4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -103,6 +103,7 @@ celerybeat.pid
 
 # Environments
 .env
+.cenv
 .venv
 env/
 venv/
diff --git a/agents/__init__.py b/agents/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/agents/history.py b/agents/history.py
new file mode 100755
index 0000000..3bf19f8
--- /dev/null
+++ b/agents/history.py
@@ -0,0 +1,333 @@
+#!/usr/bin/env python3
+
+# Copyright (c) Facebook, Inc. and its affiliates.
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+This file is derived from parlai/core/seq2seq/seq2seq.py.
+In particular, it's derived from an older version that inherits from TorchAgent rather
+than TorchGeneratorAgent.
+It should be possible to refactor this file to be comparable to the current
+parlai/core/seq2seq/seq2seq.py, i.e. inherit from TorchGeneratorAgent - this would
+probably reduce the amount of boilerplate in this file.
+However, for simplicity and to keep things as similar as possible to the version used
+for the paper, we have kept this file mostly the same.
+"""
+
+from parlai.core.torch_agent import Batch, History, TorchAgent
+from parlai.core.torch_generator_agent import TorchGeneratorAgent
+from parlai.utils.torch import padded_tensor, argsort
+# from .base_controllable_seq2seq import BaseControllableSeq2seqAgent
+# from .util import ConvAI2History
+# from .controls import get_ctrl_vec
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from collections import defaultdict, namedtuple, Counter, deque
+from operator import attrgetter
+
+import os
+import math
+import json
+import tempfile
+import copy
+from itertools import chain
+
+
+def list_to_matrix(l, n):
+    return [l[i:i+n] for i in range(0, len(l), n)]
+
+
+class SelfConsciousHistory(History):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        opt = args[0]
+        if opt['eval_type'] == 'convai2':
+            self.add_person_tokens = True
+        elif opt['eval_type'] == 'dnli':
+            self.add_person_tokens = False
+        else:
+            raise ValueError
+
+        self.world_cardinality = opt.get('world_cardinality', 5)
+        self.history_distractor_strings = [[] for _ in range(self.world_cardinality)]
+        self.history_distractor_raw_strings = [[] for _ in range(self.world_cardinality)]
+        self.history_distractor_vecs = [[] for _ in range(self.world_cardinality)]
+        # Will be used for TransferTransfo
+        self.history_token_type_ids = []
+        self.history_distractor_token_type_ids = [[] for _ in range(self.world_cardinality)]
+
+    def reset(self):
+        """Clear the history"""
+        super().reset()
+        self.history_distractor_strings = [[] for _ in range(self.world_cardinality)]
+        self.history_distractor_raw_strings = [[] for _ in range(self.world_cardinality)]
+        self.history_distractor_vecs = [[] for _ in range(self.world_cardinality)]
+        self.history_token_type_ids = []
+        self.history_distractor_token_type_ids = [[] for _ in range(self.world_cardinality)]
+
+    def _update_distractor_strings(self, text, idx):
+        history_strings = self.history_distractor_strings[idx]
+        if self.size > 0:
+            while len(history_strings) >= self.size:
+                history_strings.pop(0)
+        history_strings.append(text)
+
+    def _update_distractor_raw_strings(self, text, idx):
+        history_raw_strings = self.history_distractor_raw_strings[idx]
+        if self.size > 0:
+            while len(history_raw_strings) >= self.size:
+                history_raw_strings.pop(0)
+        history_raw_strings.append(text)
+
+    def _update_distractor_vecs(self, text, idx):
+        history_vecs = self.history_distractor_vecs[idx]
+        if self.size > 0:
+            while len(history_vecs) >= self.size:
+                history_vecs.pop(0)
+        history_vecs.append(self.parse(text))
+
+    def _update_token_type_ids(self, text, idx):
+        pass
+
+    def add_reply_to_distractors(self, model_reply):
+
+        # Update model's response to the history
+        if model_reply is not None:
+            for idx in range(self.world_cardinality):
+                self._update_distractor_raw_strings(model_reply, idx)
+                # this is causing the repetition of p2 token.
+                # need to do this only once. not every loop
+                if self.add_person_tokens and idx == 0:
+                    model_reply = self._add_person_tokens(model_reply, self.p2_token)
+                self._update_distractor_strings(model_reply, idx)
+                self._update_distractor_vecs(model_reply, idx)
+
+    # def update_history(self, obs, add_next=None):
+    def update_history(self, obs, temp_history=None):
+        """
+        Update the history with the given observation.
+        :param add_next:
+            string to append to history prior to updating it with the
+            observation
+        """
+        # super().update_history(obs, add_next)
+        super().update_history(obs, temp_history=temp_history)
+
+        # Update previous turn's my response
+        # if add_next is not None:
+            # for idx in range(self.world_cardinality):
+                # self._update_distractor_raw_strings(add_next, idx)
+                # # this is causing the repetition of p2 token.
+                # # need to do this only once. not every loop
+                # if self.add_person_tokens and idx == 0:
+                    # add_next = self._add_person_tokens(add_next, self.p2_token)
+                # self._update_distractor_strings(add_next, idx)
+                # self._update_distractor_vecs(add_next, idx)
+
+        # Update current turn's opponent's response
+        if 'distractor_text' in obs:
+            assert len(obs['distractor_text']) == self.world_cardinality, \
+                f"Numer of distractor_text must be eqaul to world_cardinality. ({len(obs['distractor_text'])} vs {self.world_cardinality})"
+            for idx, distractor_text in enumerate(obs['distractor_text']):
+                if self.split_on_newln:
+                    next_texts = distractor_text.split('\n')
+                else:
+                    next_texts = [distractor_text]
+                for text in next_texts:
+                    self._update_distractor_raw_strings(text, idx)
+                    if self.add_person_tokens:
+                        text = self._add_person_tokens(
+                            distractor_text, self.p1_token, self.add_p1_after_newln
+                        )
+                    self._update_distractor_strings(text, idx)
+                    self._update_distractor_vecs(text, idx)
+
+    def get_history_distractor_str(self):
+        """Return the list of string version of the distractor histories."""
+        if len(self.history_distractor_strings[0]) > 0:
+            return [
+                self.delimiter.join(history_strings)
+                for history_strings in self.history_distractor_strings
+            ]
+        return None
+
+    def get_history_distractor_vec(self):
+        """Return a vectorized version of the distractor histories."""
+        if len(self.history_distractor_vecs[0]) == 0:
+            return None
+
+        histories = []
+        for idx in range(self.world_cardinality):
+            history_vecs = self.history_distractor_vecs[idx]
+
+            # if self.vec_type == 'deque':
+                # history = deque(maxlen=self.max_len)
+                # for vec in history_vecs[:-1]:
+                    # history.extend(vec)
+                    # history.extend(self.delimiter_tok)
+                # history.extend(history_vecs[-1])
+            # else:
+            # vec type is a list
+            history = []
+            for vec in history_vecs[:-1]:
+                history += vec
+                history += self.delimiter_tok
+            history += history_vecs[-1]
+
+            histories.append(history)
+        return histories
+
+    def get_token_type_ids(self):
+        """
+        Return a vectorized version of the token_type_ids and
+        distractor_token_type_ids
+        """
+        pass
+
+
+class ContextConsciousHistory(History):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        opt = args[0]
+        if opt['eval_type'] == 'convai2':
+            self.add_person_tokens = True
+        elif opt['eval_type'] == 'dnli':
+            self.add_person_tokens = False
+        else:
+            raise ValueError
+
+        self.world_cardinality = opt.get('world_cardinality', 5)
+        self.history_distractor_strings = [[] for _ in range(self.world_cardinality)]
+        self.history_distractor_raw_strings = [[] for _ in range(self.world_cardinality)]
+        self.history_distractor_vecs = [[] for _ in range(self.world_cardinality)]
+        # Will be used for TransferTransfo
+        self.history_token_type_ids = []
+        self.history_distractor_token_type_ids = [[] for _ in range(self.world_cardinality)]
+        self.eval_type = opt.get('eval_type')
+
+    def reset(self):
+        """Clear the history"""
+        super().reset()
+        self.history_distractor_strings = [[] for _ in range(self.world_cardinality)]
+        self.history_distractor_raw_strings = [[] for _ in range(self.world_cardinality)]
+        self.history_distractor_vecs = [[] for _ in range(self.world_cardinality)]
+        self.history_token_type_ids = []
+        self.history_distractor_token_type_ids = [[] for _ in range(self.world_cardinality)]
+
+    def _update_distractor_strings(self, text, idx):
+        history_strings = self.history_distractor_strings[idx]
+        if self.size > 0:
+            while len(history_strings) >= self.size:
+                history_strings.pop(0)
+        history_strings.append(text)
+
+    def _update_distractor_raw_strings(self, text, idx):
+        history_raw_strings = self.history_distractor_raw_strings[idx]
+        if self.size > 0:
+            while len(history_raw_strings) >= self.size:
+                history_raw_strings.pop(0)
+        history_raw_strings.append(text)
+
+    def _update_distractor_vecs(self, text, idx):
+        history_vecs = self.history_distractor_vecs[idx]
+        if self.size > 0:
+            while len(history_vecs) >= self.size:
+                history_vecs.pop(0)
+        history_vecs.append(self.parse(text))
+
+    def _update_token_type_ids(self, text, idx):
+        pass
+
+    def add_reply_to_distractors(self, model_reply, obs=None):
+
+        # Update model's response along with distractor responses to the history
+        if model_reply is not None and 'distractor_text' in obs:
+            distractor_responses = obs['distractor_text']
+            assert len(obs['distractor_text']) == self.world_cardinality
+
+            for idx in range(self.world_cardinality):
+                self._update_distractor_raw_strings(distractor_responses[idx], idx)
+                if self.add_person_tokens:
+                    distractor_responses[idx] = self._add_person_tokens(distractor_responses[idx], self.p2_token)
+                self._update_distractor_strings(distractor_responses[idx], idx)
+                self._update_distractor_vecs(distractor_responses[idx], idx)
+
+    # def update_history(self, obs, add_next=None):
+    def update_history(self, obs, temp_history=None):
+        """
+        Update the history with the given observation.
+        :param add_next:
+            string to append to history prior to updating it with the
+            observation
+        """
+        super().update_history(obs, temp_history=temp_history)
+
+        # Update current turn's opponent's response
+        if self.eval_type == 'convai2':
+            if 'text' in obs:
+                for idx in range(self.world_cardinality):
+                    if self.split_on_newln:
+                        next_texts = obs['text'].split('\n')
+                    else:
+                        next_texts = [obs['text']]
+                    for text in next_texts:
+                        self._update_distractor_raw_strings(text, idx)
+                        if self.add_person_tokens:
+                            text = self._add_person_tokens(
+                                obs['text'], self.p1_token, self.add_p1_after_newln
+                            )
+                        self._update_distractor_strings(text, idx)
+                        self._update_distractor_vecs(text, idx)
+        else:
+            if 'distractor_text' in obs:
+                distractor_texts = obs['distractor_text']
+                for idx, distractor in enumerate(distractor_texts):
+                    self._update_distractor_raw_strings(distractor, idx)
+                    self._update_distractor_strings(distractor, idx)
+                    self._update_distractor_vecs(distractor, idx)
+
+    def get_history_distractor_str(self):
+        """Return the list of string version of the distractor histories."""
+        if len(self.history_distractor_strings[0]) > 0:
+            return [
+                self.delimiter.join(history_strings)
+                for history_strings in self.history_distractor_strings
+            ]
+        return None
+
+    def get_history_distractor_vec(self):
+        """Return a vectorized version of the distractor histories."""
+        if len(self.history_distractor_vecs[0]) == 0:
+            return None
+
+        histories = []
+        for idx in range(self.world_cardinality):
+            history_vecs = self.history_distractor_vecs[idx]
+
+            # if self.vec_type == 'deque':
+                # history = deque(maxlen=self.max_len)
+                # for vec in history_vecs[:-1]:
+                    # history.extend(vec)
+                    # history.extend(self.delimiter_tok)
+                # history.extend(history_vecs[-1])
+            # else:
+            # vec type is a list
+            history = []
+            for vec in history_vecs[:-1]:
+                history += vec
+                history += self.delimiter_tok
+            history += history_vecs[-1]
+
+            histories.append(history)
+        return histories
+
+    def get_token_type_ids(self):
+        """
+        Return a vectorized version of the token_type_ids and
+        distractor_token_type_ids
+        """
+        pass
diff --git a/agents/modules.py b/agents/modules.py
new file mode 100644
index 0000000..60cf07e
--- /dev/null
+++ b/agents/modules.py
@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+# Copyright (c) Facebook, Inc. and its affiliates.
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Implements NN code for transformers.
+
+Original paper: https://arxiv.org/abs/1706.03762. (Vaswani, 2017). The
+`Annotated Transformer` (Rush, 2018) is an excellent reading guide which explains
+much of the mechanics of the Transformer model
+(http://nlp.seas.harvard.edu/2018/04/03/attention.html).
+
+This module also supports special segments (ala BERT;
+https://arxiv.org/abs/1810.04805), and a few different variations seen in the
+literature (BERT and XLM; https://arxiv.org/abs/1901.07291).
+"""
+
+import math
+from typing import Dict, Tuple, Optional
+
+import numpy as np
+import torch
+import torch.cuda
+import torch.nn as nn
+import torch.nn.functional as F
+
+from parlai.core.torch_generator_agent import TorchGeneratorModel
+from parlai.agents.transformer.modules import TransformerGeneratorModel
+
+
+class SelfConsciousTransformerModel(TransformerGeneratorModel):
+    """
+    Implements a full transformer generator model, with pragmatic self-consciousness.
+    """
+
+    def __init__(self, opt, dictionary):
+        super().__init__(opt, dictionary)
+
+        self.alpha = 0.0 if opt['conscious_target'] == 'none' else opt['alpha']
+        self.beta = opt['beta']
+        self.world_cardinality = opt['world_cardinality']
+        self.worldprior = opt['worldprior']
+        self.target_persona = 0
+        self.fp16 = opt['fp16']
+
+    def _initialize_worldpriors(self, bsz, seqlen):
+        """
+        initialize the world prior with a uniform distribution
+        """
+        cardinality = self.world_cardinality
+        torch_dtype=torch.half if self.fp16 else torch.float
+        ones = torch.ones(1, seqlen, cardinality, dtype=torch_dtype, requires_grad=False).cuda()
+        uniform_world_prior = torch.log(ones / cardinality)
+        world_priors = uniform_world_prior.repeat(bsz, 1, 1).detach()
+
+        return world_priors
+
+    def _pragmatic_reasoning(self, s0_t, worldprior):
+        """
+        run pragmatic reasoning with the base speaker and its imaginary listener
+        """
+
+        vocab_size = self.embeddings.num_embeddings
+
+        # log-scale
+        log_score = nn.functional.log_softmax(s0_t, dim=2)
+        log_score = log_score.squeeze()  # (bpsz, vocab)
+
+        # (bsz, world_cardinality, vocab)
+        log_score = log_score.view(-1, self.world_cardinality, vocab_size)
+
+        # S_0 for L_1
+        _literal_speaker = log_score.clone()
+        _literal_speaker, _literal_s_next_token_idxs = torch.max(_literal_speaker, dim=-1, keepdim=True)
+
+        # S_0 for the actual given persona (bsz, vocab)
+        speaker_prior = log_score.select(1, self.target_persona)  # target persona is always index 0
+
+        # S_0 for L_0
+        # (bsz, vocab, world_cardinality)
+        log_score = log_score.transpose(dim0=1, dim1=2).contiguous()
+        log_score = log_score * self.beta
+
+        # L_0 \propto S_0 * p(i)
+        # worldprior should be broadcasted to all the tokens
+        # (bsz, vocab, world_cardinality)
+        listener_posterior = (log_score + worldprior) - torch.logsumexp(log_score + worldprior, 2, keepdim=True)
+
+        # (bsz, vocab)
+        listener_score = listener_posterior.select(2, self.target_persona)  # target persona is always index 0
+        listener_score = listener_score * self.alpha
+
+        speaker_posterior = (listener_score + speaker_prior) - torch.logsumexp(listener_score + speaker_prior, 1, keepdim=True)
+
+        # need to unsqueeze in the dimension 1
+        speaker_posterior = speaker_posterior.unsqueeze(1)  # (bsz, 1, vocab)
+
+        # L_0 for L_1
+        _literal_listener = listener_posterior.transpose(dim0=1, dim1=2).contiguous()
+        _literal_listener = torch.gather(_literal_listener, -1, _literal_s_next_token_idxs)
+
+        pragmatic_listener = (_literal_speaker + _literal_listener) - torch.logsumexp(_literal_speaker + _literal_listener, 1, keepdim=True)
+        pragmatic_listener = pragmatic_listener.squeeze()
+
+        return speaker_posterior, listener_posterior, pragmatic_listener
+
+    def selfconscious_decode(self, encoder_states, maxlen):
+        """
+        greedy decoding with pragmatic self-consciousness
+        """
+        bpsz = encoder_states[0].size(0)
+        bsz = bpsz // self.world_cardinality
+
+        inputs_t = self.START.detach().expand(bpsz, 1)
+        worldpriors = self._initialize_worldpriors(bsz, maxlen).detach()
+
+        s1_scores = []
+        incr_state = None
+
+        for t in range(maxlen):
+            worldprior_t = worldpriors.select(1, t).unsqueeze(1)
+
+            latent, incr_state = self.decoder(inputs_t, encoder_states, incr_state)
+            _logits = self.output(latent)
+            # only get the last timestep's logit
+            s0_t = _logits.select(dim=1, index=-1).unsqueeze(1)  # logits shape: (bpsz, 1, vocab)
+
+            # s1_t: (bsz, 1, vocab)
+            # listener_posterior: (bsz, vocab, world_cardinality)
+            s1_t, l0_t, l1_t = self._pragmatic_reasoning(s0_t, worldprior_t)
+            s1_scores.append(s1_t)
+
+            next_token = s1_t.max(2)[1].clone().detach()  # next input is current predicted output idx
+
+            idx_for_tile = torch.arange(bsz).repeat(self.world_cardinality, 1).transpose(0, 1).reshape(-1).cuda()
+            inputs_next_t = torch.index_select(next_token, 0, idx_for_tile)
+            next_token = next_token.unsqueeze(2)
+            tiled_next_token = next_token.repeat(1, 1, self.world_cardinality)
+
+            if self.worldprior != 'uniform':
+                # (bsz, vocab, world_cardinality) -> (bsz, 1, world_cardinality)
+                updated_world_prior = torch.gather(l0_t, 1, tiled_next_token).clone().detach()
+                if t + 1 < maxlen:
+                    if self.worldprior == 'L0':
+                        worldpriors[:, t + 1, :] = updated_world_prior.squeeze()
+                    elif self.worldprior == 'L1':
+                        worldpriors[:, t + 1, :] = l1_t
+                    else:
+                        raise NotImplementedError
+
+            # update inputs for next timestep
+            inputs_t = torch.cat((inputs_t, inputs_next_t), dim=1)
+
+        s1_scores = torch.cat(s1_scores, dim=1)  # (bsz, seqlen, vocab)
+        _, preds = s1_scores.max(dim=2)
+
+        return preds, s1_scores
+
+    def selfconscious_decode_forced(self, encoder_states, ys):
+        """
+        faster teacher-forced decoding with pragmatic self-consciousness
+        """
+
+        bsz = ys.size(0)
+        seqlen = ys.size(1)
+        self.longest_label = max(self.longest_label, seqlen)
+        emb_size = self.encoder.embedding_size
+        enc_outputs = encoder_states[0].view(bsz * self.world_cardinality, -1, emb_size).contiguous()
+        enc_outputs_mask = encoder_states[1].view(bsz * self.world_cardinality, -1).contiguous()
+        enc_states = (enc_outputs, enc_outputs_mask)
+        bpsz = enc_outputs.size(0)
+
+        # tile ys as much as the world_cardinality
+        idx_for_tile = torch.arange(bsz).repeat(self.world_cardinality, 1).transpose(0, 1).reshape(-1).cuda()
+        tiled_ys = torch.index_select(ys, 0, idx_for_tile)
+
+        inputs = tiled_ys.narrow(1, 0, seqlen - 1)
+        inputs = torch.cat([self.START.detach().expand(bpsz, 1), inputs], 1)
+        worldpriors = self._initialize_worldpriors(bsz, seqlen).detach()
+        s1_scores = []
+
+        latent, _ = self.decoder(inputs, enc_states)
+        base_speaker = self.output(latent)
+
+        for t in range(seqlen):
+
+            s0_t = base_speaker.select(dim=1, index=t).unsqueeze(1)  # s0_t: (bpsz, 1, vocab)
+            worldprior_t = worldpriors.select(dim=1, index=t).unsqueeze(1)
+
+            # s1_t: (bsz, 1, vocab)
+            # l0_t: (bsz, vocab, world_cardinality)
+            s1_t, l0_t, l1_t = self._pragmatic_reasoning(s0_t, worldprior_t)
+            s1_scores.append(s1_t)
+
+            # Update world_prior with listener posterior
+            if t + 1 < seqlen:
+                next_tokens = inputs.select(1, t + 1).view(-1, 1)  # (bpsz, 1): the next tokens for each bpsz instance
+                next_tokens = next_tokens.unsqueeze(2)
+                # [0, 1*world_cardinality, 2*wc, 3*wc, ..., bpsz - 1wc] -> to get the ground-truth personas
+                target_persona_idxs = torch.arange(bsz).cuda() * (self.world_cardinality)
+
+                # we only need the next token of the ground-truth persona
+                next_token = torch.index_select(next_tokens, 0, target_persona_idxs)  # (bsz, 1, 1)
+                tiled_next_token = next_token.repeat(1, 1, self.world_cardinality)  # (bsz, 1, world_cardinality)
+
+                if self.worldprior != 'uniform':
+                    # (bsz, vocab, world_cardinality) -> (bsz, 1, world_cardinality)
+                    updated_world_prior = torch.gather(l0_t, 1, tiled_next_token).clone().detach()
+                    if self.worldprior == 'L0':
+                        worldpriors[:, t + 1, :] = updated_world_prior.squeeze()
+                    elif self.worldprior == 'L1':
+                        worldpriors[:, t + 1, :] = l1_t
+                    else:
+                        raise NotImplementedError
+
+        s1_scores = torch.cat(s1_scores, 1)  # (bsz, seqlen, vocab)
+        _, preds = s1_scores.max(dim=2)
+
+        return s1_scores, preds
diff --git a/agents/selfconscious_blender.py b/agents/selfconscious_blender.py
new file mode 100644
index 0000000..8b938d6
--- /dev/null
+++ b/agents/selfconscious_blender.py
@@ -0,0 +1,543 @@
+import os
+import random
+import numpy as np
+from itertools import chain
+
+import torch
+import torch.nn.functional as F
+
+from parlai.core.opt import Opt
+from parlai.core.message import Message
+from parlai.core.torch_agent import Batch, Output
+from parlai.core.torch_generator_agent import PPLMetric
+from parlai.core.metrics import SumMetric, AverageMetric
+from parlai.utils.torch import padded_tensor
+from parlai.utils.misc import warn_once
+from parlai.agents.transformer.transformer import (
+    TransformerGeneratorAgent,
+    add_common_cmdline_args
+)
+
+from agents.modules import SelfConsciousTransformerModel
+from modules.dnli_bert import DnliBert
+from agents.history import SelfConsciousHistory, ContextConsciousHistory
+
+
+def list_to_matrix(l, n):
+    return [l[i:i+n] for i in range(0, len(l), n)]
+
+
+class SelfConsciousBlenderAgent(TransformerGeneratorAgent):
+    """
+    Implementation of the Self-Conscious Blender Agent.
+    """
+
+    @classmethod
+    def add_cmdline_args(cls, argparser):
+        """
+        Add command-line arguments specifically for this agent.
+        """
+        agent = argparser.add_argument_group('Self-conscious Blender Arguments')
+        agent.add_argument(
+            '--conscious-target',
+            type=str,
+            choices=['none', 'self', 'context'],
+            default='self',
+            help='The target which the agent will be concerned about.',
+        )
+        agent.add_argument(
+            '-a',
+            '--alpha',
+            type=float,
+            default=0,
+            help='Rationality parameter for S_1(speaker_1)',
+        )
+        agent.add_argument(
+            '-b',
+            '--beta',
+            type=float,
+            default=1,
+            help='Rationality parameter for Listener',
+        )
+        agent.add_argument(
+            '--world_cardinality',
+            type=int,
+            default=3,
+            help='Cardinality of world I:= Number of persona to use RSA model (including GT)',
+        )
+        agent.add_argument(
+            '--worldprior',
+            type=str,
+            choices=['uniform', 'L0', 'L1'],
+            default='L0',
+            help='Update world prior with a `uniform` distribution or `L0` or `L1`.',
+        )
+        agent.add_argument(
+            '--use_dnli',
+            type=bool,
+            default=True,
+            help='Whether to use dnli model to measure consistency-score in Convai2 or rerank candidates in DNLI'
+        )
+        add_common_cmdline_args(agent)
+        cls.dictionary_class().add_cmdline_args(argparser)
+
+        super(SelfConsciousBlenderAgent, cls).add_cmdline_args(argparser)
+        return agent
+
+    def __init__(self, opt: Opt, shared=None):
+
+        self.task = str.lower(opt['task'].split(':')[-1])
+
+        if opt['conscious_target'] != 'none':
+            assert opt['conscious_target'] in self.task, \
+                "conscious_target (`" + opt['conscious_target'] + "`) must match task type (`" + self.task + "`)"
+
+        SEED = 46
+        random.seed(SEED)
+        np.random.seed(SEED)
+        os.environ['PYTHONHASHSEED'] = str(SEED)
+        torch.random.manual_seed(SEED)
+        torch.cuda.manual_seed(SEED)
+        torch.manual_seed(SEED)
+        torch.cuda.manual_seed_all(SEED)
+        torch.backends.cudnn.deterministic = True
+        torch.backends.cudnn.benchmark = False
+
+        # For public self-consciousness
+        self.target_persona = opt.get('target_persona', 0)
+        self.conscious_target = opt.get('conscious_target', 'self')
+        self.world_cardinality = opt.get('world_cardinality', 3)
+        self.alpha = 0.0 if self.conscious_target == 'none' else opt.get('alpha', 2.0)
+        self.beta = opt.get('beta', 1.0)
+        self.worldprior = opt.get('worldprior', 'L0')
+
+        self.eval_type = opt.get('eval_type')
+        # self.rank_candidates = opt.get('rank_candidates', True)
+        self.multigpu = (
+            opt.get('multigpu', False) and self.use_cuda and (opt.get('batchsize') > 1)
+        )
+
+        init_model, is_finetune = self._get_init_model(opt, shared)
+        super().__init__(opt, shared)
+
+        # Implementation is based on beam_size 1
+        self.beam_size = 1
+        warn_once(f'This implementation is assumed to have beam-size 1.')
+
+        # Always rank candidates for the ranking metrics
+        self.rank_candidates = True
+        warn_once(f'rank-candidates is always True for ranking metrics.')
+
+        if opt['use_dnli']:
+            if not shared:
+                self.dnli_model = DnliBert(opt, use_cuda=self.use_cuda)
+            else:
+                self.dnli_model = shared['dnli_model']
+        else:
+            self.dnli_model = None
+
+        self.id = 'SelfConsciousBlender'
+
+        self.reset()
+
+    def build_model(self, states=None):
+        """
+        Build and return model.
+        """
+        model = SelfConsciousTransformerModel(self.opt, self.dict)
+        if self.opt['embedding_type'] != 'random':
+            self._copy_embeddings(
+                model.encoder.embeddings.weight, self.opt['embedding_type']
+            )
+        return model
+
+    def history_class(self):
+        return ContextConsciousHistory if 'context' in self.task else SelfConsciousHistory
+
+    def _model_input(self, batch):
+        """
+        Override from TorchGeneratorAgent
+        passes (batch.text_vec,) to TorchGeneratorAgent._encoder_input()
+        TGA._encoder_input() directly passes the result of TGA._model_input()
+        change batch.text_vec to batch.distractor_text_vec for pragmatic decoding
+        """
+        bsz = batch.text_vec.size(0)
+        distractor_text_vec = batch.distractor_text_vec.view(bsz * self.world_cardinality, -1).contiguous()
+        return (distractor_text_vec,)
+
+    def selfconscious_greedy_generate(self, batch, maxlen):
+        """
+        Greedy decoding with Public Self-Consciousness
+        """
+
+        bsz = batch.text_vec.size(0)
+        world_cardinality = self.world_cardinality
+        embedding_size = self.opt.get('embedding_size')
+        encoder_states = self.model.encoder(*self._encoder_input(batch))
+
+        preds, scores = self.model.selfconscious_decode(encoder_states, maxlen)
+
+        return preds, scores
+
+    def rank(self, batch):
+        """
+        Rank candidates by PPL score
+        """
+        bsz = batch.text_vec.size(0)
+        world_cardinality = self.world_cardinality
+        embedding_size = self.opt.get('embedding_size')
+        ranked_candidates = []
+        cand_ordering = []
+        encoder_states = self.model.encoder(*self._encoder_input(batch))
+        batch_dim = encoder_states[0].size(0)  # two possibilities: batchsize or batchsize * world_cardinality
+
+        if bsz != batch_dim:
+            enc_output = encoder_states[0].view(bsz, world_cardinality, -1, embedding_size).contiguous()
+            enc_output_mask = encoder_states[1].view(bsz, world_cardinality, -1).contiguous()
+            encoder_states = (enc_output, enc_output_mask)
+
+        for i in range(bsz):
+            num_cands = len(batch.candidate_vecs[i])
+            cands, _ = self._pad_tensor(batch.candidate_vecs[i])
+            # get [i]th state from encoder_states #num_cands time.
+            # because we need same encoder_states for each candidate
+            enc = self.model.reorder_encoder_states(encoder_states, [i] * num_cands)
+
+            # enc: (num_cands, world_cardinality, seqlen, emb_size)
+            # scores: (num_cands, max_len, vocab_size)
+            scores, _ = self.model.selfconscious_decode_forced(enc, cands)
+
+            cand_losses = F.cross_entropy(
+                scores.view(num_cands * cands.size(1), -1),
+                cands.view(-1),
+                reduction='none',
+            ).view(num_cands, cands.size(1))
+            # now cand_losses is cands x seqlen size, but we still need to
+            # check padding and such
+            mask = (cands != self.NULL_IDX)
+            mask = mask.half() if self.fp16 else mask.float()
+            cand_scores = (-cand_losses * mask).sum(dim=1) / (mask.sum(dim=1) + 1e-9)
+
+            if self.dnli_model is not None and self.eval_type == 'dnli':
+                cand_scores = torch.unsqueeze(cand_scores, 0)
+                cand_scores = self.dnli_model.rerank_candidates([batch.observations[i]], cand_scores)
+                cand_scores = torch.squeeze(cand_scores)
+
+            _, ordering = cand_scores.sort(descending=True)
+            ranked_candidates.append([batch.candidates[i][o] for o in ordering])
+            cand_ordering.append(ordering)
+
+        return ranked_candidates, cand_ordering
+
+    def compute_loss(self, batch, return_output=False):
+        """
+        Override from TorchGeneratorAgent
+        Compute and return the loss for the given batch.
+
+        Easily overridable for customized loss functions.
+
+        If return_output is True, the full output from the call to self.model()
+        is also returned, via a (loss, model_output) pair.
+        """
+        if batch.label_vec is None:
+            raise ValueError('Cannot compute loss without a label.')
+
+        bsz = batch.text_vec.size(0)
+        world_cardinality = self.world_cardinality
+        embedding_size = self.opt.get('embedding_size')
+        encoder_states = self.model.encoder(*self._encoder_input(batch))
+
+        enc_output = encoder_states[0].view(bsz, world_cardinality, -1, embedding_size).contiguous()
+        enc_output_mask = encoder_states[1].view(bsz, world_cardinality, -1).contiguous()
+        encoder_states = (enc_output, enc_output_mask)
+
+        scores, preds = self.model.selfconscious_decode_forced(encoder_states, batch.label_vec)
+        model_output = (scores, preds, encoder_states)
+
+        score_view = scores.view(-1, scores.size(-1))
+        loss = self.criterion(score_view, batch.label_vec.view(-1))
+        loss = loss.view(scores.shape[:-1]).sum(dim=1)
+        # save loss to metrics
+        notnull = batch.label_vec.ne(self.NULL_IDX)
+        target_tokens = notnull.long().sum(dim=-1)
+        correct = ((batch.label_vec == preds) * notnull).sum(dim=-1)
+
+        self.record_local_metric('loss', AverageMetric.many(loss, target_tokens))
+        self.record_local_metric('ppl', PPLMetric.many(loss, target_tokens))
+        self.record_local_metric(
+            'token_acc', AverageMetric.many(correct, target_tokens)
+        )
+
+        # actually do backwards loss
+        loss = loss.sum()
+        loss /= target_tokens.sum()  # average loss per token
+
+        if return_output:
+            return (loss, model_output)
+        else:
+            return loss
+
+    def _eval_convai2_step(self, batch):
+        """Evaluate a single batch of examples."""
+
+        assert self.alpha >= 0
+        if batch.distractor_text_vec is None:
+            return None
+
+        self.model.eval()
+
+        # 1. Generation
+        assert self.beam_size is 1
+        maxlen = self.label_truncate or 256
+        if not self.skip_generation:
+            preds, scores = self.selfconscious_greedy_generate(batch, maxlen)
+        else:
+            preds = None
+
+        # 2. Compute PPL with teacher-forced generation
+        # calculate loss on targets with teacher forcing
+        loss, model_output = self.compute_loss(batch, return_output=True)
+        token_losses = self._construct_token_losses(
+            batch.label_vec, model_output
+        )
+
+        # 3. Rank candidates by computing PPL for each candidates
+        if self.rank_candidates:
+            ranked_cands, ordering = self.rank(batch)
+        else:
+            ranked_cands = None
+
+        # 4. Compute consistency score
+        additional_metrics = [{'c_score': 0.0} for _ in range(len(batch.observations))]
+        output_texts = [self._v2t(p) for p in preds] if preds is not None else None
+        if not self.skip_generation:
+            if self.opt['use_dnli']:
+                c_scores = []
+                for text, obs in zip(output_texts, batch.observations):
+                    if 'context' in self.task:
+                        c_score = self.dnli_model.compute_consistency_scores(text, obs['my_context'])
+                    else:
+                        persona_strings = obs['my_persona'].split('\n')
+                        c_score = self.dnli_model.compute_consistency_scores(text, persona_strings)
+
+                    c_scores.append(c_score)
+
+                for idx, c_score in enumerate(c_scores):
+                    additional_metrics[idx]['c_score'] = c_score
+
+        return Output(output_texts, ranked_cands, token_losses=token_losses, metrics=additional_metrics)
+
+    def _eval_dnli_step(self, batch):
+        """Evaluate a single batch of examples."""
+
+        assert self.alpha >= 0
+
+        self.model.eval()
+        ranked_cands, ordering = self.rank(batch)
+
+        bsz = len(ranked_cands)
+        dnli_metrics = []
+        for batch_idx in range(bsz):
+            dnli_score = {'contradict@1': 0, 'entail@1': 0, 'neutral@1': 0}
+            top1_idx = ordering[batch_idx][0].item()
+            if top1_idx == 0:
+                pass
+                # dnli_metrics['dnli_hit@1'] += 1
+            elif top1_idx > 0 and top1_idx < 11:
+                dnli_score['contradict@1'] += 1
+            elif top1_idx >= 11 and top1_idx < 21:
+                dnli_score['entail@1'] += 1
+            else:
+                dnli_score['neutral@1'] += 1
+            dnli_metrics.append(dnli_score)
+
+        return Output(text_candidates=ranked_cands, metrics=dnli_metrics)
+
+    def eval_step(self, batch):
+
+        if self.opt['eval_type'] == 'convai2':
+            return self._eval_convai2_step(batch)
+        elif self.opt['eval_type'] == 'dnli':
+            return self._eval_dnli_step(batch)
+        else:
+            raise NotImplementedError
+
+    def self_observe(self, self_message: Message):
+        """
+        Override from TorchAgent
+        Update the model's reply or label to the history of distractor-fields in History class
+        """
+        episode_done = self.observation['episode_done']
+        use_reply = self.opt.get('use_reply', 'label')
+
+        # actually ingest the label
+        if use_reply == 'none':
+            # we're not including our own responses anyway.
+            reply = None
+        elif use_reply == 'label':
+            # first look for the true label
+            label_key = (
+                'labels'
+                if 'labels' in self.observation
+                else 'eval_labels'
+                if 'eval_labels' in self.observation
+                else None
+            )
+            if label_key is not None:
+                lbls = self.observation[label_key]
+                reply = lbls[0] if len(lbls) == 1 else self.random.choice(lbls)
+        else:
+            # otherwise, we use the last output the model generated
+            if self_message is not None:
+                reply = self_message['text']
+            else:
+                reply = None
+
+        super().self_observe(self_message)
+
+        if episode_done:
+            return None
+
+        if reply is not None:
+            if 'context' in self.task:
+                self.history.add_reply_to_distractors(reply, self.observation)
+            else:
+                self.history.add_reply_to_distractors(reply)
+
+        return reply
+
+    def _ordered_cand_scores_to_cand_text(self, ordered_cand_preds, cand_inds, candidates):
+        cand_replies = [None] * len(candidates)
+
+        for idx, order in enumerate(ordered_cand_preds):  # batch_idx, sorted cand_idx
+            batch_idx = cand_inds[idx]
+            # get the original sentences from candidates by order
+            cand_replies[batch_idx] = [candidates[batch_idx][i] for i in order]
+
+        return cand_replies
+
+    def _build_candidates_tensor(self, batch):
+        if not batch.candidates:
+            return None, None
+
+        cand_inds = [i for i in range(len(batch.candidates)) if batch.candidates[i]]
+        cands = [batch.candidate_vecs[i] for i in cand_inds]
+
+        # get the length of the longest candidate in the batch
+        max_cand_len = max(
+            [max([cand.size(0) for cand in cands_i]) for cands_i in cands]
+        )
+
+        for i, c in enumerate(cands):  #  make each instance in batch.cands to a padded tensor
+            cands[i] = padded_tensor(c, use_cuda=self.use_cuda,
+                                     max_len=max_cand_len,
+                                     fp16friendly=self.fp16)[0].unsqueeze(0)
+
+        # (batchsize, num_cands, max_len + a) +a due to fp16
+        cands = torch.cat(cands, 0)
+
+        return cands, cand_inds
+
+    def vectorize(self, obs, history, **kwargs):
+        """
+        Override from TorchAgent
+        Vectorize the texts in observation
+        """
+        super().vectorize(obs, history, **kwargs)  # candidate vecs are vectorized here
+        if not self.is_training:
+            self._set_distractor_text_vec(obs, history, kwargs['text_truncate'])
+        return obs
+
+    def _set_text_vec(self, obs, history, truncate):
+        """
+        Override from TorchAgent for DNLI evaluation
+        This will be called in super().vectorize()
+        """
+        # WARNING: self.is_training is always False in here
+        is_training = False if 'eval_labels' in obs else True
+
+        if is_training or self.opt['eval_type'] == 'convai2':
+            return super()._set_text_vec(obs, history, truncate)
+        elif self.opt['eval_type'] == 'dnli':
+            if 'text' not in obs:
+                return obs
+
+            # Vectorize the text
+            if 'text_vec' not in obs:
+                obs['full_text'] = obs['text']
+                vec = self.dict.txt2vec(obs['full_text'])
+                obs['text_vec'] = vec
+
+            # check truncation
+            if obs.get('text_vec') is not None:
+                truncated_vec = self._check_truncate(obs['text_vec'], truncate, True)
+                obs.force_set('text_vec', torch.LongTensor(truncated_vec))
+            return obs
+        else:
+            raise NotImplementedError
+
+    def _set_distractor_text_vec(self, obs, history, truncate):
+        """
+        Set 'distractor_text' and 'distractor_text_vec' field in the observation
+        """
+        if 'distractor_text' not in obs:
+            return obs
+
+        if 'distractor_text_vec' not in obs:
+            # distractor_text is in the SelfConsciousHistory class
+            distractor_string = history.get_history_distractor_str()
+
+            if distractor_string is None:
+                return obs
+
+            # Set 'full_distractor_text'
+            obs['full_distractor_text'] = distractor_string
+            # distractor_text_vec is also in the SelfConsciousHistory class
+            # they are already vectorized at SelfConsciousHistory.update_history()
+            if distractor_string:
+                obs['distractor_text_vec'] = history.get_history_distractor_vec()
+
+        # Check truncation
+        if obs.get('distractor_text_vec') is not None:
+            truncated_vec = [
+                torch.LongTensor(self._check_truncate(text_vec, truncate, True))
+                for text_vec in obs['distractor_text_vec']
+            ]
+            obs.force_set('distractor_text_vec', truncated_vec)
+        return obs
+
+    def batchify(self, *args, **kwargs):
+        """
+        Override from TorchAgent
+        Additionally batchify the distractor_text_vec and add it to batch
+        """
+        kwargs['sort'] = True  # need sort for pack_padded()
+        batch = super().batchify(*args, **kwargs)
+        sort = False  # we must not sort after super().batchify()
+
+        exs = batch.observations
+        d_text_vec, d_lens = None, None
+        if any('distractor_text_vec' in ex for ex in exs):
+            # Pad distractor vectors
+            _d_text_vec = [ex.get('distractor_text_vec', self.EMPTY) for ex in exs]
+            _d_text_vec_flattened = list(chain(*_d_text_vec))
+            d_text_vec, d_lens = self._pad_tensor(_d_text_vec_flattened)
+
+            # Reshape to (batch_size, world_cardinality, max_length)
+            bsz = len(exs)
+            d_text_vec = d_text_vec.view(bsz, self.world_cardinality, -1)
+            d_lens = list_to_matrix(d_lens, self.world_cardinality)
+
+        batch = Batch(
+            distractor_text_vec=d_text_vec,
+            distractor_text_lengths=d_lens,
+            **dict(batch)
+        )
+
+        return batch
+
+    def share(self):
+        shared = super().share()
+        if self.opt['use_dnli']:
+            shared['dnli_model'] = self.dnli_model
+        return shared
diff --git a/environment.yml b/environment.yml
new file mode 100644
index 0000000..a49fe08
--- /dev/null
+++ b/environment.yml
@@ -0,0 +1,30 @@
+name: pragmatic-consistency
+channels:
+  - defaults
+dependencies:
+  - cudatoolkit=10.1
+  - pytorch::pytorch=1.6.0
+  - python=3.6.8
+  - pip=20.1.1
+  - pip:
+    # ParlAI (use commit of 1st of October, 2020)
+    - git+https://github.com/facebookresearch/ParlAI.git@9cd6b6c0e70c72a24e959e4a328cb4093eb7f3de
+    - torchtext==0.7.0
+    - spacy==2.3.2
+    - pytorch-transformers==1.2.0
+    # For logging
+    - tqdm
+    - better-exceptions
+    # For linting
+    - pylint
+    - pycodestyle
+    - mypy
+    # For markdown preview
+    - grip
+    # etc
+    - ruamel.yaml
+    - more_itertools
+    - isort
+    - pudb
+    - jupyter
+    - orderedset
diff --git a/eval_dnli.py b/eval_dnli.py
new file mode 100644
index 0000000..292f96a
--- /dev/null
+++ b/eval_dnli.py
@@ -0,0 +1,21 @@
+from parlai.scripts.eval_model import eval_model
+from parlai.scripts.eval_model import setup_args as parlai_setupargs
+
+
+def setup_args():
+    parser = parlai_setupargs()
+    parser.set_defaults(
+        model_file='zoo:blender/blender_90M/model',
+        eval_type='dnli',
+        metrics='contradict@1,entail@1,neutral@1',
+        alpha=8,
+        beta=1,
+        use_dnli=False
+    )
+    return parser
+
+
+if __name__ == '__main__':
+    parser = setup_args()
+    opt = parser.parse_args()
+    eval_model(opt)
diff --git a/eval_personachat.py b/eval_personachat.py
new file mode 100644
index 0000000..698a46c
--- /dev/null
+++ b/eval_personachat.py
@@ -0,0 +1,20 @@
+from parlai.scripts.eval_model import eval_model
+from parlai.scripts.eval_model import setup_args as parlai_setupargs
+
+
+def setup_args():
+    parser = parlai_setupargs()
+    parser.set_defaults(
+        model_file='zoo:blender/blender_90M/model',
+        eval_type='convai2',
+        metrics='token_acc,ppl,loss,c_scores,f1',
+        alpha=2,
+        beta=0.5
+    )
+    return parser
+
+
+if __name__ == '__main__':
+    parser = setup_args()
+    opt = parser.parse_args()
+    eval_model(opt)
diff --git a/modules/__init__.py b/modules/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/modules/dnli_bert.py b/modules/dnli_bert.py
new file mode 100644
index 0000000..a98c79e
--- /dev/null
+++ b/modules/dnli_bert.py
@@ -0,0 +1,214 @@
+import os
+from copy import deepcopy
+
+import torch
+import torch.nn.functional as F
+import numpy as np
+from pytorch_transformers import (
+    BertForSequenceClassification,
+    BertTokenizer
+)
+from parlai.core.build_data import download_from_google_drive
+
+
+def _truncate_seq_pair(tokens_a, tokens_b, max_length):
+    """Truncates a sequence pair in place to the maximum length."""
+    # This is a simple heuristic which will always truncate the longer sequence
+    # one token at a time. This makes more sense than truncating an equal percent
+    # of tokens from each, since if one sequence is very short then each token
+    # that's truncated likely contains more information than a longer sequence.
+    while True:
+        total_length = len(tokens_a) + len(tokens_b)
+        if total_length <= max_length:
+            break
+        if len(tokens_a) > len(tokens_b):
+            tokens_a.pop()
+        else:
+            tokens_b.pop()
+
+
+class DnliBert(object):
+    def __init__(self,
+                 opt,
+                 dnli_lambda=1.0,
+                 dnli_k=10,
+                 max_seq_length=128,
+                 use_cuda=True):
+        self.opt = opt
+        self.dnli_lambda = dnli_lambda
+        self.dnli_k = dnli_k
+        self.max_seq_length = max_seq_length
+        self.use_cuda = use_cuda
+        self.mapper = {0: "contradiction",
+                       1: "entailment",
+                       2: "neutral"}
+
+        dnli_model, dnli_tokenizer = self._load_dnli_model()
+        self.dnli_model = dnli_model
+        self.dnli_tokenizer = dnli_tokenizer
+
+    def _load_dnli_model(self):
+        # Download pretrained weight
+        dnli_model_fname = os.path.join(self.opt['datapath'], 'dnli_model.bin')
+        if not os.path.exists(dnli_model_fname):
+            print(f"[ Download pretrained dnli model params to {dnli_model_fname}]")
+            download_from_google_drive(
+                '1Qawz1pMcV0aGLVYzOgpHPgG5vLSKPOJ1',
+                dnli_model_fname
+            )
+
+        # Load pretrained weight
+        print(f"[ Load pretrained dnli model from {dnli_model_fname}]")
+        model_state_dict = torch.load(dnli_model_fname)
+        dnli_model = BertForSequenceClassification.from_pretrained('bert-base-uncased', state_dict=model_state_dict, num_labels=3)
+        if self.use_cuda:
+            dnli_model.cuda()
+        dnli_tokenizer = BertTokenizer.from_pretrained('bert-base-uncased', do_lower_case=True)
+
+        return dnli_model, dnli_tokenizer
+
+    def rerank_candidates(self, observations, cand_scores):
+        sorted_cand_values, sorted_cand_indices = cand_scores.sort(1, descending=True)
+
+        for batch_idx, obs in enumerate(observations):
+            full_text = obs['full_text']
+            personas = []
+            for text in full_text.split('\n'):
+                if 'your persona:' in text:
+                    personas.append(text.replace('your persona:', ''))
+                else:
+                    break
+            candidates = obs['label_candidates']
+
+            tok_candidates = [self.dnli_tokenizer.tokenize(sent) for sent in candidates]
+            tok_personas = [self.dnli_tokenizer.tokenize(sent) for sent in personas]
+
+            dnli_scores = self._compute_dnli_scores(tok_candidates, tok_personas)
+            s_1 = sorted_cand_values[batch_idx, 0]
+            s_k = sorted_cand_values[batch_idx, self.dnli_k - 1]
+
+            _lambda = self.dnli_lambda
+            cand_scores[batch_idx] = cand_scores[batch_idx] - _lambda * (s_1 - s_k) * dnli_scores
+
+        return cand_scores
+
+    def compute_consistency_scores(self, pred, personas):
+        """
+        preds, and personas must be list of string
+        """
+        max_seq_length = self.max_seq_length
+
+        pred_tokenized = self.dnli_tokenizer.tokenize(pred)
+        personas_tokenized = [self.dnli_tokenizer.tokenize(sent.replace('your persona:', '')) for sent in personas]
+
+        all_input_ids = []
+        all_input_mask = []
+        all_segment_ids = []
+        for idx, persona_tokenized in enumerate(personas_tokenized):
+            _pred_tokenized = deepcopy(pred_tokenized)
+            _persona_tokenized = deepcopy(persona_tokenized)
+            _truncate_seq_pair(_pred_tokenized, _persona_tokenized, max_seq_length - 3)
+
+            tokens = ["[CLS]"] + _pred_tokenized + ["[SEP]"]
+            segment_ids = [0] * len(tokens)
+            tokens += _persona_tokenized + ["[SEP]"]
+            segment_ids += [1] * (len(_persona_tokenized) + 1)
+
+            input_ids = self.dnli_tokenizer.convert_tokens_to_ids(tokens)
+            input_mask = [1] * len(input_ids)
+            padding = [0] * (max_seq_length - len(input_ids))
+            input_ids += padding
+            input_mask += padding
+            segment_ids += padding
+
+            all_input_ids.append(input_ids)
+            all_input_mask.append(input_mask)
+            all_segment_ids.append(segment_ids)
+
+        # Convert inputs to tensors
+        all_input_ids = torch.tensor(all_input_ids, dtype=torch.long)
+        all_input_mask = torch.tensor(all_input_mask, dtype=torch.long)
+        all_segment_ids = torch.tensor(all_segment_ids, dtype=torch.long)
+        if self.use_cuda:
+            all_input_ids = all_input_ids.cuda()
+            all_input_mask = all_input_mask.cuda()
+            all_segment_ids = all_segment_ids.cuda()
+
+        # Inference
+        self.dnli_model.eval()
+        with torch.no_grad():
+            logits = self.dnli_model(all_input_ids, all_segment_ids, all_input_mask)
+            probs = F.softmax(logits[0], dim=1)
+
+        probs = probs.detach().cpu().numpy()
+        idx_max = np.argmax(probs, axis=1)
+        val_max = np.max(probs, axis=1)
+
+        consistency_score = 0.0
+        for pred_idx in idx_max:
+            if pred_idx == 0: # contradict
+                consistency_score -= 1.0
+            elif pred_idx == 1: # entailment
+                consistency_score += 1.0
+            elif pred_idx == 2: # neutral
+                consistency_score += 0.0
+
+        return consistency_score
+
+    def _compute_dnli_scores(self, tok_candidates, tok_personas):
+        max_seq_length = self.max_seq_length
+
+        dnli_scores = []
+        for cand_idx, tok_candidate in enumerate(tok_candidates):
+            all_input_ids = []
+            all_input_mask = []
+            all_segment_ids = []
+            for tok_persona in tok_personas:
+                # Prepare inputs
+                # [CLS] candidates [SEP] persona [SEP]
+                _tok_candidate = deepcopy(tok_candidate)
+                _tok_persona = deepcopy(tok_persona)
+                # Account for [CLS], [SEP], [SEP] with "- 3"
+                _truncate_seq_pair(_tok_candidate, _tok_persona, max_seq_length - 3)
+
+                # Make inputs
+                tokens = ["[CLS]"] + _tok_candidate + ["[SEP]"]
+                segment_ids = [0] * len(tokens)
+                tokens += _tok_persona + ["[SEP]"]
+                segment_ids += [1] * (len(_tok_persona) + 1)
+
+                input_ids = self.dnli_tokenizer.convert_tokens_to_ids(tokens)
+                input_mask = [1] * len(input_ids)
+                padding = [0] * (max_seq_length - len(input_ids))
+                input_ids += padding
+                input_mask += padding
+                segment_ids += padding
+
+                all_input_ids.append(input_ids)
+                all_input_mask.append(input_mask)
+                all_segment_ids.append(segment_ids)
+
+            # Convert inputs to tensors
+            all_input_ids = torch.tensor(all_input_ids, dtype=torch.long)
+            all_input_mask = torch.tensor(all_input_mask, dtype=torch.long)
+            all_segment_ids = torch.tensor(all_segment_ids, dtype=torch.long)
+            if self.use_cuda:
+                all_input_ids = all_input_ids.cuda()
+                all_input_mask = all_input_mask.cuda()
+                all_segment_ids = all_segment_ids.cuda()
+
+            # Inference
+            self.dnli_model.eval()
+            with torch.no_grad():
+                logits = self.dnli_model(all_input_ids, all_segment_ids, all_input_mask)
+                probs = F.softmax(logits[0], dim=1)
+
+            probs = probs.detach().cpu().numpy()
+            idx_max = np.argmax(probs, axis=1)
+            val_max = np.max(probs, axis=1)
+            dnli_score = np.max((idx_max == 0) * val_max)
+            dnli_scores.append(dnli_score)
+        dnli_scores = torch.tensor(dnli_scores, dtype=torch.float)
+        if self.use_cuda:
+            dnli_scores = dnli_scores.cuda()
+        return dnli_scores
diff --git a/tasks/__init__.py b/tasks/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tasks/build.py b/tasks/build.py
new file mode 100755
index 0000000..f40e0c9
--- /dev/null
+++ b/tasks/build.py
@@ -0,0 +1,80 @@
+#!/usr/bin/env python
+
+# Copyright (c) Facebook, Inc. and its affiliates.
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+import os
+import parlai.core.params as params
+import parlai.core.build_data as build_data
+
+
+FOLDER_NAME = 'self_conscious_dialogue'
+
+
+def build(opt):
+    dpath = os.path.join(opt['datapath'], FOLDER_NAME)
+    # version 1.0: initial release
+    version = '1.0'
+
+    # check whether data had been previously built
+    if not build_data.built(dpath, version_string=version):
+        print('[building data: ' + dpath + ']')
+
+        # make a clean directory if needed
+        if build_data.built(dpath):
+            # if an older version exists, remove those outdated files.
+            build_data.remove_dir(dpath)
+        build_data.make_dir(dpath)
+
+        #########################
+        # ConvAI2 (PersonaChat)
+        #########################
+        fname = 'data_v1.tar.gz'
+        url = 'https://parl.ai/downloads/controllable_dialogue/' + fname
+        build_data.download(url, dpath, fname)
+        build_data.untar(dpath, fname)
+
+        fname = 'convai2_fix_723.tgz'
+        url = 'http://parl.ai/downloads/convai2/' + fname
+        build_data.download(url, dpath, fname)
+        build_data.untar(dpath, fname)
+
+        #########################
+        # Dialogue NLI
+        #########################
+        fname = 'dialogue_nli.zip'
+        gd_id = '1WtbXCv3vPB5ql6w0FVDmAEMmWadbrCuG'
+        build_data.download_from_google_drive(gd_id, os.path.join(dpath, fname))
+        build_data.untar(dpath, fname)
+
+        fname = 'dialogue_nli_evaluation.zip'
+        gd_id = '1sllq30KMJzEVQ4C0-a9ShSLSPIZc3iMi'
+        build_data.download_from_google_drive(gd_id, os.path.join(dpath, fname))
+        build_data.untar(dpath, fname)
+
+        #########################
+        # Distractor personas
+        #########################
+        fname = 'train_sorted_50_personas.json'
+        gd_id = '1SGFdJqyNYeepKFqwMLv4Ym717QQTtpi8'
+        build_data.download_from_google_drive(gd_id, os.path.join(dpath, fname))
+        fname = 'valid_sorted_50_personas.json'
+        gd_id = '1A7oVKmjJ1EZTh6-3Gio4XQo81QgnTGGi'
+        build_data.download_from_google_drive(gd_id, os.path.join(dpath, fname))
+        fname = 'dnli_sorted_50_personas.json'
+        gd_id = '1wlIkVcBZoGQd3rbI7XWNhuq4rvw9FyoP'
+        build_data.download_from_google_drive(gd_id, os.path.join(dpath, fname))
+
+        print("Data has been placed in " + dpath)
+
+        build_data.mark_done(dpath, version)
+
+
+def make_path(opt, fname):
+    return os.path.join(opt['datapath'], FOLDER_NAME, fname)
+
+
+if __name__ == '__main__':
+    opt = params.ParlaiParser().parse_args(print_args=False)
+    build(opt)
diff --git a/tasks/teachers.py b/tasks/teachers.py
new file mode 100644
index 0000000..350046d
--- /dev/null
+++ b/tasks/teachers.py
@@ -0,0 +1,497 @@
+import copy
+import os
+import math
+import json
+import random
+from operator import itemgetter
+from orderedset import OrderedSet
+from collections import defaultdict
+import pickle
+
+from parlai.utils.misc import warn_once, str_to_msg
+from parlai.core.message import Message
+from parlai.core.torch_agent import TorchAgent
+from parlai.core.teachers import (
+    ParlAIDialogTeacher,
+    FixedDialogTeacher,
+    FbDeprecatedDialogTeacher,
+    DialogData
+)
+
+from .build import build, make_path
+
+__PATH__ = os.path.abspath(os.path.dirname(__file__))
+
+
+def _path(opt):
+    build(opt)
+    datatype = opt['datatype'].split(':')[0]
+    if datatype == 'test':
+        warn_once("WARNING: Test set not included. Setting datatype to valid.")
+        datatype = 'valid'
+    return make_path(opt, datatype + '.txt'), datatype
+
+
+def _split_persona_and_context(text, eval_type='convai2'):
+    if 'your persona:' not in text:
+        return None, text
+    else:
+        if eval_type == 'convai2':
+            texts = text.split('\n')
+            return '\n'.join(texts[:-1]), texts[-1]
+        elif eval_type =='dnli':
+            texts = text.split('\n')
+            last_idx = 0
+            for idx, text in enumerate(texts):
+                if 'your persona:' in text:
+                    last_idx = idx
+            persona_texts = texts[:last_idx+1]
+            context_texts = texts[last_idx+1:]
+            return '\n'.join(persona_texts), '\n'.join(context_texts)
+
+
+def _split_personas_and_context(text):
+    if 'your persona:' not in text:
+        return text, text, text
+    else:
+        your_personas = []
+        partner_personas = []
+        context = []
+        texts = text.split('\n')
+        for text in texts:
+            if text.startswith('your persona:'):
+                your_personas.append(text)
+            elif text.startswith("partner's persona:"):
+                partner_personas.append(text)
+            else:
+                context.append(text)
+
+        return '\n'.join(your_personas), '\n'.join(partner_personas), context
+
+
+class SelfConsciousDialogueTeacher(FixedDialogTeacher):
+    """
+     Teacher (i.e. input data supplier) for the Self-conscious Agent.
+     SelfConsciousDialogueTeacher (SCDT) supplies data input
+     along with the distractors to the Self-conscious Agent.
+    """
+    def __init__(self, opt, shared=None):
+        super().__init__(opt, shared)
+        self.opt = opt
+
+        datapath, datatype = _path(opt)
+
+        if not shared:
+            self.episodes = []
+            self.num_exs = 0
+            self._setup_data(datapath, datatype)
+        else:
+            self.episodes = shared['episodes']
+            self.num_exs = sum(len(e) for e in self.episodes)
+        self.id = 'self_conscious_dialogue'
+        self.reset()
+
+    @staticmethod
+    def add_cmdline_args(argparser):
+        agent = argparser.add_argument_group('Self Conscious Dialogue Teacher arguments')
+        agent.add_argument(
+            '--eval-type',
+            type=str,
+            choices=['convai2', 'dnli'],
+            default='dnli',
+            help='Which validation data to use',
+        )
+
+    def _setup_data(self, path, datatype):
+
+        random.seed(46)
+
+        # Data loading with script of ParlAIDialogTeacher
+        print(f"[Loading ParlAI text data: {path}]")
+
+        # Read data from ConvAI2
+        convai2_datapath = make_path(self.opt, f'{datatype}_both_original.txt')
+        convai2_episodes = self._load_convai2_data(convai2_datapath)
+
+        # Get persona pool
+        all_personas, persona_to_idx = self._get_persona_pool(self.opt)
+        sorted_personas = self._get_sorted_persona_pool(datatype)
+
+
+        if self.opt['eval_type'] == 'convai2':
+            self.episodes = []
+            self.num_exs = 0
+            eps = []
+            with open(path) as read:
+                for line in read:
+                    msg = str_to_msg(line.rstrip('\n'))
+                    if msg:
+                        self.num_exs += 1
+                        eps.append(msg)
+                        if msg.get('episode_done', False):
+                            self.episodes.append(eps)
+                            eps = []
+            if len(eps) > 0:
+                # add last episode
+                eps[-1].force_set('episode_done', True)
+                self.episodes.append(eps)
+            # Add label candidates and partner's persona
+            for episode_idx, episode in enumerate(self.episodes):
+                for turn_idx, turn in enumerate(episode):
+                    convai2_turn = convai2_episodes[episode_idx][turn_idx]
+                    convai2_text = convai2_turn[0]
+                    label_candidates = convai2_turn[3]
+
+                    turn['label_candidates'] = label_candidates
+                    if turn_idx == 0:
+                        my_persona, partner_persona, _ = _split_personas_and_context(convai2_text)
+                        turn['partner_persona'] = partner_persona
+                        turn['my_persona'] = my_persona
+                    else:
+                        turn['partner_persona'] = episode[0]['partner_persona']
+                        turn['my_persona'] = episode[0]['my_persona']
+        elif self.opt['eval_type'] == 'dnli':
+            self.episodes = []
+            self.num_exs = 0
+            for eval_set in ['attributes', 'havenot', 'likedislike']:
+                datapath = make_path(self.opt, f'{datatype}_{eval_set}.jsonl')
+                with open(datapath, 'r') as fp:
+                    for line in fp:
+                        msg = json.loads(line)
+                        msg['eval_set'] = eval_set
+                        msg['episode_done'] = True
+
+                        # Make 'text'
+                        persona_lines = [f'your persona: {x[:-2]}.' for x in msg['persona']]
+                        utts = msg['prefix']
+
+                        p1_token, p2_token = TorchAgent.P1_TOKEN, TorchAgent.P2_TOKEN
+                        lines = persona_lines
+                        # Identify the dialogue lines. It's assumed that p1 goes first.
+                        for i, utt in enumerate(utts):
+                            if i % 2 == 0:
+                                lines.append(f'{p1_token} {utt}')
+                            else:
+                                lines.append(f'{p2_token} {utt}')
+                        text = '\n'.join(lines)
+
+                        msg['text'] = text
+
+                        # Make 'label_candidates'
+                        cands = msg['candidates']
+                        msg['label_candidates'] = cands['label'] + cands['neg'][:10] \
+                            + cands['similar'][:10] + cands['rand'][:10]
+
+                        # Remove unused attributes
+                        del msg['persona']
+                        del msg['prefix']
+                        del msg['triple']
+                        del msg['relevant_persona_sentence']
+                        del msg['candidates']
+
+                        self.episodes.append([msg])
+                        self.num_exs += 1
+
+        # Add distractor personas
+        if self.opt['world_cardinality'] > 0:
+            num_all_personas = len(all_personas)
+            persona_indices = list(range(num_all_personas))
+            world_cardinality = self.opt['world_cardinality']
+            for episode in self.episodes:
+                gt_persona, first_context = _split_persona_and_context(episode[0]['text'], self.opt['eval_type'])
+                gt_persona_idx = persona_to_idx.get(gt_persona, -1)
+
+                # Choose random distractor personas
+                distractor_indices = random.sample(persona_indices, world_cardinality - 1)
+                while gt_persona_idx in distractor_indices:
+                    # Resample if gt_persona is sampled
+                    distractor_indices = random.sample(persona_indices, world_cardinality - 1)
+                distractor_personas = itemgetter(*distractor_indices)(all_personas)
+                distractor_personas = list(distractor_personas)
+
+                # Make it to 'distractor_text'
+                for turn_idx, turn in enumerate(episode):
+                    if turn_idx == 0:
+                        turn['distractor_text'] = [
+                            '\n'.join([persona, first_context])
+                            for persona in [gt_persona] + distractor_personas
+                        ]
+                    else:
+                        turn['distractor_text'] = [turn['text']] * world_cardinality
+
+    def _get_persona_pool(self, opt, remove_duplicate=True):
+        print("[loading persona pool from convai2 training data]")
+        # Get episodes from training dataset
+        datapath = make_path(opt, 'train.txt')
+        episodes = []
+        eps = []
+        with open(datapath) as read:
+            for line in read:
+                msg = str_to_msg(line.rstrip('\n'))
+                if msg:
+                    # self.num_exs += 1
+                    eps.append(msg)
+                    if msg.get('episode_done', False):
+                        episodes.append(eps)
+                        eps = []
+        if len(eps) > 0:
+            # add last episode
+            eps[-1].force_set('episode_done', True)
+            episodes.append(eps)
+
+        # Extract personas from episodes
+        persona_set = OrderedSet()
+        for episode in episodes:
+            first_turn = episode[0]
+            text = first_turn['text']
+            persona, _ = _split_persona_and_context(text)
+            persona_set.add(persona)
+
+        # Remove duplicate
+        if remove_duplicate:
+            train_persona_fname = os.path.join(__PATH__, 'train_persona_map.pkl')
+            with open(train_persona_fname, 'rb') as fp:
+                _train_personas = pickle.load(fp)
+            train_personas = []
+            for personas in _train_personas.values():
+                longest_idx = 0
+                longest_length = -1
+                for idx, persona in enumerate(personas):
+                    if len(persona) > longest_length:
+                        longest_idx = idx
+                        longest_length = len(persona)
+                selected_persona = map(lambda x: f"your persona: {x}.",personas[longest_idx])
+                selected_persona = '\n'.join(selected_persona)
+                train_personas.append(selected_persona)
+            persona_set = OrderedSet()
+            for train_persona in train_personas:
+                persona_set.add(train_persona)
+
+        all_personas = []
+        persona_to_idx = {}
+        for i, persona in enumerate(persona_set):
+            all_personas.append(persona)
+            persona_to_idx[persona] = i
+
+        print(f"Total {len(all_personas)} personas in dataset")
+
+        return all_personas, persona_to_idx
+
+    def _get_sorted_persona_pool(self, datatype):
+        print("[loading sorted persona pool from convai2 training data]")
+        eval_type = self.opt['eval_type']
+        if eval_type == 'convai2':
+            datapath = make_path(self.opt, 'valid_sorted_50_personas.json')
+        elif eval_type == 'dnli':
+            datapath = make_path(self.opt, 'dnli_sorted_50_personas.json')
+        else:
+            raise ValueError("eval_set must be one of convai2 and dnli")
+
+        with open(datapath, 'r') as fp:
+            sorted_personas = json.load(fp)
+        sorted_personas['idx2persona'] = sorted_personas['train_personas']
+        sorted_personas['persona2idx'] = {}
+        for idx, persona in enumerate(sorted_personas['train_personas']):
+            sorted_personas['persona2idx'][persona] = idx
+
+        return sorted_personas
+
+    def _load_convai2_data(self, datapath):
+        """
+        Read data in the fbdialog format.
+        Returns ``(x, y, r, c)`` tuples.
+        ``x`` represents a query, ``y`` represents the labels, ``r`` represents
+        any reward, and ``c`` represents any label_candidates.
+        The example above will be translated into the following tuples:
+        ::
+            x: 'Sam went to the kitchen\nPat gave Sam the milk\nWhere is the milk?'
+            y: ['kitchen']
+            r: '1'
+            c: ['hallway', 'kitchen', 'bathroom']
+            new_episode = True (this is the first example in the episode)
+        ::
+            x: 'Sam went to the hallway\\nPat went to the bathroom\\nWhere is the
+                milk?'
+            y: ['hallway']
+            r: '1'
+            c: ['hallway', 'kitchen', 'bathroom']
+            new_episode = False (this is the second example in the episode)
+        """
+        self.cloze = False  # Set this to use FbDialogTeacher
+        convai2_dataloader = FbDeprecatedDialogTeacher.setup_data(self, datapath)
+        convai2_episodes = []
+        for episode in DialogData._read_episode(self, convai2_dataloader):
+            convai2_episodes.append(episode)
+        del self.cloze
+        return convai2_episodes
+
+    def share(self):
+        shared = super().share()
+        shared['episodes'] = self.episodes
+        return shared
+
+    def num_examples(self):
+        return self.num_exs
+
+    def num_episodes(self):
+        return len(self.episodes)
+
+    def get(self, episode_idx, entry_idx=None):
+        return self.episodes[episode_idx][entry_idx]
+
+
+class ContextConsciousDialogueTeacher(SelfConsciousDialogueTeacher):
+    def _setup_data(self, path, datatype):
+        # random.seed(self.opt['random_seed'])  # Set this for pick same distractor persona
+        random.seed(46)  # Set this for pick same distractor persona
+        # Data loading with script of ParlAIDialogTeacher
+        print(f"[Loading ParlAI text data: {path}]")
+
+        # Read data from ConvAI2
+        convai2_datapath = make_path(self.opt, f'{datatype}_both_original.txt')
+        convai2_episodes = self._load_convai2_data(convai2_datapath)
+
+        if self.opt['eval_type'] == 'convai2':
+            self.episodes = []
+            self.num_exs = 0
+            eps = []
+            with open(path) as read:
+                for line in read:
+                    msg = str_to_msg(line.rstrip('\n'))
+                    if msg:
+                        self.num_exs += 1
+                        eps.append(msg)
+                        if msg.get('episode_done', False):
+                            self.episodes.append(eps)
+                            eps = []
+            if len(eps) > 0:
+                # add last episode
+                eps[-1].force_set('episode_done', True)
+                self.episodes.append(eps)
+            # Add label candidates and partner's persona
+            for episode_idx, episode in enumerate(self.episodes):
+                for turn_idx, turn in enumerate(episode):
+                    convai2_turn = convai2_episodes[episode_idx][turn_idx]
+                    convai2_text = convai2_turn[0]
+                    label_candidates = convai2_turn[3]
+
+                    turn['label_candidates'] = label_candidates
+                    if turn_idx == 0:
+                        my_persona, partner_persona, _ = _split_personas_and_context(convai2_text)
+                        turn['partner_persona'] = partner_persona
+                        turn['my_persona'] = my_persona
+                    else:
+                        turn['partner_persona'] = episode[0]['partner_persona']
+                        turn['my_persona'] = episode[0]['my_persona']
+        elif self.opt['eval_type'] == 'dnli':
+            self.episodes = []
+            self.num_exs = 0
+            for eval_set in ['attributes', 'havenot', 'likedislike']:
+                datapath = make_path(self.opt, f'{datatype}_{eval_set}.jsonl')
+                with open(datapath, 'r') as fp:
+                    for line in fp:
+                        msg = json.loads(line)
+                        msg['eval_set'] = eval_set
+                        msg['episode_done'] = True
+
+                        # Make 'text'
+                        persona_lines = [f'your persona: {x[:-2]}.' for x in msg['persona']]
+                        utts = msg['prefix']
+
+                        p1_token, p2_token = TorchAgent.P1_TOKEN, TorchAgent.P2_TOKEN
+                        lines = persona_lines
+                        # Identify the dialogue lines. It's assumed that p1 goes first.
+                        for i, utt in enumerate(utts):
+                            if i % 2 == 0:
+                                lines.append(f'{p1_token} {utt}')
+                            else:
+                                lines.append(f'{p2_token} {utt}')
+                        text = '\n'.join(lines)
+
+                        msg['text'] = text
+
+                        # Make 'label_candidates'
+                        cands = msg['candidates']
+                        msg['label_candidates'] = cands['label'] + cands['neg'][:10] \
+                            + cands['similar'][:10] + cands['rand'][:10]
+
+                        # Remove unused attributes
+                        del msg['persona']
+                        del msg['prefix']
+                        del msg['triple']
+                        del msg['relevant_persona_sentence']
+                        del msg['candidates']
+
+                        self.episodes.append([msg])
+                        self.num_exs += 1
+
+        # Get dialogue history pool
+        context_pool = self._get_context_pool(self.opt)
+
+        # Add distractor history
+        if self.opt['world_cardinality'] > 0:
+            for episode in self.episodes:
+                gt_persona, first_context = _split_persona_and_context(episode[0]['text'], self.opt['eval_type'])
+
+                # Select distractor history
+                if self.opt['eval_type'] == 'convai2':
+                    num_turn = len(episode)
+                else:
+                    dialogue = first_context.split('\n')
+                    num_turn = math.ceil(len(dialogue)/2)
+                    if num_turn < min(context_pool.keys()):
+                        # orginal_num_turn = num_turn
+                        num_turn = min(context_pool.keys())
+
+                context_indices = list(range(len(context_pool[num_turn])))
+
+                distractor_c_indices = random.sample(context_indices, self.opt['world_cardinality'] - 1)
+                distractor_contexts = itemgetter(*distractor_c_indices)(context_pool[num_turn])
+
+                # Make it to 'distractor_text'
+                if self.opt['eval_type'] == 'convai2':
+                    for turn_idx, turn in enumerate(episode):
+                        turn['distractor_text'] = turn['labels'] + [c[turn_idx] for c in distractor_contexts]
+                        if turn_idx == 0:
+                            turn['my_context'] = turn['labels']
+                        else:
+                            turn['my_context'] = episode[turn_idx - 1]['my_context'] + turn['labels']
+                else:
+                    # DNLI
+                    distractor_text = [episode[0]['text']]
+                    for c in distractor_contexts:
+                        copied_dialogue = copy.deepcopy(dialogue)
+                        for turn_idx, utterance in enumerate(copied_dialogue):
+                            if turn_idx % 2 == 1:
+                                copied_dialogue[turn_idx] = p2_token + c[turn_idx // 2]
+                        distractor_context = '\n'.join([gt_persona] + copied_dialogue)
+                        distractor_text.append(distractor_context)
+                    episode[0]['distractor_text'] = distractor_text
+
+    def _get_context_pool(self, opt):
+        print("[loading history pool from convai2 training data]")
+        datapath = make_path(opt, 'train.txt')
+        episodes = []
+        eps = []
+        with open(datapath) as read:
+            for line in read:
+                msg = str_to_msg(line.rstrip('\n'))
+                if msg:
+                    eps.append(msg)
+                    if msg.get('episode_done', False):
+                        episodes.append(eps)
+                        eps = []
+        if len(eps) > 0:
+            # add last episode
+            eps[-1].force_set('episode_done', True)
+            episodes.append(eps)
+
+        context_pool = defaultdict(list)
+        for ep in episodes:
+            context_pool[len(ep)].append([turn['labels'][0] for turn in ep])
+
+        return dict(context_pool)
+
+
+class DefaultTeacher(SelfConsciousDialogueTeacher):
+    pass
diff --git a/tasks/test_persona_map.pkl b/tasks/test_persona_map.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..042d5928952bb31a55d588394d58d576de5e47c1
GIT binary patch
literal 58923
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
GH~$`O44^^)

literal 0
HcmV?d00001

diff --git a/tasks/train_persona_map.pkl b/tasks/train_persona_map.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..21e69b46778bd777a670144067a086b9df5a239d
GIT binary patch
literal 634531
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
IZOvZ$|L*UBkpKVy

literal 0
HcmV?d00001

diff --git a/tasks/valid_persona_map.pkl b/tasks/valid_persona_map.pkl
new file mode 100644
index 0000000000000000000000000000000000000000..30c3462ea2b98f8195eeedccb060ad459c43d7f8
GIT binary patch
literal 62668
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

literal 0
HcmV?d00001