class_docstr: Adaptive version of the `EncodingStageInterface`.
  
  This class has the same functionality as the `EncodingStageInterface`, but in
  addition maintains a state, which is adaptive based on the values being
  compressed and can parameterize the way encoding functionality works. Note
  that this is useful only in case where the encoding is executed in multiple
  iterations.
  
  A typical implementation of this interface would be a wrapper of an
  implementation of `EncodingStageInterface, which uses the existing stateless
  transformations and adds state that controls some of the parameters returned
  by the `get_params` method.
  
  The important distinction is that in addition to `encoded_tensors`, the
  `encode` method of this class returns an additional dictionary of
  `state_update_tensors`. The `commutes_with_sum` property talks about summation
  of only the `encoded_tensors`. The `state_update_tensors` can be aggregated
  in more flexible ways, specified by the `state_update_aggregation_modes`
  property, before being passed to the `update_state` method.
  
  Each implementation should also be wrapped by `tf_style_encoding_stage` to
  ensure adherence to the TensorFlow style guide. The adherence is enforced by
  the `BaseEncodingStageTest` test class. See `test_utils.py` for more details.
docstr: Returns the parameters needed for encoding.
  
  This method returns parameters controlling the behavior of the `encode` and
  `decode` methods.
  
  Note that this method is not purely functional in terms of `TensorFlow`. The
  params can be derived from an internal state of the compressor. For
  instance, if a constructor optionally takes a `Variable` as an input
  argument, which is allowed to change during iterative execution, that
  `Variable`, or a function of it, would be exposed via this method.However,
  only values that can be TensorFlow values should be exposed via params. If a
  parameter always needs to be a Python constant, for instance used for Python
  control flow, it should not be exposed via params, and accessed via `self`
  instead.
  
  Args:
    state: A dictionary of `Tensor` objects. This should be the object
      controlled by the `initial_state` and `update_state` methods.
  
  Returns:
    A tuple `(encode_params, decode_params)`, where
    `encode_params`: A dictionary to be passed as argument to the `encode`
      method.
    `decode_params`: A dictionary to be passed as argument to the `decode`
      method.
    Each value of the dictionaries can be either a `Tensor` or any python
    constant.
docstr_tok: ["Returns","the","parameters","needed","for","encoding",".","This","method","returns","parameters","controlling","the","behavior","of","the","`","encode","`","and","`","decode","`","methods",".","Note","that","this","method","is","not","purely","functional","in","terms","of","`","TensorFlow","`",".","The","params","can","be","derived","from","an","internal","state","of","the","compressor",".","For","instance",",","if","a","constructor","optionally","takes","a","`","Variable","`","as","an","input","argument",",","which","is","allowed","to","change","during","iterative","execution",",","that","`","Variable","`",",","or","a","function","of","it",",","would","be","exposed","via","this","method.However",",","only","values","that","can","be","TensorFlow","values","should","be","exposed","via","params",".","If","a","parameter","always","needs","to","be","a","Python","constant",",","for","instance","used","for","Python","control","flow",",","it","should","not","be","exposed","via","params",",","and","accessed","via","`","self","`","instead",".","Args",":","state",":","A","dictionary","of","`","Tensor","`","objects",".","This","should","be","the","object","controlled","by","the","`","initial_state","`","and","`","update_state","`","methods",".","Returns",":","A","tuple","`","(","encode_params",",","decode_params",")","`",",","where","`","encode_params","`",":","A","dictionary","to","be","passed","as","argument","to","the","`","encode","`","method",".","`","decode_params","`",":","A","dictionary","to","be","passed","as","argument","to","the","`","decode","`","method",".","Each","value","of","the","dictionaries","can","be","either","a","`","Tensor","`","or","any","python","constant","."]
code: def get_params(self, state):
      """Returns the parameters needed for encoding.
  
      This method returns parameters controlling the behavior of the `encode` and
      `decode` methods.
  
      Note that this method is not purely functional in terms of `TensorFlow`. The
      params can be derived from an internal state of the compressor. For
      instance, if a constructor optionally takes a `Variable` as an input
      argument, which is allowed to change during iterative execution, that
      `Variable`, or a function of it, would be exposed via this method.However,
      only values that can be TensorFlow values should be exposed via params. If a
      parameter always needs to be a Python constant, for instance used for Python
      control flow, it should not be exposed via params, and accessed via `self`
      instead.
  
      Args:
        state: A dictionary of `Tensor` objects. This should be the object
          controlled by the `initial_state` and `update_state` methods.
  
      Returns:
        A tuple `(encode_params, decode_params)`, where
        `encode_params`: A dictionary to be passed as argument to the `encode`
          method.
        `decode_params`: A dictionary to be passed as argument to the `decode`
          method.
        Each value of the dictionaries can be either a `Tensor` or any python
        constant.
      """
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import abc
  import enum
  import six
  import tensorflow
label_desc: Use image node_id 8 for calling the AdaptiveEncodingStageInterface obj's underlying member method code with example usage: obj.get_params(state) without return types