def create_actor_network(self, state_size, action_dim): print("Now we build the model") with tf.name_scope('ActorNetwork') as scope: S = Input(shape=[state_size], name='state') h0 = Dense(HIDDEN1_UNITS, activation='relu', name='DenseLayer0')(S) h1 = Dense(HIDDEN2_UNITS, activation='relu', name='DenseLayer1')(h0) Steering = Dense( 1, name='Steering', activation='tanh', kernel_initializer=variance_scaling(scale=1e-4, distribution='normal'), bias_initializer=variance_scaling(scale=1e-4, distribution='normal') )( h1 ) #,init=lambda shape, name: normal(shape, scale=1e-4, name=name))(h1) Acceleration = Dense( 1, name='Acceleration', activation='tanh', kernel_initializer=variance_scaling(scale=1e-4, distribution='normal'), bias_initializer=variance_scaling(scale=1e-4, distribution='normal') )( h1 ) #,init=lambda shape, name: normal(shape, scale=1e-4, name=name))(h1) #Brake = Dense(1,activation='sigmoid', kernel_initializer=variance_scaling(scale=1e-4, distribution='normal'), bias_initializer=variance_scaling(scale=1e-4, distribution='normal'))(h1) #Gear = Dense(3,activation='softmax')(h1) V = concatenate([Steering, Acceleration], name='Action') #,Brake]) model = Model(inputs=S, outputs=V) return model, model.trainable_weights, S
def create_tensor_graph(self, model_input_params, class_count, algorithm_params): with tf.device(model_input_params.device_id): with slim.arg_scope([slim.conv2d, slim.fully_connected], weights_initializer=initializers.variance_scaling(scale=2.0), weights_regularizer=slim.l2_regularizer(algorithm_params["l2regularizer_scale"])): band_size = model_input_params.x.get_shape()[3].value hs_lidar_groups = tf.split(axis=3, num_or_size_splits=[band_size - 1, 1], value=model_input_params.x) lrelu = lambda inp: slim.nn.leaky_relu(inp, alpha=algorithm_params["lrelu_alpha"]) bn_training_params = {'is_training': model_input_params.is_training, 'decay': 0.95} hs_lidar_diff = algorithm_params["hs_lidar_diff"] hs_net = self._create_hs_tensor_branch(algorithm_params, bn_training_params, hs_lidar_groups[0][:, hs_lidar_diff:-hs_lidar_diff, hs_lidar_diff:-hs_lidar_diff, :], lrelu, model_input_params) lidar_net = self._create_lidar_tensor_branch(bn_training_params, hs_lidar_groups[1], lrelu, model_input_params) # net = tf.concat(axis=3, values=[hs_net, lidar_net]) net = tf.concat(axis=1, values=[slim.flatten(hs_net), slim.flatten(lidar_net)]) net = self._create_fc_tensor_branch(algorithm_params, bn_training_params, class_count, lrelu, model_input_params, net) return ModelOutputTensors(y_conv=net, image_output=None, image_original=None, histogram_tensors=[])
def _shadowdata_discriminator_model(generated_data, generator_input, is_training=True): with slim.arg_scope( [slim.fully_connected, slim.separable_conv2d, slim.convolution1d], weights_initializer=initializers.variance_scaling(scale=2.0), weights_regularizer=slim.l2_regularizer(0.001), # normalizer_fn=slim.batch_norm, # normalizer_params={'is_training': is_training, 'decay': 0.999}, # normalizer_fn=slim.instance_norm, # normalizer_params={'center': True, 'scale': True, 'epsilon': 0.001}, activation_fn=(lambda inp: slim.nn.leaky_relu(inp, alpha=0.1))): band_size = generated_data.get_shape()[3].value net = generated_data net = tf.squeeze(net, axis=[1, 2]) net = tf.expand_dims(net, axis=2) net1 = slim.convolution1d(net, band_size, band_size, padding='VALID') net2 = slim.convolution1d(transpose(net1, perm=[0, 2, 1]), band_size, band_size, padding='VALID', normalizer_fn=None, normalizer_params=None, activation_fn=None) return tf.expand_dims(tf.expand_dims(slim.flatten(net2), axis=1), axis=1)
def _shadowdata_generator_model_v2(netinput, is_training=True): with slim.arg_scope( [slim.conv2d, slim.conv2d_transpose, slim.separable_conv2d], weights_initializer=initializers.variance_scaling(scale=2.0), weights_regularizer=slim.l2_regularizer(0.00001), normalizer_fn=slim.batch_norm, normalizer_params={ 'is_training': is_training, 'decay': 0.95 }, # normalizer_fn=slim.instance_norm, # normalizer_params={'center': True, 'scale': True, 'epsilon': 0.001}, activation_fn=(lambda inp: slim.nn.leaky_relu(inp)), trainable=is_training): net_hats = [] for index in range(0, 64): level0 = expand_dims(netinput[:, :, :, index], axis=3) level1 = slim.conv2d(level0, 1, [1, 1], normalizer_fn=None, normalizer_params=None, weights_regularizer=None) net_hats.append(level1) net = tf.concat(net_hats, axis=3) return net
def _shadowdata_discriminator_model(generated_data, generator_input, is_training=True): # bn_training_params = {'is_training': is_training, 'decay': 0.95} # normalizer_fn=slim.batch_norm, with slim.arg_scope( [slim.fully_connected], weights_initializer=initializers.variance_scaling(scale=2.0), # weights_regularizer=slim.l2_regularizer(0.001), # normalizer_fn=slim.batch_norm, # normalizer_params={'is_training': is_training, 'decay': 0.95}, # normalizer_fn=slim.instance_norm, # normalizer_params={'center': True, 'scale': True, 'epsilon': 0.001}, activation_fn=(lambda inp: slim.nn.leaky_relu(inp))): net = tf.concat(axis=3, values=[generated_data, generator_input]) # net = tf.transpose(net, [0, 3, 1, 2]) # filter_count = 16 # net = slim.conv2d(net, filter_count, [1, 1], stride=2) # net = slim.conv2d(net, int(filter_count / 2), [1, 1], stride=2) # net = slim.conv2d(net, int(filter_count / 4), [1, 1], stride=2) # net = slim.conv2d(net, int(filter_count / 8), [1, 1], stride=2) # net = slim.conv2d(net, int(filter_count / 16), [1, 1], stride=2) net = slim.flatten(net) net = slim.fully_connected(net, 192, scope='fc1') net = slim.fully_connected(net, 128, scope='fc2') net = slim.fully_connected(net, 96, scope='fc3') net = slim.fully_connected(net, 64, scope='fc4') net = slim.fully_connected(net, 48, scope='fc5') net = slim.fully_connected(net, 32, scope='fc6') return net
def build(self, input_shape: Union[list, tuple]): super().build(input_shape) logit_count = self.__policy__.num_inputs + 1 k_init = init.variance_scaling() b_init = init.zeros() self.__create_weights__(k_init((input_shape[-1], logit_count)), 'actor_kernel') self.__create_weights__(b_init(logit_count), 'actor_bias')
def _srdata_generator_model(netinput, is_training=True): with slim.arg_scope( [slim.conv2d, slim.conv2d_transpose], weights_initializer=initializers.variance_scaling(scale=2.0), # weights_regularizer=slim.l2_regularizer(0.00001), # normalizer_fn=slim.batch_norm, # normalizer_params={'is_training': is_training, 'decay': 0.95}, # normalizer_fn=slim.instance_norm, # normalizer_params={'center': True, 'scale': True, 'epsilon': 0.001}, # activation_fn=(lambda inp: slim.nn.leaky_relu(inp)), trainable=is_training, data_format="NHWC"): net = gen_net_method3(netinput) return net
def _srdata_discriminator_model(generated_data, generator_input, is_training=True): with slim.arg_scope( [slim.fully_connected], weights_initializer=initializers.variance_scaling(scale=2.0), weights_regularizer=slim.l2_regularizer(0.001), # normalizer_fn=slim.batch_norm, # normalizer_params={'is_training': is_training, 'decay': 0.95}, normalizer_fn=slim.instance_norm, normalizer_params={ 'center': True, 'scale': True, 'epsilon': 0.001 }, activation_fn=(lambda inp: slim.nn.leaky_relu(inp))): # net = tf.concat(axis=3, values=[generated_data, generator_input]) # # net = slim.flatten(net) # net = slim.fully_connected(net, 768 * 2, scope='fc2') # net = slim.fully_connected(net, 384 * 2, scope='fc2') # net = slim.fully_connected(net, 192 * 2, scope='fc3') # net = slim.fully_connected(net, 128, scope='fc4') # net = slim.fully_connected(net, 96, scope='fc5') # net = slim.fully_connected(net, 64, scope='fc6') net_hats = [] for index in range(0, 144): level0 = expand_dims(generated_data[:, :, :, index], axis=3) level1 = slim.conv2d(level0, 1, [5, 5], padding='VALID') level2 = slim.conv2d(level1, 1, [3, 3], padding='VALID') level3 = slim.conv2d(level2, 1, [1, 1], padding='VALID', activation_fn=None, normalizer_fn=None, normalizer_params=None) net_hats.append(level3) net = tf.concat(net_hats, axis=3) # net = slim.flatten(net) # net = slim.fully_connected(net, 4 * 4 * 144, scope='fc1') # net = slim.dropout(net, is_training=is_training) # net = slim.fully_connected(net, 4 * 4 * 144, scope='fc2', # activation_fn=None, normalizer_fn=None, normalizer_params=None) # net = tf.reshape(net, [-1, 2, 2, 144]) return net
def _shadowdata_feature_discriminator_model(generated_data, is_training=True): with slim.arg_scope( [slim.fully_connected, slim.separable_conv2d, slim.convolution1d], weights_initializer=initializers.variance_scaling(scale=2.0), weights_regularizer=slim.l2_regularizer(0.001), # normalizer_fn=slim.batch_norm, # normalizer_params={'is_training': is_training, 'decay': 0.999}, # normalizer_fn=slim.instance_norm, # normalizer_params={'center': True, 'scale': True, 'epsilon': 0.001}, activation_fn=(lambda inp: slim.nn.leaky_relu(inp, alpha=0.1))): band_size = generated_data.get_shape()[3].value net = generated_data net = slim.flatten(net) net1 = slim.fully_connected(net, band_size // 2) net2 = slim.fully_connected(net1, band_size // 4) net3 = slim.fully_connected(net2, band_size // 8) return net3
def _shadowdata_discriminator_model_simple(generated_data, generator_input, is_training=True): with slim.arg_scope( [slim.fully_connected, slim.separable_conv2d, slim.convolution1d], weights_initializer=initializers.variance_scaling(scale=2.0), activation_fn=(lambda inp: slim.nn.leaky_relu(inp, alpha=0.01))): band_size = generated_data.get_shape()[3].value net = tf.concat(axis=3, values=[generated_data, generator_input]) net = tf.squeeze(net, axis=[1, 2]) net = tf.expand_dims(net, axis=2) size = band_size * 2 net = slim.convolution1d(net, size, size, padding='VALID', normalizer_fn=None, normalizer_params=None, activation_fn=None) net = tf.expand_dims(tf.expand_dims(slim.flatten(net), axis=1), axis=1) return net
def _shadowdata_generator_model(netinput, is_training=True): with slim.arg_scope( [slim.conv2d, slim.conv2d_transpose], weights_initializer=initializers.variance_scaling(scale=2.0), # weights_regularizer=slim.l2_regularizer(0.001), # normalizer_fn=slim.batch_norm, # normalizer_params={'is_training': is_training, 'decay': 0.95}, # normalizer_fn=slim.instance_norm, # normalizer_params={'center': True, 'scale': True, 'epsilon': 0.001}, activation_fn=(lambda inp: slim.nn.leaky_relu(inp)), trainable=is_training, data_format="NHWC"): # netinput = tf.transpose(netinput, [0, 3, 1, 2]) net = slim.conv2d(netinput, 144, [1, 1]) net = slim.conv2d(net, 72, [1, 1]) net = slim.conv2d(net, 36, [1, 1]) net = slim.conv2d(net, 36, [1, 1]) net = slim.conv2d(net, 36, [1, 1]) net = slim.conv2d(net, 72, [1, 1]) net = slim.conv2d(net, 144, [1, 1]) # net = tf.transpose(net, [0, 2, 3, 1]) return net
def _shadowdata_discriminator_model(generated_data, generator_input, is_training=True): # bn_training_params = {'is_training': is_training, 'decay': 0.95} # normalizer_fn=slim.batch_norm, with slim.arg_scope( [slim.fully_connected, slim.separable_conv2d], weights_initializer=initializers.variance_scaling(scale=2.0), # weights_regularizer=slim.l2_regularizer(0.001), # normalizer_fn=slim.batch_norm, # normalizer_params={'is_training': is_training, 'decay': 0.95}, # normalizer_fn=slim.instance_norm, # normalizer_params={'center': True, 'scale': True, 'epsilon': 0.001}, activation_fn=(lambda inp: slim.nn.leaky_relu(inp))): # net = tf.concat(axis=3, values=[generated_data, generator_input]) # net = slim.flatten(net) # net = slim.fully_connected(net, 192, scope='fc1') # net = slim.dropout(net, is_training=is_training) # net = slim.fully_connected(net, 128, scope='fc2') # net = slim.dropout(net, is_training=is_training) # net = slim.fully_connected(net, 96, scope='fc3') # net_hats = [] # for index in range(0, 64): # level0 = expand_dims(generated_data[:, :, :, index], axis=3) # level1 = slim.conv2d(level0, 1, [1, 1], padding='VALID', # activation_fn=None, normalizer_fn=None, normalizer_params=None) # net_hats.append(level1) # net = tf.concat(net_hats, axis=3) net = slim.separable_conv2d(generated_data, 64, [1, 1], 64, normalizer_fn=None, normalizer_params=None, weights_regularizer=None) return net
def create_tensor_graph(self, model_input_params, class_count, algorithm_params): with tf.device(model_input_params.device_id): data_format = None # 'NHWC' bn_training_params = { 'is_training': model_input_params.is_training, 'decay': algorithm_params["bn_decay"] } lrelu = lambda inp: slim.nn.leaky_relu( inp, alpha=algorithm_params["lrelu_alpha"]) with slim.arg_scope( [slim.conv2d, slim.fully_connected], weights_initializer=initializers.variance_scaling( scale=2.0), weights_regularizer=slim.l2_regularizer( algorithm_params["l2regularizer_scale"]), normalizer_fn=slim.batch_norm, normalizer_params=bn_training_params, activation_fn=lrelu): level_filter_count = algorithm_params["filter_count"] if data_format == 'NCHW': net0 = tf.transpose(model_input_params.x, [0, 3, 1, 2]) # Convert input to NCHW else: net0 = model_input_params.x spectral_hierarchy_level = algorithm_params[ "spectral_hierarchy_level"] net1 = self.__create_spectral_nn_layers( data_format, level_filter_count, net0, spectral_hierarchy_level, True) net1 = net1 + CNNModelv4.__scale_input_to_output(net0, net1) net2 = self.__create_spectral_nn_layers( data_format, level_filter_count, net1, spectral_hierarchy_level, False) net2 = net2 + CNNModelv4.__scale_input_to_output(net1, net2) spatial_hierarchy_level = algorithm_params[ "spatial_hierarchy_level"] net3 = self.__create_levels_as_blocks( data_format, int(net2.get_shape()[3].value / 2), net2, spatial_hierarchy_level) net3 = net3 + CNNModelv4.__scale_input_to_output(net2, net3) net4 = slim.flatten(net3) degradation_coeff = algorithm_params["degradation_coeff"] net5 = self.__create_fc_block(algorithm_params, class_count, degradation_coeff, model_input_params, net4) net6 = slim.fully_connected(net5, class_count, weights_regularizer=None, activation_fn=None, scope='fc_final') image_gen_net4 = None if model_input_params.is_training: image_gen_net1 = slim.fully_connected( net6, class_count * 3, weights_regularizer=None, scope='image_gen_net_1') image_gen_net2 = slim.fully_connected( image_gen_net1, class_count * 9, weights_regularizer=None, scope='image_gen_net_2') image_gen_net3 = slim.fully_connected( image_gen_net2, class_count * 27, weights_regularizer=None, scope='image_gen_net_3') image_size = (net0.get_shape()[1] * net0.get_shape()[2] * net0.get_shape()[3]).value image_gen_net4 = slim.fully_connected( image_gen_net3, image_size, weights_regularizer=None, activation_fn=tf.sigmoid, scope='image_gen_net_4') return ModelOutputTensors(y_conv=net6, image_output=image_gen_net4, image_original=net0)
def create_tensor_graph(self, model_input_params, class_count, algorithm_params): iter_routing = algorithm_params["iter_routing"] conv_layer_kernel_size = [ algorithm_params["conv_layer_kernel_size"], algorithm_params["conv_layer_kernel_size"] ] primary_caps_kernel_size = [ algorithm_params["primary_caps_kernel_size"], algorithm_params["primary_caps_kernel_size"] ] feature_count = algorithm_params["feature_count"] primary_capsule_count = algorithm_params["primary_capsule_count"] primary_capsule_output_space = algorithm_params[ "digit_capsule_output_space"] digit_capsule_output_space = algorithm_params[ "digit_capsule_output_space"] digit_capsule_count = class_count batch_size = -1 enable_decoding = algorithm_params["enable_decoding"] lrelu_func = lambda inp: slim.nn.leaky_relu( inp, alpha=algorithm_params["lrelu_alpha"]) with tf.device(model_input_params.device_id): with slim.arg_scope( [slim.conv2d], trainable=model_input_params.is_training, weights_initializer=initializers.variance_scaling( scale=2.0)): with tf.variable_scope('Conv1_layer') as scope: image_output = slim.conv2d( model_input_params.x, num_outputs=feature_count, activation_fn=lrelu_func, kernel_size=conv_layer_kernel_size, padding='VALID', scope=scope) with tf.variable_scope('PrimaryCaps_layer') as scope: image_output = slim.conv2d( image_output, num_outputs=primary_capsule_count * primary_capsule_output_space, kernel_size=primary_caps_kernel_size, stride=2, padding='VALID', scope=scope, activation_fn=lrelu_func) data_size = (image_output.get_shape()[1] * image_output.get_shape()[2] * image_output.get_shape()[3]).value data_size = int(data_size / primary_capsule_output_space) image_output = tf.reshape(image_output, [ batch_size, data_size, 1, primary_capsule_output_space ]) with tf.variable_scope('DigitCaps_layer'): u_hats = [] image_output_groups = tf.split( axis=1, num_or_size_splits=data_size, value=image_output) for i in range(data_size): u_hat = slim.conv2d(image_output_groups[i], num_outputs=digit_capsule_count * digit_capsule_output_space, kernel_size=[1, 1], padding='VALID', scope='DigitCaps_layer_w_' + str(i), activation_fn=lrelu_func) u_hat = tf.reshape(u_hat, [ batch_size, 1, digit_capsule_count, digit_capsule_output_space ]) u_hats.append(u_hat) image_output = tf.concat(u_hats, axis=1) b_ijs = tf.constant( numpy.zeros([data_size, digit_capsule_count], dtype=numpy.float32)) v_js = [] for r_iter in range(iter_routing): with tf.variable_scope('iter_' + str(r_iter)): b_ij_groups = tf.split( axis=1, num_or_size_splits=digit_capsule_count, value=b_ijs) c_ijs = tf.nn.softmax(b_ijs, axis=1) c_ij_groups = tf.split( axis=1, num_or_size_splits=digit_capsule_count, value=c_ijs) image_output_groups = tf.split( axis=2, num_or_size_splits=digit_capsule_count, value=image_output) for i in range(digit_capsule_count): c_ij = tf.reshape( tf.tile(c_ij_groups[i], [1, digit_capsule_output_space]), [ c_ij_groups[i].get_shape()[0], 1, digit_capsule_output_space, 1 ]) s_j = tf.nn.depthwise_conv2d( image_output_groups[i], c_ij, strides=[1, 1, 1, 1], padding='VALID') # Squash function s_j = tf.reshape( s_j, [batch_size, digit_capsule_output_space]) s_j_norm_square = tf.reduce_mean( tf.square(s_j), axis=1, keepdims=True) v_j = s_j_norm_square * s_j / ( (1 + s_j_norm_square) * tf.sqrt(s_j_norm_square + 1e-9)) b_ij_groups[i] = b_ij_groups[ i] + tf.reduce_sum(tf.matmul( tf.reshape(image_output_groups[i], [ batch_size, image_output_groups[i].get_shape() [1], digit_capsule_output_space ]), tf.reshape(v_j, [ batch_size, digit_capsule_output_space, 1 ])), axis=0) if r_iter == iter_routing - 1: v_js.append( tf.reshape(v_j, [ batch_size, 1, digit_capsule_output_space ])) b_ijs = tf.concat(b_ij_groups, axis=1) image_output = tf.concat(v_js, axis=1) with tf.variable_scope('Masking'): y_conv = tf.norm(image_output, axis=2) decoder_image_output = None if model_input_params.is_training and enable_decoding: y_as_float = tf.cast(model_input_params.y, dtype=tf.float32) masked_v = tf.matmul( image_output, tf.reshape(y_as_float, [batch_size, digit_capsule_count, 1]), transpose_a=True) masked_v = tf.reshape( masked_v, [batch_size, digit_capsule_output_space]) with tf.variable_scope('Decoder'): size = (model_input_params.x.get_shape()[1] * model_input_params.x.get_shape()[2] * model_input_params.x.get_shape()[3]).value image_output = slim.fully_connected( masked_v, 512, scope='fc1', activation_fn=lrelu_func, trainable=model_input_params.is_training) image_output = slim.fully_connected( image_output, 1024, scope='fc2', activation_fn=lrelu_func, trainable=model_input_params.is_training) decoder_image_output = slim.fully_connected( image_output, size, scope='fc3', activation_fn=tf.sigmoid, trainable=model_input_params.is_training) return ModelOutputTensors(y_conv=y_conv, image_output=decoder_image_output, image_original=model_input_params.x)