def build_model(dist: Union[Distribution, PixelCNN], input_shape: tuple = None, filepath: str = None) \ -> Tuple[tf.keras.Model, Union[Distribution, PixelCNN]]: """ Create tf.keras.Model from TF distribution. Parameters ---------- dist TensorFlow distribution. input_shape Input shape of the model. filepath File to load model weights from. Returns ------- TensorFlow model. """ x_in = Input(shape=input_shape) log_prob = dist.log_prob(x_in) model = Model(inputs=x_in, outputs=log_prob) model.add_loss(-tf.reduce_mean(log_prob)) if isinstance(filepath, str): model.load_weights(filepath) return model, dist
def _build_model(self): sequence_source_id = Input([900], name='source_id', dtype=tf.int32) sequence_target_id = Input([200], name='target_id', dtype=tf.int32) sequence_target_mask = Input([200], name='target_mask', dtype=tf.int32) self.encoder = Encoder(self.vocab_size, self.emb_dim, self.dropout_keep, self.encode_dim, self.n_agents, self.encoder_layers_num, self.batch_size) self.decode = Decoder(self.mode, self.attention_units, self.encode_dim, self.decode_len, self.vocab_size, self.emb_dim, self.batch_size, self.word2id) self.softmax = Softmax(axis=-1) encoder_outputs = self.encoder(sequence_source_id) # encoder_outputs = Concatenate(encoder_outputs, axis=1) decoder_output = self.decode(sequence_target_id, encoder_outputs) print('##########', encoder_outputs) print('##########', decoder_output.shape) # decoder_output = Lambda(lambda x:tf.unstack(x))(decoder_output) vocab_dists = self.softmax(decoder_output) self.loss = Seq2SeqLoss(sequence_target_mask, self.batch_size) model = Model([sequence_source_id, sequence_target_id], vocab_dists) loss = losses(self.decode_len, sequence_target_mask, self.batch_size, vocab_dists, sequence_target_id) model.add_loss(loss) model.compile(Adam(self.learning_rate)) return model
def compile(self): x = Input(shape=(self.input_dim, ), name="input") latent_dim = self.layer_sizes[-1] encoder = self.make_encoder() decoder = self.make_decoder() sampling_layer = Lambda(sampling_func, output_shape=(latent_dim, ), name="sampling_layer") z_mean, z_log_var = encoder(x) z = sampling_layer([z_mean, z_log_var]) x_decoded_mean = decoder(z) model = Model(inputs=x, outputs=x_decoded_mean) if self.recons_type == "xent": recons_loss = self.input_dim * metrics.binary_crossentropy( Flatten()(x), Flatten()(x_decoded_mean)) elif self.recons_type == "mse": recons_loss = metrics.mse(x, x_decoded_mean) kl_loss = -0.5 * tf.reduce_sum( 1 + z_log_var - tf.square(z_mean) - tf.exp(z_log_var), axis=-1) vae_loss = tf.reduce_mean(recons_loss + self.beta * kl_loss) model.add_loss(vae_loss) adam = Adam(learning_rate=self.learning_rate) model.compile(optimizer=adam) self.model = model self.encoder = encoder self.decoder = decoder
def build_model(hp): params = hp.copy() params['e_dim'] = params['dim'] params['r_dim'] = params['dim'] params['name'] = 'embedding_model' embedding_model = models[params['embedding_model']] embedding_model = embedding_model(**params) triple = Input((3, )) ftriple = Input((3, )) inputs = [triple, ftriple] score = embedding_model(triple) fscore = embedding_model(ftriple) loss_function = loss_function_lookup(params['loss_function']) loss = loss_function(score, fscore, params['margin'] or 1, 1) model = Model(inputs=inputs, outputs=loss) model.add_loss(loss) model.compile(optimizer='adam', loss=None) return model
def get_model(feature_extractor, rpn_model, anchors, hyper_params, mode="training"): """Generating rpn model for given backbone base model and hyper params. inputs: feature_extractor = feature extractor layer from the base model rpn_model = tf.keras.model generated rpn model anchors = (total_anchors, [y1, x1, y2, x2]) these values in normalized format between [0, 1] hyper_params = dictionary mode = "training" or "inference" outputs: frcnn_model = tf.keras.model """ input_img = rpn_model.input rpn_reg_predictions, rpn_cls_predictions = rpn_model.output # roi_bboxes = RoIBBox(anchors, mode, hyper_params, name="roi_bboxes")([rpn_reg_predictions, rpn_cls_predictions]) # roi_pooled = RoIPooling(hyper_params, name="roi_pooling")([feature_extractor.output, roi_bboxes]) # output = TimeDistributed(Flatten(), name="frcnn_flatten")(roi_pooled) output = TimeDistributed(Dense(4096, activation="relu"), name="frcnn_fc1")(output) output = TimeDistributed(Dropout(0.5), name="frcnn_dropout1")(output) output = TimeDistributed(Dense(4096, activation="relu"), name="frcnn_fc2")(output) output = TimeDistributed(Dropout(0.5), name="frcnn_dropout2")(output) frcnn_cls_predictions = TimeDistributed(Dense(hyper_params["total_labels"], activation="softmax"), name="frcnn_cls")(output) frcnn_reg_predictions = TimeDistributed(Dense(hyper_params["total_labels"] * 4, activation="linear"), name="frcnn_reg")(output) # if mode == "training": input_gt_boxes = Input(shape=(None, 4), name="input_gt_boxes", dtype=tf.float32) input_gt_labels = Input(shape=(None, ), name="input_gt_labels", dtype=tf.int32) rpn_cls_actuals = Input(shape=(None, None, hyper_params["anchor_count"]), name="input_rpn_cls_actuals", dtype=tf.float32) rpn_reg_actuals = Input(shape=(None, 4), name="input_rpn_reg_actuals", dtype=tf.float32) frcnn_reg_actuals, frcnn_cls_actuals = RoIDelta(hyper_params, name="roi_deltas")( [roi_bboxes, input_gt_boxes, input_gt_labels]) # loss_names = ["rpn_reg_loss", "rpn_cls_loss", "frcnn_reg_loss", "frcnn_cls_loss"] rpn_reg_loss_layer = Lambda(train_utils.reg_loss, name=loss_names[0])([rpn_reg_actuals, rpn_reg_predictions]) rpn_cls_loss_layer = Lambda(train_utils.rpn_cls_loss, name=loss_names[1])([rpn_cls_actuals, rpn_cls_predictions]) frcnn_reg_loss_layer = Lambda(train_utils.reg_loss, name=loss_names[2])([frcnn_reg_actuals, frcnn_reg_predictions]) frcnn_cls_loss_layer = Lambda(train_utils.frcnn_cls_loss, name=loss_names[3])([frcnn_cls_actuals, frcnn_cls_predictions]) # frcnn_model = Model(inputs=[input_img, input_gt_boxes, input_gt_labels, rpn_reg_actuals, rpn_cls_actuals], outputs=[roi_bboxes, rpn_reg_predictions, rpn_cls_predictions, frcnn_reg_predictions, frcnn_cls_predictions, rpn_reg_loss_layer, rpn_cls_loss_layer, frcnn_reg_loss_layer, frcnn_cls_loss_layer]) # for layer_name in loss_names: layer = frcnn_model.get_layer(layer_name) frcnn_model.add_loss(layer.output) frcnn_model.add_metric(layer.output, name=layer_name, aggregation="mean") # else: bboxes, labels, scores = Decoder(hyper_params["variances"], hyper_params["total_labels"], name="faster_rcnn_decoder")( [roi_bboxes, frcnn_reg_predictions, frcnn_cls_predictions]) frcnn_model = Model(inputs=input_img, outputs=[bboxes, labels, scores]) # return frcnn_model
def get_model(self): """create triplet model Use pretrained model, MobileNetV2 Returns: tupple embedding model and model with triplet loss function """ base_model = MobileNetV2(input_shape=(224, 224, 3), weights='imagenet', include_top=False, pooling='max') for layer in base_model.layers: layer.trainable = False x = base_model.output x = Dropout(0.6)(x) x = Dense(EMBEDDING_DIM)(x) x = Lambda(lambda x: K.l2_normalize(x, axis=1))(x) embedding_model = Model(base_model.input, x, name='embedding') input_shape = (IMAGE_SIZE, IMAGE_SIZE, 3) anchor_input = Input(input_shape, name='anchor_input') positive_input = Input(input_shape, name='positive_input') negative_input = Input(input_shape, name='negative_input') anchor_embedding = embedding_model(anchor_input) positive_embedding = embedding_model(positive_input) negative_embedding = embedding_model(negative_input) inputs = [anchor_input, positive_input, negative_input] outputs = [anchor_embedding, positive_embedding, negative_embedding] triplet_model = Model(inputs, outputs) triplet_model.add_loss(K.mean(self.triplet_loss(outputs))) return embedding_model, triplet_model
def make_model(n_features, n_outputs, n_nodes=100, dropout_reg=1e-5, wd=0): losses = [] inp = Input(shape=(n_features,)) x = inp x, loss = ConcreteDropout(Dense(n_nodes, activation='relu'), weight_regularizer=wd, dropout_regularizer=dropout_reg)(x) losses.append(loss) x, loss = ConcreteDropout(Dense(n_nodes, activation='relu'), weight_regularizer=wd, dropout_regularizer=dropout_reg)(x) losses.append(loss) x, loss = ConcreteDropout(Dense(n_nodes, activation='relu'), weight_regularizer=wd, dropout_regularizer=dropout_reg)(x) losses.append(loss) mean, loss = ConcreteDropout(Dense(n_outputs), weight_regularizer=wd, dropout_regularizer=dropout_reg)(x) losses.append(loss) log_var, loss = ConcreteDropout(Dense(n_outputs), weight_regularizer=wd, dropout_regularizer=dropout_reg)(x) losses.append(loss) out = concatenate([mean, log_var]) model = Model(inp, out) for loss in losses: model.add_loss(loss) model.compile(optimizer=optimizers.Adam(), loss=heteroscedastic_loss, metrics=[mse_loss]) assert len(model.layers[1].trainable_weights) == 3 # kernel, bias, and dropout prob assert len(model.losses) == 5, f'{len(model.losses)} is not 5' # a loss for each Concrete Dropout layer return model
class valiationalAutoencoder: def __init__(self, input_dim, output_dim, batch_size, epochs): self.batch_size = batch_size self.input_dim = input_dim self.output_dim = output_dim self.epochs = epochs inputs = Input(shape=(self.input_dim,), name='encoder_input') x = Dense(1024, activation='relu')(inputs) x = BatchNormalization()(x) x = Dropout(0.3)(x) x = Dense(512, activation='relu')(x) x = BatchNormalization()(x) x = Dropout(0.3)(x) x = Dense(256, activation='relu')(x) x = BatchNormalization()(x) x = Dropout(0.3)(x) z_mean = Dense(128, name='z_mean')(x) z_log_var = Dense(128, name='z_log_var')(x) z = Lambda(sampling, output_shape=(128,), name='z')([z_mean, z_log_var]) self.encoder = Model(inputs, [z_mean, z_log_var, z], name='encoder') # print(self.encoder.summary()) latent_inputs = Input(shape=(128,), name='z_sampling') x = Dense(256, activation='relu')(latent_inputs) x = BatchNormalization()(x) x = Dropout(0.3)(x) x = Dense(512, activation='relu')(x) x = BatchNormalization()(x) x = Dropout(0.3)(x) x = Dense(1024, activation='relu')(x) outputs = Dense(self.input_dim, activation='sigmoid')(x) self.decoder = Model(latent_inputs, outputs, name='decoder') # print(self.decoder.summary()) outputs = self.decoder(self.encoder(inputs)[2]) self.vae = Model(inputs, outputs, name='vae_mlp') reconstruction_loss = mse(inputs, outputs) reconstruction_loss *= self.input_dim kl_loss = 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var) # kl_loss = K.sum(kl_loss, axis=-1) kl_loss = K.mean(kl_loss, axis=-1) # kl_loss *= -0.5 kl_loss *= -5e-4 vae_loss = K.mean(reconstruction_loss + kl_loss) self.vae.add_loss(vae_loss) self.vae.compile(optimizer='adam') # print(self.vae.summary()) def train(self, X_train, model): tb_hist = tensorflow.keras.callbacks.TensorBoard(log_dir='./graph_' + model, histogram_freq=1, write_graph=True, write_images=True) model_path = './' + model + '.h5'#'{epoch:02d}-{val_loss:.4f}.h5' cb_checkpoint = ModelCheckpoint(filepath=model_path, monitor='val_loss', verbose=1, save_best_only=True, save_format='tf') history = self.vae.fit(X_train, batch_size=self.batch_size, epochs=self.epochs, verbose=1, shuffle=True, validation_split=0.2, callbacks=[tb_hist, cb_checkpoint]) return history
def gaussian_blindspot_network(input_shape, mode, reg_weight=0): """ Create a variant of the Gaussian blindspot newtork. input_shape: Shape of input image mode: mse, uncalib, global, perpixel, poisson mse -- regress to expected value using mean squared error loss uncalib -- model prior and noise together with single Gaussian at each pixel gaussian -- Gaussian noise poisson -- Poisson noise poissongaussian -- Poisson-Gaussian noise reg_weight: strength of regularization on prior std. dev. """ # create input layer inputs = Input(input_shape) # run blindspot network x = blindspot_network(inputs) # get prior parameters loc = Conv2D(1, 1, kernel_initializer='he_normal', name='loc')(x) if mode != 'mse': std = Conv2D(1, 1, kernel_initializer='he_normal', name='std')(x) # get noise variance if mode == 'mse': pass elif mode == 'uncalib': pass elif mode == 'gaussian': noise_std = GaussianLayer()([]) elif mode == 'poisson': noise_std = PoissonLayer()(loc) elif mode == 'poissongaussian': noise_std = PoissonGaussianLayer()(loc) else: raise ValueError('unknown mode %s' % mode) # get outputs if mode == 'mse': outputs = loc elif mode == 'uncalib': outputs = [loc, std] else: outputs = Lambda(lambda x: gaussian_posterior_mean(*x))( [inputs, loc, std, noise_std]) # create model model = Model(inputs=inputs, outputs=outputs) # create loss function # input is evaluated against output distribution if mode == 'mse': loss = mse_loss(inputs, loc) elif mode == 'uncalib': loss = uncalib_gaussian_loss(inputs, loc, std) else: loss = gaussian_loss(inputs, loc, std, noise_std, reg_weight) model.add_loss(loss) return model
def construct_model(embedding_dim, initial_model=None, learning_rate=None, margin=None): inputs = Input(shape=(data.H, data.W, 3), name='inputs') conv = Conv2D(filters=16, kernel_size=5, strides=2, padding='same', activation='elu')(inputs) conv = Conv2D(filters=32, kernel_size=3, strides=2, padding='same', activation='elu')(conv) conv = Conv2D(filters=32, kernel_size=3, strides=2, padding='same', activation='elu')(conv) conv = Conv2D(filters=32, kernel_size=3, strides=2, padding='same', activation='elu')(conv) mlp = Flatten()(conv) mlp = Dropout(rate=0.5)(mlp) mlp = Dense(units=64, activation='elu')(mlp) embeddings = Dense(units=embedding_dim, activation=None, name='embedding')(mlp) embeddings = NormaliseLayer()(embeddings) model = Model(inputs=inputs, outputs=embeddings) print(model.summary()) if initial_model is not None: model.load_weights(initial_model) # use setting of learning_rate (and margin) to denote if # we should compile also if learning_rate is None: # inference only return model else: assert margin is not None # use custom loss function since we have no y_true # (wrap it in an object as a cleaner way of tracking the internal ops we'll probe) loss_fn = TripletLoss(embeddings, embedding_dim, margin) model.add_loss(loss_fn.triplet_loss()) model.compile(optimizer=optimizers.Adam(lr=learning_rate), loss=None) # for the training model we'll use the model as well as the inputs # & the loss_fn so we can feed directly from inputs -> elements # in loss for summaries. return model, inputs, loss_fn
def build_cvae(z_dim = 8, inter_dim = 256, seq_length = 128, n_features = 13): inputs = Input(shape=(seq_length,n_features)) x_encoded = Conv1D(inter_dim, 3, padding='same', activation='relu')(inputs) x_encoded = MaxPooling1D(pool_size=2, padding='same')(x_encoded) x_encoded = Dropout(0.5)(x_encoded) x_encoded = Conv1D(inter_dim, 3, padding='same', activation='relu')(x_encoded) x_encoded = MaxPooling1D(pool_size=2, padding='same')(x_encoded) x_encoded = BatchNormalization()(x_encoded) x_encoded = Conv1D(inter_dim, 3, padding='same', activation='relu')(x_encoded) x_encoded = MaxPooling1D(pool_size=2, padding='same')(x_encoded) x_encoded = Dropout(0.5)(x_encoded) x_encoded = Flatten()(x_encoded) x_encoded = Dense(500, activation='relu')(x_encoded) x_encoded = Dropout(0.5)(x_encoded) x_encoded = Dense(25, activation='relu')(x_encoded) mu = Dense(z_dim, activation='linear')(x_encoded) log_var = Dense(z_dim, activation='linear')(x_encoded) z = Lambda(sampling, output_shape=(z_dim,))([mu, log_var]) encoder = Model(inputs, [mu, log_var, z], name='encoder') latent_inputs = Input(shape=(z_dim,)) z_decoder = Dense(z_dim, activation='relu')(latent_inputs) z_decoder = Dense(25, activation='relu')(z_decoder) z_decoder = Dense(500, activation='relu')(z_decoder) z_decoder = Dense(int(seq_length/8)*inter_dim, activation='relu')(z_decoder) z_decoder = Reshape((int(seq_length/8), inter_dim))(z_decoder) z_decoder = UpSampling1D(2)(z_decoder) z_decoder = Conv1D(inter_dim,3,padding='same', activation='relu')(z_decoder) z_decoder = UpSampling1D(2)(z_decoder) z_decoder = Conv1D(inter_dim,3,padding='same', activation='relu')(z_decoder) z_decoder = UpSampling1D(2)(z_decoder) z_decoder = Conv1D(inter_dim,3,padding='same', activation='relu')(z_decoder) # No activation decoder_output = Dense(n_features, activation='relu')(z_decoder) decoder = Model(latent_inputs, decoder_output, name='decoder') outputs = decoder(encoder(inputs)[2]) # build model cvae = Model(inputs, outputs) # loss reconstruction_loss = tf.reduce_mean(binary_crossentropy(inputs, outputs)) * (seq_length*n_features) kl_loss = 1 + log_var - tf.square(mu) - tf.exp(log_var) kl_loss = tf.reduce_mean(kl_loss) kl_loss *= -0.5 total_loss = reconstruction_loss + kl_loss # build model optimizer = tf.keras.optimizers.Adam(learning_rate=0.0005) cvae.add_loss(total_loss) cvae.compile(optimizer='rmsprop') return encoder, decoder, cvae
def build_vae(input_shape): ''' Arguments: input_shape(tuple): the shape of input images (H, W, C) Returns: encoder, decoder, autoencoder models ''' def build_encoder(input_shape, latent_dim): inputs = Input(input_shape) x = Conv2D(256, 4, strides=2, padding='same', activation='relu')(inputs) x = Conv2D(128, 4, strides=2, padding='same', activation='relu')(x) x = Conv2D(64, 4, strides=2, padding='same', activation='relu')(x) # x = Conv2D(64, 4, strides=2, padding='same', activation='relu')(x) x = Flatten()(x) mean = Dense(latent_dim)(x) logvar = Dense(latent_dim)(x) epsilon = K.random_normal(K.shape(mean)) z = mean + K.exp(0.5 * logvar) * epsilon encoder = Model(inputs, [z, mean, logvar], name='encoder') return encoder def build_decoder(latent_dim): decoder = Sequential([ Dense(4* 4* 64, activation='relu', input_shape=(latent_dim,)), Reshape((4, 4, 64)), # Conv2DTranspose(128, 4, strides=2, padding='same', activation='relu'), Conv2DTranspose(64, 4, strides=2, padding='same', activation='relu'), Conv2DTranspose(32, 4, strides=2, padding='same', activation='relu'), Conv2DTranspose(3, 4, strides=2, padding='same', activation='sigmoid') ], name='decoder') return decoder latent_dim = 512 encoder = build_encoder(input_shape, latent_dim) # encoder.summary() decoder = build_decoder(latent_dim) # decoder.summary() inputs = Input(input_shape) z, mean, logvar = encoder(inputs) decoder_out = decoder(z) autoencoder = Model(inputs, decoder_out) bce_loss = K.sum(binary_crossentropy(inputs, decoder_out), axis=[1, 2]) kl_loss = -0.5 * K.sum(1 + logvar - K.square(mean) - K.exp(logvar), axis=-1) vae_loss = K.mean(bce_loss + kl_loss) autoencoder.add_loss(vae_loss) autoencoder.add_metric(tf.reduce_mean(bce_loss), name='bce_sum', aggregation='mean') autoencoder.add_metric(tf.reduce_mean(bce_loss) / input_shape[0] / input_shape[1], name='bce', aggregation='mean') autoencoder.add_metric(tf.reduce_mean(kl_loss), name='KL', aggregation='mean') autoencoder.compile(Adam(1e-3, decay=5e-4)) return encoder, decoder, autoencoder
def createVAE(decoder, encoder): # We are saying that the decoder takes the last output of the encoder as the input dec_out = decoder(encoder.outputs[2]) # Defining an end-to-end model with encoder inputs and decoder outputs vae = Model(inputs=encoder.inputs, outputs=dec_out) vae.summary() # VAE loss comprises both crossentropy and KL divergence loss vae.compile(loss='binary_crossentropy', optimizer='rmsprop') vae.add_loss(kl_loss(encoder.outputs[0], encoder.outputs[1])) return vae
def task_5_model(x_train, filters=16, n_latent=5, kernel_size=3): inputs = Input(shape=x_train.shape[1:]) x = inputs for i in range(2): filters *= 2 x = Conv2D(filters, kernel_size, activation="relu", strides=2, padding="same")(x) shape = K.int_shape(x) x = Flatten()(x) x = Dense(filters, activation="relu")(x) z_mean = Dense(n_latent)(x) z_log_var = Dense(n_latent)(x) z = Lambda(sampling)([z_mean, z_log_var]) encoder = Model(inputs, [z_mean, z_log_var, z], name="encoder") latent_inputs = Input(shape=(n_latent, )) x = Dense(shape[1] * shape[2] * shape[3], activation="relu")(latent_inputs) x = Reshape((shape[1], shape[2], shape[3]))(x) for i in range(2): x = Conv2DTranspose(filters, kernel_size, activation="relu", strides=2, padding="same")(x) filters //= 2 outputs = Conv2DTranspose(filters=1, kernel_size=kernel_size, activation="sigmoid", padding="same")(x) decoder = Model(latent_inputs, outputs, name="decoder") outputs = decoder(encoder(inputs)[2]) vae = Model(inputs, outputs) reconstruction_loss = mse(K.flatten(inputs), K.flatten(outputs)) reconstruction_loss *= np.prod(x_train.shape[1:3]) kl_loss = 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var) kl_loss = K.sum(kl_loss, axis=-1) kl_loss *= -0.5 vae_loss = K.mean(reconstruction_loss + kl_loss) vae.add_loss(vae_loss) return vae
class policy_model: #input (state, state, state, state, action) def __init__(self, innput_size, policy_lr, policy_clip=5): ACTI = 'relu' policy_lr = policy_lr policy_clip = policy_clip inputes = Input(shape=(innput_size * 4, )) actions_true = Input(shape=[innput_size], name='actions_true') advantages = Input(shape=[1], name='advantages') _ = Dense(128, activation=ACTI)(inputes) #512 #_ = Dense(32, activation=ACTI)(_) #_ = Dropout(0.1)(_) #_ = Dense(256, activation=ACTI)(_) #_ = Dropout(0.1)(_) #_ = Dense(128, activation=ACTI)(_) out_1 = Dense(innput_size, activation='softmax')(_) #@tf.function def custom_loss_old(y_true, y_pred, adv): log_lik = K.log(y_true * (y_true - y_pred) + (1 - y_true) * (y_true + y_pred)) #loss = 1 / (-K.mean(log_lik * adv, keepdims=True)) return K.mean(log_lik * adv, keepdims=True) def custom_loss(y_true, y_pred, adv): log_lik = K.log(y_true * (y_true - y_pred) + (1 - y_true) * (y_true + y_pred)) loss = 1 / (-K.mean(log_lik * adv, keepdims=True)) return K.clip(loss, -0.5, 0.5) #return loss #self.policy.compile(optimizer=Adam(lr=1e-2), loss=custom_loss) self.policy = Model(inputs=[inputes, actions_true, advantages], outputs=[out_1]) self.policy.add_loss(custom_loss(actions_true, out_1, advantages)) self.policy.compile(optimizer=Adam( lr=policy_lr)) # -3, -2 give NaN if value is -4, 8e-3 #self.policy.compile(optimizer=Adam(lr=1e-2), loss='mean_squared_error') #self.policy.compile(optimizer=Adam(lr=1e-1), loss='mean_squared_error') self.prediction = Model(inputs=inputes, outputs=[out_1]) #trro vi bruke monte carlo, kjor en heil episode foor trening def partial_fit(self, x): return self.policy.train_on_batch(x) def partial_fit_two(self, x, y, adv): adv = np.array(adv) return self.policy.train_on_batch([x], y, sample_weight=adv) def predict(self, x): #print(f'x shape: {x.shape}') return self.prediction.predict( x=x)[0] #Why only take firse of 8 output :P
def build_vae(intermediate_dim=512, latent_dim=2): """ Build VAE :param intermediate_dim: size of hidden layers of the encoder/decoder :param latent_dim: latent space size :returns tuple: the encoder, the decoder, and the full vae """ # encoder first inputs = Input(shape=(image_size, ), name='encoder_input') x = Dense(intermediate_dim, activation='relu')(inputs) # latent mean and variance z_mean = Dense(latent_dim, name='z_mean')(x) z_log_var = Dense(latent_dim, name='z_log_var')(x) # Reparameterization trick for random sampling # Note the use of the Lambda layer # At runtime, it will call the sampling function z = Lambda(sampling, output_shape=(latent_dim, ), name='z')([z_mean, z_log_var]) # full encoder encoder model encoder = Model(inputs, [z_mean, z_log_var, z], name='encoder') encoder.summary() # decoder latent_inputs = Input(shape=(latent_dim, ), name='z_sampling') x = Dense(intermediate_dim, activation='relu')(latent_inputs) outputs = Dense(image_size, activation='sigmoid')(x) # full decoder model decoder = Model(latent_inputs, outputs, name='decoder') decoder.summary() # VAE model outputs = decoder(encoder(inputs)[2]) vae = Model(inputs, outputs, name='vae') # Loss function # we start wit the reconstruction loss reconstruction_loss = binary_crossentropy(inputs, outputs) * image_size # next is the KL divergence kl_loss = 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var) kl_loss = tf.keras.backend.sum(kl_loss, axis=-1) kl_loss *= -0.5 # we combine them in a total loss vae_loss = K.mean(reconstruction_loss + kl_loss) vae.add_loss(vae_loss) return encoder, decoder, vae
def make_model(loss_type, n_features, n_outputs, n_nodes=400, dropout_reg=1e-5, wd=1e-3): losses = [] inp = Input(shape=(n_features, )) x = inp x, loss = ConcreteDropout(Dense(n_nodes, activation='relu'), weight_regularizer=wd, dropout_regularizer=dropout_reg)(x) losses.append(loss) x, loss = ConcreteDropout(Dense(n_nodes, activation='relu'), weight_regularizer=wd, dropout_regularizer=dropout_reg)(x) losses.append(loss) x, loss = ConcreteDropout(Dense(n_nodes, activation='relu'), weight_regularizer=wd, dropout_regularizer=dropout_reg)(x) losses.append(loss) if loss_type == MSE: mean = Dense(100, activation='relu')(x) final_mean = Dense(n_outputs, activation='linear')(mean) model = Model(inp, final_mean) learning_rate_fn = tf.keras.optimizers.schedules.PolynomialDecay( 1e-3, 500, 1e-5, power=0.5) model.compile( optimizer=optimizers.Adam(learning_rate=learning_rate_fn), loss=mse_loss) if loss_type == HETEROSCEDASTIC: mean = Dense(100, activation='relu')(x) final_mean = Dense(n_outputs, activation='linear')(mean) log_var = Dense(100, activation='relu')(x) final_log_var = Dense(n_outputs, activation='linear')(log_var) out = concatenate([final_mean, final_log_var]) model = Model(inp, out) for loss in losses: model.add_loss(loss) learning_rate_fn = tf.keras.optimizers.schedules.PolynomialDecay( 1e-3, 500, 1e-5, power=0.5) model.compile( optimizer=optimizers.Adam(learning_rate=learning_rate_fn), loss=heteroscedastic_loss, metrics=[mse_loss]) return model
def build_actor_con(self): b_model = robot_khop_model() #b_model.load_weights('gnn_khop_env3_share.h5', by_name=True) advantage = Input(shape=(1, )) old_prediction = Input(shape=(NUM_ACTIONS, )) y_true = Input(shape=(NUM_ACTIONS, )) model = Model( inputs=[b_model.input, advantage, old_prediction, y_true], outputs=[b_model.output]) model.add_loss( proximal_policy_optimization_loss_con(advantage, old_prediction, y_true, b_model.output)) model.compile(optimizer=Adam(learning_rate=Learning_rate)) return model
def _build_model(self): """Build VAE = encoder + decoder + vae_loss""" # Build Encoder inputs = Input(shape=(self.n_features_,)) # Input layer layer = Dense(self.n_features_, activation=self.hidden_activation)( inputs) # Hidden layers for neurons in self.encoder_neurons: layer = Dense(neurons, activation=self.hidden_activation, activity_regularizer=l2(self.l2_regularizer))(layer) layer = Dropout(self.dropout_rate)(layer) # Create mu and sigma of latent variables z_mean = Dense(self.latent_dim)(layer) z_log = Dense(self.latent_dim)(layer) # Use parametrisation sampling z = Lambda(self.sampling, output_shape=(self.latent_dim,))( [z_mean, z_log]) # Instantiate encoder encoder = Model(inputs, [z_mean, z_log, z]) if self.verbosity >= 1: encoder.summary() # Build Decoder latent_inputs = Input(shape=(self.latent_dim,)) # Latent input layer layer = Dense(self.latent_dim, activation=self.hidden_activation)( latent_inputs) # Hidden layers for neurons in self.decoder_neurons: layer = Dense(neurons, activation=self.hidden_activation)(layer) layer = Dropout(self.dropout_rate)(layer) # Output layer outputs = Dense(self.n_features_, activation=self.output_activation)( layer) # Instatiate decoder decoder = Model(latent_inputs, outputs) if self.verbosity >= 1: decoder.summary() # Generate outputs outputs = decoder(encoder(inputs)[2]) # Instantiate VAE vae = Model(inputs, outputs) vae.add_loss(self.vae_loss(inputs, outputs, z_mean, z_log)) vae.compile(optimizer=self.optimizer) if self.verbosity >= 1: vae.summary() return vae, encoder, decoder
def create_implExModel(num_nodes, num_edges, embed_size=50, n3_reg=1e-3, learning_rate=5e-1, num_negs=50, alpha=1., beta=1.): # Build complEx Model sub_inputs = Input(shape=(), name='subject') obj_inputs = Input(shape=(), name='object') rel_inputs = Input(shape=(), name='relation') cnt_inputs = Input(shape=(), name='count') y_true_inputs = Input(shape=(), name='label') inputs = { "subject": sub_inputs, "object": obj_inputs, "relation": rel_inputs, "count": cnt_inputs, "label": y_true_inputs } node_layer = Embedding(input_dim=num_nodes, output_dim=embed_size, embeddings_initializer=GlorotUniform(), name='node_embedding') edge_layer = Embedding(input_dim=num_edges, output_dim=embed_size, embeddings_initializer=GlorotUniform(), name='edge_embedding') sub_embed = node_layer(sub_inputs) rel_embed = edge_layer(rel_inputs) obj_embed = node_layer(obj_inputs) outputs = ComplExDotScore(n3_reg)([sub_embed, rel_embed, obj_embed]) model = Model(inputs, outputs, name='implEx') # Compile implEx Model wbce_loss = tf.nn.weighted_cross_entropy_with_logits( y_true_inputs, outputs, num_negs) / num_negs confidence = 1 + alpha * tf.math.log(1 + cnt_inputs / beta) loss = K.sum(confidence * wbce_loss) model.add_loss(loss) model.add_metric(K.mean(wbce_loss), 'weighted_binarycrossentropy') model.compile(optimizer=Adagrad(learning_rate)) return model
def build_dense_model(num_features): """ Simple two layer MLP """ regression_target = layers.Input(shape=(1,), name='ground_truth') feature_input = layers.Input(shape=(num_features,), name='feature_input') encoder_output = layers.GaussianDropout(0.1)(feature_input) encoder_output = layers.Dense(64, activation='tanh', name='encoder_hidden')(encoder_output) encoder_output = layers.Dense(64, activation='tanh', name='encoder_hidden_2')(encoder_output) z_mean, z_log_var = layers.Dense(LATENT_DIM, name='z_mean')(encoder_output), \ layers.Dense(LATENT_DIM, name='z_log_var')(encoder_output) r_mean, r_log_var = layers.Dense(1, name='r_mean')(encoder_output), \ layers.Dense(1, name='r_log_var')(encoder_output) # Sample latent and regression target z = layers.Lambda(sampling, output_shape=(LATENT_DIM,), name='z')([z_mean, z_log_var]) r = layers.Lambda(sampling, output_shape=(1,), name='r')([r_mean, r_log_var]) # Latent generator pz_mean = layers.Dense(LATENT_DIM, kernel_constraint=constraints.unit_norm(), name='pz_mean')(r) encoder = Model([feature_input, regression_target], [z_mean, z_log_var, z, r_mean, r_log_var, r, pz_mean], name='encoder') latent_input = layers.Input(shape=(LATENT_DIM,), name='decoder_input') decoder_output = layers.Dense(64, activation='tanh', name='decoder_hidden')(latent_input) decoder_output = layers.Dense(64, activation='tanh', name='decoder_hidden_2')(decoder_output) decoder_output = layers.Dense(num_features, name='decoder_output')(decoder_output) decoder = Model(latent_input, decoder_output, name='decoder') encoder_decoder_output = decoder(encoder([feature_input, regression_target])[2]) vae = Model([feature_input, regression_target], encoder_decoder_output, name='vae') # Manually write up losses reconstruction_loss = mse(feature_input, encoder_decoder_output) kl_loss = 1 + z_log_var - K.square(z_mean - pz_mean) - K.exp(z_log_var) kl_loss = -0.5 * K.sum(kl_loss, axis=-1) label_loss = tf.divide(0.5 * K.square(r_mean - regression_target), K.exp(r_log_var)) + 0.5 * r_log_var vae_loss = K.mean(reconstruction_loss + kl_loss + label_loss) vae.add_loss(vae_loss) vae.compile(optimizer=Adam()) regressor = Model(feature_input, r_mean, name='regressor') return vae, regressor
def create_transEModel(num_nodes, num_edges, embed_size=50, ord='l1', margin=1, learning_rate=2e-1): # build transE Model pos_sub_inputs = Input(shape=(), name='pos_subject') neg_sub_inputs = Input(shape=(), name='neg_subject') pos_obj_inputs = Input(shape=(), name='pos_object') neg_obj_inputs = Input(shape=(), name='neg_object') rel_inputs = Input(shape=(), name='relation') inputs = { "pos_subject": pos_sub_inputs, "neg_subject": neg_sub_inputs, "pos_object": pos_obj_inputs, "neg_object": neg_obj_inputs, "relation": rel_inputs } # 초기화 방식은 논문에 나와있는 방식으로 구성 init_range = 6 / np.sqrt(embed_size) init_op = RandomUniform(-init_range, init_range) node_layer = Embedding(input_dim=num_nodes, output_dim=embed_size, embeddings_initializer=init_op, name='node_embedding') edge_layer = Embedding(input_dim=num_edges, output_dim=embed_size, embeddings_initializer=init_op, name='edge_embedding') pos_sub = node_layer(pos_sub_inputs) neg_sub = node_layer(neg_sub_inputs) pos_obj = node_layer(pos_obj_inputs) neg_obj = node_layer(neg_obj_inputs) rel = edge_layer(rel_inputs) score = TransEScore(ord, margin)([pos_sub, neg_sub, pos_obj, neg_obj, rel]) model = Model(inputs, score) # Compile transE Model model.add_loss(score) model.compile(optimizer=Adagrad(learning_rate)) return model
def vae_model(input_shape, hidden_dim, latent_dim, original_dim): """ Variational autoencoder :param input_shape: flatten genotype input shape :param hidden_dim: dimension of hidden layer :param latent_dim: dimension of latent layer :param original_dim: dimension of original genotype data """ inputs = Input(shape=input_shape, name='encoder_input') x = Dense(hidden_dim, activation='relu')(inputs) z_mean = Dense(latent_dim, name='z_mean')(x) z_log_var = Dense(latent_dim, name='z_log_var')(x) z = Lambda(sampling, output_shape=(latent_dim, ), name='z')([z_mean, z_log_var]) # encoder model encoder = Model(inputs, [z_mean, z_log_var, z], name='encoder') latent_inputs = Input(shape=(latent_dim, ), name='z_sampling') encoder.summary() x = Dense(hidden_dim, activation='relu')(latent_inputs) outputs = Dense(original_dim, activation='softmax')(x) # decoder model decoder = Model(latent_inputs, outputs, name='decoder') decoder.summary() outputs = decoder(encoder(inputs)[2]) vae = Model(inputs, outputs, name='vae_mlp') # define loss # reconstruction loss reconstruction_loss = binary_crossentropy(inputs, outputs) reconstruction_loss *= original_dim # kl divergence kl_loss = 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var) kl_loss = K.sum(kl_loss, axis=-1) kl_loss *= -0.5 vae_loss = K.mean(reconstruction_loss + kl_loss) vae.add_loss(vae_loss) vae.compile(optimizer='adam') return vae, encoder
def model_build(self): z_mean, z_log_var, z = self.encoder(self.encoder_inputs) outputs = self.decoder(z) model = Model(self.encoder_inputs, outputs) reconstruction_loss = binary_crossentropy(self.encoder_inputs, outputs) reconstruction_loss *= self.image_size * self.image_size * 3 kl_loss = 1 + z_log_var - tf.square(z_mean) - tf.exp(z_log_var) kl_loss = tf.reduce_mean(kl_loss) kl_loss *= -0.5 vae_loss = tf.keras.backend.mean(reconstruction_loss + kl_loss) model.add_loss(vae_loss) model.compile(optimizer='adam') return model
def build_bandit_lstm_classifier(timesteps=32, feature_size=784, output_shape=3, repr_size=64, activation='tanh', inp_drop=0.0, re_drop=0.0, l2_coef=1e-3, lr=3e-4, translation=0.0): seq_inputs = layers.Input(shape=(timesteps, feature_size), name='Sequential_Input') x = layers.Masking(mask_value=0, name='Masking')(seq_inputs) x = layers.LSTM(repr_size, activation=activation, use_bias=True, dropout=inp_drop, recurrent_dropout=re_drop, return_sequences=False, name='Sequential_Representation')(x) class_pred = layers.Dense(output_shape, activation='softmax', use_bias=True, kernel_regularizer=l2(l2_coef), name='Class_Prediction')(x) action = layers.Input(shape=(output_shape, ), name='Action_Input', dtype=tf.int32) propen = layers.Input(shape=(), name='Propensity_Input', dtype=tf.float32) delta = layers.Input(shape=(), name='Delta_Input', dtype=tf.float32) ips_loss = IpsLossLayer(translation=translation, name='ipsloss')( [class_pred, action, propen, delta]) m = Model(inputs=[seq_inputs, action, propen, delta], outputs=ips_loss, name='training') m.add_loss(ips_loss) m.compile(optimizer=Adam(lr=lr)) test_m = Model(inputs=m.get_layer('Sequential_Input').input, outputs=m.get_layer('Class_Prediction').output, name='testing') test_m.compile(optimizer=Adam(lr=lr), loss='categorical_crossentropy', metrics=['accuracy']) print('model is built and compiled') return m, test_m
def create_model_and_compile(self): input_shape = self.in_shape self.base_model = self.base_network() self.cs_layer = Dense(self.num_classes, use_bias=False, name='CS_layer') qpn_in = Input(shape=input_shape, name='in_qpn') qpny = Input(shape=(self.num_classes, ), name='in_qpny') qpny_label = Input(shape=(1, ), name='in_qpny_label') qpn_out = self.base_model(qpn_in) qpn_cls_sig = self.cs_layer(qpn_out) fe_loss = Lambda(self.triplet_loss_all_combinations, name='triplet_loss_FE')(qpn_out) * self.fe_weight fe_accuracy = Lambda(self.FE_accuracy, name='FE_accuracy_metric')(qpn_out) cs_loss = Lambda(self.manual_CS_loss, name='CS_loss_calc')( [qpn_cls_sig, qpny]) * self.cs_weight cs_accuracy = Lambda(self.CS_accuracy, name='CS_Acc')([qpn_cls_sig, qpny]) total_loss = fe_loss + cs_loss model = Model(inputs=[qpn_in, qpny, qpny_label], outputs=[qpn_cls_sig], name='FEModel') if 'adm' in self.optim: optm = Adam(lr=self.LR) elif 'ranger' in self.optim: # option to use a newer optimizer radam = tfa.optimizers.RectifiedAdam(lr=self.LR, min_lr=1e-7) optm = tfa.optimizers.Lookahead(radam, sync_period=6, slow_step_size=0.5) model.add_loss(total_loss) model.compile(optimizer=optm) # Metrics to track the accuracy and loss progression model.add_metric(fe_accuracy, name='fe_a', aggregation='mean') model.add_metric(cs_accuracy, name='cs_a', aggregation='mean') model.add_metric(fe_loss, name='fe_loss', aggregation='mean') model.add_metric(cs_loss, name='cs_loss_out', aggregation='mean') return model, optm
def _build_vae(self): #VAE = encoder + decoder outputs = self.decoder( self.encoder(self.inputs) [2]) #the position 2 refers to the latent vector output z vae = Model(inputs=self.inputs, outputs=outputs, name='vae') # VAE loss = mse_loss or xent_loss + kl_loss reconstruction_loss = binary_crossentropy(K.flatten(self.inputs), K.flatten(outputs)) #alternativly: reconstruction_loss = mse(K.flatten(inputs), K.flatten(outputs)) reconstruction_loss *= self.image_size * self.image_size #calc total loss and add to model vae_loss = K.mean(reconstruction_loss + self.kl_loss) vae.add_loss(vae_loss) vae.compile(optimizer='rmsprop') vae.summary() return vae, outputs
def vae(original_dim, intermediate_dim=512, latent_dim=20): ''' vae.fit(x_train, epochs=epochs, batch_size=batch_size, validation_data=(x_test, None)) bottleneck_representation,_,_ = encoder.predict(x_test) ''' # encoder input_shape = (original_dim, ) inputs = Input(shape=input_shape, name='encoder_input') x = Dense(intermediate_dim, activation='relu')(inputs) z_mean = Dense(latent_dim, name='z_mean')(x) z_log_var = Dense(latent_dim, name='z_log_var')(x) z = Lambda(sampling, output_shape=(latent_dim, ), name='z')([z_mean, z_log_var]) encoder = Model(inputs, [z_mean, z_log_var, z], name='encoder') # encoder.summary() # plot_model(encoder, to_file='vae_mlp_encoder.png', show_shapes=True) # decoder latent_inputs = Input(shape=(latent_dim, ), name='z_sampling') x = Dense(intermediate_dim, activation='relu')(latent_inputs) outputs = Dense(original_dim, activation='sigmoid')(x) decoder = Model(latent_inputs, outputs, name='decoder') # decoder.summary() # plot_model(decoder, to_file='vae_mlp_decoder.png', show_shapes=True) # VAE model outputs = decoder(encoder(inputs)[2]) vae = Model(inputs, outputs, name='vae') # loss reconstruction_loss = binary_crossentropy(inputs, outputs) reconstruction_loss *= original_dim kl_loss = 1 + z_log_var - K.square(z_mean) - K.exp(z_log_var) kl_loss = K.sum(kl_loss, axis=-1) kl_loss *= -0.5 vae_loss = K.mean(reconstruction_loss + kl_loss) vae.add_loss(vae_loss) vae.compile(optimizer='adam') # vae.summary() # plot_model(vae, to_file='vae_mlp.png', show_shapes=True) return vae, encoder
def _cnn_variational_autoencoder(self, orignal_dim): inputs = Input(shape= orignal_dim, name = 'encoder_input') x = Conv2D(64, 3, padding='same', activation='relu')(inputs) x = Conv2D(32, 3, padding='same', activation='relu')(x) x = Conv2D(3, 3, padding='same', activation='relu')(x) shape_bf_flatten = x.shape[1:] x = Flatten()(x) x = Dense(np.prod(shape_bf_flatten), activation = 'relu', kernel_initializer= 'he_uniform')(x) x = Dense(1000, activation = 'relu', kernel_initializer= 'he_uniform')(x) x = Dense(self.latent_dim, activation = 'relu', kernel_initializer= 'he_uniform')(x) z_mean = Dense(self.latent_dim, activation = None, name='z_mean')(x) z_log_var = Dense(self.latent_dim, activation = None, name='z_log_var' ,kernel_initializer = initializers.glorot_normal())(x) z = Lambda(self._sampling, output_shape = (self.latent_dim,), name ='z')([z_mean, z_log_var]) encoder = Model(inputs, [z_mean, z_log_var, z], name ='encoder') latent_input = Input(shape=(self.latent_dim,), name = 'z_sampling') x = Dense(1000, activation = 'relu', kernel_initializer= 'he_uniform')(latent_input) x = Dense(np.prod(shape_bf_flatten), activation = 'relu', kernel_initializer= 'he_uniform')(x) x = Reshape(shape_bf_flatten)(x) x = Conv2D(3, 3, padding='same', activation='relu')(x) x = Conv2D(32, 3, padding='same', activation='relu')(x) x = Conv2D(64, 3, padding='same', activation='relu')(x) x = Conv2D(1, 3, padding='same', activation='relu')(x) decoder = Model(latent_input, x, name ='decoder') output = decoder(encoder(inputs)[2]) def _vae_loss(): model_input = K.flatten(inputs) model_output = K.flatten(output) recon_loss= mse(model_input, model_output) # recon_loss *= self.input_shape[0] kl_loss = -5e-4 * K.mean(1 + z_log_var - K.square(z_mean) - K.exp(z_log_var), axis=-1) return K.mean(recon_loss + kl_loss) vae = Model(inputs, output, name='vae') vae.add_loss(vae_loss()) return vae, encoder, decoder
def _variational_autoencoder(self, orignal_dim): orignal_dim = int(orignal_dim[0]) inputs = Input(shape= orignal_dim, name = 'encoder_input') x = Dense(64, activation = 'relu', kernel_initializer= 'he_uniform')(inputs) x = Dense(128, activation = 'relu', kernel_initializer= 'he_uniform')(x) x = Dense(64, activation = 'relu', kernel_initializer= 'he_uniform')(x) x = Dense(32, activation = 'relu', kernel_initializer= 'he_uniform')(x) x = Dense(30, activation = 'relu', kernel_initializer= 'he_uniform')(x) x = Dense(self.latent_dim, activation = 'relu', kernel_initializer= 'he_uniform')(x) z_mean = Dense(self.latent_dim, activation = None, name='z_mean')(x) z_log_var = Dense(self.latent_dim, activation = None, name='z_log_var' ,kernel_initializer = initializers.glorot_normal())(x) z = Lambda(self._sampling, output_shape = (self.latent_dim,), name ='z')([z_mean, z_log_var]) encoder = Model(inputs, [z_mean, z_log_var, z], name ='encoder') latent_input = Input(shape=(self.latent_dim,), name = 'z_sampling') x = Dense(30, activation = 'relu', kernel_initializer= 'he_uniform')(latent_input) x = Dense(32, activation = 'relu', kernel_initializer= 'he_uniform')(x) x = Dense(64, activation = 'relu', kernel_initializer= 'he_uniform')(x) x = Dense(128, activation = 'relu', kernel_initializer= 'he_uniform')(x) x = Dense(64, activation = 'relu', kernel_initializer= 'he_uniform')(x) x = Dense(orignal_dim, activation = None, kernel_initializer= None)(x) decoder = Model(latent_input, x, name ='decoder') output = decoder(encoder(inputs)[2]) def vae_loss(): model_input = K.flatten(inputs) model_output = K.flatten(output) recon_loss= mse(model_input, model_output) # recon_loss = binary_crossentropy(model_input, model_output) # recon_loss *= self.input_shape[0] kl_loss = -5e-4 * K.mean(1 + z_log_var - K.square(z_mean) - K.exp(z_log_var), axis=-1) return K.mean(recon_loss + kl_loss) vae = Model(inputs, output, name='vae') vae.add_loss(vae_loss()) return vae, encoder, decoder