tf_agents.agents.BehavioralCloningAgent

An behavioral cloning Agent.

Inherits From: TFAgent

View aliases

Main aliases

tf_agents.agents.behavioral_cloning.behavioral_cloning_agent.BehavioralCloningAgent

tf_agents.agents.BehavioralCloningAgent(
    *args, **kwargs
)

Implements behavioral cloning, wherein the network learns to clone given experience. Users must provide their own loss functions. Note this implementation will use a QPolicy. To use with other policies subclass this agent and override the _get_policies method. Note the cloning_network must match the requirements of the generated policies.

Behavioral cloning was proposed in the following articles:

Pomerleau, D.A., 1991. Efficient training of artificial neural networks for autonomous navigation. Neural Computation, 3(1), pp.88-97.

Russell, S., 1998, July. Learning agents for uncertain environments. In Proceedings of the eleventh annual conference on Computational learning theory (pp. 101-103). ACM.

Args:

time_step_spec: A TimeStep spec of the expected time_steps.
action_spec: A nest of BoundedTensorSpec representing the actions.
cloning_network: A tf_agents.network.Network to be used by the agent. The network will be called as

network(observation, step_type, network_state=())
(with network_state optional) and must return a 2-tuple with elements (output, next_network_state) where output will be passed as the first argument to loss_fn, and used by a Policy. Input tensors will be shaped [batch, time, ...] when training, and they will be shaped [batch, ...] when the network is called within a Policy. If cloning_network has an empty network state, then for training time will always be 1 (individual examples).

optimizer: The optimizer to use for training.
num_outer_dims: The number of outer dimensions for the agent. Must be either 1 or 2. If 2, training will require both a batch_size and time dimension on every Tensor; if 1, training will require only a batch_size outer dimension.
epsilon_greedy: probability of choosing a random action in the default epsilon-greedy collect policy (used only if a wrapper is not provided to the collect_policy method).
loss_fn: A function for computing the error between the output of the cloning network and the action that was taken. If None, the loss depends on the action dtype. If the dtype is integer, then loss_fn is

def loss_fn(logits, action):
  return tf.compat.v1.nn.sparse_softmax_cross_entropy_with_logits(
    labels=action - action_spec.minimum, logits=logits)

If the dtype is floating point, the loss is tf.math.squared_difference.

loss_fn must return a loss value for each element of the batch.

gradient_clipping: Norm length to clip gradients.
debug_summaries: A bool to gather debug summaries.
summarize_grads_and_vars: If True, gradient and network variable summaries will be written during training.
train_step_counter: An optional counter to increment every time the train op is run. Defaults to the global_step.
name: The name of this agent. All variables in this module will fall under that name. Defaults to the class name.

Attributes:

action_spec: TensorSpec describing the action produced by the agent.
collect_data_spec: Returns a Trajectory spec, as expected by the collect_policy.
collect_policy: Return a policy that can be used to collect data from the environment.
debug_summaries
name: Returns the name of this module as passed or determined in the ctor.

NOTE: This is not the same as the self.name_scope.name which includes parent module names.
name_scope: Returns a tf.name_scope instance for this class.
policy: Return the current policy held by the agent.
submodules: Sequence of all sub-modules.

Submodules are modules which are properties of this module, or found as properties of modules which are properties of this module (and so on).

a = tf.Module()
b = tf.Module()
c = tf.Module()
a.b = b
b.c = c
assert list(a.submodules) == [b, c]
assert list(b.submodules) == [c]
assert list(c.submodules) == []

summaries_enabled
summarize_grads_and_vars
time_step_spec: Describes the TimeStep tensors expected by the agent.
train_sequence_length: The number of time steps needed in experience tensors passed to train.

Train requires experience to be a Trajectory containing tensors shaped [B, T, ...]. This argument describes the value of T required.

For example, for non-RNN DQN training, T=2 because DQN requires single transitions.

If this value is None, then train can handle an unknown T (it can be determined at runtime from the data). Most RNN-based agents fall into this category.
train_step_counter
trainable_variables: Sequence of trainable variables owned by this module and its submodules.

Note: this method uses reflection to find variables on the current instance and submodules. For performance reasons you may wish to cache the result of calling this method if you don't expect the return value to change.
variables: Sequence of variables owned by this module and its submodules.

Note: this method uses reflection to find variables on the current instance and submodules. For performance reasons you may wish to cache the result of calling this method if you don't expect the return value to change.

Raises:

ValueError: If action_spec contains more than one action, but a custom loss_fn is not provided.

Methods

`initialize`

View source

initialize()

Initializes the agent.

Returns:

An operation that can be used to initialize the agent.

Raises:

RuntimeError: If the class was not initialized properly (super.__init__ was not called).

`train`

View source

train(
    experience, weights=None
)

Trains the agent.

Args:

experience: A batch of experience data in the form of a Trajectory. The structure of experience must match that of self.collect_data_spec. All tensors in experience must be shaped [batch, time, ...] where time must be equal to self.train_step_length if that property is not None.
weights: (optional). A Tensor, either 0-D or shaped [batch], containing weights to be used when calculating the total train loss. Weights are typically multiplied elementwise against the per-batch loss, but the implementation is up to the Agent.

Returns:

A LossInfo loss tuple containing loss and info tensors.

In eager mode, the loss values are first calculated, then a train step is performed before they are returned.
In graph mode, executing any or all of the loss tensors will first calculate the loss value(s), then perform a train step, and return the pre-train-step LossInfo.

Raises:

TypeError: If experience is not type Trajectory. Or if experience does not match self.collect_data_spec structure types.
ValueError: If experience tensors' time axes are not compatible with self.train_sequence_length. Or if experience does not match self.collect_data_spec structure.
RuntimeError: If the class was not initialized properly (super.__init__ was not called).

`with_name_scope`

@classmethod
with_name_scope(
    cls, method
)

Decorator to automatically enter the module name scope.

class MyModule(tf.Module):
  @tf.Module.with_name_scope
  def __call__(self, x):
    if not hasattr(self, 'w'):
      self.w = tf.Variable(tf.random.normal([x.shape[1], 64]))
    return tf.matmul(x, self.w)

Using the above module would produce tf.Variables and tf.Tensors whose names included the module name:

mod = MyModule()
mod(tf.ones([8, 32]))
# ==> <tf.Tensor: ...>
mod.w
# ==> <tf.Variable ...'my_module/w:0'>

Args:

method: The method to wrap.

Returns:

The original method wrapped such that it enters the module's name scope.