def build(self, input_shape): input_dimension = input_shape[-1] units1 = self.output_dimension * self.number_of_mixtures self.mu_kernel = self.add_weight(name="mu_kernel", shape = shape(input_dimension, units1), initializer=initializers.random_normal(), trainable=True) self.mu_bias = self.add_weight(name="mu_bias", shape = shape(units1), initializer=initializers.zeros(), trainable=True) self.sigma_kernel = self.add_weight(name="sigma_kernel", shape = shape(input_dimension, units1), initializer=initializers.random_normal(), trainable=True) self.sigma_bias = self.add_weight(name="sigma_bias", shape = shape(units1), initializer=initializers.zeros(), trainable=True) units2 = self.number_of_mixtures self.pi_kernel = self.add_weight(name="pi_kernel", shape = shape(input_dimension, units2), initializer=initializers.random_normal(), trainable=True) self.pi_bias = self.add_weight(name="pi_bias", shape = shape(units2), initializer=initializers.zeros(), trainable=True)
def __init__(self): (self.train_X, self.train_y), (self.test_X, self.test_y) = mnist.load_data() self.image_input_layer = layers.InputLayer(input_shape=(28, 28, 1)) self.convolution2d_layer = layers.Conv2D( 20, use_bias=True, strides=(1, 1), activation='relu', padding='same', kernel_size=(5, 5), kernel_initializer=initializers.random_normal(mean=0, stddev=0.01, seed=None)) self.max_pooling2d_layer = layers.MaxPooling2D(strides=(2, 2), pool_size=(2, 2), padding='valid') self.fully_connected_layer1 = layers.Dense( 100, use_bias=True, activation='relu', kernel_initializer=initializers.random_normal(mean=0, stddev=0.01, seed=None)) self.fully_connected_layer2 = layers.Dense(10, use_bias=True, activation='softmax') self.optimizer = SGD(momentum=0.9, lr=0.001) self.history_list = list() self.score_list = list()
def _kernel_init(kernel_size): if 'tanh' == activations.serialize(self.activation): stddev = np.sqrt(1. / (kernel_size * self.char_dim)) return initializers.random_normal(mean=0., stddev=stddev) if 'relu' == activations.serialize(self.activation): return 'random_uniform' return 'glorot_uniform'
def _build_q_net(self): model = keras.Sequential() self.f1 = kl.Dense( units=20, input_shape=(self.n_features, ), activation='relu', kernel_initializer=initializers.random_normal(mean=0, stddev=0.1), bias_initializer=initializers.constant_initializer(0.1)) self.all_act = kl.Dense( units=self.n_actions, activation=None, kernel_initializer=initializers.random_normal(mean=0, stddev=0.1), bias_initializer=initializers.constant_initializer(0.1)) self.all_act_prob = kl.Activation('softmax') model.add(self.f1) model.add(self.all_act) model.add(self.all_act_prob) def _sparse_softmax_cross_entropy_with_logits(self, target): pass
def get_model(learning_rate, std_dev): model = tf.keras.models.Sequential([ tf.keras.layers.Flatten(), tf.keras.layers.Dense( 1000, activation=tf.nn.sigmoid, kernel_initializer=random_normal(stddev=std_dev)), tf.keras.layers.Dense( 100, activation=tf.nn.sigmoid, kernel_initializer=random_normal(stddev=std_dev)), tf.keras.layers.Dense( 50, activation=tf.nn.sigmoid, kernel_initializer=random_normal(stddev=std_dev)), tf.keras.layers.Dense( 100, activation=tf.nn.sigmoid, kernel_initializer=random_normal(stddev=std_dev)), tf.keras.layers.Dense( 1000, activation=tf.nn.sigmoid, kernel_initializer=random_normal(stddev=std_dev)), tf.keras.layers.Dense( D * D * 3, activation=tf.nn.sigmoid, kernel_initializer=random_normal(stddev=std_dev)), ]) model.compile(optimizer=tf.train.AdamOptimizer(learning_rate), loss='mean_squared_error', metrics=['accuracy']) return model
def build(self, input_shape=None): channels = input_shape[-1] if channels is None: raise ValueError('Channel dimension of the inputs should be defined. Found `None`.') self.input_spec = layers.InputSpec(ndim=max(2, len(input_shape)), axes={-1: channels}) kernel_initializer = initializers.random_normal(mean=0., stddev=np.sqrt(1. / channels)) self.carry = layers.Dense( channels, kernel_initializer=kernel_initializer, bias_initializer=initializers.constant(-2.), activation='sigmoid') self.transform = layers.Dense( channels, kernel_initializer=kernel_initializer, activation='relu') super().build(input_shape)
def build(self, input_shape): self.kernel_mu = self.add_weight( name='kernel_mu', shape=(input_shape[1], self.units), initializer=tf.keras.initializers.random_normal( stddev=self.init_sigma), trainable=True) self.bias_mu = self.add_weight( name='bias_mu', shape=(self.units, ), initializer=initializers.random_normal(stddev=self.init_sigma), trainable=True) self.kernel_rho = self.add_weight( name='kernel_rho', shape=(input_shape[1], self.units), initializer=initializers.constant(0.0), trainable=True) self.bias_rho = self.add_weight(name='bias_rho', shape=(self.units, ), initializer=initializers.constant(0.0), trainable=True) super().build(input_shape)
def __init__(self, weights_path, train_conv_layers): self.__angle_values = [-1, -0.5, 0, 0.5, 1] self.__nb_actions = 5 self.__gamma = 0.99 #Define the model activation = 'relu' pic_input = Input(shape=(59, 255, 3)) img_stack = Conv2D(16, (3, 3), name='convolution0', padding='same', activation=activation, trainable=train_conv_layers)(pic_input) img_stack = MaxPooling2D(pool_size=(2, 2))(img_stack) img_stack = Conv2D(32, (3, 3), activation=activation, padding='same', name='convolution1', trainable=train_conv_layers)(img_stack) img_stack = MaxPooling2D(pool_size=(2, 2))(img_stack) img_stack = Conv2D(32, (3, 3), activation=activation, padding='same', name='convolution2', trainable=train_conv_layers)(img_stack) img_stack = MaxPooling2D(pool_size=(2, 2))(img_stack) img_stack = Flatten()(img_stack) img_stack = Dropout(0.2)(img_stack) img_stack = Dense( 128, name='rl_dense', kernel_initializer=random_normal(stddev=0.01))(img_stack) img_stack = Dropout(0.2)(img_stack) output = Dense( self.__nb_actions, name='rl_output', kernel_initializer=random_normal(stddev=0.01))(img_stack) opt = Adam() self.__action_model = Model(inputs=[pic_input], outputs=output) self.__action_model.compile(optimizer=opt, loss='mean_squared_error') self.__action_model.summary() self.__data_dir = "" self.__experiment_name = "local_run" # If we are using pretrained weights for the conv layers, load them and verify the first layer. if (weights_path is not None and len(weights_path) > 0): print('Loading weights from my_model_weights.h5...') print('Current working dir is {0}'.format(os.getcwd())) self.__action_model.load_weights(weights_path, by_name=True) print('First layer: ') w = np.array(self.__action_model.get_weights()[0]) print(w) else: print('Not loading weights') # Set up the target model. # This is a trick that will allow the model to converge more rapidly. #commenting out next 4 lines self.__action_context = tf.get_default_graph( ) #tf.compat.v1.get_default_graph() #tf.get_default_graph() self.__target_model = clone_model(self.__action_model) self.__target_context = tf.get_default_graph( ) #tf.compat.v1.get_default_graph() #tf.get_default_graph() self.__model_lock = threading.Lock()