code: def _get_encoder_module(self) -> Tuple[mx.mod.BucketingModule, int]:
          
  
          def sym_gen(source_seq_len: int):
              source = mx.sym.Variable(C.SOURCE_NAME)
              source_words = source.split(num_outputs=self.num_source_factors, axis=2, squeeze_axis=True)[0]
              source_length = utils.compute_lengths(source_words)
  
              # source embedding
              (source_embed,
               source_embed_length,
               source_embed_seq_len) = self.embedding_source.encode(source, source_length, source_seq_len)
  
              # encoder
              # source_encoded: (source_encoded_length, batch_size, encoder_depth)
              (source_encoded,
               source_encoded_length,
               source_encoded_seq_len) = self.encoder.encode(source_embed,
                                                             source_embed_length,
                                                             source_embed_seq_len)
  
              # initial decoder states
              decoder_init_states = self.decoder.init_states(source_encoded,
                                                             source_encoded_length,
                                                             source_encoded_seq_len)
  
              data_names = [C.SOURCE_NAME]
              label_names = []  # type: List[str]
  
              # predict length ratios
              predicted_length_ratios = []  # type: List[mx.nd.NDArray]
              if self.length_ratio is not None:
                  # predicted_length_ratios: List[(n, 1)]
                  predicted_length_ratios = [self.length_ratio(source_encoded, source_encoded_length)]
  
              return mx.sym.Group(decoder_init_states + predicted_length_ratios), data_names, label_names
  
          default_bucket_key = self.max_input_length
          module = mx.mod.BucketingModule(sym_gen=sym_gen,
                                          default_bucket_key=default_bucket_key,
                                          context=self.context)
          return module, default_bucket_key
docs: Returns a BucketingModule for the encoder. Given a source sequence, it returns
          the initial decoder states of the model.
          The bucket key for this module is the length of the source sequence.
  
          :return: Tuple of encoder module and default bucket key.