A neural network based epsilon greedy agent.
Inherits From: GreedyRewardPredictionAgent
, TFAgent
tf_agents.bandits.agents.neural_epsilon_greedy_agent.NeuralEpsilonGreedyAgent(
time_step_spec: tf_agents.typing.types.TimeStep
,
action_spec: tf_agents.typing.types.BoundedTensorSpec
,
reward_network: tf_agents.typing.types.Network
,
optimizer: tf_agents.typing.types.Optimizer
,
epsilon: float,
observation_and_action_constraint_splitter: Optional[types.Splitter] = None,
accepts_per_arm_features: bool = False,
constraints: Iterable[tf_agents.bandits.policies.constraints.NeuralConstraint
] = (),
error_loss_fn: tf_agents.typing.types.LossFn
= tf.compat.v1.losses.mean_squared_error,
gradient_clipping: Optional[float] = None,
debug_summaries: bool = False,
summarize_grads_and_vars: bool = False,
enable_summaries: bool = True,
emit_policy_info: Tuple[Text, ...] = (),
train_step_counter: Optional[tf.Variable] = None,
laplacian_matrix: Optional[types.Float] = None,
laplacian_smoothing_weight: float = 0.001,
info_fields_to_inherit_from_greedy: Sequence[Text] = (),
name: Optional[Text] = None
)
This agent receives a neural network that it trains to predict rewards. The
action is chosen greedily with respect to the prediction with probability
1 - epsilon
, and uniformly randomly with probability epsilon
.
Args |
time_step_spec
|
A TimeStep spec of the expected time_steps.
|
action_spec
|
A nest of BoundedTensorSpec representing the actions.
|
reward_network
|
A tf_agents.network.Network to be used by the agent. The
network will be called with call(observation, step_type) and it is
expected to provide a reward prediction for all actions. Note: when
using observation_and_action_constraint_splitter , make sure the
reward_network is compatible with the network-specific half of the
output of the observation_and_action_constraint_splitter . In
particular, observation_and_action_constraint_splitter will be called
on the observation before passing to the network.
|
optimizer
|
The optimizer to use for training.
|
epsilon
|
A float representing the probability of choosing a random action
instead of the greedy action.
|
observation_and_action_constraint_splitter
|
A function used for masking
valid/invalid actions with each state of the environment. The function
takes in a full observation and returns a tuple consisting of 1) the
part of the observation intended as input to the bandit agent and
policy, and 2) the boolean mask. This function should also work with a
TensorSpec as input, and should output TensorSpec objects for the
observation and mask.
|
accepts_per_arm_features
|
(bool) Whether the policy accepts per-arm
features.
|
constraints
|
iterable of constraints objects that are instances of
tf_agents.bandits.agents.NeuralConstraint . WARNING: only the greedy
actions respect the constraints. Uniform random actions may not.
|
error_loss_fn
|
A function for computing the error loss, taking parameters
labels, predictions, and weights (any function from tf.losses would
work). The default is tf.losses.mean_squared_error .
|
gradient_clipping
|
A float representing the norm length to clip gradients
(or None for no clipping.)
|
debug_summaries
|
A Python bool, default False. When True, debug summaries
are gathered.
|
summarize_grads_and_vars
|
A Python bool, default False. When True,
gradients and network variable summaries are written during training.
|
enable_summaries
|
A Python bool, default True. When False, all summaries
(debug or otherwise) should not be written.
|
emit_policy_info
|
(tuple of strings) what side information we want to get
as part of the policy info. Allowed values can be found in
policy_utilities.PolicyInfo .
|
train_step_counter
|
An optional tf.Variable to increment every time the
train op is run. Defaults to the global_step .
|
laplacian_matrix
|
A float Tensor shaped [num_actions, num_actions] .
This holds the Laplacian matrix used to regularize the smoothness of the
estimated expected reward function. This only applies to problems where
the actions have a graph structure. If None , the regularization is not
applied.
|
laplacian_smoothing_weight
|
A float that determines the weight of the
regularization term. Note that this has no effect if laplacian_matrix
above is None .
|
info_fields_to_inherit_from_greedy
|
List of info fields that are reported
from the greedy policy even when exploratory action is taken.
|
name
|
Python str name of this agent. All variables in this module will
fall under that name. Defaults to the class name.
|
Raises |
ValueError
|
If the action spec contains more than one action or or it is
not a bounded scalar int32 spec with minimum 0.
|
Attributes |
action_spec
|
TensorSpec describing the action produced by the agent.
|
collect_data_context
|
|
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.
|
data_context
|
|
debug_summaries
|
|
num_samples
|
|
policy
|
Return the current policy held by the agent.
|
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
|
|
training_data_spec
|
Returns a trajectory spec, as expected by the train() function.
|
Methods
compute_summaries
View source
compute_summaries(
loss: tf_agents.typing.types.Tensor
,
constraint_loss: Optional[types.Tensor] = None
)
initialize
View source
initialize() -> Optional[tf.Operation]
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).
|
loss
View source
loss(
experience: tf_agents.typing.types.NestedTensor
,
weights: Optional[types.Tensor] = None,
training: bool = False,
**kwargs
) -> tf_agents.agents.tf_agent.LossInfo
Gets loss from the agent.
If the user calls this from _train, it must be in a tf.GradientTape
scope
in order to apply gradients to trainable variables.
If intermediate gradient steps are needed, _loss and _train will return
different values since _loss only supports updating all gradients at once
after all losses have been calculated.
Args |
experience
|
A batch of experience data in the form of a Trajectory . The
structure of experience must match that of self.training_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.
|
training
|
Explicit argument to pass to loss . This typically affects
network computation paths like dropout and batch normalization.
|
**kwargs
|
Any additional data as args to loss .
|
Returns |
A LossInfo loss tuple containing loss and info tensors.
|
Raises |
RuntimeError
|
If the class was not initialized properly (super.__init__
was not called).
|
post_process_policy
View source
post_process_policy() -> tf_agents.policies.TFPolicy
Post process policies after training.
The policies of some agents require expensive post processing after training
before they can be used. e.g. A Recommender agent might require rebuilding
an index of actions. For such agents, this method will return a post
processed version of the policy. The post processing may either update the
existing policies in place or create a new policy, depnding on the agent.
The default implementation for agents that do not want to override this
method is to return agent.policy.
Returns |
The post processed policy.
|
preprocess_sequence
View source
preprocess_sequence(
experience: tf_agents.typing.types.NestedTensor
) -> tf_agents.typing.types.NestedTensor
Defines preprocess_sequence function to be fed into replay buffers.
This defines how we preprocess the collected data before training.
Defaults to pass through for most agents.
Structure of experience
must match that of self.collect_data_spec
.
Args |
experience
|
a Trajectory shaped [batch, time, ...] or [time, ...] which
represents the collected experience data.
|
Returns |
A post processed Trajectory with the same shape as the input.
|
reward_loss
View source
reward_loss(
observations: tf_agents.typing.types.NestedTensor
,
actions: tf_agents.typing.types.Tensor
,
rewards: tf_agents.typing.types.Tensor
,
weights: Optional[types.Float] = None,
training: bool = False
) -> tf_agents.typing.types.Tensor
Computes loss for reward prediction training.
Args |
observations
|
A batch of observations.
|
actions
|
A batch of actions.
|
rewards
|
A batch of rewards.
|
weights
|
Optional scalar or elementwise (per-batch-entry) importance
weights. The output batch loss will be scaled by these weights, and the
final scalar loss is the mean of these values.
|
training
|
Whether the loss is being used for training.
|
Returns |
loss
|
A Tensor containing the loss for the training step.
|
Raises |
ValueError
|
if the number of actions is greater than 1.
|
train
View source
train(
experience: tf_agents.typing.types.NestedTensor
,
weights: Optional[types.Tensor] = None,
**kwargs
) -> tf_agents.agents.tf_agent.LossInfo
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.training_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.
|
**kwargs
|
Any additional data to pass to the subclass.
|
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 |
RuntimeError
|
If the class was not initialized properly (super.__init__
was not called).
|