def _shadowdata_generator_model(netinput, is_training=True): with slim.arg_scope( [slim.conv2d, slim.conv2d_transpose, slim.convolution1d], # weights_initializer=initializers.variance_scaling(scale=2.0), weights_initializer=initializers.zeros(), # weights_regularizer=slim.l1_l2_regularizer(), # 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, alpha=0.1)), trainable=is_training, data_format="NHWC"): num_filters = 1 band_size = netinput.get_shape()[3].value kernel_size = band_size net0 = tf.expand_dims(tf.squeeze(netinput, axis=[1, 2]), axis=2) net1 = slim.convolution1d(net0, num_filters, kernel_size, padding='SAME') net1 = net1 + net0 net2 = slim.convolution1d(net1, num_filters, kernel_size // 2, padding='SAME') net2 = net2 + net1 + net0 net3 = slim.convolution1d(net2, num_filters, kernel_size // 4, padding='SAME') net3 = net3 + net2 + net1 net4 = slim.convolution1d(net3, num_filters, kernel_size // 8, padding='SAME') net4 = net4 + net3 + net2 net5 = slim.convolution1d(net4, num_filters, kernel_size // 4, padding='SAME') net5 = net5 + net4 + net3 net6 = slim.convolution1d(net5, num_filters, kernel_size // 2, padding='SAME') net6 = net6 + net5 + net4 net7 = slim.convolution1d(net6, num_filters, kernel_size, padding='SAME', normalizer_fn=None, normalizer_params=None, weights_regularizer=None, activation_fn=None) flatten = slim.flatten(net7) # net9 = slim.fully_connected(flatten, band_size, activation_fn=None) return tf.expand_dims(tf.expand_dims(flatten, axis=1), axis=1)
# experiment with small datasets trainX = trainX[:1000] trainY = trainY[:1000] for neuron_count in neurons: tf.reset_default_graph() with tf.Session() as sess: # Create the model lr = tf.placeholder(tf.float32, []) x = tf.placeholder(tf.float32, [None, NUM_FEATURES]) y_ = tf.placeholder(tf.float32, [None, 1]) # Build the graph for the deep net hidden_layer = layers.dense(x, neuron_count, activation=tf.nn.relu, kernel_initializer=init.orthogonal(np.sqrt(2)), bias_initializer=init.zeros(), kernel_regularizer=l2_regularizer(1e-3)) output_layer = layers.dense(hidden_layer, 1, kernel_initializer=init.orthogonal(), bias_initializer=init.zeros(), kernel_regularizer=l2_regularizer(1e-3)) loss = tf.reduce_mean(tf.square(y_ - output_layer) ) + get_regularization_loss() # Create the gradient descent optimizer with the given learning rate. optimizer = tf.train.GradientDescentOptimizer(lr) train_op = optimizer.minimize(loss) error = tf.reduce_mean(tf.square(y_ - output_layer)) fold_errors = [] for o in range(NUM_FOLDS): sess.run(tf.global_variables_initializer())
trainX, trainY = X_data[m:], Y_data[m:] # experiment with small datasets trainX = trainX[:1000] trainY = trainY[:1000] # Create the model x = tf.placeholder(tf.float32, [None, NUM_FEATURES]) y_ = tf.placeholder(tf.float32, [None, 1]) # Build the graph for the deep net hidden_layer = layers.dense(x, 100, activation=tf.nn.relu, kernel_initializer=init.orthogonal(np.sqrt(2)), bias_initializer=init.zeros(), kernel_regularizer=l2_regularizer(1e-3)) output_layer = layers.dense(hidden_layer, 1, kernel_initializer=init.orthogonal(), bias_initializer=init.zeros(), kernel_regularizer=l2_regularizer(1e-3)) loss = tf.reduce_mean(tf.square(y_ - output_layer)) + get_regularization_loss() # Create the gradient descent optimizer with the given learning rate. optimizer = tf.train.GradientDescentOptimizer(learning_rate) train_op = optimizer.minimize(loss) error = tf.reduce_mean(tf.square(y_ - output_layer)) with tf.Session() as sess:
def __init__(self, name, session, observation_space, action_space): self.name = name assert isinstance(action_space, spaces.Box) assert len(action_space.shape) == 1 assert (np.abs(action_space.low) == action_space.high ).all() # we assume symmetric actions. self.session = session with tf.variable_scope(self.name): self.observations_input = tf.placeholder( observation_space.dtype, shape=tuple([None] + list(observation_space.shape)), name="observations_input") self.actions_input = tf.placeholder( action_space.dtype, shape=tuple([None] + list(action_space.shape)), name="actions_input") self.actions_size = action_space.shape[0] self.combined_input = tf.concat( [self.observations_input, self.actions_input], axis=1, name="combined_input") with tf.variable_scope("actor"): self.actor01 = layers.dense( inputs=self.observations_input, units=64, activation=tf.tanh, name="layer_one", bias_initializer=initializers.zeros(), kernel_initializer=initializers.orthogonal( gain=np.sqrt(2))) self.actor02 = layers.dense( inputs=self.actor01, units=64, activation=tf.tanh, name="layer_two", bias_initializer=initializers.zeros(), kernel_initializer=initializers.orthogonal( gain=np.sqrt(2))) self.actor_head = layers.dense( inputs=self.actor02, units=self.actions_input.shape[1].value, activation=tf.tanh, name="head", bias_initializer=initializers.zeros(), kernel_initializer=initializers.orthogonal(gain=0.01)) self.actor_head_rescaled = self.actor_head * action_space.high self.model_computed_combined = tf.concat( [self.observations_input, self.actor_head_rescaled], axis=1, name="model_computed_combined") with tf.variable_scope("critic"): self.critic01 = layers.dense( inputs=self.combined_input, units=64, activation=tf.tanh, name="layer_one", bias_initializer=initializers.zeros(), kernel_initializer=initializers.orthogonal( gain=np.sqrt(2))) self.critic02 = layers.dense( inputs=self.critic01, units=64, activation=tf.tanh, name="layer_two", bias_initializer=initializers.zeros(), kernel_initializer=initializers.orthogonal( gain=np.sqrt(2))) self.action_value_head = layers.dense( inputs=self.critic02, units=1, activation=None, name="head", bias_initializer=initializers.zeros(), kernel_initializer=initializers.random_uniform( -3.0e-3, 3.0e-3)) self.model_critic01 = layers.dense( inputs=self.model_computed_combined, units=64, activation=tf.tanh, name="layer_one", bias_initializer=initializers.zeros(), kernel_initializer=initializers.orthogonal( gain=np.sqrt(2)), reuse= True # Use the same weights for 'critic' and for 'model critic' ) self.model_critic02 = layers.dense( inputs=self.model_critic01, units=64, activation=tf.tanh, name="layer_two", bias_initializer=initializers.zeros(), kernel_initializer=initializers.orthogonal( gain=np.sqrt(2)), reuse= True # Use the same weights for 'critic' and for 'model critic' ) self.state_value_head = layers.dense( inputs=self.model_critic02, units=1, activation=None, name="head", bias_initializer=initializers.zeros(), kernel_initializer=initializers.random_uniform( -3.0e-3, 3.0e-3), reuse= True # Use the same weights for 'critic' and for 'model critic' )
# experiment with small datasets trainX = trainX[:1000] trainX = (trainX - np.mean(trainX, axis=0)) / np.std(trainX, axis=0) trainY = trainY[:1000] n = trainX.shape[0] # Create the model x = tf.placeholder(tf.float32, [None, NUM_FEATURES]) y_ = tf.placeholder(tf.float32, [None, NUM_CLASSES]) # Build the graph for the deep nets hidden_layer = layers.dense(x, 10, activation=tf.nn.selu, kernel_initializer=init.orthogonal(), bias_initializer=init.zeros(), kernel_regularizer=l2_regularizer(1e-6)) output_layer = layers.dense(x, NUM_CLASSES, kernel_initializer=init.orthogonal(), bias_initializer=init.zeros(), kernel_regularizer=l2_regularizer(1e-6)) cross_entropy = tf.nn.softmax_cross_entropy_with_logits_v2(labels=y_, logits=output_layer) loss = tf.reduce_mean(cross_entropy) + get_regularization_loss() # Create the gradient descent optimizer with the given learning rate. optimizer = tf.train.GradientDescentOptimizer(learning_rate) train_op = optimizer.minimize(loss) correct_prediction = tf.cast(tf.equal(tf.argmax(output_layer, 1), tf.argmax(y_, 1)), tf.float32) accuracy = tf.reduce_mean(correct_prediction) with tf.Session() as sess:
# experiment with small datasets trainX = trainX[:1000] trainY = trainY[:1000] n = trainX.shape[0] # Create the model x = tf.placeholder(tf.float32, [None, NUM_FEATURES]) y_ = tf.placeholder(tf.float32, [None, NUM_CLASSES]) # Build the graph for the deep net hidden_layer = layers.dense(x, 10, activation=tf.nn.relu, kernel_initializer=init.orthogonal( np.sqrt(2)), bias_initializer=init.zeros(), kernel_regularizer=l2_regularizer(1e-6)) output_layer = layers.dense(hidden_layer, 6, kernel_initializer=init.orthogonal( ), bias_initializer=init.zeros(), kernel_regularizer=l2_regularizer(1e-6)) cross_entropy = tf.nn.softmax_cross_entropy_with_logits_v2( labels=y_, logits=output_layer) loss = tf.reduce_mean(cross_entropy) + get_regularization_loss() # Create the gradient descent optimizer with the given learning rate. optimizer = tf.train.GradientDescentOptimizer(learning_rate) train_op = optimizer.minimize(loss) correct_prediction = tf.cast( tf.equal(tf.argmax(output_layer, 1), tf.argmax(y_, 1)), tf.float32) accuracy = tf.reduce_mean(correct_prediction)
def build(self, input_shape: Union[list, tuple]): super().build(input_shape) self.__create_weights__(init.zeros()(self.__num_outputs__), 'log_std_params')