def _build_layers_v2(self, input_dict: dict, num_outputs: int, config: dict):
import tensorflow.contrib.slim as slim
with tf.name_scope("fc_net"):
last_layer = input_dict['obs']
activation = get_activation_fn(config.get("fcnet_activation"))
for i, size in enumerate(config.get("fcnet_hiddens"), 1):
last_layer = slim.fully_connected(
inputs=last_layer,
num_outputs=size,
weights_initializer=normc_initializer(1.0),
activation_fn=activation,
scope="fc{}".format(i),
)
last_layer = tf.layers.dropout(
inputs=last_layer,
rate=config.get("fcnet_dropout_rate"),
training=input_dict['is_training'],
name="dropout{}".format(i),
)
output = slim.fully_connected(
inputs=last_layer,
num_outputs=num_outputs,
weights_initializer=normc_initializer(0.01),
activation_fn=None,
scope="fc_out",
)
return output, last_layer
def _build_layers(self, inputs, num_outputs, options):
hiddens = options.get("fcnet_hiddens", [256, 256])
activation = get_activation_fn(options.get("fcnet_activation", "tanh"))
with tf.name_scope("fc_net"):
i = 1
last_layer = inputs
for size in hiddens:
label = "fc{}".format(i)
last_layer = slim.fully_connected(
last_layer,
size,
weights_initializer=normc_initializer(1.0),
activation_fn=activation,
scope=label)
i += 1
label = "fc_out"
output = slim.fully_connected(
last_layer,
num_outputs,
weights_initializer=normc_initializer(0.01),
activation_fn=None,
scope=label)
return output, last_layer
def _build_layers_v2(self, input_dict, num_outputs, options):
inputs = input_dict["obs"]
filters = options.get("conv_filters")
if not filters:
filters = _get_filter_config(inputs.shape.as_list()[1:])
activation = get_activation_fn(options.get("conv_activation"))
with tf.name_scope("vision_net"):
for i, (out_size, kernel, stride) in enumerate(filters[:-1], 1):
inputs = tf.layers.conv2d(inputs,
out_size,
kernel,
stride,
activation=activation,
padding="same",
name="conv{}".format(i))
out_size, kernel, stride = filters[-1]
fc1 = tf.layers.conv2d(inputs,
out_size,
kernel,
stride,
activation=activation,
padding="valid",
name="fc1")
fc2 = tf.layers.conv2d(fc1,
num_outputs, [1, 1],
activation=None,
padding="same",
name="fc2")
return flatten(fc2), flatten(fc1)
def _build_layers(self, inputs, num_outputs, options):
"""Process the flattened inputs.
Note that dict inputs will be flattened into a vector. To define a
model that processes the components separately, use _build_layers_v2().
"""
import tensorflow.contrib.slim as slim
hiddens = options.get("fcnet_hiddens")
activation = get_activation_fn(options.get("fcnet_activation"))
with tf.name_scope("fc_net"):
i = 1
last_layer = inputs
for size in hiddens:
label = "fc{}".format(i)
last_layer = slim.fully_connected(
last_layer,
size,
weights_initializer=normc_initializer(1.0),
activation_fn=activation,
scope=label)
i += 1
label = "fc_out"
output = slim.fully_connected(
last_layer,
num_outputs,
weights_initializer=normc_initializer(0.01),
activation_fn=None,
scope=label)
return output, last_layer
def _build_layers(self, inputs, num_outputs, options):
"""Define the layers of a custom model.
Arguments:
input_dict (dict): Dictionary of input tensors, including "obs",
"prev_action", "prev_reward".
num_outputs (int): Output tensor must be of size
[BATCH_SIZE, num_outputs].
options (dict): Model options.
"""
hiddens = options.get("fcnet_hiddens", Config.fcnet_hiddens)
activation = get_activation_fn(
options.get("fcnet_activation", Config.fcnet_activation))
with tf.name_scope("fc_net"):
i = 1
last_layer = inputs
for size in hiddens:
label = "fc{}".format(i)
last_layer = slim.fully_connected(
last_layer,
size,
weights_initializer=normc_initializer(1.0),
activation_fn=activation,
scope=label)
i += 1
label = "fc_out"
output = slim.fully_connected(
last_layer,
num_outputs,
weights_initializer=normc_initializer(0.01),
activation_fn=None,
scope=label)
return output, last_layer
def _build_layers_v2(self, input_dict, num_outputs, options):
inputs = input_dict["obs"]
filters = options.get("conv_filters")
if not filters:
filters = get_filter_config(inputs)
activation = get_activation_fn(options.get("conv_activation"))
with tf.name_scope("vision_net"):
for i, (out_size, kernel, stride) in enumerate(filters[:-1], 1):
inputs = slim.conv2d(
inputs,
out_size,
kernel,
stride,
activation_fn=activation,
scope="conv{}".format(i))
out_size, kernel, stride = filters[-1]
fc1 = slim.conv2d(
inputs,
out_size,
kernel,
stride,
activation_fn=activation,
padding="VALID",
scope="fc1")
fc2 = slim.conv2d(
fc1,
num_outputs, [1, 1],
activation_fn=None,
normalizer_fn=None,
scope="fc2")
return flatten(fc2), flatten(fc1)
def _build_layers(self, inputs, num_outputs, options):
"""Process the flattened inputs.
Note that dict inputs will be flattened into a vector. To define a
model that processes the components separately, use _build_layers_v2().
"""
hiddens = options.get("fcnet_hiddens")
activation = get_activation_fn(options.get("fcnet_activation"))
with tf.name_scope("fc_net"):
i = 1
last_layer = inputs
for size in hiddens:
label = "fc{}".format(i)
last_layer = tf.layers.dense(
last_layer,
size,
kernel_initializer=normc_initializer(1.0),
activation=activation,
name=label)
i += 1
label = "fc_out"
output = tf.layers.dense(
last_layer,
num_outputs,
kernel_initializer=normc_initializer(0.01),
activation=None,
name=label)
return output, last_layer
def _build_layers_v2(self, input_dict, num_outputs, options):
# print(input_dict)
# exit(222)
hparams = copy.copy(options["custom_options"]["hparams"])
#targets = tf.placeholder(
# tf.float32, [None, 11, 11, 1])
targets = input_dict["prev_actions"]
inputs = input_dict["obs"]
# if not (tf.get_variable_scope().reuse or
# hparams.mode == tf.estimator.ModeKeys.PREDICT):
# tf.summary.image("inputs", inputs, max_outputs=1)
# tf.summary.image("targets", targets, max_outputs=1)
with tf.name_scope('enc_prep'):
encoder_input = cia.prepare_encoder(inputs, hparams)
with tf.name_scope('enc_layers'):
encoder_output = cia.transformer_encoder_layers(
encoder_input,
hparams.num_encoder_layers,
hparams,
attention_type=hparams.enc_attention_type,
name="encoder")
with tf.name_scope('dec_prep'):
decoder_input, rows, cols = cia.prepare_decoder(
targets, hparams)
with tf.name_scope('dec_layers'):
decoder_output = cia.transformer_decoder_layers(
decoder_input,
encoder_output,
hparams.num_decoder_layers,
hparams,
attention_type=hparams.dec_attention_type,
name="decoder")
#with tf.name_scope('dec_out'):
# output = cia.create_output(decoder_output, rows, cols, targets, hparams)
#print(output, encoder_output)
out_size, kernel, stride = [32, [3, 3], 2]
activation = get_activation_fn(options.get("conv_activation"))
fc1 = slim.conv2d(
decoder_output,
out_size,
kernel,
stride,
activation_fn=activation,
padding="VALID",
scope="fc1")
fc2 = slim.conv2d(
fc1,
num_outputs, [1, 1],
activation_fn=None,
normalizer_fn=None,
scope="fc2")
#print(fc1, fc2)
#print(flatten(fc1), flatten(fc2))
#exit(123)
return flatten(fc2), flatten(fc1)
def _build_layers(self, inputs, num_outputs, options):
if options.get('custom_options', {}).get('add_coordinates'):
with_r = False
if options.get('custom_options', {}).get('add_coords_with_r'):
with_r = True
addcoords = AddCoords(x_dim=int(np.shape(inputs)[1]),
y_dim=int(np.shape(inputs)[1]),
with_r=with_r)
inputs = addcoords(inputs)
print("visionnet: Added coordinate filters tensor size is now {}".
format(np.shape(inputs)))
filters = options.get("conv_filters")
if not filters:
filters = get_filter_config(options)
activation = get_activation_fn(options.get("conv_activation", "relu"))
with tf.name_scope("vision_net"):
for i, (out_size, kernel, stride) in enumerate(filters[:-1], 1):
inputs = slim.conv2d(inputs,
out_size,
kernel,
stride,
activation_fn=activation,
scope="conv{}".format(i))
out_size, kernel, stride = filters[-1]
fc1 = slim.conv2d(inputs,
out_size,
kernel,
stride,
activation_fn=activation,
padding="VALID",
scope="fc1")
if tf.__version__ == '1.4.0':
fc2 = slim.conv2d(fc1,
num_outputs,
1,
activation_fn=None,
normalizer_fn=None,
scope="fc2")
else:
fc2 = slim.conv2d(fc1,
num_outputs, [1, 1],
activation_fn=None,
normalizer_fn=None,
scope="fc2")
return flatten(fc2), flatten(fc1)
def _build_layers(self, inputs, num_outputs, options):
hiddens = options.get("fcnet_hiddens")
activation = get_activation_fn(options.get("fcnet_activation"))
vf_share_layers = options.get("custom_options").get("vf_share_layers")
model = self.KERAS_MODEL(layer_units=hiddens + [num_outputs],
activation=activation,
custom_params=self.custom_params,
vf_share_layers=vf_share_layers)
self.keras_model = model
if vf_share_layers:
output, value_function = model(inputs)
self._value_function = tf.reshape(value_function, [-1])
else:
output = model(inputs)
last_layer = model.layers[-1]
return output, last_layer
def _build_layers(self, inputs, num_outputs, options):
hiddens = options.get("fcnet_hiddens", [256, 256])
activation = get_activation_fn(options.get("fcnet_activation", "relu"))
with tf.name_scope("fc_net"):
last_layer = flatten(inputs)
for size in hiddens:
last_layer = layers.dense(
last_layer,
size,
kernel_initializer=normc_initializer(1.0),
activation=activation)
output = layers.dense(
last_layer,
num_outputs,
kernel_initializer=normc_initializer(1.0),
activation=None)
return output, last_layer
def _build_layers_v2(self, input_dict, num_outputs, options):
inputs = input_dict["obs"]
filters = options.get("conv_filters")
if not filters:
filters = _get_filter_config(inputs.shape.as_list()[1:])
activation = get_activation_fn(options.get("conv_activation"))
inputs = slim.conv2d(inputs,
16, (3, 3),
1,
activation_fn=activation,
scope="conv_trans_in")
tf.layers.max_pooling2d(
inputs,
(2, 2),
strides=1,
padding='same',
# data_format='channels_last',
name="pooling")
""" Begin Transformer"""
hparams = image_transformer_2d.img2img_transformer2d_tiny()
hparams.data_dir = ""
hparams.img_len = IMAGE
hparams.num_channels = 16
hparams.hidden_size = 8
p_hparams = Img2imgCeleba().get_hparams(hparams)
p_hparams.modality = {
"inputs": modalities.ModalityType.IMAGE,
"targets": modalities.ModalityType.IMAGE,
}
p_hparams.vocab_size = {
"inputs": IMAGE,
"targets": IMAGE,
}
features = {
"inputs": inputs,
#"targets": target,
#"target_space_id": tf.constant(1, dtype=tf.int32),
}
#model = image_transformer_2d.Img2imgTransformer(hparams, tf.estimator.ModeKeys.TRAIN, p_hparams)
model = ImgEncTransformer(hparams, tf.estimator.ModeKeys.TRAIN,
p_hparams)
trans_logits, trans_losses = model(features)
print("trans_logits", trans_logits)
print("inputs", inputs)
""" End Transformer"""
#inputs = trans_logits
## TAKE CARE! Normalization?!
inputs = tf.contrib.layers.batch_norm(
trans_logits,
data_format=
'NHWC', # Matching the "cnn" tensor which has shape (?, 480, 640, 128).
center=True,
scale=True,
#is_training=training,
scope='cnn-batch_norm')
with tf.name_scope("vision_net"):
for i, (out_size, kernel, stride) in enumerate(filters[:-1], 1):
inputs = slim.conv2d(inputs,
out_size,
kernel,
stride,
activation_fn=activation,
scope="conv{}".format(i))
print(i, inputs)
out_size, kernel, stride = filters[-1]
fc1 = slim.conv2d(inputs,
out_size,
kernel,
stride,
activation_fn=activation,
padding="VALID",
scope="fc1")
fc2 = slim.conv2d(fc1,
num_outputs, [1, 1],
activation_fn=None,
normalizer_fn=None,
scope="fc2")
print(fc1, fc2)
print(flatten(fc1), flatten(fc2))
# exit(123)
return flatten(fc2), flatten(fc1)
def _build_layers_v2(self, input_dict, num_outputs, options):
if isinstance(input_dict['obs'], dict):
# unpacking Doom observation dict, and
obs = input_dict['obs']['obs']
else:
obs = input_dict['obs']
obs = tf_normalize(obs, self.obs_space, low=0, high=255)
if isinstance(input_dict['obs'],
dict) and 'measurements' in input_dict['obs']:
# health, ammo, etc.
measurements = input_dict['obs']['measurements']
else:
measurements = None
filters = options.get('conv_filters')
if not filters:
filters = _get_filter_config(obs.shape.as_list()[1:])
activation = get_activation_fn(options.get('conv_activation'))
fcnet_activation = get_activation_fn(options.get('fcnet_activation'))
with tf.name_scope('vision_net'):
for i, (out_size, kernel, stride) in enumerate(filters, 1):
obs = tf.layers.conv2d(
obs,
out_size,
kernel,
stride,
activation=activation,
padding='same',
name='conv{}'.format(i),
)
vis_input_flat = flatten(obs)
if measurements is not None:
measurements_fc = tf.layers.dense(measurements,
128,
activation=fcnet_activation,
name=f'm_fc1')
measurements_fc = tf.layers.dense(measurements_fc,
128,
activation=fcnet_activation,
name=f'm_fc2')
all_input = tf.concat([vis_input_flat, measurements_fc],
axis=1)
else:
all_input = vis_input_flat
fc_hiddens = [512]
for i, fc_hidden in enumerate(fc_hiddens, 1):
hidden = tf.layers.dense(all_input,
fc_hidden,
activation=fcnet_activation,
name=f'fc{i}')
# this will be used later for value function
last_hidden = hidden
fc_final = tf.layers.dense(last_hidden,
num_outputs,
activation=None,
name=f'fc_final')
return fc_final, last_hidden
def _build_layers_v2(self, input_dict, num_outputs, options):
inputs = input_dict["obs"]
#make_image(inputs)
#tf.summary.image('images', tf.reshape(inputs, [-1, IMAGE_SIZE, IMAGE_SIZE, 1]), 50)
hiddens = options.get("fcnet_hiddens")
activation = get_activation_fn(options.get("fcnet_activation"))
# Conv Layers
convs = [32, 32, 32, 32]
kerns = [3, 3, 3, 3]
strides = [2, 2, 2, 2]
pads = 'valid'
#fc = 256
activ = tf.nn.elu
with tf.name_scope('conv1'):
conv1 = tf.layers.conv2d(
inputs=inputs,
filters=convs[0],
kernel_size=kerns[0],
strides=strides[0],
padding=pads,
activation=activ,
name='conv1')
with tf.name_scope('conv2'):
conv2 = tf.layers.conv2d(
inputs=conv1,
filters=convs[1],
kernel_size=kerns[1],
strides=strides[1],
padding=pads,
activation=activ,
name='conv2')
with tf.name_scope('conv3'):
conv3 = tf.layers.conv2d(
inputs=conv2,
filters=convs[2],
kernel_size=kerns[2],
strides=strides[2],
padding=pads,
activation=activ,
name='conv3')
with tf.name_scope('conv4'):
conv4 = tf.layers.conv2d(
inputs=conv3,
filters=convs[3],
kernel_size=kerns[3],
strides=strides[3],
padding=pads,
activation=activ,
name='conv4')
flat = tf.layers.flatten(conv4)
with tf.name_scope("fc_net"):
i = 1
last_layer = flat
for size in hiddens:
label = "fc{}".format(i)
last_layer = slim.fully_connected(
last_layer,
size,
weights_initializer=normc_initializer(1.0),
activation_fn=activation,
scope=label)
i += 1
label = "fc_out"
output = slim.fully_connected(
last_layer,
num_outputs,
weights_initializer=normc_initializer(0.01),
activation_fn=None,
scope=label)
return output, last_layer
