class_docstr: Character-level CNN encoder to generate word representations, as input to
  transformer encoder.
code: def forward(self, src_tokens, src_lengths, char_inds, word_lengths):
      self.tracker.reset()
      # char_inds has shape (batch_size, max_words_per_sent, max_word_len)
      bsz, seqlen, maxchars = char_inds.size()
      # char_cnn_encoder takes input (max_word_length, total_words)
      char_inds_flat = char_inds.view(-1, maxchars).t()
      # output (total_words, encoder_dim)
      char_cnn_output = self.char_cnn_encoder(char_inds_flat)
      x = char_cnn_output.view(bsz, seqlen, char_cnn_output.shape[-1])
      x = x.transpose(0, 1)  # (seqlen, bsz, char_cnn_output_dim)
      x = self.char_layer_norm(x)
      x = self.char_scale * x
  
      embedded_tokens = self.embed_tokens(src_tokens)
      # (seqlen, bsz, token_embed_dim)
      embedded_tokens = embedded_tokens.transpose(0, 1)
      embedded_tokens = self.word_layer_norm(embedded_tokens)
      embedded_tokens = self.word_scale * embedded_tokens
      x = torch.cat([x, embedded_tokens], dim=2)
  
      self.tracker.track(
          x, "token_embeddings", retain_grad=self.track_gradients
      )
  
      # T x B x C -> B x T x C
      x = x.transpose(0, 1)
  
      if self.word_to_transformer_embed is not None:
          x = self.word_to_transformer_embed(x)
      positions = self.embed_positions(src_tokens)
      x += positions
      x = F.dropout(x, p=self.dropout, training=self.training)
      # B x T x C -> T x B x C
      x = x.transpose(0, 1)
      # compute padding mask (B x T)
      encoder_padding_mask = src_tokens.eq(self.padding_idx)
      if not encoder_padding_mask.any():
          encoder_padding_mask = None
  
      x = self.transformer_encoder_given_embeddings(
          x=x,
          positions=positions,
          encoder_padding_mask=encoder_padding_mask,
      )
  
      # tracing requires a tensor value
      if self.onnx_export_model and encoder_padding_mask is None:
          encoder_padding_mask = torch.Tensor([]).type_as(src_tokens)
  
      return x, src_tokens, encoder_padding_mask
  
imports: import logging
  import math
  from ast import literal_eval
  import torch
  import torch.nn
  import torch.nn.functional
  from fairseq.models import FairseqEncoder, register_model, register_model_architecture, transformer
  from fairseq.modules import SinusoidalPositionalEmbedding
  from pytorch_translate import char_encoder, char_source_model, hybrid_transformer_rnn, model_constants, rnn, transformer, utils, vocab_constants
  from pytorch_translate.common_layers import TransformerEncoderGivenEmbeddings, VariableTracker
  from pytorch_translate.data.dictionary import TAGS
label_desc: Use image node_id 5 for calling the CharCNNEncoder obj's underlying member method code with example usage: obj.forward(src_tokens, src_lengths, char_inds, word_lengths) and returns: x,  src_tokens,  encoder_padding_mask