code: def test_adaptive_std_network_output_values(
      self,
      mock_normal,
      filters,
      in_channels,
      strides,
      output_dim,
      hidden_sizes,
  ):
      mock_normal.return_value = 0.5
      model = GaussianCNNModel(
          input_dim=self.input_dim,
          filters=filters,
          strides=strides,
          padding="VALID",
          output_dim=output_dim,
          hidden_sizes=hidden_sizes,
          std_share_network=False,
          adaptive_std=True,
          hidden_nonlinearity=None,
          std_hidden_nonlinearity=None,
          std_filters=filters,
          std_strides=strides,
          std_padding="VALID",
          std_hidden_sizes=hidden_sizes,
          hidden_w_init=tf.constant_initializer(0.01),
          output_w_init=tf.constant_initializer(1),
          std_hidden_w_init=tf.constant_initializer(0.01),
          std_output_w_init=tf.constant_initializer(1),
      )
      outputs = model.build(self._input_ph).outputs
  
      action, mean, log_std, std_param = self.sess.run(
          outputs[:-1], feed_dict={self._input_ph: self.obs}
      )
  
      filter_sum = 1
  
      for filter_iter, in_channel in zip(filters, in_channels):
          filter_height = filter_iter[1][0]
          filter_width = filter_iter[1][1]
          filter_sum *= 0.01 * filter_height * filter_width * in_channel
  
      for _ in hidden_sizes:
          filter_sum *= 0.01
  
      height_size = self.input_height
      width_size = self.input_width
      for filter_iter, stride in zip(filters, strides):
          height_size = (
              int((height_size - filter_iter[1][0]) / stride) + 1
          )
          width_size = (
              int((width_size - filter_iter[1][1]) / stride) + 1
          )
      flatten_shape = height_size * width_size * filters[-1][0]
  
      network_output = (
          filter_sum * flatten_shape * np.prod(hidden_sizes)
      )
      expected_mean = np.full(
          (self.batch_size, output_dim),
          network_output,
          dtype=np.float32,
      )
      expected_std_param = np.full(
          (self.batch_size, output_dim),
          network_output,
          dtype=np.float32,
      )
      expected_log_std = np.full(
          (self.batch_size, output_dim),
          network_output,
          dtype=np.float32,
      )
  
      assert np.allclose(mean, expected_mean)
  
      assert np.allclose(std_param, expected_std_param)
      assert np.allclose(log_std, expected_log_std)
  
      expected_action = 0.5 * np.exp(expected_log_std) + expected_mean
      assert np.allclose(action, expected_action, rtol=0, atol=0.1)
  
imports: import pickle
  from unittest import mock
  import numpy
  import pytest
  import tensorflow
  from garage.tf.models import GaussianCNNModel
  from tests.fixtures import TfGraphTestCase
label_desc: Use image node_id 6 for calling the TestGaussianCNNModel obj's underlying member method code with example usage: obj.test_adaptive_std_network_output_values(mock_normal, filters, in_channels, strides, output_dim, hidden_sizes) without return types