class_docstr: This class implements the Biattentive Classification Network model described
  in section 5 of `Learned in Translation: Contextualized Word Vectors (NIPS 2017)
  <https://arxiv.org/abs/1708.00107>`_ for text classification. We assume we're
  given a piece of text, and we predict some output label.
  
  At a high level, the model starts by embedding the tokens and running them through
  a feed-forward neural net (``pre_encode_feedforward``). Then, we encode these
  representations with a ``Seq2SeqEncoder`` (``encoder``). We run biattention
  on the encoder output represenatations (self-attention in this case, since
  the two representations that typically go into biattention are identical) and
  get out an attentive vector representation of the text. We combine this text
  representation with the encoder outputs computed earlier, and then run this through
  yet another ``Seq2SeqEncoder`` (the ``integrator``). Lastly, we take the output of the
  integrator and max, min, mean, and self-attention pool to create a final representation,
  which is passed through a maxout network or some feed-forward layers
  to output a classification (``output_layer``).
  
  Parameters
  ----------
  vocab : ``Vocabulary``, required
      A Vocabulary, required in order to compute sizes for input/output projections.
  text_field_embedder : ``TextFieldEmbedder``, required
      Used to embed the ``tokens`` ``TextField`` we get as input to the model.
  embedding_dropout : ``float``
      The amount of dropout to apply on the embeddings.
  pre_encode_feedforward : ``FeedForward``
      A feedforward network that is run on the embedded tokens before they
      are passed to the encoder.
  encoder : ``Seq2SeqEncoder``
      The encoder to use on the tokens.
  integrator : ``Seq2SeqEncoder``
      The encoder to use when integrating the attentive text encoding
      with the token encodings.
  integrator_dropout : ``float``
      The amount of dropout to apply on integrator output.
  output_layer : ``Union[Maxout, FeedForward]``
      The maxout or feed forward network that takes the final representations and produces
      a classification prediction.
  elmo : ``Elmo``, optional (default=``None``)
      If provided, will be used to concatenate pretrained ELMo representations to
      either the integrator output (``use_integrator_output_elmo``) or the
      input (``use_input_elmo``).
  use_input_elmo : ``bool`` (default=``False``)
      If true, concatenate pretrained ELMo representations to the input vectors.
  use_integrator_output_elmo : ``bool`` (default=``False``)
      If true, concatenate pretrained ELMo representations to the integrator output.
  initializer : ``InitializerApplicator``, optional (default=``InitializerApplicator()``)
      Used to initialize the model parameters.
  regularizer : ``RegularizerApplicator``, optional (default=``None``)
      If provided, will be used to calculate the regularization penalty during training.
class_docstr_tok: ["This","class","implements","the","Biattentive","Classification","Network","model","described","in","section","5","of","`","Learned","in","Translation",":","Contextualized","Word","Vectors","(","NIPS","2017",")","<","https",":","\/\/arxiv.org\/abs\/1708.00107",">","`","_","for","text","classification",".","We","assume","we're","given","a","piece","of","text",",","and","we","predict","some","output","label",".","At","a","high","level",",","the","model","starts","by","embedding","the","tokens","and","running","them","through","a","feed-forward","neural","net","(","``","pre_encode_feedforward","``",")",".","Then",",","we","encode","these","representations","with","a","``","Seq2SeqEncoder","``","(","``","encoder","``",")",".","We","run","biattention","on","the","encoder","output","represenatations","(","self-attention","in","this","case",",","since","the","two","representations","that","typically","go","into","biattention","are","identical",")","and","get","out","an","attentive","vector","representation","of","the","text",".","We","combine","this","text","representation","with","the","encoder","outputs","computed","earlier",",","and","then","run","this","through","yet","another","``","Seq2SeqEncoder","``","(","the","``","integrator","``",")",".","Lastly",",","we","take","the","output","of","the","integrator","and","max",",","min",",","mean",",","and","self-attention","pool","to","create","a","final","representation",",","which","is","passed","through","a","maxout","network","or","some","feed-forward","layers","to","output","a","classification","(","``","output_layer","``",")",".","Parameters","--","--","--","--","--","vocab",":","``","Vocabulary","``",",","required","A","Vocabulary",",","required","in","order","to","compute","sizes","for","input\/output","projections",".","text_field_embedder",":","``","TextFieldEmbedder","``",",","required","Used","to","embed","the","``","tokens","``","``","TextField","``","we","get","as","input","to","the","model",".","embedding_dropout",":","``","float","``","The","amount","of","dropout","to","apply","on","the","embeddings",".","pre_encode_feedforward",":","``","FeedForward","``","A","feedforward","network","that","is","run","on","the","embedded","tokens","before","they","are","passed","to","the","encoder",".","encoder",":","``","Seq2SeqEncoder","``","The","encoder","to","use","on","the","tokens",".","integrator",":","``","Seq2SeqEncoder","``","The","encoder","to","use","when","integrating","the","attentive","text","encoding","with","the","token","encodings",".","integrator_dropout",":","``","float","``","The","amount","of","dropout","to","apply","on","integrator","output",".","output_layer",":","``","Union","[","Maxout",",","FeedForward","]","``","The","maxout","or","feed","forward","network","that","takes","the","final","representations","and","produces","a","classification","prediction",".","elmo",":","``","Elmo","``",",","optional","(","default=","``","None","``",")","If","provided",",","will","be","used","to","concatenate","pretrained","ELMo","representations","to","either","the","integrator","output","(","``","use_integrator_output_elmo","``",")","or","the","input","(","``","use_input_elmo","``",")",".","use_input_elmo",":","``","bool","``","(","default=","``","False","``",")","If","true",",","concatenate","pretrained","ELMo","representations","to","the","input","vectors",".","use_integrator_output_elmo",":","``","bool","``","(","default=","``","False","``",")","If","true",",","concatenate","pretrained","ELMo","representations","to","the","integrator","output",".","initializer",":","``","InitializerApplicator","``",",","optional","(","default=","``","InitializerApplicator","(",")","``",")","Used","to","initialize","the","model","parameters",".","regularizer",":","``","RegularizerApplicator","``",",","optional","(","default=","``","None","``",")","If","provided",",","will","be","used","to","calculate","the","regularization","penalty","during","training","."]
code: def __init__(
      self,
      vocab,
      text_field_embedder,
      embedding_dropout,
      pre_encode_feedforward,
      encoder,
      integrator,
      integrator_dropout,
      output_layer,
      elmo,
      use_input_elmo=False,
      use_integrator_output_elmo=False,
      initializer=InitializerApplicator(),
      regularizer=None,
  ):
      super(BiattentiveClassificationNetwork, self).__init__(
          vocab, regularizer
      )
  
      self._text_field_embedder = text_field_embedder
      if "elmo" in list(
          self._text_field_embedder._token_embedders.keys()
      ):  # pylint: disable=protected-access
          raise ConfigurationError(
              "To use ELMo in the BiattentiveClassificationNetwork input, "
              "remove elmo from the text_field_embedder and pass an "
              "Elmo object to the BiattentiveClassificationNetwork and set the "
              "'use_input_elmo' and 'use_integrator_output_elmo' flags accordingly."
          )
      self._embedding_dropout = nn.Dropout(embedding_dropout)
      self._num_classes = self.vocab.get_vocab_size("labels")
  
      self._pre_encode_feedforward = pre_encode_feedforward
      self._encoder = encoder
      self._integrator = integrator
      self._integrator_dropout = nn.Dropout(integrator_dropout)
  
      self._elmo = elmo
      self._use_input_elmo = use_input_elmo
      self._use_integrator_output_elmo = use_integrator_output_elmo
      self._num_elmo_layers = int(self._use_input_elmo) + int(
          self._use_integrator_output_elmo
      )
      # Check that, if elmo is None, none of the elmo flags are set.
      if self._elmo is None and self._num_elmo_layers != 0:
          raise ConfigurationError(
              "One of 'use_input_elmo' or 'use_integrator_output_elmo' is True, "
              "but no Elmo object was provided upon construction. Pass in an Elmo "
              "object to use Elmo."
          )
  
      if self._elmo is not None:
          # Check that, if elmo is not None, we use it somewhere.
          if self._num_elmo_layers == 0:
              raise ConfigurationError(
                  "Elmo object provided upon construction, but both 'use_input_elmo' "
                  "and 'use_integrator_output_elmo' are 'False'. Set one of them to "
                  "'True' to use Elmo, or do not provide an Elmo object upon construction."
              )
          # Check that the number of flags set is equal to the num_output_representations of the Elmo object
          # pylint: disable=protected-access,too-many-format-args
          if len(self._elmo._scalar_mixes) != self._num_elmo_layers:
              raise ConfigurationError(
                  "Elmo object has num_output_representations=%s, but this does not "
                  "match the number of use_*_elmo flags set to true. use_input_elmo "
                  "is %s, and use_integrator_output_elmo is %s".format(
                      unicode(len(self._elmo._scalar_mixes)),
                      unicode(self._use_input_elmo),
                      unicode(self._use_integrator_output_elmo),
                  )
              )
  
      # Calculate combined integrator output dim, taking into account elmo
      if self._use_integrator_output_elmo:
          self._combined_integrator_output_dim = (
              self._integrator.get_output_dim()
              + self._elmo.get_output_dim()
          )
      else:
          self._combined_integrator_output_dim = (
              self._integrator.get_output_dim()
          )
  
      self._self_attentive_pooling_projection = nn.Linear(
          self._combined_integrator_output_dim, 1
      )
      self._output_layer = output_layer
  
      if self._use_input_elmo:
          check_dimensions_match(
              text_field_embedder.get_output_dim()
              + self._elmo.get_output_dim(),
              self._pre_encode_feedforward.get_input_dim(),
              "text field embedder output dim + ELMo output dim",
              "Pre-encoder feedforward input dim",
          )
      else:
          check_dimensions_match(
              text_field_embedder.get_output_dim(),
              self._pre_encode_feedforward.get_input_dim(),
              "text field embedder output dim",
              "Pre-encoder feedforward input dim",
          )
  
      check_dimensions_match(
          self._pre_encode_feedforward.get_output_dim(),
          self._encoder.get_input_dim(),
          "Pre-encoder feedforward output dim",
          "Encoder input dim",
      )
      check_dimensions_match(
          self._encoder.get_output_dim() * 3,
          self._integrator.get_input_dim(),
          "Encoder output dim * 3",
          "Integrator input dim",
      )
      if self._use_integrator_output_elmo:
          check_dimensions_match(
              self._combined_integrator_output_dim * 4,
              self._output_layer.get_input_dim(),
              "(Integrator output dim + ELMo output dim) * 4",
              "Output layer input dim",
          )
      else:
          check_dimensions_match(
              self._integrator.get_output_dim() * 4,
              self._output_layer.get_input_dim(),
              "Integrator output dim * 4",
              "Output layer input dim",
          )
  
      check_dimensions_match(
          self._output_layer.get_output_dim(),
          self._num_classes,
          "Output layer output dim",
          "Number of classes.",
      )
  
      self.metrics = {
          "accuracy": CategoricalAccuracy(),
          "accuracy3": CategoricalAccuracy(top_k=3),
      }
      self.loss = torch.nn.CrossEntropyLoss()
      initializer(self)
  
imports: from __future__ import division
  from __future__ import absolute_import
  import numpy
  import torch
  from torch import nn
  import torch.nn.functional
  from allennlp.common import Params
  from allennlp.common.checks import check_dimensions_match, ConfigurationError
  from allennlp.data import Vocabulary
  from allennlp.modules import Elmo, FeedForward, Maxout, Seq2SeqEncoder, TextFieldEmbedder
  from allennlp.models.model import Model
  from allennlp.nn import InitializerApplicator, RegularizerApplicator
  from allennlp.nn import util
  from allennlp.training.metrics import CategoricalAccuracy
label_desc: Use image node_id 1 to create a new BiattentiveClassificationNetwork object from inherited base classes: Model with example: obj = BiattentiveClassificationNetwork(vocab, text_field_embedder, embedding_dropout, pre_encode_feedforward, encoder, integrator, integrator_dropout, output_layer, elmo, use_input_elmo, use_integrator_output_elmo, initializer, regularizer)