def __init__(self, args): self.args = args torch.manual_seed(self.args.seed) np.random.seed(self.args.seed) print('{} detection...'.format(args.dataset)) white_noise = dp.DatasetReader(white_noise=self.args.dataset, data_path=data_path, data_source=args.data_source, len_seg=self.args.len_seg) _, self.testset = white_noise(args.net_name) self.spots = np.load('{}/spots.npy'.format(info_path)) self.AE = AutoEncoder(args) self.latent = np.load('{}/features/{}.npy'.format( save_path, self.file_name()))
def __init__(self, args): self.args = args white_noise = DatasetReader(white_noise='W-1', data_path=data_path, data_source=args.data_source, len_seg=self.args.len_seg) self.dataset, _ = white_noise(args.net_name) self.spots = np.load('{}/spots.npy'.format(info_path)) self.AE = AutoEncoder(args) self.font = { 'family': 'Arial', 'style': 'normal', 'weight': 'bold', 'size': 10, 'color': 'k', }
def train_model(x_data, y_data): model = None if args.name == "VAE": model = vae(args, device).to(device) elif args.name == "AutoEncoder": model = AutoEncoder(args, device).to(device) for epoch in range(args.nb_epochs): x_train, y_train = Utils.SuffleData(x_data, y_data, args.batch_size) loss = model.learn(x_train) if epoch % args.log_interval == 0: print('Epoch {:4d}/{} loss: {:.6f} '.format(epoch, args.nb_epochs, loss)) return model
def baseline_ae_model(region_tensors, is_training, encoded_dims): squared_euclidean = squared_x = None for name in region_tensors: tensors = region_tensors[name]['tensors'] filters = region_tensors[name]['filters'] reuse = region_tensors[name]['reuse'] scope = region_tensors[name]['scope'] ae = AutoEncoder(tensors, encoded_dims=encoded_dims, filters=filters, is_training=is_training, reuse=reuse, name='compressor_{}'.format(scope)) sq_x, sq_euclidean, cosine_similarity = reconstruction_distances(ae.input_tensor, ae.reconstruction) with tf.name_scope('latent_variables'): if squared_euclidean is None: squared_euclidean = sq_euclidean squared_x = sq_x else: squared_euclidean = squared_euclidean + sq_euclidean squared_x = squared_x + sq_x return tf.sqrt(squared_euclidean) / tf.sqrt(squared_x), ae.flatten_encoded, tf.reduce_mean(squared_euclidean)
def __init__(self, args): self.args = args torch.manual_seed(self.args.seed) np.random.seed(self.args.seed) print('> Training arguments:') for arg in vars(args): print('>>> {}: {}'.format(arg, getattr(args, arg))) white_noise = dp.DatasetReader(white_noise=self.args.dataset, data_path=data_path, data_source=args.data_source, len_seg=self.args.len_seg) dataset, _ = white_noise(args.net_name) self.data_loader = DataLoader(dataset=dataset, batch_size=args.batch_size, shuffle=False) self.spots = np.load('{}/spots.npy'.format(info_path)) self.AE = AutoEncoder(args).to(device) # AutoEncoder self.AE.apply(self.weights_init) self.criterion = nn.MSELoss() self.vis = visdom.Visdom( env='{}'.format(self.file_name()), log_to_filename='{}/visualization/{}.log'.format( save_path, self.file_name())) plt.figure(figsize=(15, 15))
from tensorflow.python.keras.datasets import mnist from models.AutoEncoder import AutoEncoder import tensorflow as tf import numpy as np (x_train, _), (x_test, _) = mnist.load_data() x_train = x_train.astype('float32') / 255. x_test = x_test.astype('float32') / 255. x_train = np.reshape(x_train, (len(x_train), 28, 28, 1)) x_test = np.reshape(x_test, (len(x_test), 28, 28, 1)) autoencoder = AutoEncoder() autoencoder.build() # autoencoder.train(x_train, x_test)
from Preprocessor import Preprocessor from train.SDNetTrainer import SDNetTrainer from datasets.STL10 import STL10 from models.AutoEncoder import AutoEncoder from models.SpotNet import SNet target_shape = [96, 96, 3] ae = AutoEncoder(num_layers=4, batch_size=128, target_shape=target_shape, tag='default') model = SNet(ae, batch_size=128, target_shape=target_shape, disc_pad='SAME', tag='default') data = STL10() preprocessor = Preprocessor(target_shape=target_shape, augment_color=True) trainer = SDNetTrainer(model=model, dataset=data, pre_processor=preprocessor, num_epochs=500, init_lr=0.0003, lr_policy='linear', num_gpus=2) trainer.train_model(None)
def dagmm(region_tensors, is_training, encoded_dims=2, mixtures=3, lambda_1=0.1, lambda_2=0.005, use_cosine_similarity=False, latent_dims=2): """ :param region_tensors: restore the related tensors :param is_training: a tensorflow placeholder to indicate whether it is in the training phase or not :param encoded_dims: :param mixtures: :param lambda_1: :param lambda_2: :param use_cosine_similarity: :param latent_dims: reduce the dimension of encoded vector to a smaller one :return: """ squared_x = squared_euclidean = z = None for name in region_tensors: tensors = region_tensors[name]['tensors'] filters = region_tensors[name]['filters'] reuse = region_tensors[name]['reuse'] scope = region_tensors[name]['scope'] ae = AutoEncoder(tensors, encoded_dims=encoded_dims, filters=filters, is_training=is_training, reuse=reuse, name='compressor_{}'.format(scope)) reduced_latent = base_dense_layer(ae.flatten_encoded, latent_dims, 'reducer_{}'.format(name), is_training=is_training, bn=False, activation_fn=None) sq_x, sq_euclidean, cosine_similarity = reconstruction_distances( ae.input_tensor, ae.reconstruction) with tf.name_scope('latent_variables'): if use_cosine_similarity: relative_euclidean = tf.sqrt(sq_euclidean) / tf.sqrt(sq_x) relative_euclidean = tf.reshape(relative_euclidean, [-1, 1]) cosine_similarity = tf.reshape(cosine_similarity, [-1, 1]) distances = tf.concat([relative_euclidean, cosine_similarity], axis=1) else: distances = tf.sqrt(sq_euclidean) / tf.sqrt(sq_x) distances = tf.reshape(distances, [-1, 1]) if squared_x is None: squared_x = sq_x squared_euclidean = sq_euclidean z = tf.concat([reduced_latent, distances], axis=1) else: squared_x = squared_x + sq_x squared_euclidean = squared_euclidean + sq_euclidean z = tf.concat([z, reduced_latent, distances], axis=1) with tf.name_scope('n_count'): n_count = tf.shape(z)[0] n_count = tf.cast(n_count, tf.float32) estimator = Estimator(mixtures, z, is_training=is_training) gammas = estimator.output_tensor with tf.variable_scope('gmm_parameters'): phis = tf.get_variable('phis', shape=[mixtures], initializer=tf.ones_initializer(), dtype=tf.float32, trainable=False) mus = tf.get_variable('mus', shape=[mixtures, z.get_shape()[1]], initializer=tf.ones_initializer(), dtype=tf.float32, trainable=False) init_sigmas = 0.5 * np.expand_dims(np.identity(z.get_shape()[1]), axis=0) init_sigmas = np.tile(init_sigmas, [mixtures, 1, 1]) init_sigmas = tf.constant_initializer(init_sigmas) sigmas = tf.get_variable( 'sigmas', shape=[mixtures, z.get_shape()[1], z.get_shape()[1]], initializer=init_sigmas, dtype=tf.float32, trainable=False) sums = tf.reduce_sum(gammas, axis=0) sums_exp_dims = tf.expand_dims(sums, axis=-1) phis_ = sums / n_count mus_ = tf.matmul(gammas, z, transpose_a=True) / sums_exp_dims def assign_training_phis_mus(): with tf.control_dependencies( [phis.assign(phis_), mus.assign(mus_)]): return [tf.identity(phis), tf.identity(mus)] phis, mus = tf.cond(is_training, assign_training_phis_mus, lambda: [phis, mus]) phis_exp_dims = tf.expand_dims(phis, axis=0) phis_exp_dims = tf.expand_dims(phis_exp_dims, axis=-1) phis_exp_dims = tf.expand_dims(phis_exp_dims, axis=-1) zs_exp_dims = tf.expand_dims(z, 1) zs_exp_dims = tf.expand_dims(zs_exp_dims, -1) mus_exp_dims = tf.expand_dims(mus, 0) mus_exp_dims = tf.expand_dims(mus_exp_dims, -1) zs_minus_mus = zs_exp_dims - mus_exp_dims sigmas_ = tf.matmul(zs_minus_mus, zs_minus_mus, transpose_b=True) broadcast_gammas = tf.expand_dims(gammas, axis=-1) broadcast_gammas = tf.expand_dims(broadcast_gammas, axis=-1) sigmas_ = broadcast_gammas * sigmas_ sigmas_ = tf.reduce_sum(sigmas_, axis=0) sigmas_ = sigmas_ / tf.expand_dims(sums_exp_dims, axis=-1) sigmas_ = add_noise(sigmas_) def assign_training_sigmas(): with tf.control_dependencies([sigmas.assign(sigmas_)]): return tf.identity(sigmas) sigmas = tf.cond(is_training, assign_training_sigmas, lambda: sigmas) with tf.name_scope('loss'): loss_reconstruction = tf.reduce_mean(squared_euclidean, name='loss_reconstruction') inversed_sigmas = tf.expand_dims(tf.matrix_inverse(sigmas), axis=0) inversed_sigmas = tf.tile(inversed_sigmas, [tf.shape(zs_minus_mus)[0], 1, 1, 1]) energy = tf.matmul(zs_minus_mus, inversed_sigmas, transpose_a=True) energy = tf.matmul(energy, zs_minus_mus) energy = tf.squeeze(phis_exp_dims * tf.exp(-0.5 * energy), axis=[2, 3]) energy_divided_by = tf.expand_dims(tf.sqrt( 2.0 * math.pi * tf.matrix_determinant(sigmas)), axis=0) + 1e-12 energy = tf.reduce_sum(energy / energy_divided_by, axis=1) + 1e-12 energy = -1.0 * tf.log(energy) energy_mean = tf.reduce_sum(energy) / n_count loss_sigmas_diag = 1.0 / tf.matrix_diag_part(sigmas) loss_sigmas_diag = tf.reduce_sum(loss_sigmas_diag) loss = loss_reconstruction + lambda_1 * energy_mean + lambda_2 * loss_sigmas_diag return energy, z, loss, loss_reconstruction, energy_mean, loss_sigmas_diag