code: def make_default_networks(
      action_spec: specs.BoundedArray,
      policy_layer_sizes: Sequence[int] = (256, 256, 256),
      critic_layer_sizes: Sequence[int] = (512, 512, 256),
      vmin: float = -150.0,
      vmax: float = 150.0,
      num_atoms: int = 51,
  ) -> Mapping[str, types.TensorTransformation]:
      """Creates networks used by the agent."""
  
      # Get total number of action dimensions from action spec.
      num_dimensions = np.prod(action_spec.shape, dtype=int)
  
      # Create the shared observation network; here simply a state-less operation.
      observation_network = tf2_utils.batch_concat
  
      # Create the policy network.
      policy_network = snt.Sequential(
          [
              networks.LayerNormMLP(
                  policy_layer_sizes, activate_final=True
              ),
              networks.NearZeroInitializedLinear(num_dimensions),
              networks.TanhToSpec(action_spec),
          ]
      )
  
      # Create the critic network.
      critic_network = snt.Sequential(
          [
              # The multiplexer concatenates the observations/actions.
              networks.CriticMultiplexer(),
              networks.LayerNormMLP(
                  critic_layer_sizes, activate_final=True
              ),
              networks.DiscreteValuedHead(vmin, vmax, num_atoms),
          ]
      )
  
      return {
          "policy": policy_network,
          "critic": critic_network,
          "observation": observation_network,
      }
  
imports: from typing import Mapping, Sequence
  from acme import specs
  from acme import types
  from acme.tf import networks
  from acme.tf import utils
  import numpy
  import sonnet
label_desc: Use image node_id 1 for calling a global function with example usage: make_default_networks(action_spec, policy_layer_sizes, critic_layer_sizes, vmin, vmax, num_atoms) and returns: dict