code: def test_same_policy_same_output(self):
      if not tf.executing_eagerly():
          self.skipTest(
              "Skipping test: sequential networks not supported in TF1"
          )
      observation_tensor_spec = tf.TensorSpec(
          shape=[1], dtype=tf.float32
      )
      action_tensor_spec = tensor_spec.BoundedTensorSpec(
          (8,), tf.float32, -1, 1
      )
  
      value_net = value_network.ValueNetwork(
          observation_tensor_spec, fc_layer_params=(1,)
      )
  
      actor_net_lib = ppo_actor_network.PPOActorNetwork()
      actor_net_lib.seed_stream_class = DeterministicSeedStream
      actor_net_sequential = actor_net_lib.create_sequential_actor_net(
          fc_layer_units=(1,),
          action_tensor_spec=action_tensor_spec,
          seed=1,
      )
      actor_net_actor_dist = (
          actor_distribution_network.ActorDistributionNetwork(
              observation_tensor_spec,
              action_tensor_spec,
              fc_layer_params=(1,),
              activation_fn=tf.nn.tanh,
              kernel_initializer=tf.keras.initializers.Orthogonal(
                  seed=1
              ),
              seed_stream_class=DeterministicSeedStream,
              seed=1,
          )
      )
  
      tf.random.set_seed(111)
      seq_policy = ppo_policy.PPOPolicy(
          ts.time_step_spec(observation_tensor_spec),
          action_tensor_spec,
          actor_net_sequential,
          value_net,
          collect=True,
      )
      tf.random.set_seed(111)
      actor_dist_policy = ppo_policy.PPOPolicy(
          ts.time_step_spec(observation_tensor_spec),
          action_tensor_spec,
          actor_net_actor_dist,
          value_net,
          collect=True,
      )
  
      sample_timestep = ts.TimeStep(
          step_type=tf.constant([1, 1], dtype=tf.int32),
          reward=tf.constant([1, 1], dtype=tf.float32),
          discount=tf.constant([1, 1], dtype=tf.float32),
          observation=tf.constant([[1], [2]], dtype=tf.float32),
      )
      seq_policy_step = seq_policy._distribution(
          sample_timestep, policy_state=()
      )
      act_dist_policy_step = actor_dist_policy._distribution(
          sample_timestep, policy_state=()
      )
  
      seq_scale = seq_policy_step.info["dist_params"]["scale_diag"]
      act_dist_scale = act_dist_policy_step.info["dist_params"]["scale"]
      self.assertAllEqual(seq_scale, act_dist_scale)
      self.assertAllEqual(
          seq_policy_step.info["dist_params"]["loc"],
          act_dist_policy_step.info["dist_params"]["loc"],
      )
  
imports: from absl import flags
  from absl.testing import parameterized
  import numpy
  import tensorflow
  from tf_agents.agents.ppo import ppo_actor_network
  from tf_agents.agents.ppo import ppo_agent
  from tf_agents.agents.ppo import ppo_policy
  from tf_agents.distributions import utils
  from tf_agents.networks import actor_distribution_network
  from tf_agents.networks import value_network
  from tf_agents.specs import tensor_spec
  from tf_agents.trajectories import time_step
  from tf_agents.trajectories import trajectory
  from tf_agents.utils import test_utils
label_desc: Use image node_id 6 for calling the PpoActorNetworkTest obj's underlying member method code with example usage: obj.test_same_policy_same_output() without return types