class_docstr: Also a word tagging model, but uses bytes as inputs to the model. Using
  bytes instead of words, the model does not need to store a word embedding
  table mapping words in the vocab to their embedding vector representations,
  but instead compute them on the fly using CharacterEmbedding. This produces
  an exported/serialized model that requires much less storage space as well
  as less memory during run/inference time.
code: def torchscriptify(self, tensorizers, traced_model):
      output_layer = self.output_layer.torchscript_predictions()
      max_seq_len = tensorizers["token_bytes"].max_seq_len or -1
      max_byte_len = tensorizers["token_bytes"].max_byte_len
      byte_offset_for_non_padding = tensorizers[
          "token_bytes"
      ].offset_for_non_padding
  
      class Model(torch.jit.ScriptModule):
          def __init__(self):
              super().__init__()
              self.max_seq_len = torch.jit.Attribute(max_seq_len, int)
              self.max_byte_len = torch.jit.Attribute(max_byte_len, int)
              self.byte_offset_for_non_padding = torch.jit.Attribute(
                  byte_offset_for_non_padding, int
              )
              self.model = traced_model
              self.output_layer = output_layer
  
          @torch.jit.script_method
          def forward(
              self,
              texts: Optional[List[str]] = None,
              multi_texts: Optional[List[List[str]]] = None,
              tokens: Optional[List[List[str]]] = None,
              languages: Optional[List[str]] = None,
          ):
              if tokens is None:
                  raise RuntimeError("tokens is required")
  
              tokens = truncate_tokens(
                  tokens, self.max_seq_len, SpecialTokens.PAD
              )
              seq_lens = make_sequence_lengths(tokens)
              token_bytes, _ = make_byte_inputs(
                  tokens,
                  self.max_byte_len,
                  self.byte_offset_for_non_padding,
              )
              logits = self.model(token_bytes, torch.tensor(seq_lens))
              return self.output_layer(logits)
  
      return Model()
  
imports: from typing import List, Optional, Union
  import torch
  from pytext.common.constants import SpecialTokens
  from pytext.data.tensorizers import ByteTokenTensorizer, SlotLabelTensorizer, TokenTensorizer
  from pytext.data.tokenizers import DoNothingTokenizer
  from pytext.exporters.exporter import ModelExporter
  from pytext.models.decoders.mlp_decoder import MLPDecoder
  from pytext.models.embeddings import CharacterEmbedding, WordEmbedding
  from pytext.models.model import Model
  from pytext.models.module import create_module
  from pytext.models.output_layers import CRFOutputLayer, WordTaggingOutputLayer
  from pytext.models.representations.bilstm_slot_attn import BiLSTMSlotAttention
  from pytext.models.representations.biseqcnn import BSeqCNNRepresentation
  from pytext.models.representations.deepcnn import DeepCNNRepresentation
  from pytext.models.representations.pass_through import PassThroughRepresentation
  from pytext.torchscript.utils import make_byte_inputs, make_sequence_lengths, truncate_tokens
  from pytext.torchscript.vocab import ScriptVocabulary
  from pytext.utils.usage import log_class_usage
  from pytorch.text.fb.utils.transform_utils import pad_2d
label_desc: Use image node_id 6 for calling the WordTaggingLiteModel obj's underlying member method code with example usage: obj.torchscriptify(tensorizers, traced_model) and returns: Model, self