class_docstr: DQfD agent.
  
  This implements a single-process DQN agent that mixes demonstrations with
  actor experience.
class_docstr_tok: ["DQfD","agent",".","This","implements","a","single-process","DQN","agent","that","mixes","demonstrations","with","actor","experience","."]
docstr: Initialize the agent.
  
  Args:
    environment_spec: description of the actions, observations, etc.
    network: the online Q network (the one being optimized)
    demonstration_dataset: tf.data.Dataset producing (timestep, action)
      tuples containing full episodes.
    demonstration_ratio: Ratio of transitions coming from demonstrations.
    batch_size: batch size for updates.
    prefetch_size: size to prefetch from replay.
    target_update_period: number of learner steps to perform before updating
      the target networks.
    samples_per_insert: number of samples to take from replay for every insert
      that is made.
    min_replay_size: minimum replay size before updating. This and all
      following arguments are related to dataset construction and will be
      ignored if a dataset argument is passed.
    max_replay_size: maximum replay size.
    importance_sampling_exponent: power to which importance weights are raised
      before normalizing.
    n_step: number of steps to squash into a single transition.
    epsilon: probability of taking a random action; ignored if a policy
      network is given.
    learning_rate: learning rate for the q-network update.
    discount: discount to use for TD updates.
docstr_tok: ["Initialize","the","agent",".","Args",":","environment_spec",":","description","of","the","actions",",","observations",",","etc",".","network",":","the","online","Q","network","(","the","one","being","optimized",")","demonstration_dataset",":","tf.data.Dataset","producing","(","timestep",",","action",")","tuples","containing","full","episodes",".","demonstration_ratio",":","Ratio","of","transitions","coming","from","demonstrations",".","batch_size",":","batch","size","for","updates",".","prefetch_size",":","size","to","prefetch","from","replay",".","target_update_period",":","number","of","learner","steps","to","perform","before","updating","the","target","networks",".","samples_per_insert",":","number","of","samples","to","take","from","replay","for","every","insert","that","is","made",".","min_replay_size",":","minimum","replay","size","before","updating",".","This","and","all","following","arguments","are","related","to","dataset","construction","and","will","be","ignored","if","a","dataset","argument","is","passed",".","max_replay_size",":","maximum","replay","size",".","importance_sampling_exponent",":","power","to","which","importance","weights","are","raised","before","normalizing",".","n_step",":","number","of","steps","to","squash","into","a","single","transition",".","epsilon",":","probability","of","taking","a","random","action",";","ignored","if","a","policy","network","is","given",".","learning_rate",":","learning","rate","for","the","q-network","update",".","discount",":","discount","to","use","for","TD","updates","."]
code: def __init__(
      self,
      environment_spec: specs.EnvironmentSpec,
      network: snt.Module,
      demonstration_dataset: tf.data.Dataset,
      demonstration_ratio: float,
      batch_size: int = 256,
      prefetch_size: int = 4,
      target_update_period: int = 100,
      samples_per_insert: float = 32.0,
      min_replay_size: int = 1000,
      max_replay_size: int = 1000000,
      importance_sampling_exponent: float = 0.2,
      n_step: int = 5,
      epsilon: Optional[tf.Tensor] = None,
      learning_rate: float = 1e-3,
      discount: float = 0.99,
  ):
      """Initialize the agent.
  
      Args:
        environment_spec: description of the actions, observations, etc.
        network: the online Q network (the one being optimized)
        demonstration_dataset: tf.data.Dataset producing (timestep, action)
          tuples containing full episodes.
        demonstration_ratio: Ratio of transitions coming from demonstrations.
        batch_size: batch size for updates.
        prefetch_size: size to prefetch from replay.
        target_update_period: number of learner steps to perform before updating
          the target networks.
        samples_per_insert: number of samples to take from replay for every insert
          that is made.
        min_replay_size: minimum replay size before updating. This and all
          following arguments are related to dataset construction and will be
          ignored if a dataset argument is passed.
        max_replay_size: maximum replay size.
        importance_sampling_exponent: power to which importance weights are raised
          before normalizing.
        n_step: number of steps to squash into a single transition.
        epsilon: probability of taking a random action; ignored if a policy
          network is given.
        learning_rate: learning rate for the q-network update.
        discount: discount to use for TD updates.
      """
  
      # Create a replay server to add data to. This uses no limiter behavior in
      # order to allow the Agent interface to handle it.
      replay_table = reverb.Table(
          name=adders.DEFAULT_PRIORITY_TABLE,
          sampler=reverb.selectors.Uniform(),
          remover=reverb.selectors.Fifo(),
          max_size=max_replay_size,
          rate_limiter=reverb.rate_limiters.MinSize(1),
          signature=adders.NStepTransitionAdder.signature(
              environment_spec
          ),
      )
      self._server = reverb.Server([replay_table], port=None)
  
      # The adder is used to insert observations into replay.
      address = f"localhost:{self._server.port}"
      adder = adders.NStepTransitionAdder(
          client=reverb.Client(address),
          n_step=n_step,
          discount=discount,
      )
  
      # The dataset provides an interface to sample from replay.
      replay_client = reverb.TFClient(address)
      dataset = datasets.make_reverb_dataset(server_address=address)
  
      # Combine with demonstration dataset.
      transition = functools.partial(
          _n_step_transition_from_episode,
          n_step=n_step,
          discount=discount,
      )
      dataset_demos = demonstration_dataset.map(transition)
      dataset = tf.data.experimental.sample_from_datasets(
          [dataset, dataset_demos],
          [1 - demonstration_ratio, demonstration_ratio],
      )
  
      # Batch and prefetch.
      dataset = dataset.batch(batch_size, drop_remainder=True)
      dataset = dataset.prefetch(prefetch_size)
  
      # Use constant 0.05 epsilon greedy policy by default.
      if epsilon is None:
          epsilon = tf.Variable(0.05, trainable=False)
      policy_network = snt.Sequential(
          [
              network,
              lambda q: trfl.epsilon_greedy(
                  q, epsilon=epsilon
              ).sample(),
          ]
      )
  
      # Create a target network.
      target_network = copy.deepcopy(network)
  
      # Ensure that we create the variables before proceeding (maybe not needed).
      tf2_utils.create_variables(
          network, [environment_spec.observations]
      )
      tf2_utils.create_variables(
          target_network, [environment_spec.observations]
      )
  
      # Create the actor which defines how we take actions.
      actor = actors.FeedForwardActor(policy_network, adder)
  
      # The learner updates the parameters (and initializes them).
      learner = dqn.DQNLearner(
          network=network,
          target_network=target_network,
          discount=discount,
          importance_sampling_exponent=importance_sampling_exponent,
          learning_rate=learning_rate,
          target_update_period=target_update_period,
          dataset=dataset,
          replay_client=replay_client,
      )
  
      super().__init__(
          actor=actor,
          learner=learner,
          min_observations=max(batch_size, min_replay_size),
          observations_per_step=float(batch_size) / samples_per_insert,
      )
  
imports: import copy
  import functools
  import operator
  from typing import Optional
  from acme import datasets
  from acme import specs
  from acme import types
  from acme.adders import reverb
  from acme.agents import agent
  from acme.agents.tf import actors
  from acme.agents.tf import dqn
  from acme.tf import utils
  import reverb
  import sonnet
  import tensorflow
  import tree
  import trfl
label_desc: Use image node_id 1 to create a new DQfD object from inherited base classes: agent with example: obj = DQfD(environment_spec, network, demonstration_dataset, demonstration_ratio, batch_size, prefetch_size, target_update_period, samples_per_insert, min_replay_size, max_replay_size, importance_sampling_exponent, n_step, epsilon, learning_rate, discount)