def __init__(self, activation_function=tf.nn.relu,
scheme: MiddlewareScheme = MiddlewareScheme.Medium,
batchnorm: bool = False, dropout: bool = False, name="middleware_embedder", dense_layer=Dense,
is_training=False):
self.name = name
self.input = None
self.output = None
self.activation_function = activation_function
self.batchnorm = batchnorm
self.dropout = dropout
self.dropout_rate = 0
self.scheme = scheme
self.return_type = MiddlewareEmbedding
self.dense_layer = dense_layer
self.is_training = is_training
# layers order is conv -> batchnorm -> activation -> dropout
if isinstance(self.scheme, MiddlewareScheme):
self.layers_params = copy.copy(self.schemes[self.scheme])
else:
self.layers_params = copy.copy(self.scheme)
# we allow adding batchnorm, dropout or activation functions after each layer.
# The motivation is to simplify the transition between a network with batchnorm and a network without
# batchnorm to a single flag (the same applies to activation function and dropout)
if self.batchnorm or self.activation_function or self.dropout:
for layer_idx in reversed(range(len(self.layers_params))):
self.layers_params.insert(layer_idx+1,
BatchnormActivationDropout(batchnorm=self.batchnorm,
activation_function=self.activation_function,
dropout_rate=self.dropout_rate))
def _build_module(self, input_layer):
weight_init = Orthogonal(gain=np.sqrt(2))
input_layer = Conv2d(num_filters=32, kernel_size=8, strides=4)(input_layer, kernel_initializer=weight_init)
input_layer = BatchnormActivationDropout(activation_function=self.activation_function)(input_layer)[-1]
input_layer = Conv2d(num_filters=64, kernel_size=4, strides=2)(input_layer, kernel_initializer=weight_init)
input_layer = BatchnormActivationDropout(activation_function=self.activation_function)(input_layer)[-1]
input_layer = Conv2d(num_filters=64, kernel_size=3, strides=1)(input_layer, kernel_initializer=weight_init)
input_layer = BatchnormActivationDropout(activation_function=self.activation_function)(input_layer)[-1]
input_layer = tf.contrib.layers.flatten(input_layer)
if self.is_predictor:
input_layer = self.dense_layer(512)(input_layer, kernel_initializer=weight_init)
input_layer = BatchnormActivationDropout(activation_function=tf.nn.relu)(input_layer)[-1]
input_layer = self.dense_layer(512)(input_layer, kernel_initializer=weight_init)
input_layer = BatchnormActivationDropout(activation_function=tf.nn.relu)(input_layer)[-1]
self.output = self.dense_layer(512)(input_layer, name='output', kernel_initializer=weight_init)
def __init__(self,
input_size: List[int],
activation_function=tf.nn.relu,
scheme: EmbedderScheme = None,
batchnorm: bool = False,
dropout_rate: float = 0.0,
name: str = "embedder",
input_rescaling=1.0,
input_offset=0.0,
input_clipping=None,
dense_layer=Dense,
is_training=False,
flatten=True):
self.name = name
self.input_size = input_size
self.activation_function = activation_function
self.batchnorm = batchnorm
self.dropout_rate = dropout_rate
self.input = None
self.output = None
self.scheme = scheme
self.return_type = InputEmbedding
self.layers_params = []
self.layers = []
self.input_rescaling = input_rescaling
self.input_offset = input_offset
self.input_clipping = input_clipping
self.dense_layer = dense_layer
if self.dense_layer is None:
self.dense_layer = Dense
self.is_training = is_training
self.flatten = flatten
# layers order is conv -> batchnorm -> activation -> dropout
if isinstance(self.scheme, EmbedderScheme):
self.layers_params = copy.copy(self.schemes[self.scheme])
self.layers_params = [convert_layer(l) for l in self.layers_params]
else:
# if scheme is specified directly, convert to TF layer if it's not a callable object
# NOTE: if layer object is callable, it must return a TF tensor when invoked
self.layers_params = [
convert_layer(l) for l in copy.copy(self.scheme)
]
# we allow adding batchnorm, dropout or activation functions after each layer.
# The motivation is to simplify the transition between a network with batchnorm and a network without
# batchnorm to a single flag (the same applies to activation function and dropout)
if self.batchnorm or self.activation_function or self.dropout_rate > 0:
for layer_idx in reversed(range(len(self.layers_params))):
self.layers_params.insert(
layer_idx + 1,
BatchnormActivationDropout(
batchnorm=self.batchnorm,
activation_function=self.activation_function,
dropout_rate=self.dropout_rate))
schedule_params.steps_between_evaluation_periods = TrainingSteps(500)
schedule_params.evaluation_steps = EnvironmentEpisodes(5)
schedule_params.heatup_steps = EnvironmentSteps(0)
################
# Agent Params #
################
agent_params = CILAgentParameters()
# forward camera and measurements input
agent_params.network_wrappers['main'].input_embedders_parameters = {
'CameraRGB':
InputEmbedderParameters(
scheme=[
Conv2d(32, 5, 2),
BatchnormActivationDropout(batchnorm=True,
activation_function=tf.tanh),
Conv2d(32, 3, 1),
BatchnormActivationDropout(batchnorm=True,
activation_function=tf.tanh),
Conv2d(64, 3, 2),
BatchnormActivationDropout(batchnorm=True,
activation_function=tf.tanh),
Conv2d(64, 3, 1),
BatchnormActivationDropout(batchnorm=True,
activation_function=tf.tanh),
Conv2d(128, 3, 2),
BatchnormActivationDropout(batchnorm=True,
activation_function=tf.tanh),
Conv2d(128, 3, 1),
BatchnormActivationDropout(batchnorm=True,
activation_function=tf.tanh),