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