diff --git a/deep_qa/data/dataset.py b/deep_qa/data/dataset.py
index 524aa7828..71a1ee822 100644
--- a/deep_qa/data/dataset.py
+++ b/deep_qa/data/dataset.py
@@ -81,12 +81,13 @@ def read_from_lines(lines: List[str], instance_class):
         instances = [instance_class.read_from_line(x) for x in lines]
         labels = [(x.label, x) for x in instances]
         labels.sort(key=lambda x: str(x[0]))
-        label_counts = [(label, len([x for x in group]))
-                        for label, group in itertools.groupby(labels, lambda x: x[0])]
-        label_count_str = str(label_counts)
-        if len(label_count_str) > 100:
-            label_count_str = label_count_str[:100] + '...'
-        logger.info("Finished reading dataset; label counts: %s", label_count_str)
+        if len(labels) < 1:
+            label_counts = [(label, len([x for x in group]))
+                            for label, group in itertools.groupby(labels, lambda x: x[0])]
+            label_count_str = str(label_counts)
+            if len(label_count_str) > 100:
+                label_count_str = label_count_str[:100] + '...'
+            logger.info("Finished reading dataset; label counts: %s", label_count_str)
         return TextDataset(instances)
 
 
diff --git a/deep_qa/data/instances/text_classification/__init__.py b/deep_qa/data/instances/text_classification/__init__.py
index dfd787a5b..a5c710bb3 100644
--- a/deep_qa/data/instances/text_classification/__init__.py
+++ b/deep_qa/data/instances/text_classification/__init__.py
@@ -1,3 +1,10 @@
+from deep_qa.data.instances.text_classification.frame_embedded_label_instance import FrameEmbeddedLabelInstance
+from deep_qa.data.instances.text_classification.frame_instance import FrameInstance
 from .logical_form_instance import LogicalFormInstance, IndexedLogicalFormInstance
 from .text_classification_instance import TextClassificationInstance, IndexedTextClassificationInstance
 from .tuple_instance import TupleInstance, IndexedTupleInstance
+
+concrete_instances = {
+        'FrameInstance': FrameInstance,
+        'FrameEmbeddedLabelInstance': FrameEmbeddedLabelInstance
+        }
diff --git a/deep_qa/data/instances/text_classification/frame_embedded_label_instance.py b/deep_qa/data/instances/text_classification/frame_embedded_label_instance.py
new file mode 100644
index 000000000..5a2129fe1
--- /dev/null
+++ b/deep_qa/data/instances/text_classification/frame_embedded_label_instance.py
@@ -0,0 +1,205 @@
+from typing import Dict, List
+
+import numpy
+from overrides import overrides
+
+from ..instance import TextInstance, IndexedInstance
+from ...data_indexer import DataIndexer
+
+# the slotnames can vary according to different end applications, e.g., a HowTo tuple, OpenIE tuple ...
+SLOTNAMES_ORDERED = ["agent", "beneficiary", "causer", "context", "definition", "event",
+                     "finalloc", "headverb", "initloc", "input", "output", "manner",
+                     "patient", "resultant", "timebegin", "timeend", "temporal", "hierarchical",
+                     "similar", "contemporary", "enables", "mechanism", "condition", "purpose",
+                     "cause", "openrel", "participant"]
+UNKNOWN_SLOTVAL = "missingval"  # making an open world assumption, we do not observe all the values
+QUES_SLOTVAL = "ques"  # this slot in the frame must be queried/completed.
+
+
+class FrameEmbeddedLabelInstance(TextInstance):
+
+    """
+    A FrameEmbeddedLabelInstance is a kind of TextInstance that has text in multiple slots.
+    """
+    def __init__(self,
+                 dense_frame: List[str],
+                 phrase_dims_in_queried_slot: numpy.array):  # output label: vector representation of label phrase
+        super(FrameEmbeddedLabelInstance, self).__init__(phrase_dims_in_queried_slot)
+        self.text = dense_frame  # "event:plant absorb water###participant:water###agent:plant" TAB "agent:plant"
+
+    def __str__(self):
+        return 'FrameEmbeddedLabelInstance( [' + ',\n'.join(self.text) + '] , ' + str(self.label) + ')'
+
+    @overrides
+    def words(self) -> Dict[str, List[str]]:
+        # Accumulate words from each slot's phrase.
+        # Label is a vector representation of the phrase
+        words = []
+        for phrase in self.text:  # phrases
+            phrase_words = self._words_from_text(phrase)
+            words.extend(phrase_words['words'])
+        return {'words': words, 'slot_names': SLOTNAMES_ORDERED}
+
+    @staticmethod
+    def query_slot_from(slot_as_dims: str,
+                        kv_separator: str=":"):
+        """
+        :param slot_as_dims: "participant:water"
+        :param sparse_given_frame: If the expected slot name is given in the query
+        but its value is not, then pick the value from the sparse_given_frame
+        :param kv_separator: typically colon separated
+        :return: name=participant, val=0.98877,098762,-0.876,... embedding
+        """
+        slot_name_val = slot_as_dims.split(kv_separator)
+        csv_of_floats = slot_name_val[1]
+        val_arr = numpy.array(list(csv_of_floats
+                                   .replace('\n', ',')
+                                   .replace(' ', '')
+                                   .replace(',,', ',')
+                                   .split(',')),
+                              dtype='float64')
+        # val_arr = numpy.genfromtxt(StringIO(csv_of_floats), delimiter=",", dtype="float64", autostrip=True)
+        # The shape and type is automatically inferred by numpy based on csv of reals.
+        return {'name': slot_name_val[0], 'val': val_arr}
+
+    @staticmethod
+    def unpack_input(frame_as_string: str,
+                     kv_separator: str="\t"):
+        """
+        :param frame_as_string: "event:plant absorb water###participant:water" TAB "participant:water"
+        :param kv_separator: typically TAB separated partial frame and query
+        :return: event:plant absorb water###participant:water, and query: participant:water
+                Both event and query will be lowercased
+        """
+        # No information loss in lower-casing, and simplifies matching.
+        partialframe_query = frame_as_string.lower().split(kv_separator)
+        if len(partialframe_query) != 2:
+            raise RuntimeError("Unexpected number (not 2) of fields in frame: " + frame_as_string)
+        return {'content': partialframe_query[0], 'query': partialframe_query[1]}
+
+    @staticmethod
+    def given_slots_from(slots_csv: str,
+                         values_separator: str="###",
+                         kv_separator: str=":"):
+        """
+        :param slots_csv: event:plant absorb water###participant:water
+        :param values_separator: typically "###"
+        :param kv_separator: typically ":"
+        :return: map of slotnames -> slot phrase [event -> plant absorb water , participant -> water]
+        """
+        # ValueError: dictionary update sequence element  # 3 has length 1; 2 is required
+        return dict(map(lambda x: x.split(kv_separator), slots_csv.split(values_separator)))
+
+    @staticmethod
+    def dense_frame_from(sparse_frame: Dict[str, str],
+                         query_slotname: str):
+        """
+        Performs two types of padding:
+        i) unobserved slots are filled with self.unknown_slotval
+        ii) query slot is masked with self.unknown_queryval
+        The order of slots strictly follows from SLOTNAMES_ORDERED.
+        :param sparse_frame:
+                slotnames -> slot phrase [event -> plant absorb water , participant -> water]
+        :param query_slotname:
+                participant
+        :return: [plant absorb water, ques, missingval, missingval, ...]
+        """
+        slots = []
+        for slot_name in SLOTNAMES_ORDERED:
+            if slot_name == query_slotname:  # query hence masked
+                slots.append(QUES_SLOTVAL)
+            elif slot_name in sparse_frame:  # observed hence as-is
+                slots.append(sparse_frame[slot_name])
+            else:  # unobserved hence inserted
+                slots.append(UNKNOWN_SLOTVAL)
+        return slots
+
+    @classmethod
+    @overrides
+    def read_from_line(cls, line: str):
+        """
+        Reads a FrameEmbeddedLabelInstance from a line.  The format is:
+        frame represented as list of <role:role value phrase of maxlen 5> TAB <label>
+        e.g., from
+        event:plant absorb water###participant:water###agent:plant###finalloc:soil
+              to
+        ["plant", "missingval", "missingval", "missingval", "missingval", "plant absorb water",
+          "soil", "missingval", "missingval", "missingval", "missingval", "missingval",
+          "missingval", "missingval", "missingval", "missingval", "missingval", "missingval",
+          "missingval", "missingval", "missingval", "missingval", "missingval", "missingval",
+          "missingval", "missingval", "water"]
+        Provides ordering (input can be composed of slots in arbitrary order)
+        and sparseness flexibility (only a few slots can be mentioned in the input).
+        """
+        # Extract the query slot name and expected value
+        # e.g. from, participant:water, extract the expected slot value "water"
+        unpacked_input = cls.unpack_input(line)
+        given_sparse_frame = cls.given_slots_from(unpacked_input['content'])
+        query_slot = cls.query_slot_from(unpacked_input['query'])
+        dense_frame = cls.dense_frame_from(given_sparse_frame, query_slot['name'])
+        return cls(dense_frame, phrase_dims_in_queried_slot=query_slot['val'])
+
+    @overrides
+    def to_indexed_instance(self, data_indexer: DataIndexer):
+        # A phrase in a slot, is converted from list of words to list of wordids.
+        # This is repeated for every slot, hence a list of list of wordids/integers.
+        indices_slotvals = [self._index_text(phrase, data_indexer) for phrase in self.text]
+        indices_label = self.label
+        return IndexedNumericalFrameInstance(indices_slotvals, indices_label)
+
+
+class IndexedNumericalFrameInstance(IndexedInstance):
+    """
+    Ensures that a phrase in every slot.
+    Max length of a phrase is 6 (configurable), pad phrases with fewer words; if it exceeds 6 then truncate.
+    """
+    def __init__(self, word_indices: List[List[int]], label: numpy.array):
+        """
+        :param word_indices: One list of ints make up a slotvalue because a slotvalue is a phrase,
+                             and so every word of the phrase is identified with an int id.
+        :param label: embedding, hence an ndArray of type float64.
+        """
+        super(IndexedNumericalFrameInstance, self).__init__(label)
+        self.word_indices = word_indices
+
+    @classmethod
+    @overrides
+    def empty_instance(cls):
+        return IndexedNumericalFrameInstance([], label=None)
+
+    @overrides
+    def get_padding_lengths(self) -> Dict[str, int]:
+        # Record the length of every slot content
+        # Let the model pad to the max phrase length#
+        # e.g., ["1000", "1", "1", "1", "1", "1 2 3",..]
+        # slotlen  1,1,1,1,3..
+        # Expected: Dict ['some key', 3] which is the max phrase len across all slots.
+        all_slot_lengths = [self._get_word_sequence_lengths(slot_indices) for slot_indices in self.word_indices]
+        # find the max from all_slot_lengths
+        lengths = {}
+        for key in all_slot_lengths[0]:
+            lengths[key] = max(slot_lengths[key] for slot_lengths in all_slot_lengths)
+        return lengths
+
+    @overrides
+    def pad(self, padding_lengths: Dict[str, int]):
+        """
+        Pads (or truncates) all slot values to the maxlen
+        Input: (phrases corresponding to each slot, the number of slots is fixed.)
+        e.g., ["1000", "1", "1", "1", "1", "1 2 3",..]
+        Note: these are arrays over phrase word ids.
+        Output: (padded phrases, as phrases are composed of variable number of words)
+        e.g., ["1000 0 0 0 0", "1 0 0 0 0", "1 0 0 0 0", "1 0 0 0 0", "1 0 0 0 0", "1 2 3 0 0",..]
+        Note: padding is fixed length, anything larger or small will be pruned. Phrases are truncated from left.
+        """
+        truncate_from_right = False
+        self.word_indices = [self.pad_word_sequence(indices, padding_lengths, truncate_from_right)
+                             for indices in self.word_indices]
+        # labels are not strings, and need not be padded. We already provide a phrase vector.
+
+    @overrides
+    def as_training_data(self):
+        # The frame and the label must be numpy matrix and array respectively
+        frame_as_matrix = numpy.asarray(self.word_indices, dtype='int32')
+        label_as_embedding = self.label
+        return frame_as_matrix, label_as_embedding
diff --git a/deep_qa/data/instances/text_classification/frame_instance.py b/deep_qa/data/instances/text_classification/frame_instance.py
new file mode 100644
index 000000000..60d2d37df
--- /dev/null
+++ b/deep_qa/data/instances/text_classification/frame_instance.py
@@ -0,0 +1,205 @@
+from typing import Dict, List
+
+import numpy
+from overrides import overrides
+
+from ..instance import TextInstance, IndexedInstance
+from ...data_indexer import DataIndexer
+
+# TODO PR request for having these in the json as an application specific configuration.
+# the slotnames can vary according to different end applications, e.g., a HowTo tuple, OpenIE tuple ...
+SLOTNAMES_ORDERED = ["agent", "beneficiary", "causer", "context", "definition", "event",
+                     "finalloc", "headverb", "initloc", "input", "output", "manner",
+                     "patient", "resultant", "timebegin", "timeend", "temporal", "hierarchical",
+                     "similar", "contemporary", "enables", "mechanism", "condition", "purpose",
+                     "cause", "openrel", "participant"]
+UNKNOWN_SLOTVAL = "missingval"  # making an open world assumption, we do not observe all the values
+QUES_SLOTVAL = "ques"  # this slot in the frame must be queried/completed.
+
+
+class FrameInstance(TextInstance):
+
+    """
+    A FrameInstance is a kind of TextInstance that has text in multiple slots. This generalizes a FrameInstance.
+    """
+    def __init__(self,
+                 dense_frame: List[str],
+                 phrase_in_queried_slot: str=None):  # output label is a phrase
+        super(FrameInstance, self).__init__(phrase_in_queried_slot)
+        self.text = dense_frame  # "event:plant absorb water###participant:water###agent:plant" TAB "agent:plant"
+
+    def __str__(self):
+        return 'FrameInstance( [' + ',\n'.join(self.text) + '] , ' + str(self.label) + ')'
+
+    @overrides
+    def words(self) -> Dict[str, List[str]]:
+        # Accumulate words from each slot's phrase.
+        # Label is also a phrase, so additionally accumulate words from label
+        words = []
+        for phrase in self.text:  # phrases
+            phrase_words = self._words_from_text(phrase)
+            words.extend(phrase_words['words'])
+        label_words = self._words_from_text(self.label)
+        words.extend(label_words['words'])
+        return {'words': words, 'slot_names': SLOTNAMES_ORDERED}
+
+    @staticmethod
+    def query_slot_from(slot_as_string: str,
+                        sparse_given_frame: Dict[str, str],
+                        kv_separator: str=":"):
+        """
+        :param slot_as_string: "participant:water"
+        :param sparse_given_frame: If the expected slot name is given in the query
+        but its value is not, then pick the value from the sparse_given_frame
+        :param kv_separator: typically colon separated
+        :return: name=participant, val=water
+        """
+        slot_name_val = slot_as_string.split(kv_separator)
+        # Suppose slot_as_string is: participant (i.e. no value is specified)
+        # this is assumed as participant:BLANK_VALUE, if we cannot look it up in the partial frame.
+        if len(slot_name_val) == 1:
+            slot_name_val = (slot_as_string + ":" +
+                             sparse_given_frame.get(slot_name_val[0], '')).split(kv_separator)
+        return {'name': slot_name_val[0], 'val': slot_name_val[1]}
+
+    @staticmethod
+    def unpack_input(frame_as_string: str,
+                     kv_separator: str="\t"):
+        """
+        :param frame_as_string: "event:plant absorb water###participant:water" TAB "participant:water"
+        :param kv_separator: typically TAB separated partial frame and query
+        :return: event:plant absorb water###participant:water, and query: participant:water
+                Both event and query will be lowercased
+        """
+        # No information loss in lower-casing, and simplifies matching.
+        partialframe_query = frame_as_string.lower().split(kv_separator)
+        if len(partialframe_query) != 2:
+            raise RuntimeError("Unexpected number (not 2) of fields in frame: " + frame_as_string)
+        return {'content': partialframe_query[0], 'query': partialframe_query[1]}
+
+    @staticmethod
+    def given_slots_from(slots_csv: str,
+                         values_separator: str="###",
+                         kv_separator: str=":"):
+        """
+        :param slots_csv: event:plant absorb water###participant:water
+        :param values_separator: typically "###"
+        :param kv_separator: typically ":"
+        :return: map of slotnames -> slot phrase [event -> plant absorb water , participant -> water]
+        """
+        return dict(map(lambda x: x.split(kv_separator), slots_csv.split(values_separator)))
+
+    @staticmethod
+    def dense_frame_from(sparse_frame: Dict[str, str],
+                         query_slotname: str):
+        """
+        Performs two types of padding:
+        i) unobserved slots are filled with self.unknown_slotval
+        ii) query slot is masked with self.unknown_queryval
+        The order of slots strictly follows from SLOTNAMES_ORDERED.
+        :param sparse_frame:
+                slotnames -> slot phrase [event -> plant absorb water , participant -> water]
+        :param query_slotname:
+                participant
+        :return: [plant absorb water, ques, missingval, missingval, ...]
+        """
+        slots = []
+        for slot_name in SLOTNAMES_ORDERED:
+            if slot_name == query_slotname:  # query hence masked
+                slots.append(QUES_SLOTVAL)
+            elif slot_name in sparse_frame:  # observed hence as-is
+                slots.append(sparse_frame[slot_name])
+            else:  # unobserved hence inserted
+                slots.append(UNKNOWN_SLOTVAL)
+        return slots
+
+    @classmethod
+    @overrides
+    def read_from_line(cls, line: str):
+        """
+        Reads a FrameInstance from a line.  The format is:
+        frame represented as list of <role:role value phrase of maxlen 5> TAB <label>
+        e.g., from
+        event:plant absorb water###participant:water###agent:plant###finalloc:soil
+              to
+        ["plant", "missingval", "missingval", "missingval", "missingval", "plant absorb water",
+          "soil", "missingval", "missingval", "missingval", "missingval", "missingval",
+          "missingval", "missingval", "missingval", "missingval", "missingval", "missingval",
+          "missingval", "missingval", "missingval", "missingval", "missingval", "missingval",
+          "missingval", "missingval", "water"]
+        Provides ordering (input can be composed of slots in arbitrary order)
+        and sparseness flexibility (only a few slots can be mentioned in the input).
+        """
+        # Extract the query slot name and expected value
+        # e.g. from, participant:water, extract the expected slot value "water"
+        unpacked_input = cls.unpack_input(line)
+        given_sparse_frame = cls.given_slots_from(unpacked_input['content'])
+        query_slot = cls.query_slot_from(unpacked_input['query'], given_sparse_frame)
+        dense_frame = cls.dense_frame_from(given_sparse_frame, query_slot['name'])
+        return cls(dense_frame, phrase_in_queried_slot=query_slot['val'])
+
+    @overrides
+    def to_indexed_instance(self, data_indexer: DataIndexer):
+        # A phrase in a slot, is converted from list of words to list of wordids.
+        # This is repeated for every slot, hence a list of list of wordids/integers.
+        indices_slotvals = [self._index_text(phrase, data_indexer) for phrase in self.text]
+        # The label is a phrase, and is converted from list of words to list of wordids.
+        indices_label = self._index_text(self.label, data_indexer)
+        return IndexedFrameInstance(indices_slotvals, indices_label)
+
+
+class IndexedFrameInstance(IndexedInstance):
+    """
+    Ensures that a phrase in every slot, and the label (also a phrase) are padded to be of a fixed maxlen.
+    Max length of a phrase is 6 (configurable), pad phrases with fewer words; if it exceeds 6 then truncate.
+    """
+    def __init__(self, word_indices: List[List[int]], label):
+        """
+        :param word_indices: One list of ints make up a slotvalue because a slotvalue is a phrase,
+                             and so every word of the phrase is identified with an int id.
+        :param label: phrase, hence a list of ints.
+        """
+        super(IndexedFrameInstance, self).__init__(label)
+        self.word_indices = word_indices
+
+    @classmethod
+    @overrides
+    def empty_instance(cls):
+        return IndexedFrameInstance([], label=None)
+
+    @overrides
+    def get_padding_lengths(self) -> Dict[str, int]:
+        # Record the length of every slot content
+        # Let the model pad to the max phrase length#
+        # e.g., ["1000", "1", "1", "1", "1", "1 2 3",..]
+        # slotlen  1,1,1,1,3..
+        # Expected: Dict ['some key', 3] which is the max phrase len across all slots.
+        all_slot_lengths = [self._get_word_sequence_lengths(slot_indices) for slot_indices in self.word_indices]
+        # find the max from all_slot_lengths
+        lengths = {}
+        for key in all_slot_lengths[0]:
+            lengths[key] = max(slot_lengths[key] for slot_lengths in all_slot_lengths)
+        return lengths
+
+    @overrides
+    def pad(self, padding_lengths: Dict[str, int]):
+        """
+        Pads (or truncates) all slot values to the maxlen
+        Input: (phrases corresponding to each slot, the number of slots is fixed.)
+        e.g., ["1000", "1", "1", "1", "1", "1 2 3",..]
+        Note: these are arrays over phrase word ids.
+        Output: (padded phrases, as phrases are composed of variable number of words)
+        e.g., ["1000 0 0 0 0", "1 0 0 0 0", "1 0 0 0 0", "1 0 0 0 0", "1 0 0 0 0", "1 2 3 0 0",..]
+        Note: padding is fixed length, anything larger or small will be pruned. Phrases are truncated from left.
+        """
+        truncate_from_right = False
+        self.word_indices = [self.pad_word_sequence(indices, padding_lengths, truncate_from_right)
+                             for indices in self.word_indices]
+        self.label = self.pad_word_sequence(self.label, padding_lengths, truncate_from_right)
+
+    @overrides
+    def as_training_data(self):
+        # The frame and the label must be numpy matrix and array respectively
+        frame_as_matrix = numpy.asarray(self.word_indices, dtype='int32')
+        label_as_list = numpy.asarray(self.label, dtype='int32')
+        return frame_as_matrix, label_as_list
diff --git a/deep_qa/layers/encoders/AveragedBOWEncoder.py b/deep_qa/layers/encoders/AveragedBOWEncoder.py
new file mode 100644
index 000000000..6b2acd6bc
--- /dev/null
+++ b/deep_qa/layers/encoders/AveragedBOWEncoder.py
@@ -0,0 +1,102 @@
+from keras import backend as K
+from keras.engine import InputSpec
+from overrides import overrides
+
+from deep_qa.layers import MaskedLayer
+
+
+class AveragedBOWEncoder(MaskedLayer):
+    """
+    An encoder that averages (like a BOWEncoder) over a particular dimension of the tensor.
+    e.g., for a 4D tensor, averages over the specified dimension (e.g., = 2)
+    which is not the embedding dimension. The use case is suppose every token in a sequence
+    can be decomposed into multiple words. Then, embedding for each word is averaged.
+    """
+    def __init__(self, averaging_over_dim=-2, num_dimensions=3, **kwargs):
+        self.num_dimensions = num_dimensions
+        self.input_spec = [InputSpec(ndim=self.num_dimensions)]
+        if averaging_over_dim < 0:
+            self.averaging_over_dim = self.num_dimensions + averaging_over_dim
+        else:
+            self.averaging_over_dim = averaging_over_dim
+        # For consistency of handling sentence encoders, we will often get passed this parameter.
+        # We don't use it, but Layer will complain if it's there, so we get rid of it here.
+        kwargs.pop('units', None)
+        super(AveragedBOWEncoder, self).__init__(**kwargs)
+
+    @overrides
+    def compute_output_shape(self, input_shape):
+        # Drop the nth dimension. (n = self.averaging_over_dim)
+        #
+        # e.g., drop the phrase_len dimension in shape(batch, num_slots, phrase_len, embedding)
+        # implies, return input_shape[0], input_shape[1], input_shape[3]
+        return tuple([x for (index, x) in enumerate(input_shape) if index != self.averaging_over_dim])
+
+    @overrides
+    def compute_mask(self, inputs, mask=None):
+
+        if mask is None:
+            return None
+
+        elif K.ndim(mask) <= self.averaging_over_dim:
+            # If we were averaging a dimension that is not covered,
+            # the mask is unchanged.
+            return mask
+        else:
+            # If we are averaging over a dimension which is covered by the mask,
+            # then the new mask should contain a 0 only in the case that the
+            # entire dimension was masked previously for a given input.
+            return K.any(mask, self.averaging_over_dim)
+        return None
+
+    @overrides
+    def call(self, inputs, mask=None):
+        # pylint: disable=redefined-variable-type
+        if mask is None:
+            return K.mean(inputs, axis=self.averaging_over_dim)
+
+        # whether we need to use the mask depends on whether the dimension we are reducing
+        # is itself covered by the mask
+        # i.e., ignore masking if the dimension is not masked.
+        # e.g., if the embedding dimension is not masked so when we average over it
+        # we should not take into account any mask.
+        # However, pass the mask on through the layer regardless.
+        elif self.averaging_over_dim >= K.ndim(mask):
+            return K.mean(inputs, axis=self.averaging_over_dim)
+
+        else:
+            # Compute weights such that masked elements have zero weights and the remaining
+            # weight is distributed equally among the unmasked elements.
+            # Mask (batch_size, num_slots, num_words_in_slot, embedding)
+            # has 0s for masked elements and 1s everywhere else.
+            # Mask is of type int8. While Theano would automatically make weighted_mask below
+            # of type float32 even if mask remains int8, Tensorflow would complain. Let's cast it
+            # explicitly to remain compatible with tf.
+            float_mask = K.cast(mask, 'float32')
+
+            # Get nth (e.g., 3rd) dimension from the tensor (batch, num_slots, phrase_len, embedding)
+            # Perform multiplication: input x mask
+
+            # Expanding dims of the denominator to make it the same shape as the numerator,
+            # epsilon added to avoid division by zero.
+            weighted_mask = \
+                float_mask / \
+                (K.sum(
+                        float_mask,
+                        axis=self.averaging_over_dim,
+                        keepdims=True)
+                 + K.epsilon())
+            if K.ndim(weighted_mask) < K.ndim(inputs):
+                weighted_mask = K.expand_dims(weighted_mask)
+            averaged = K.sum(inputs * weighted_mask, axis=self.averaging_over_dim)
+            return averaged
+
+    @overrides
+    def get_config(self):
+        base_config = super(AveragedBOWEncoder, self).get_config()
+        config = {
+                'averaging_over_dim': self.averaging_over_dim,
+                'num_dimensions': self.num_dimensions
+                }
+        config.update(base_config)
+        return config
diff --git a/deep_qa/models/text_classification/__init__.py b/deep_qa/models/text_classification/__init__.py
index 2553bb4d2..1e8e6076e 100644
--- a/deep_qa/models/text_classification/__init__.py
+++ b/deep_qa/models/text_classification/__init__.py
@@ -1,5 +1,7 @@
+from .framecloze_model import FrameClozeModel
 from .classification_model import ClassificationModel
 
 concrete_models = {  # pylint: disable=invalid-name
         'ClassificationModel': ClassificationModel,
+        'FrameClozeModel': FrameClozeModel,
         }
diff --git a/deep_qa/models/text_classification/framecloze_model.py b/deep_qa/models/text_classification/framecloze_model.py
new file mode 100644
index 000000000..6ced38da5
--- /dev/null
+++ b/deep_qa/models/text_classification/framecloze_model.py
@@ -0,0 +1,127 @@
+from overrides import overrides
+
+from keras.layers import Dense, Dropout, Input
+
+from deep_qa.data.instances.text_classification import concrete_instances
+from deep_qa.layers.encoders import BOWEncoder
+from deep_qa.layers.encoders.AveragedBOWEncoder import AveragedBOWEncoder
+from ...training.text_trainer import TextTrainer
+from ...training.models import DeepQaModel
+from ...common.params import Params
+
+
+class FrameClozeModel(TextTrainer):
+    """
+    This ``FrameClozeModel`` is a type of text train with:
+    ------------
+    Input/ Output
+    ------------
+    input: a partial frame (list of phrases in a fixed order), a query (slot to complete).
+    predicts: an embedding for the query slot
+    where,
+    - partial frame is a list of phrases in a fixed order, see ``FrameInstance`` for examples,
+    - query is the slot to complete. Instead of a one hot vector we provide it with a default token (ques)
+    - embedding for the queried slot is the BOW representation of the phrase value of the queried slot.
+    ---------------------
+    Network architecture
+    ---------------------
+    We use BOW encoder along with a dense layer.
+    We use stacked seq2seq encoders followed by a dense layer.
+    ----------
+    Parameters
+    ----------
+    # num_stacked_rnns : int, optional (default: ``1``)
+        The number of ``seq2seq_encoders`` that we should stack on top of each other before
+        predicting tags.
+    # instance_type : str
+        Specifies the instance type, currently the only supported type is "FrameInstance",
+        which defines things like how the input data is formatted and tokenized.
+    """
+    def __init__(self, params: Params):
+        self.num_stacked_rnns = params.pop('num_stacked_rnns', 1)
+        instance_type = params.pop('instance_type', "FrameInstance")
+        self.nearest_neighbor_dim = params.pop('nearest_neighbor_dim', 100)
+        self.instance_type = concrete_instances[instance_type]
+        super(FrameClozeModel, self).__init__(params)
+        # set this from json file, because instance_type is a class and not an instance
+        self.num_slots = params.pop('num_slots', 27)
+        # self.num_slots = self._instance_type().words()['slot_names']
+
+    @overrides
+    def _build_model(self):
+
+        # Input: (slots, query-slot)
+        # Output: (queried-slot-phrase-embedding)
+
+        # Step 1: Convert the frame input into sequences of word vectors
+        # corresponding to the slot values/phrases (ignoring the slot names).
+
+        # slots_input: numpy array: int32 (batch_size, num_slots, text_length).
+        # Left padded arrays of word indices from sentences in training data.
+        # We have a list of phrases as input. The base class implementation of
+        # _get_sentence_shape provides sentence length, which is the phrase length
+        # in this model. We shall additionally supply number of slots.
+        slots_input = Input(
+                shape=((self.num_slots, ) + self._get_sentence_shape()),  # Note: excludes batch size
+                dtype='int32',  # shape encodes lengths, lengths are of type int.
+                name="slots_input"  # Should it be "words"?
+                )
+
+        # Step 2: Pass the sequences of word vectors through the sentence encoder to get a sentence vector.
+        # Shape: (batch_size, number_of_slots, max_phrase_len, embedding_dim)
+        each_slot_embedding = self._embed_input(slots_input)
+
+        # average out over phrase_len:
+        # from: batch_size, number_of_slots, phrase_len, embedding_dim
+        # output should become: batch_size, number_of_slots, embedding_dim
+        averaging_layer = AveragedBOWEncoder(2, 4)
+        # batch_size, number_of_slots, embedding_dim
+        each_slot_embedding = averaging_layer(each_slot_embedding)
+
+        # Shape: (batch_size, number_of_slots, embedding_dim)
+        # We first convert a sentence to a sequence of word embeddings
+        # and then apply a stack of seq2seq encoders.
+        for i in range(self.num_stacked_rnns):
+            encoder = self._get_seq2seq_encoder(name="encoder_{}".format(i),
+                                                fallback_behavior="use default params")
+            # shape still (batch_size, number_of_slots, 2 * embedding_dim)
+            each_slot_embedding = encoder(each_slot_embedding)
+
+        # From (batch_size, number_of_slots, 2 * embedding_dim),
+        # convert to batch_size, 2*embedding_dim
+        bow_features = BOWEncoder()
+        avg_slot_embedding = bow_features(each_slot_embedding)
+        # Add a dropout after LSTM.
+        regularized_embedding = Dropout(0.2)(avg_slot_embedding)
+
+        # Step 3: Dense projection
+        # From:(batch_size, 2*embedding_dim),
+        # convert to (batch_size, nn_embedding_dim),
+        # so, a dense layer is needed
+        projection_layer = Dense(int(self.nearest_neighbor_dim), activation='relu', name='projector')
+        projected_frame = projection_layer(regularized_embedding)
+
+        # Step 4: Define squared loss against labels as the loss.
+        # Requires that training input contain a vector representation of the queried slot as label.
+        # Further, we need to find all the possible nearest neighbors for this vector.
+        return DeepQaModel(inputs=slots_input, outputs=projected_frame)
+
+    def _instance_type(self):
+        return self.instance_type
+
+    @overrides
+    def _set_padding_lengths_from_model(self):
+        # We return the dimensions of
+        # 0th layer which is "indexed input" (0),
+        # and everything that comes after the batch_size which "includes #words, #characters etc." [2:]
+        # e.g., model.get_input_shape_at(0) -> None x 27 x 3 (BS x #slots x phrase_len_per_slot)
+        self._set_text_lengths_from_model_input(self.model.get_input_shape_at(0)[2:])
+
+    @classmethod
+    @overrides
+    def _get_custom_objects(cls):
+        custom_objects = super(FrameClozeModel, cls)._get_custom_objects()
+        # If we use any custom layers implemented in deep_qa (not part of original Keras),
+        # they need to be added in the custom_objects dictionary.
+        custom_objects["AveragedBOWEncoder"] = AveragedBOWEncoder
+        return custom_objects
diff --git a/example_experiments/sequence_tagging/simple_tagger_local.json b/example_experiments/sequence_tagging/simple_tagger_local.json
new file mode 100644
index 000000000..d5c387c7e
--- /dev/null
+++ b/example_experiments/sequence_tagging/simple_tagger_local.json
@@ -0,0 +1,39 @@
+{
+    "model_class": "SimpleTagger",
+    "model_serialization_prefix": "/Users/nikett/Documents/work/code/thirdparty/deepqa/deep_qa/datasets-pulled/models/simple_tagger_test/",
+    "encoder": {
+        "word": {
+          "type": "cnn",
+          "ngram_filter_sizes": [2, 3, 4, 5],
+          "num_filters": 100
+        }
+    },
+    "seq2seq_encoder": {
+        "default": {
+            "type": "bi_gru",
+            "encoder_params": {
+                "units": 100
+            },
+            "wrapper_params": {}
+        }
+    },
+    "num_stacked_rnns": 2,
+    "instance_type": "PreTokenizedTaggingInstance",
+    "pretrained_embeddings_file": "/Users/nikett/Documents/work/code/thirdparty/deepqa/deep_qa/datasets-pulled/glove.6B.100d.txt.gz",
+    "project_embeddings": false,
+    "fine_tune_embeddings": false,
+    "tokenizer": {
+      "type": "words and characters",
+      "processor": {"word_splitter": "no_op"}
+    },
+    "embedding_dropout": 0.2,
+    "patience": 3,
+    "embedding_dim": {"words": 100, "characters": 8},
+    "num_epochs": 20,
+    "optimizer": {
+      "type": "adadelta",
+      "learning_rate": 0.5
+    },
+    "validation_files": ["/Users/nikett/Documents/work/code/thirdparty/deepqa/deep_qa/datasets-pulled/tagging_dev.tsv"],
+    "train_files": ["/Users/nikett/Documents/work/code/thirdparty/deepqa/deep_qa/datasets-pulled/tagging_train.tsv"]
+}
diff --git a/example_experiments/text_classification/simple_framecloze_local.json b/example_experiments/text_classification/simple_framecloze_local.json
new file mode 100644
index 000000000..6f1159927
--- /dev/null
+++ b/example_experiments/text_classification/simple_framecloze_local.json
@@ -0,0 +1,31 @@
+{
+    "model_class": "FrameClozeModel",
+    "model_serialization_prefix": "/Users/nikett/Documents/work/code/thirdparty/deepqa/deep_qa/datasets-toy/models/simple_framecloze_test/",
+    "seq2seq_encoder": {
+        "default": {
+            "type": "bi_gru",
+            "encoder_params": {
+                "units": 100
+            },
+            "wrapper_params": {}
+        }
+    },
+    "num_stacked_rnns": 2,
+    "instance_type": "FrameEmbeddedLabelInstance",
+    "embeddings": {"words":
+                        {"dimension": 100,
+                            "pretrained_embeddings_file": "/Users/nikett/Documents/work/code/thirdparty/deepqa/deep_qa/datasets-pulled/glove.6B.100d.txt.gz"
+                        },
+                    "characters": {"dimension": 8}
+                  },
+    "patience": 3,
+    "loss": "mean_squared_error",
+    "num_epochs": 10,
+    "optimizer": {
+      "type": "adadelta",
+      "learning_rate": 0.5
+    },
+    "validation_metric": "val_loss",
+    "validation_files": ["/Users/nikett/Documents/work/code/thirdparty/deepqa/deep_qa/datasets-toy/framecloze-numerical.dev.sample.tsv"],
+    "train_files": ["/Users/nikett/Documents/work/code/thirdparty/deepqa/deep_qa/datasets-toy/framecloze-numerical.train.sample.tsv"]
+}
diff --git a/requirements.txt b/requirements.txt
index f344a3362..5caf84382 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -7,7 +7,8 @@
 # Keras had a bug that needed to be fixed.  This commit is the bugfix commit.  Once 2.0.5 comes
 # out, we can remove this pin.
 # keras
-git+git://github.com/fchollet/keras.git@b5490b20d23ed1ffd45d535f0799804d54308b09
+#git+git://github.com/fchollet/keras.git@b5490b20d23ed1ffd45d535f0799804d54308b09
+keras==2.0.5
 h5py
 scikit-learn
 
diff --git a/tests/common/test_case.py b/tests/common/test_case.py
index c4be8b488..1739a050c 100644
--- a/tests/common/test_case.py
+++ b/tests/common/test_case.py
@@ -157,6 +157,22 @@ def write_verb_semantics_files(self):
                                   '\t2,3\t5,5\tCREATE\t7,7\t-1,-1\n')
             validation_file.write('lakes####contain####water\t1,1\t2,2\tNONE\t-1,-1\t-1,-1\n')
 
+    def write_frame_cloze_files(self):
+        with codecs.open(self.TRAIN_FILE, 'w', 'utf-8') as train_file:
+            #
+            # Do not use the no_op word splitter otherwise:
+            # DeepQA fails on single worded sentences (in our case, single worded phrase)
+            # So we manually prepend "the". DeepQA complains due to the folloowing assertion
+            # File "deep_qa/data/tokenizers/word_splitter.py", line 125, in split_words
+            # assert isinstance(sentence, list), "This splitter is only meant to be used for pre-split text"
+            #
+            train_file.write('event:plant absorb water###participant:water###agent:plant\tfinalloc:-0.0891758,0.121832,-0.0671959,0.0477279,-0.013659,-0.0671959,0.0640559,-0.0331269,-0.0364239,0.00565199,-0.017113,-0.10362,0.0552639,-0.00706499,-0.0643699,0.08,0.110528,-0.108644,0.00374837,-0.020567,-0.0464719,-0.015386,0.0979678,-0.02364,-0.012717,0.0251199,-0.0389359,0.0828958,0.10676,0.0390929,0.0756738,0.0140515,-0.021823,0.162024,0.0941998,-0.0118535,-0.0452159,-0.0298299,0.0423899,0.0712,0.002487,-0.00883123,0.0577759,-0.0189185,0.0168775,0.0408199,-0.0405059,0.0539,0.0891758,0.121832,-0.0671959,0.0477279,-0.013659,-0.069,0.0640559,-0.0331269,-0.0364239,0.00565199,-0.017113,-0.10362,0.0552639,-0.00706499,-0.0643699,0.08,0.110528,-0.108644,0.00374837,-0.020567,-0.0464719,-0.015386,0.0979678,-0.02364,-0.012717,0.0251199,-0.0389359,0.0828958,0.10676,0.0390929,0.0756738,0.0140515,-0.021823,0.162024,0.0941998,-0.0118535,-0.0452159,-0.0298299,0.0423899,0.0712,0.002487,-0.00883123,0.0577759,-0.0189185,0.0168775,0.0408199,-0.0405059,0.0539,-0.0480419,-0.0277889,0.0872918,-0.0189185\n')
+            train_file.write('event:plant absorb carbon###participant:water###agent:plant\tfinalloc:0.0191758,0.121832,-0.0671959,0.0477279,-0.013659,-0.0671959,0.0640559,-0.0331269,-0.0364239,0.00565199,-0.017113,-0.10362,0.0552639,-0.00706499,-0.0643699,0.08,0.110528,-0.108644,0.00374837,-0.020567,-0.0464719,-0.015386,0.0979678,-0.02364,-0.012717,0.0251199,-0.0389359,0.0828958,0.10676,0.0390929,0.0756738,0.0140515,-0.021823,0.162024,0.0941998,-0.0118535,-0.0452159,-0.0298299,0.0423899,0.0712,0.002487,-0.00883123,0.0577759,-0.0189185,0.0168775,0.0408199,-0.0405059,0.0539,0.0891758,0.121832,-0.0671959,0.0477279,-0.013659,-0.069,0.0640559,-0.0331269,-0.0364239,0.00565199,-0.017113,-0.10362,0.0552639,-0.00706499,-0.0643699,0.08,0.110528,-0.108644,0.00374837,-0.020567,-0.0464719,-0.015386,0.0979678,-0.02364,-0.012717,0.0251199,-0.0389359,0.0828958,0.10676,0.0390929,0.0756738,0.0140515,-0.021823,0.162024,0.0941998,-0.0118535,-0.0452159,-0.0298299,0.0423899,0.0712,0.002487,-0.00883123,0.0577759,-0.0189185,0.0168775,0.0408199,-0.0405059,0.0539,-0.0480419,-0.0277889,0.0872918,-0.0189185\n')
+            train_file.write('event:animal eat###participant:water###agent:animal\tfinalloc:0.6891758,0.121832,-0.0671959,0.0477279,-0.013659,-0.0671959,0.0640559,-0.0331269,-0.0364239,0.00565199,-0.017113,-0.10362,0.0552639,-0.00706499,-0.0643699,0.08,0.110528,-0.108644,0.00374837,-0.020567,-0.0464719,-0.015386,0.0979678,-0.02364,-0.012717,0.0251199,-0.0389359,0.0828958,0.10676,0.0390929,0.0756738,0.0140515,-0.021823,0.162024,0.0941998,-0.0118535,-0.0452159,-0.0298299,0.0423899,0.0712,0.002487,-0.00883123,0.0577759,-0.0189185,0.0168775,0.0408199,-0.0405059,0.0539,0.0891758,0.121832,-0.0671959,0.0477279,-0.013659,-0.069,0.0640559,-0.0331269,-0.0364239,0.00565199,-0.017113,-0.10362,0.0552639,-0.00706499,-0.0643699,0.08,0.110528,-0.108644,0.00374837,-0.020567,-0.0464719,-0.015386,0.0979678,-0.02364,-0.012717,0.0251199,-0.0389359,0.0828958,0.10676,0.0390929,0.0756738,0.0140515,-0.021823,0.162024,0.0941998,-0.0118535,-0.0452159,-0.0298299,0.0423899,0.0712,0.002487,-0.00883123,0.0577759,-0.0189185,0.0168775,0.0408199,-0.0405059,0.0539,-0.0480419,-0.0277889,0.0872918,-0.0189185\n')
+        with codecs.open(self.VALIDATION_FILE, 'w', 'utf-8') as validation_file:
+            validation_file.write('event:plant take water###participant:water###agent:plant\tfinalloc:-0.0891758,0.121832,-0.0671959,0.0477279,-0.013659,-0.0671959,0.0640559,-0.0331269,-0.0364239,0.00565199,-0.017113,-0.10362,0.0552639,-0.00706499,-0.0643699,0.08,0.110528,-0.108644,0.00374837,-0.020567,-0.0464719,-0.015386,0.0979678,-0.02364,-0.012717,0.0251199,-0.0389359,0.0828958,0.10676,0.0390929,0.0756738,0.0140515,-0.021823,0.162024,0.0941998,-0.0118535,-0.0452159,-0.0298299,0.0423899,0.0712,0.002487,-0.00883123,0.0577759,-0.0189185,0.0168775,0.0408199,-0.0405059,0.0539,0.0891758,0.121832,-0.0671959,0.0477279,-0.013659,-0.069,0.0640559,-0.0331269,-0.0364239,0.00565199,-0.017113,-0.10362,0.0552639,-0.00706499,-0.0643699,0.08,0.110528,-0.108644,0.00374837,-0.020567,-0.0464719,-0.015386,0.0979678,-0.02364,-0.012717,0.0251199,-0.0389359,0.0828958,0.10676,0.0390929,0.0756738,0.0140515,-0.021823,0.162024,0.0941998,-0.0118535,-0.0452159,-0.0298299,0.0423899,0.0712,0.002487,-0.00883123,0.0577759,-0.0189185,0.0168775,0.0408199,-0.0405059,0.0539,-0.0480419,-0.0277889,0.0872918,-0.0189185\n')
+            validation_file.write('event:animal consume###participant:water###agent:animal\tfinalloc:0.6891758,0.121832,-0.0671959,0.0477279,-0.013659,-0.0671959,0.0640559,-0.0331269,-0.0364239,0.00565199,-0.017113,-0.10362,0.0552639,-0.00706499,-0.0643699,0.08,0.110528,-0.108644,0.00374837,-0.020567,-0.0464719,-0.015386,0.0979678,-0.02364,-0.012717,0.0251199,-0.0389359,0.0828958,0.10676,0.0390929,0.0756738,0.0140515,-0.021823,0.162024,0.0941998,-0.0118535,-0.0452159,-0.0298299,0.0423899,0.0712,0.002487,-0.00883123,0.0577759,-0.0189185,0.0168775,0.0408199,-0.0405059,0.0539,0.0891758,0.121832,-0.0671959,0.0477279,-0.013659,-0.069,0.0640559,-0.0331269,-0.0364239,0.00565199,-0.017113,-0.10362,0.0552639,-0.00706499,-0.0643699,0.08,0.110528,-0.108644,0.00374837,-0.020567,-0.0464719,-0.015386,0.0979678,-0.02364,-0.012717,0.0251199,-0.0389359,0.0828958,0.10676,0.0390929,0.0756738,0.0140515,-0.021823,0.162024,0.0941998,-0.0118535,-0.0452159,-0.0298299,0.0423899,0.0712,0.002487,-0.00883123,0.0577759,-0.0189185,0.0168775,0.0408199,-0.0405059,0.0539,-0.0480419,-0.0277889,0.0872918,-0.0189185\n')
+
     def write_true_false_model_files(self):
         with codecs.open(self.VALIDATION_FILE, 'w', 'utf-8') as validation_file:
             validation_file.write('1\tq1a1\t0\n')
diff --git a/tests/data/instances/text_classification/frame_embedded_label_instance_test.py b/tests/data/instances/text_classification/frame_embedded_label_instance_test.py
new file mode 100644
index 000000000..80812a0bd
--- /dev/null
+++ b/tests/data/instances/text_classification/frame_embedded_label_instance_test.py
@@ -0,0 +1,101 @@
+# pylint: disable=no-self-use,invalid-name
+import numpy
+
+from deep_qa.data import DataIndexer
+from deep_qa.data.instances.text_classification.frame_embedded_label_instance import FrameEmbeddedLabelInstance, \
+    IndexedNumericalFrameInstance
+from tests.common.test_case import DeepQaTestCase
+
+
+class TestFrameEmbeddedLabelInstance(DeepQaTestCase):
+
+    embedded_label_str = "0.0891758,0.121832,-0.0671959,0.0477279,-0.013659,-0.0671959,0.0640559,-0.0331269 , " \
+                              "-0.0364239,0.00565199,-0.017113,-0.10362,0.0552639,-0.00706499,-0.0643699,0.08," \
+                              "0.110528,-0.108644,0.00374837,-0.020567,-0.0464719,-0.015386,0.0979678,-0.02364," \
+                              "-0.012717,0.0251199,-0.0389359,0.0828958,0.10676,0.0390929,0.0756738,0.0140515," \
+                              "-0.021823,0.162024,0.0941998,-0.0118535,-0.0452159,-0.0298299,0.0423899,0.0712," \
+                              "0.002487,-0.00883123,0.0577759,-0.0189185,0.0168775,0.0408199,-0.0405059,0.0539," \
+                              "0.0891758,0.121832,-0.0671959,0.0477279,-0.013659,-0.069,0.0640559,-0.0331269," \
+                              "-0.0364239,0.00565199,-0.017113,-0.10362,0.0552639,-0.00706499,-0.0643699,0.08," \
+                              "0.110528,-0.108644,0.00374837,-0.020567,-0.0464719,-0.015386,0.0979678,-0.02364," \
+                              "-0.012717,0.0251199,-0.0389359,0.0828958,0.10676,0.0390929,0.0756738,0.0140515," \
+                              "-0.021823,0.162024,0.0941998,-0.0118535,-0.0452159,-0.0298299,0.0423899,0.0712," \
+                              "0.002487,-0.00883123,0.0577759,-0.0189185,0.0168775,0.0408199,-0.0405059,0.0539," \
+                              "-0.0480419,-0.0277889,0.0872918,-0.0189185"
+
+    embedded_label = numpy.array(list(embedded_label_str.replace(' ', '').split(',')), dtype='float64')
+
+    def setUp(self):
+        super(TestFrameEmbeddedLabelInstance, self).setUp()
+        # Example of a typical input
+        self.line = "event:plant absorb water###" \
+                    "participant:water###" \
+                    "agent:plant###" \
+                    "finalloc:" \
+                    + "\t" + "finalloc:"+self.embedded_label_str
+        self.line_with_no_label_val = "event:plant absorb water###" \
+                                      "participant:water###" \
+                                      "agent:plant" \
+                                      + "\t" + "finalloc:"+self.embedded_label_str
+        self.padded_slots = ['plant', 'missingval', 'missingval', 'missingval', 'missingval',
+                             'plant absorb water', 'ques', 'missingval', 'missingval',
+                             'missingval', 'missingval', 'missingval', 'missingval', 'missingval', 'missingval',
+                             'missingval', 'missingval', 'missingval', 'missingval', 'missingval', 'missingval',
+                             'missingval', 'missingval', 'missingval', 'missingval', 'missingval', 'water']
+        self.data_indexer = DataIndexer()
+        for word in ['plant', 'missingval', 'absorb', 'ques', 'water']:
+            self.data_indexer.add_word_to_index(word)
+
+    def test_convert_instance_to_indexed_instance(self):
+        instance = FrameEmbeddedLabelInstance.read_from_line(self.line)
+        indexed_instance = instance.to_indexed_instance(self.data_indexer)
+        assert (indexed_instance.label == self.embedded_label).all()
+
+    def test_slots_unwrap_correctly(self):
+        instance = FrameEmbeddedLabelInstance.read_from_line(self.line)
+        # what we construct
+        machine_label = instance.label
+        machine_slot_values = instance.text
+        # do they match?
+        assert (machine_label == self.embedded_label).all()
+        assert machine_slot_values == self.padded_slots
+
+    def test_words_from_frame_aggregated_correctly(self):
+        instance = FrameEmbeddedLabelInstance.read_from_line(self.line)
+        # Compared to analogous test in FrameInstanceTest, "soil" is missing as a true label.
+        assert len(instance.words()['words']) == 29
+
+    def test_words_from_no_label_value_frame_aggregated_correctly(self):
+        instance = FrameEmbeddedLabelInstance.read_from_line(self.line_with_no_label_val)
+        assert len(instance.words()['words']) == 29
+
+
+class TestIndexedFrameInstance(DeepQaTestCase):
+    embedded_label_str = "0.0891758,0.121832,-0.0671959,0.0477279,-0.013659,-0.0671959,0.0640559,-0.0331269 , " \
+                              "-0.0364239,0.00565199,-0.017113,-0.10362,0.0552639,-0.00706499,-0.0643699,0.08," \
+                              "0.110528,-0.108644,0.00374837,-0.020567,-0.0464719,-0.015386,0.0979678,-0.02364," \
+                              "-0.012717,0.0251199,-0.0389359,0.0828958,0.10676,0.0390929,0.0756738,0.0140515," \
+                              "-0.021823,0.162024,0.0941998,-0.0118535,-0.0452159,-0.0298299,0.0423899,0.0712," \
+                              "0.002487,-0.00883123,0.0577759,-0.0189185,0.0168775,0.0408199,-0.0405059,0.0539," \
+                              "0.0891758,0.121832,-0.0671959,0.0477279,-0.013659,-0.069,0.0640559,-0.0331269," \
+                              "-0.0364239,0.00565199,-0.017113,-0.10362,0.0552639,-0.00706499,-0.0643699,0.08," \
+                              "0.110528,-0.108644,0.00374837,-0.020567,-0.0464719,-0.015386,0.0979678,-0.02364," \
+                              "-0.012717,0.0251199,-0.0389359,0.0828958,0.10676,0.0390929,0.0756738,0.0140515," \
+                              "-0.021823,0.162024,0.0941998,-0.0118535,-0.0452159,-0.0298299,0.0423899,0.0712," \
+                              "0.002487,-0.00883123,0.0577759,-0.0189185,0.0168775,0.0408199,-0.0405059,0.0539," \
+                              "-0.0480419,-0.0277889,0.0872918,-0.0189185"
+    embedded_label = numpy.array(list(embedded_label_str.replace(' ', '').split(',')), dtype='float64')
+
+    def test_words_from_frame_aggregated_correctly(self):
+        # word ids in phrases, that would be eventually padded
+        indexed_instance = IndexedNumericalFrameInstance([[1000], [1, 2, 3, 4, 5, 6, 7, 8], [1, 2, 3]],
+                                                         self.embedded_label)
+        # unpadded label should be read correctly.
+        assert (indexed_instance.label == TestFrameEmbeddedLabelInstance.embedded_label).any()
+        padding_lengths = indexed_instance.get_padding_lengths()
+        assert padding_lengths['num_sentence_words'] == 8
+        indexed_instance.pad(padding_lengths)
+        assert (indexed_instance.label == TestFrameEmbeddedLabelInstance.embedded_label).any()
+        assert indexed_instance.word_indices == [[1000, 0, 0, 0, 0, 0, 0, 0],
+                                                 [1, 2, 3, 4, 5, 6, 7, 8],
+                                                 [1, 2, 3, 0, 0, 0, 0, 0]]
diff --git a/tests/data/instances/text_classification/frame_instance_test.py b/tests/data/instances/text_classification/frame_instance_test.py
new file mode 100644
index 000000000..eddb13d15
--- /dev/null
+++ b/tests/data/instances/text_classification/frame_instance_test.py
@@ -0,0 +1,86 @@
+# pylint: disable=no-self-use,invalid-name
+from deep_qa.data import DataIndexer
+
+from deep_qa.data.instances.text_classification.frame_instance import FrameInstance, IndexedFrameInstance
+from tests.common.test_case import DeepQaTestCase
+
+
+class TestFrameInstance(DeepQaTestCase):
+
+    def setUp(self):
+        super(TestFrameInstance, self).setUp()
+        # Example of a typical input
+        self.line = "event:plant absorb water###" \
+                    "participant:water###" \
+                    "agent:plant###" \
+                    "finalloc:soil" \
+                    + "\t" + "finalloc:soil"
+        self.line_with_no_label_val = "event:plant absorb water###" \
+                                      "participant:water###" \
+                                      "agent:plant###" \
+                                      "finalloc:soil" \
+                                      + "\t" + "finalloc"
+        self.padded_slots = ['plant', 'missingval', 'missingval', 'missingval', 'missingval',
+                             'plant absorb water', 'ques', 'missingval', 'missingval',
+                             'missingval', 'missingval', 'missingval', 'missingval', 'missingval', 'missingval',
+                             'missingval', 'missingval', 'missingval', 'missingval', 'missingval', 'missingval',
+                             'missingval', 'missingval', 'missingval', 'missingval', 'missingval', 'water']
+        self.data_indexer = DataIndexer()
+        for word in ['plant', 'missingval', 'absorb', 'ques', 'water', 'soil']:
+            self.data_indexer.add_word_to_index(word)
+
+    def test_convert_instance_to_indexed_instance(self):
+        instance = FrameInstance.read_from_line(self.line)
+        indexed_instance = instance.to_indexed_instance(self.data_indexer)
+        assert indexed_instance.label == [self.data_indexer.get_word_index('soil')]
+
+    def test_convert_instance_no_label_value_to_indexed_instance(self):
+        instance = FrameInstance.read_from_line(self.line_with_no_label_val)
+        indexed_instance = instance.to_indexed_instance(self.data_indexer)
+        assert indexed_instance.label == [self.data_indexer.get_word_index('soil')]
+
+    def test_slots_unwrap_correctly(self):
+        instance = FrameInstance.read_from_line(self.line)
+        # what we construct
+        machine_label = instance.label
+        machine_slot_values = instance.text
+        # what we expect
+        expected_label = "soil"
+        # do they match?
+        assert machine_label == expected_label
+        assert machine_slot_values == self.padded_slots
+
+    def test_slots_no_label_value_unwrap_correctly(self):
+        instance = FrameInstance.read_from_line(self.line_with_no_label_val)
+        # what we construct
+        machine_label = instance.label
+        machine_slot_values = instance.text
+        # what we expect
+        expected_label = "soil"
+        # do they match?
+        assert machine_label == expected_label
+        assert machine_slot_values == self.padded_slots
+
+    def test_words_from_frame_aggregated_correctly(self):
+        instance = FrameInstance.read_from_line(self.line)
+        assert len(instance.words()['words']) == 30
+
+    def test_words_from_no_label_value_frame_aggregated_correctly(self):
+        instance = FrameInstance.read_from_line(self.line_with_no_label_val)
+        assert len(instance.words()['words']) == 30
+
+
+class TestIndexedFrameInstance(DeepQaTestCase):
+
+    def test_words_from_frame_aggregated_correctly(self):
+        indexed_instance = IndexedFrameInstance([[1000], [1, 2, 3, 4, 5, 6, 7, 8],
+                                                 [1, 2, 3]], [1, 2, 3])
+        # unpadded label should be read correctly.
+        assert indexed_instance.label == [1, 2, 3]
+        padding_lengths = indexed_instance.get_padding_lengths()
+        assert padding_lengths['num_sentence_words'] == 8
+        indexed_instance.pad(padding_lengths)
+        assert indexed_instance.label == [1, 2, 3, 0, 0, 0, 0, 0]
+        assert indexed_instance.word_indices == [[1000, 0, 0, 0, 0, 0, 0, 0],
+                                                 [1, 2, 3, 4, 5, 6, 7, 8],
+                                                 [1, 2, 3, 0, 0, 0, 0, 0]]
diff --git a/tests/layers/encoders/averaged_bow_encoder_test.py b/tests/layers/encoders/averaged_bow_encoder_test.py
new file mode 100644
index 000000000..dcd9c0b41
--- /dev/null
+++ b/tests/layers/encoders/averaged_bow_encoder_test.py
@@ -0,0 +1,106 @@
+# pylint: disable=no-self-use,invalid-name
+import numpy
+from keras.layers import Input, Embedding
+from keras.models import Model
+
+from deep_qa.layers.wrappers.output_mask import OutputMask
+from deep_qa.layers.encoders.AveragedBOWEncoder import AveragedBOWEncoder
+from tests.common.test_case import DeepQaTestCase
+
+
+class TestAveragedBOWEncoder(DeepQaTestCase):
+
+    def test_on_unmasked_input(self):
+        dimension_to_average = 2
+        num_dimensions = 3
+        sentence_length = 5
+        embedding_dim = 10
+        vocabulary_size = 15
+        input_layer = Input(shape=(sentence_length,), dtype='int32')
+        # Embedding does not mask zeros
+        embedding = Embedding(input_dim=vocabulary_size, output_dim=embedding_dim)
+        encoder = AveragedBOWEncoder(dimension_to_average, num_dimensions)
+        embedded_input = embedding(input_layer)
+        encoded_input = encoder(embedded_input)
+        model = Model(inputs=input_layer, outputs=encoded_input)
+        model.compile(loss="mse", optimizer="sgd")  # Will not train this model
+        test_input = numpy.asarray([[0, 3, 1, 7, 10]], dtype='int32')
+        embedding_weights = embedding.get_weights()[0]  # get_weights returns a list with one element.
+        expected_output = numpy.mean(embedding_weights[test_input], axis=dimension_to_average)
+        actual_output = model.predict(test_input)
+        numpy.testing.assert_array_almost_equal(expected_output, actual_output)
+
+    def test_on_masked_input(self):
+        # Average over a dimension in which some elements are masked, and
+        # check that they are masked correctly in the average.
+        dimension_to_average = 1
+        num_dimensions = 3
+        sentence_length = 5
+        embedding_dim = 10
+        vocabulary_size = 15
+        input_layer = Input(shape=(sentence_length,), dtype='int32')
+        # Embedding masks zeros
+        embedding = Embedding(input_dim=vocabulary_size, output_dim=embedding_dim, mask_zero=True)
+        encoder = AveragedBOWEncoder(dimension_to_average, num_dimensions)
+        embedded_input = embedding(input_layer)
+        encoded_input = encoder(embedded_input)
+        encoder_mask = OutputMask()(encoded_input)
+        model = Model(inputs=input_layer, outputs=[encoded_input, encoder_mask])
+        test_input = numpy.asarray([[0, 3, 1, 7, 10]], dtype='int32')
+        embedding_weights = embedding.get_weights()[0]  # get_weights returns a list with one element.
+
+        # Don't take the first element because it should be masked.
+        expected_output = numpy.mean(embedding_weights[test_input[:, 1:]], axis=dimension_to_average)
+        actual_output, actual_mask = model.predict(test_input)
+        # Mask should now
+
+        numpy.testing.assert_array_equal(actual_mask, numpy.array([True]))
+        numpy.testing.assert_array_almost_equal(expected_output, actual_output)
+
+    def test_mask_is_propagated_if_required(self):
+        # Here we test averaging over a dimension which is not masked, but in which the
+        # output still requires a mask.
+        dimension_to_average = 2
+        num_dimensions = 3
+        sentence_length = 5
+        embedding_dim = 10
+        vocabulary_size = 15
+        input_layer = Input(shape=(sentence_length,), dtype='int32')
+        # Embedding masks zeros
+        embedding = Embedding(input_dim=vocabulary_size, output_dim=embedding_dim, mask_zero=True)
+        encoder = AveragedBOWEncoder(dimension_to_average, num_dimensions)
+        embedded_input = embedding(input_layer)
+        encoded_input = encoder(embedded_input)
+        encoder_mask = OutputMask()(encoded_input)
+        model = Model(inputs=input_layer, outputs=[encoded_input, encoder_mask])
+        test_input = numpy.asarray([[0, 3, 1, 7, 10]], dtype='int32')
+        embedding_weights = embedding.get_weights()[0]  # get_weights returns a list with one element.
+
+        # Here, the dimension we are reducing is the embedding dimension. In this case,
+        # the actual value of the returned output should be equal to averaging without masking,
+        # (as there is nothing to mask in a dimension not covered by the mask) but the mask should
+        # be propagated through the layer, still masking the correct index.
+        expected_output = numpy.mean(embedding_weights[test_input], axis=dimension_to_average)
+        actual_output, actual_mask = model.predict(test_input)
+        # First index should still be masked.
+        numpy.testing.assert_array_equal(actual_mask, numpy.array([[False, True, True, True, True]]))
+        numpy.testing.assert_array_almost_equal(expected_output, actual_output)
+
+    def test_on_all_zeros(self):
+        sentence_length = 5
+        embedding_dim = 10
+        vocabulary_size = 15
+        input_layer = Input(shape=(sentence_length,), dtype='int32')
+        # Embedding masks zeros
+        embedding = Embedding(input_dim=vocabulary_size, output_dim=embedding_dim, mask_zero=True)
+        encoder = AveragedBOWEncoder()
+        embedded_input = embedding(input_layer)
+        encoded_input = encoder(embedded_input)
+        model = Model(inputs=input_layer, outputs=encoded_input)
+        model.compile(loss="mse", optimizer="sgd")  # Will not train this model
+        test_input = numpy.asarray([[0, 0, 0, 0, 0]], dtype='int32')
+        # Omitting the first element (0), because that is supposed to be masked in the model.
+        expected_output = numpy.zeros((1, embedding_dim))
+        actual_output = model.predict(test_input)
+        # Following comparison is till the sixth decimal.
+        numpy.testing.assert_array_almost_equal(expected_output, actual_output)
diff --git a/tests/models/text_classification/__init__.py b/tests/models/text_classification/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/models/text_classification/frame_cloze_model_test.py b/tests/models/text_classification/frame_cloze_model_test.py
new file mode 100644
index 000000000..3bbbb8933
--- /dev/null
+++ b/tests/models/text_classification/frame_cloze_model_test.py
@@ -0,0 +1,26 @@
+from deep_qa.common.params import Params
+from deep_qa.models.text_classification import FrameClozeModel
+from tests.common.test_case import DeepQaTestCase
+
+
+class TestFrameClozeModel(DeepQaTestCase):
+    def test_trains_and_loads_correctly(self):
+        self.write_frame_cloze_files()
+        pre_ = "/Users/nikett/Documents/work/code/thirdparty/deepqa/deep_qa/datasets-pulled/glove.6B.100d.txt.gz"
+        args = Params({
+                'save_models': True,
+                'show_summary_with_masking_info': True,
+                'instance_type': 'FrameEmbeddedLabelInstance',
+                'validation_metric': 'val_loss',
+                # 'model_serialization_prefix': '/Users/nikett/TEMP/',
+                'loss': 'mean_squared_error',
+                # 'num_slots': 27, TODO: why? ->  "Extra parameters passed to Trainer: {'num_slots': 27}"
+                "embeddings": {"words":
+                               {"dimension": 100,
+                                "pretrained_embeddings_file": pre_
+                               },
+                               "characters": {"dimension": 8}
+                              },
+                'tokenizer': {'processor': {'word_splitter': 'simple'}},
+                })
+        self.ensure_model_trains_and_loads(FrameClozeModel, args)