class_docstr: Q function based on a CNN-MLP structure for continuous action space.
  
  This class implements a Q value network to predict Q based on the
  input state and action. It uses an CNN and a MLP to fit the function
  of Q(s, a).
  
  Args:
      env_spec (EnvSpec): Environment specification.
      filters (Tuple[Tuple[int, Tuple[int, int]], ...]): Number and dimension
          of filters. For example, ((3, (3, 5)), (32, (3, 3))) means there
          are two convolutional layers. The filter for the first layer have 3
          channels and its shape is (3 x 5), while the filter for the second
          layer have 32 channels and its shape is (3 x 3).
      strides (tuple[int]): The stride of the sliding window. For example,
          (1, 2) means there are two convolutional layers. The stride of the
          filter for first layer is 1 and that of the second layer is 2.
      hidden_sizes (tuple[int]): Output dimension of dense layer(s).
          For example, (32, 32) means the MLP of this q-function consists of
          two hidden layers, each with 32 hidden units.
      action_merge_layer (int): The index of layers at which to concatenate
          action inputs with the network. The indexing works like standard
          python list indexing. Index of 0 refers to the input layer
          (observation input) while an index of -1 points to the last
          hidden layer. Default parameter points to second layer from the
          end.
      name (str): Variable scope of the cnn.
      padding (str): The type of padding algorithm to use,
          either 'SAME' or 'VALID'.
      max_pooling (bool): Boolean for using max pooling layer or not.
      pool_shapes (tuple[int]): Dimension of the pooling layer(s). For
          example, (2, 2) means that all the pooling layers have
          shape (2, 2).
      pool_strides (tuple[int]): The strides of the pooling layer(s). For
          example, (2, 2) means that all the pooling layers have
          strides (2, 2).
      cnn_hidden_nonlinearity (callable): Activation function for
          intermediate dense layer(s) in the CNN. It should return a
          tf.Tensor. Set it to None to maintain a linear activation.
      hidden_nonlinearity (callable): Activation function for intermediate
          dense layer(s) in the MLP. It should return a tf.Tensor. Set it to
          None to maintain a linear activation.
      hidden_w_init (callable): Initializer function for the weight
          of intermediate dense layer(s) in the MLP. The function should
          return a tf.Tensor.
      hidden_b_init (callable): Initializer function for the bias
          of intermediate dense layer(s) in the MLP. The function should
          return a tf.Tensor.
      output_nonlinearity (callable): Activation function for output dense
          layer in the MLP. It should return a tf.Tensor. Set it to None
          to maintain a linear activation.
      output_w_init (callable): Initializer function for the weight
          of output dense layer(s) in the MLP. The function should return
          a tf.Tensor.
      output_b_init (callable): Initializer function for the bias
          of output dense layer(s) in the MLP. The function should return
          a tf.Tensor.
      layer_normalization (bool): Bool for using layer normalization or not.
code: def _initialize(self):
      action_ph = tf.compat.v1.placeholder(
          tf.float32, (None,) + self._action_dim, name="action"
      )
      if isinstance(self._env_spec.observation_space, akro.Image):
          obs_ph = tf.compat.v1.placeholder(
              tf.uint8, (None,) + self._obs_dim, name="state"
          )
          augmented_obs_ph = tf.cast(obs_ph, tf.float32) / 255.0
      else:
          obs_ph = tf.compat.v1.placeholder(
              tf.float32, (None,) + self._obs_dim, name="state"
          )
          augmented_obs_ph = obs_ph
      outputs = super().build(augmented_obs_ph, action_ph).outputs
      self._f_qval = tf.compat.v1.get_default_session().make_callable(
          outputs, feed_list=[obs_ph, action_ph]
      )
  
      self._obs_input = obs_ph
      self._act_input = action_ph
  
file_path: garage/src/garage/tf/q_functions/continuous_cnn_q_function.py
imports: import akro
  import tensorflow
  from garage.experiment import deterministic
  from garage.tf.models import CNNMLPMergeModel
label_desc: Use image node_id 2 for calling the ContinuousCNNQFunction obj's underlying member method code with example usage: obj._initialize() without return types