def train_model(gpu_count, image_shape, batch_gen, batch_gen_val, len_train_set, len_dev_set, len_class_size): checkpoint = ModelCheckpoint( filepath=args.model_save_path + args.model_name + '-sh=' + str(args.sh) + '-ep={epoch:02d},bz=' + str(args.batch_size) + ',loss={loss:.4f}.h5', monitor='loss', verbose=1) if gpu_count > 1: with tf.device('/cpu:0'): base_model = autoencoder(image_shape, len_class_size) model = base_model.model() print_summary(model, print_fn=lambda x: print(x, file=sys.stderr)) model.compile(loss='binary_crossentropy', optimizer='sgd') checkpoint = DelegatingCallbackWithFixedModel(checkpoint, model) model = multi_gpu_model(model, gpus=gpu_count) else: # base_model = autoencoder(image_shape, len_class_size) base_model = ResNet50(include_top=True, weights=None, input_tensor=None, input_shape=image_shape, pooling=None, classes=len_class_size) model = base_model print_summary(model, print_fn=lambda x: print(x, file=sys.stderr)) model.compile(loss='binary_crossentropy', optimizer='sgd') model.fit_generator( batch_gen, steps_per_epoch=len_train_set // args.batch_size, epochs=args.number_of_epochs, verbose=1, shuffle=True, callbacks=[checkpoint], validation_data=batch_gen_val, validation_steps=len_dev_set // args.batch_size)
def cae_encode(): # Load the autoencoder graph ae = model.autoencoder(input_shape=[None, 64, 64, 6]) # Load the data data, names = datasets.load_6f_images(args.data_dir) # Add ops to save and restore all the variables. saver = tf.train.Saver() with tf.Session() as sess: # Restore weights/tensors from disk saver.restore(sess, args.model_ckpt) print("Model restored.") # Evaluate the encoded tensor z encoded = sess.run(ae['z'], feed_dict={ae['x']: data}) print('Encoded data shape:', encoded.shape) # Save the encoded data mkdir(args.results_path) for i in range(data.shape[0]): # Save the encoded map as an RGB image cv2.imwrite(os.path.join(args.results_path, '%s.jpg' % names[i]), encoded[i]) # Save the encoded map as a numpy file np.save(os.path.join(args.results_path, '%s.npy' % names[i]), encoded[i])
def pretrain(self): """ Pretraining the weights for the deep SVDD network using autoencoder""" ae = autoencoder(self.args.latent_dim).to(self.device) ae.apply(weights_init_normal) optimizer = optim.Adam(ae.parameters(), lr=self.args.lr_ae, weight_decay=self.args.weight_decay_ae) scheduler = optim.lr_scheduler.MultiStepLR( optimizer, milestones=self.args.lr_milestones, gamma=0.1) ae.train() for epoch in range(self.args.num_epochs_ae): total_loss = 0 for x, _ in Bar(self.train_loader): x = x.float().to(self.device) optimizer.zero_grad() x_hat = ae(x) reconst_loss = torch.mean( torch.sum((x_hat - x)**2, dim=tuple(range(1, x_hat.dim())))) reconst_loss.backward() optimizer.step() total_loss += reconst_loss.item() scheduler.step() print('Pretraining Autoencoder... Epoch: {}, Loss: {:.3f}'.format( epoch, total_loss / len(self.train_loader))) self.save_weights_for_DeepSVDD(ae, self.train_loader)
def create_model(print_data=False): bioma_shape = data_microbioma_train.shape[1] if data_domain_train is not None: domain_shape = data_domain_train.shape[1] else: domain_shape = None models = autoencoder( bioma_shape=bioma_shape, #bioma_shape=717, domain_shape=domain_shape, output_shape=bioma_shape, #output_shape=717, latent_space=latent_space, bioma_layers=layers, domain_layers=domain_layers, input_transform=input_transform, output_transform=output_transform, activation_function_encoder=activation, activation_function_decoder=activation, activation_function_latent=activation_latent) model, encoder_bioma, encoder_domain, decoder_bioma = models if print_data: plot_models(model, encoder_bioma, encoder_domain, decoder_bioma) compile_train(model, encoder_bioma=encoder_bioma, encoder_domain=encoder_domain, reconstruction_error=reconstruction_loss, encoded_comparison_error=losses.MeanAbsoluteError(), metrics=get_experiment_metrics(input_transform, output_transform), optimizer=optimizer) return model, encoder_bioma, encoder_domain, decoder_bioma
def test(): # Load the autoencoder graph ae = model.autoencoder(input_shape=[None, 64, 64, 6]) # Load the data data, names = datasets.load_6f_images(args.data_dir, shuffle=True, sample=False) # Add ops to save and restore all the variables. saver = tf.train.Saver() with tf.Session() as sess: # Restore weights/tensors from disk saver.restore(sess, args.model_ckpt) print("Model restored.") # Evaluate test data in batches batch_size = data.shape[0] // NUM_BATCHES recon = np.ndarray(data.shape) encoded = np.ndarray([data.shape[0], 16, 16, 3]) for i in range(NUM_BATCHES): if i == NUM_BATCHES - 1: batch_x = data[i * batch_size:] recon[i * batch_size:] = sess.run(ae['y'], feed_dict={ae['x']: batch_x}) encoded[i * batch_size:] = sess.run( ae['z'], feed_dict={ae['x']: batch_x}) else: batch_x = data[i * batch_size:i * batch_size + batch_size] recon[i * batch_size:i * batch_size + batch_size] = sess.run( ae['y'], feed_dict={ae['x']: batch_x}) encoded[i * batch_size:i * batch_size + batch_size] = sess.run( ae['z'], feed_dict={ae['x']: batch_x}) # Save the various stages through the network mkdir(args.results_path) mkdir(os.path.join(args.results_path, 'reconstructions')) mkdir(os.path.join(args.results_path, 'error_maps')) mkdir(os.path.join(args.results_path, 'inputs')) mkdir(os.path.join(args.results_path, 'encodings')) for i in range(data.shape[0]): # Save the reconstructed images np.save( os.path.join(args.results_path, 'reconstructions', '%s.npy' % names[i]), recon[i]) # Save the encoded maps np.save( os.path.join(args.results_path, 'encodings', '%s.npy' % names[i]), encoded[i]) # Save the input images np.save(os.path.join(args.results_path, 'inputs', '%s.npy' % names[i]), data[i]) # Save the error maps between input and reconstructed images np.save( os.path.join(args.results_path, 'error_maps', '%s.npy' % names[i]), get_error_map(data[i], recon[i]))
def main(**kwargs): opt.parse(kwargs) opt.show() model = autoencoder().cuda() criterion = nn.MSELoss() optimizer = t.optim.Adam(model.parameters(), lr=opt.learning_rate, weight_decay=1e-5) dataloader = get_loader(opt) if opt.load_from is not None: state = t.load(opt.load_from) model.load_state_dict(state['state_dict']) optimizer.load_state_dict(state['optimizer']) for epoch in range(opt.num_epochs): for ii, data in enumerate(dataloader): img, _ = data img = Variable(img).cuda() output = model(img) loss = criterion(output, img) optimizer.zero_grad() loss.backward() optimizer.step() if ii % 100 == 0: print("step [{}:{}], loss {:.4f}".format( epoch + 1, ii, loss.data[0])) print("epoch [{}/{}], loss{:.4f}".format(epoch + 1, opt.num_epochs, loss.data[0])) if epoch % 5 == 0: pic = to_img(output.cpu().data) save_image( pic, os.path.join(opt.save_dir, 'dc_img', 'img_{}.png'.format(epoch))) state = { 'epoch': epoch, 'state_dict': model.state_dict(), 'optimizer': optimizer.state_dict(), } t.save( state, os.path.join(opt.save_dir, 'model', 'ckpt_{}.pt'.format(epoch)))
def train(): # load mastcam data train_data, train_names = datasets.load_6f_images(path=args.train_dir) val_data, val_names = datasets.load_6f_images(path=args.val_dir) ae = model.autoencoder(input_shape=[None, 64, 64, 6], loss=args.loss_fn, hybrid_lambda=args.hybrid_lambda) learning_rate = 0.001 optimizer = tf.train.AdamOptimizer(learning_rate, epsilon=1.0).minimize(ae['cost']) # We create a session to use the graph sess = tf.Session() train_writer = tf.summary.FileWriter(os.path.join(args.summaries_dir, 'train'), sess.graph) val_writer = tf.summary.FileWriter(os.path.join(args.summaries_dir, 'validation')) sess.run(tf.global_variables_initializer()) # Add ops to save and restore all the variables. saver = tf.train.Saver() # Fit all training data num_batches = train_data.shape[0] / args.batch_size print("num batches = %d" % num_batches) step = 1 epochs = 1 prev_loss = 10000000 while True: for batch_i in range(num_batches): idx = batch_i*args.batch_size batch_xs = train_data[idx:idx+args.batch_size] sess.run(optimizer, feed_dict={ae['x']: batch_xs, ae['keep_prob']: 0.6}) train_loss = sess.run(ae['merged'], feed_dict={ae['x']: batch_xs, ae['keep_prob']: 0.6}) train_writer.add_summary(train_loss, step) step += 1 val_loss = sess.run(ae['merged'], feed_dict={ae['x']: val_data, ae['keep_prob']: 1.0}) val_writer.add_summary(val_loss, step) loss = sess.run(ae['cost'], feed_dict={ae['x']: val_data, ae['keep_prob']: 1.0}) print('Validation loss at Epoch %d (delta=%f)' % (epochs, prev_loss - loss), loss) if prev_loss - loss < args.convergence_delta: break prev_loss = loss epochs += 1 # Save the model for future training or testing name = 'udr_12-8-3_3-3-3_nodrop_loss=%s_lambda=%f_epochs=%d_data=%s' % (args.loss_fn, args.hybrid_lambda, epochs, args.train_dir.split('/')[-2]) save_path = saver.save(sess, "/scratch/hkerner/saved_sessions/%s.ckpt" % name) print("Model saved in path: %s" % save_path) val_writer.close() train_writer.close()
def main(args): basedir = args.basedir savedir = args.savedir filelist = args.filelist weights = args.weight_path if filelist is not None: with open(filelist) as f: filenames = f.read().splitlines() if not os.path.exists(savedir): os.makedirs(savedir) model = autoencoder() model.load_weights(weights) for filename in filenames: filepath = os.path.join(basedir, 'images/%s.jpg' % (filename)) print(filepath) img = cv2.imread(filepath) img = cv2.resize(img, (256, 256)) img = img[:, :, [2, 1, 0]] # to RGB x = np.array(img) X = np.expand_dims(x, 0) X = X / 127.5 X = X - 1. y_pred = model.predict(X) y_pred = np.argmax(y_pred, axis=-1) pred_mask = y_pred.reshape((256, 256)) pred_mask = pred_mask.astype('int') h, w = pred_mask.shape ori = cv2.resize(img, (w, h)) for i in range(class_num + 1): mask = (pred_mask == i).astype(np.bool) color_mask = np.array(color_list[i], dtype=np.uint8) alpha = 0.55 ori[mask] = ori[mask] * (1 - alpha) + color_mask * (alpha) filesave = os.path.join(savedir, '%s.jpg' % (filename)) cv2.imwrite(filesave, ori)
def main(unused_argv): if len(unused_argv ) != 1: # prints a message if you've entered flags incorrectly raise Exception("Problem with flags: %s" % unused_argv) if (FLAGS.mode != 'train'): FLAGS.batch_size = 1 batcher = Batcher(FLAGS.dataset, "MNIST_data/", FLAGS.mode, FLAGS.batch_size, FLAGS.err_type, FLAGS.err_frac, FLAGS.antimode) nfeatures = batcher.nfeatures if (FLAGS.dataset == 'timeseries'): model = rnnautoencoder(FLAGS.mode, FLAGS.batch_size, nfeatures) else: model = autoencoder(FLAGS.mode, FLAGS.batch_size, nfeatures) if (FLAGS.mode == 'train'): setup_training(model, batcher) elif (FLAGS.mode == 'val'): run_eval(model, batcher) elif (FLAGS.mode == 'decode'): run_decoding(model, batcher)
def run_inference(model_file, input, n_hidden, dim_z): tf.reset_default_graph() # network architecture n_hidden = n_hidden dim_input = input.shape[1] # number of samples per segment dim_z = dim_z # input placeholders # In denoising-autoencoder, x_hat == x + noise, otherwise x_hat == x x_hat = tf.placeholder(tf.float32, shape=[None, dim_input], name='input_img') x = tf.placeholder(tf.float32, shape=[None, dim_input], name='target_img') # dropout keep_prob = tf.placeholder(tf.float32, name='keep_prob') # input for PMLR #z_in = tf.placeholder(tf.float32, shape=[None, dim_z], name='latent_variable') y, z, loss, neg_marginal_likelihood, KL_divergence = model.autoencoder( x_hat, x, dim_input, dim_z, n_hidden, keep_prob) saver = tf.train.Saver() with tf.Session() as sess: saver.restore(sess, model_file) return sess.run((z, y, loss), feed_dict={ x_hat: input, x: input, keep_prob: 1.0 })
def make_model( data_dim, latent_dim, num_epochs, ): # Layer graph data = lbann.Input(data_field='samples') autoencoder = model.autoencoder.FullyConnectedAutoencoder( data_dim, latent_dim, ) reconstructed = autoencoder(data) loss = lbann.MeanSquaredError(data, reconstructed) # Metrics metrics = [ lbann.Metric(loss, name='loss'), ] # Callbacks callbacks = [ lbann.CallbackPrint(), lbann.CallbackTimer(), lbann.CallbackDumpWeights(directory='weights', epoch_interval=num_epochs), ] # Contruct model return lbann.Model( num_epochs, layers=lbann.traverse_layer_graph(loss), objective_function=loss, metrics=metrics, callbacks=callbacks, )
# Set TensorFlow to allow for growth. Helps compatibility. import tensorflow as tf from keras import backend as ktf ktf.clear_session() config = tf.ConfigProto() config.gpu_options.allow_growth = True session = tf.Session(config=config) ktf.set_session(session) input_shape = (32, 32, 3) target_size = input_shape[:2] batch_size = 64 model = autoencoder() # model = UNET() model.compile(loss="mean_squared_error", optimizer=Adam(lr=0.001)) model.summary() image_generator = ImageDataGenerator( # rotation_range=15, # width_shift_range=0.1, # height_shift_range=0.1, # shear_range=0.01, # zoom_range=[0.9, 1.25], horizontal_flip=False, vertical_flip=False, # fill_mode='reflect',
def test(model, args): data_path = args.data_path n_channels = args.channels n_classes = args.classes data_width = args.width data_height = args.height gpu = args.gpu # Hyper paremter for MagNet thresholds = [0.01, 0.05, 0.001, 0.005] reformer_model = None if args.reformer == 'autoencoder1': reformer_model = autoencoder(n_channels) elif args.reformer == 'autoencoder2': reformer_model = autoencoder2(n_channels) else: print("wrong reformer model : must be autoencoder1 or autoencoder2") raise SystemExit print('reformer model') summary(reformer_model, input_size=(n_channels, data_height, data_width), device='cpu') detector_model = None if args.detector == 'autoencoder1': detector_model = autoencoder(n_channels) elif args.detector == 'autoencoder2': detector_model = autoencoder2(n_channels) else: print("wrong detector model : must be autoencoder1 or autoencoder2") raise SystemExit print('detector model') summary(detector_model, input_size=(n_channels, data_height, data_width), device='cpu') # set device configuration device_ids = [] if gpu == 'gpu': if not torch.cuda.is_available(): print("No cuda available") raise SystemExit device = torch.device(args.model_device1) device_defense = torch.device(args.defense_model_device) device_ids.append(args.model_device1) if args.model_device2 != -1: device_ids.append(args.model_device2) if args.model_device3 != -1: device_ids.append(args.model_device3) if args.model_device4 != -1: device_ids.append(args.model_device4) else: device = torch.device("cpu") device_defense = torch.device("cpu") detector = AEDetector(detector_model, device_defense, args.detector_path, p=2) reformer = SimpleReformer(reformer_model, device_defense, args.reformer_path) classifier = Classifier(model, device, args.model_path, device_ids) # set testdataset test_dataset = SampleDataset(data_path) test_loader = DataLoader( test_dataset, batch_size=10, num_workers=4, ) print('test_dataset : {}, test_loader : {}'.format(len(test_dataset), len(test_loader))) # Defense with MagNet print('test start') for thrs in thresholds: print('----------------------------------------') counter = 0 avg_score = 0.0 thrs = torch.tensor(thrs) with torch.no_grad(): for batch_idx, (inputs, labels) in enumerate(test_loader): inputs = inputs.float() labels = labels.to(device).long() target = make_one_hot(labels[:, 0, :, :], n_classes, device) operate_results = operate(reformer, classifier, inputs) all_pass, _ = filters(detector, inputs, thrs) if len(all_pass) == 0: continue filtered_results = operate_results[all_pass] pred = filtered_results.to(device).float() target = target[all_pass] loss = dice_score(pred, target) avg_score += loss.data.cpu().numpy() # statistics counter += 1 del inputs, labels, pred, target, loss if counter: avg_score = avg_score / counter print('threshold : {:.4f}, avg_score : {:.4f}'.format( thrs, avg_score)) else: print( 'threshold : {:.4f} , no images pass from filter'.format(thrs))
label="Error" if name == 1 else "Normal") ax.legend() plt.title("Reconstruction error for different classes") plt.ylabel("Reconstruction error") plt.xlabel("Data point index") plt.show() if __name__ == '__main__': #data import filename = 'Book1.csv' df = pd.read_csv(filename) df_train, df_valid, df_test, df_test_y = preprocessing(df) #create the model model = autoencoder(df_train.shape[1]) model.summary() #train the model output = model.fit(df_train, df_valid) train_plot(output) #predict model.load_model('autoencoder_v1.h5') x_pred = model.predict(df_test) #calculate and plot the reconstruction loss error = reconstruction_loss(df_test, x_pred, df_test_y) error_plot(error)
torch.save(model_state_dict, model_path) return loss_history if __name__ == "__main__": args = get_args() n_channels = args.channels n_classes = args.classes model = None if args.model_number == 1: model = autoencoder(n_channels) elif args.model_number == 2: model = autoencoder2(n_channels) else: print("wrong model number : must be 1 or 2") raise SystemExit print('Training Autoencoder {}'.format(str(args.model_number))) summary(model, input_size=(n_channels, args.height, args.width), device='cpu') loss_history = train_net(model, args)
def train(args): ##parameters n_steps = args.n_steps n_input = args.n_input batch_size = args.batch_size dropout_constant = args.dropout_constant ## Underlying graph graph = tf.Graph() with graph.as_default(): #data with tf.name_scope('input'): x = tf.placeholder(tf.float32, [None, n_input], name='x-input') with tf.name_scope('dropout'): keep_prob = tf.placeholder(tf.float32) tf.summary.scalar('dropout_keep_probability', keep_prob) with tf.name_scope('noise'): noise_std = tf.placeholder(tf.float32) tf.summary.scalar('dropout_keep_probability', noise_std) #model code, reconstruction = autoencoder(x, dropout=keep_prob, noise_std=noise_std) #loss with tf.name_scope('MSE_loss'): loss = tf.reduce_sum(tf.square(x - reconstruction)) global_step = tf.Variable(0) # count the number of steps taken. learning_rate = tf.train.exponential_decay(0.01, global_step, 100, 0.91) optimizer = tf.train.AdamOptimizer( learning_rate=learning_rate).minimize(loss, global_step=global_step) tf.summary.scalar("loss", loss) #logging log_dir = args.log_dir if tf.gfile.Exists(log_dir): tf.gfile.DeleteRecursively(log_dir) tf.gfile.MakeDirs(log_dir) merged = tf.summary.merge_all() train_writer = tf.summary.FileWriter(log_dir + '/train', graph=graph) test_writer = tf.summary.FileWriter(log_dir + '/test') #training sess = tf.InteractiveSession(graph=graph) tf.global_variables_initializer().run() mean_img_train = np.mean(mnist.train.images[:50000], axis=0) mean_img_validation = np.mean(mnist.train.images[50000:55000], axis=0) x_valid = [img - mean_img_validation for img in mnist.train.images][50000:55000] for i in range(n_steps): if i % 10 == 0: #test error cost, summary = sess.run([loss, merged], feed_dict={ x: x_valid, keep_prob: 1.0, noise_std: 0 }) test_writer.add_summary(summary, i) print "Loss at step %d: %.1f" % (i, cost) else: # Record train set summaries and train offset = (i * batch_size) % (50000 - batch_size) # Generate a minibatch. batch_data = mnist.train.images[offset:(offset + batch_size), :] x_batch = np.array( [img - mean_img_train for img in batch_data]) # Record execution stats (every 100th step) if i % 100 == 99: run_options = tf.RunOptions( trace_level=tf.RunOptions.FULL_TRACE) run_metadata = tf.RunMetadata() _, summary = sess.run([optimizer, merged], feed_dict={ x: x_batch, keep_prob: dropout_constant, noise_std: 0.05 }, options=run_options, run_metadata=run_metadata) train_writer.add_run_metadata(run_metadata, 'step%03d' % i) train_writer.add_summary(summary, i) print('Adding run metadata for', i) else: _, cost, summary = sess.run([optimizer, loss, merged], feed_dict={ x: x_batch, keep_prob: dropout_constant, noise_std: 0.05 }) train_writer.add_summary(summary, i) train_writer.close() test_writer.close() print( "For Autoencoder tensorboard logs run 'tensorboard --logdir=%s'" % log_dir) #Autoencoder Benchmarking #Embeddings from encoded train set train_size = 55000 mean_img_train = np.mean(mnist.train.images[:train_size], axis=0) for i in range(train_size / 100): step = i * 100 x_mnist_train, y_mnist_train = mnist.train.images[ step:step + 100], mnist.train.labels[step:step + 100] x_mnist_train_norm = np.array( [img - mean_img_train for img in x_mnist_train]) new_embedds = sess.run(code, feed_dict={ x: x_mnist_train_norm, keep_prob: 1, noise_std: 0 }) if i == 0: train_embedds = new_embedds else: train_embedds = np.concatenate((train_embedds, new_embedds), axis=0) #Multiclass LogRegression clf = LogisticRegression(multi_class='multinomial', solver='lbfgs') clf.fit(train_embedds, np.argmax(mnist.train.labels[:train_size], axis=1)) #Embeddings from encoded train set test_size = 10000 mean_img_test = np.mean(mnist.test.images, axis=0) for i in range(test_size / 100): step = i * 100 x_mnist_test, y_test = mnist.test.images[ step:step + 100], mnist.test.labels[step:step + 100] x_mnist_test_norm = np.array( [img - mean_img_train for img in x_mnist_test]) new_embedds = sess.run(code, feed_dict={ x: x_mnist_test_norm, keep_prob: 1, noise_std: 0 }) if i == 0: test_embedds = new_embedds else: test_embedds = np.concatenate((test_embedds, new_embedds), axis=0) #LogRegression Accuracy accuracy = np.mean( clf.predict(test_embedds) == np.argmax( mnist.test.labels[:test_size], axis=1)) print('Accuracy: %.2f%%' % (accuracy * 100))
confusion_matrix_op_1, cross_entropy_1, train_op_1, global_step_tensor_1, saver_1, accuracy_1, lhs_1, rhs_1 = FourLayerConvNet( input, output, args.learning_rate, args.momentum_1, args.momentum_2) print("LABELS") print(labels.shape) print("=======================================") print("DATA SHAPE") print(data.shape) else: # get ImageNet data and process its data = np.load('/work/cse496dl/shared/homework/02/imagenet_images.npy') train_data = np.reshape(data, [-1, 32, 32, 3]) train_num_examples = train_data.shape[0] # image net total_loss_1, train_op_1, global_step_tensor_1, saver_1 = autoencoder( input, args.learning_rate, args.momentum_1, args.momentum_2) print("=======================================") print("DATA SHAPE") print(data.shape) # Training with tf.Session() as session: # initialize variables session.run(tf.global_variables_initializer()) # batch size batch_size = args.batch_size # Hypterparameter information print('Model: {}'.format(args.load_data))
def run_single_model(val, loss="mean_squared_error"): ae, encoder = autoencoder(val.shape[1], loss=loss) ae.fit(val, val, batch_size=32, epochs=EPOCHS) bottleneck_representation = encoder.predict(val) cluster = k_means(bottleneck_representation, CLUSTER) return cluster, bottleneck_representation
dataset = [] for i in range(2): dataset.append(CustomDataset(data_dir, i)) dataloaders = { x: torch.utils.data.DataLoader(dataset[x], batch_size=batch_size, shuffle=True, num_workers=12) for x in range(2) } dataset_sizes = {x: len(dataloaders[x]) for x in range(2)} model = autoencoder(learning_rate).cuda() criterion = nn.MSELoss() for epoch in range(num_epochs): for actor in range(2): cum_loss = [] tot = 0 model.setMode(actor) for warped, original in dataloaders[actor]: img = warped.float() img = Variable(img).cuda() original = original.float() original = Variable(original).cuda()
num_epochs = 10 batch_size = 4 learning_rate = 1e-3 img_transform = transforms.Compose([ transforms.ToPILImage(), transforms.Resize((image_size,image_size)), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ]) dataset_training = RainyDataset('rainy-image-dataset/training', transform=img_transform) total_train = len(dataset_training) dataloader_training = DataLoader(dataset_training, batch_size=batch_size, shuffle=True,num_workers=4) model = autoencoder().cuda() criterion = nn.MSELoss() optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=1e-5) model.train() print("Training model, total samples %d"%total_train) for epoch in range(num_epochs): epoch_loss = 0 os.makedirs('%s/epoch_%d'%(img_dirs,epoch),exist_ok=True) ssim = 0 for index,data in enumerate(dataloader_training): clean_img = data["clean"] rainy_img = data["rain"] f_rain = data["fourier_rain"]
def main(args): path_dataset = args.dataset # '/home/philyang/drone/data/data512' traintxt = args.traintxt # '/home/philyang/drone/data/data512/train.txt' trainGen = DataGen(filepath=traintxt, path_dataset=path_dataset) # trainGen = DataGenCifar10(batch_size=4, class_num=10, dim=(256,256), n_channels=3) valtxt = args.valtxt valGen = DataGen(filepath=valtxt, path_dataset=path_dataset) # valGen = DataGenCifar10(batch_size=4, class_num=10, dim=(256,256), n_channels=3) # define checkpoint dataset_name = trainGen.name() dirname = 'ckpt-' + dataset_name if not os.path.exists(dirname): os.makedirs(dirname) timestr = datetime.datetime.now().strftime("%Y%m%d-%H%M%S") filepath = os.path.join(dirname, 'weights-%s-{epoch:02d}-{loss:.2f}.hdf5' %(timestr)) checkpoint = ModelCheckpoint(filepath=filepath, monitor='val_loss', # acc outperforms loss verbose=1, save_best_only=False, save_weights_only=True, period=5) # define logs for tensorboard tensorboard = TensorBoard(log_dir='logs', histogram_freq=0) wgtdir = 'weights' if not os.path.exists(wgtdir): os.makedirs(wgtdir) strategy = tf.distribute.MirroredStrategy() print("Number of devices: {}".format(strategy.num_replicas_in_sync)) # Open a strategy scope. # with strategy.scope(): model = autoencoder() model.compile(optimizer=tf.keras.optimizers.SGD(learning_rate=0.001), loss=sparse_crossentropy) model.summary() start_epoch = 0 # Load weight of unfinish training model(optional) if args.weights is not None and args.start_epoch is not None: weights_path = args.weights start_epoch = int(args.start_epoch) model.load_weights(weights_path) model.fit_generator( generator=trainGen, steps_per_epoch=len(trainGen), validation_data=valGen, validation_steps=len(valGen), initial_epoch=start_epoch, epochs=1000, callbacks=[checkpoint,tensorboard], use_multiprocessing=False, verbose=1, workers=1, max_queue_size=10) model.save('./model.h5')
savedir = './results/run' \ if args.savedir is None else args.savedir if not os.path.isdir(savedir): os.makedirs(savedir) # get data xtr, ytr, xte, yte = mnist_1000(args.mnist_path) # placeholders x = tf.placeholder(tf.float32, [None, 784]) n_train_batches = int(1000/args.batch_size) n_test_batches = int(1000/args.batch_size) # models net = autoencoder(x, args.zdim, True) # train tnet = autoencoder(x, args.zdim, False, reuse=True) # test # for visualization z = tf.placeholder(tf.float32, [None, args.zdim]) tennet = encoder(x, args.zdim, reuse=True) # test encoder tdenet = decoder(z, reuse=True) # test decoder def train(): loss = -net['elbo'] # negative ELBO global_step = tf.train.get_or_create_global_step() lr = tf.train.piecewise_constant(tf.cast(global_step, tf.int32), [int(n_train_batches*args.n_epochs/2)], [1e-3, 1e-4]) train_op = tf.train.AdamOptimizer(lr).minimize(loss, global_step=global_step)
def main(args, train_data, test_data): tf.reset_default_graph() """ parameters """ # network architecture n_hidden = args.n_hidden dim_input = train_data.shape[1] # number of samples per segment dim_z = args.dim_z # train n_epochs = args.num_epochs batch_size = args.batch_size learn_rate = args.learn_rate run_name = "{}_{}_{}_{}".format( args.encoder, ('iaf' if args.iaf else ('mmd' if args.mmd else 'kl')), str(args.dim_z), args.run_name) + ('_mse' if args.mse else '') print(run_name) """ prepare data """ n_train = train_data.shape[0] n_test = test_data.shape[0] """ build graph """ # input placeholders # In denoising-autoencoder, x_hat == x + noise, otherwise x_hat == x x_hat = tf.placeholder(tf.float32, shape=[None, dim_input], name='input_img') x = tf.placeholder(tf.float32, shape=[None, dim_input], name='target_img') # dropout keep_prob = tf.placeholder(tf.float32, name='keep_prob') # input for PMLR #z_in = tf.placeholder(tf.float32, shape=[None, dim_z], name='latent_variable') # network architecture y, z, loss, neg_marginal_likelihood, KL_divergence, norm =\ model.autoencoder(x, x, dim_input, dim_z, n_hidden, keep_prob, encoder=args.encoder, decoder=args.decoder, use_iaf=args.iaf, use_mmd=args.mmd, mse=args.mse) s1 = tf.summary.scalar('train/loss', loss) s2 = tf.summary.scalar('train/neg_marginal_likelihood', neg_marginal_likelihood) s3 = tf.summary.scalar('train/KL_divergence', KL_divergence) s4 = tf.summary.scalar('norm', norm) training_summaries = tf.summary.merge([s1, s2, s3, s4]) # optimization train_op = tf.train.AdamOptimizer(learn_rate).minimize(loss) """ training """ # save saver = tf.train.Saver() # train n_batches_train = np.ceil(n_train / batch_size).astype(int) n_batches_test = np.ceil(n_test / batch_size).astype(int) min_tot_loss = 1e99 all_losses = [] all_likelihoods = [] all_divergences = [] with tf.Session() as sess: # train model if args.visualize_sample == -1: # Random shuffling -> disable for now # np.random.shuffle(train_data) writer = tf.summary.FileWriter( '/cache/tensorboard-logdir/{}'.format(run_name), graph=tf.get_default_graph()) with open('{}.log'.format(run_name), 'w') as logfile: print('Training model {}'.format(run_name)) sess.run(tf.global_variables_initializer(), feed_dict={keep_prob: 0.9}) for epoch in range(n_epochs): # For collecting latent dim embeddings z_out = np.zeros((0, dim_z)) test_losses = [] test_likelihoods = [] test_divergences = [] train_losses = [] train_likelihoods = [] train_divergences = [] # Loop over all batches for i in range(n_batches_train): # Compute the offset of the current minibatch in the data. offset = i * batch_size batch_train_input = train_data[offset:(offset + batch_size)] _, tot_loss, loss_likelihood, loss_divergence, train_summary, z_in = sess.run( (train_op, loss, neg_marginal_likelihood, KL_divergence, training_summaries, z), feed_dict={ x_hat: batch_train_input, x: batch_train_input, keep_prob: 1.0 }) writer.add_summary(train_summary, epoch * n_batches_train + i) train_losses.append(tot_loss) train_likelihoods.append(loss_likelihood) train_divergences.append(loss_divergence) # Add embeddings to list z_out = np.concatenate((z_out, z_in), axis=0) for i in range(n_batches_test): offset = i * batch_size batch_test_input = test_data[offset:(offset + batch_size)] test_loss, test_likelihood, test_divergence, reconstr, z_in = sess.run( (loss, neg_marginal_likelihood, KL_divergence, y, z), feed_dict={ x_hat: batch_test_input, x: batch_test_input, keep_prob: 1.0 }) test_losses.append(test_loss) test_likelihoods.append(test_likelihood) test_divergences.append(test_divergence) z_out = np.concatenate((z_out, z_in), axis=0) all_losses += test_losses all_likelihoods += test_likelihoods all_divergences += test_divergences test_summaries = tf.Summary() test_summaries.value.add(tag="test/loss", simple_value=np.mean(test_losses)) test_summaries.value.add( tag="test/neg_marginal_likelihood", simple_value=np.mean(test_likelihoods)) test_summaries.value.add( tag="test/KL_divergence", simple_value=np.mean(test_divergences)) writer.add_summary(test_summaries, (epoch + 1) * n_batches_train - 1) # print cost every epoch train_line = "epoch %d: L_tot %.2E L_likelihood %.2E L_divergence %.2E" % ( epoch, tot_loss, loss_likelihood, loss_divergence) test_line = " test: L_tot %.2E L_likelihood %.2E L_divergence %.2E" % ( test_loss, test_likelihood, test_divergence) logfile.write(train_line + '\n') logfile.write(test_line + '\n') print(train_line) print(test_line) # if minimum loss is updated or final epoch, plot results if test_loss < min_tot_loss: min_tot_loss = test_loss #with open('min_{}.txt'.format(run_name), 'w') as log: # log.write('Minimum total loss: ' + str(test_loss) + '\n') # log.write('Minimum likelihood: ' + str(test_likelihood) + '\n') # log.write('Minimum divergence: ' + str(test_divergence) + '\n') #batch_test_input = np.reshape(batch_train_input, (-1, nchannel, 128)) #reconstr = np.reshape(reconstr, (-1, nchannel, 128)) #for ch in range(nchannel): # plot_to_file('./images/reconstruction_{}.png'.format(ch), # batch_test_input[0][ch], reconstr[0][ch]) # fft = lambda x: np.abs(np.fft.fft(x - np.mean(x))) # plot_to_file('./images/fft_{}.png'.format(ch), # fft(batch_test_input[0][ch]), fft(reconstr[0][ch])) # if training is finished if epoch + 1 == n_epochs: #save_embedding(np.concatenate((train_data, test_data)), z_out, sess, writer, channel_idx) save_path = saver.save( sess, '/cache/model-{}.ckpt'.format(run_name)) print('Model saved to {}'.format(save_path)) #np.save('losses_{}'.format(run_name), all_losses) #np.save('likelihoods_{}'.format(run_name), all_likelihoods) #np.save('divergences_{}'.format(run_name), all_divergences) #moving_average_n = 10 #plot_training('{}.png'.format(run_name), # [np.convolve(x, np.ones((moving_average_n,))/moving_average_n, mode='valid') for x in # [all_losses, all_likelihoods, all_divergences]], # ['Total loss', 'Loss likelihood', 'KL divergence']) batch_test_input = np.reshape(batch_train_input, (-1, nchannel, 128)) reconstr = np.reshape(reconstr, (-1, nchannel, 128)) for ch in range(nchannel): plot_to_file( './images/reconstruction_{}.png'.format(ch), batch_test_input[0][ch], reconstr[0][ch]) fft = lambda x: np.abs(np.fft.fft(x - np.mean(x))) plot_to_file('./images/fft_{}.png'.format(ch), fft(batch_test_input[0][ch]), fft(reconstr[0][ch])) # visualize model else: saver.restore(sess, './logs/model-{}.ckpt'.format(args.run_name)) with h5py.File('/data/eeg_channels.h5', 'r') as h5f: input = [ (h5f['one_sec_norm'][args.channel, args.visualize_sample, :] + 1.0) / 2.0 ] latent_space, reconstr, loss_sample = sess.run( (z, y, loss), feed_dict={ x_hat: input, x: input, keep_prob: 1.0 }) plot_to_file( './logs/{}/reconstruction_{}.png'.format( args.channel, args.visualize_sample), input[0], reconstr[0]) plot_to_file( './logs/{}/freq_{}.png'.format(args.channel, args.visualize_sample), scipy.signal.periodogram(input[0] * 256), scipy.signal.periodogram(reconstr[0] * 256))
def main(): args = parse_args() print("Params:") print(args) print() config = tf.ConfigProto() config.gpu_options.allow_growth = True X = tf.placeholder(tf.float32, [17770, None], name='X') Y = tf.placeholder(tf.float32, [17770, None], name='Y') Yhat, weights = model.autoencoder(X, args.layers, keep_prob=(1.0 - args.dropout), constrained=args.constrained) YhatDev, weights = model.autoencoder(X, args.layers, constrained=args.constrained, weights=weights) loss = model.get_loss(Y, Yhat) loss_sum, loss_examples = model.get_test_loss(Y, Yhat) loss_sum_dev, loss_examples_dev = model.get_test_loss(Y, YhatDev) losses = (loss, loss_sum, loss_examples, loss_sum_dev, loss_examples_dev) optimizer = model.get_optimizer(args.optimizer_type, args.lr, args.momentum) if args.small_dataset: train_path = "../data/netflix/output_small_train" dev_path = "../data/netflix/output_small_dev" test_path = "../data/netflix/output_small_test" else: train_path = "../data/netflix/output_train" dev_path = "../data/netflix/output_dev" test_path = "../data/netflix/output_test" data_train = data_manager.Data(size=args.chunk_size, batch=args.batch_size, path=train_path) data_dev = data_manager.Data(size=args.chunk_size, batch=args.batch_size, path=dev_path, test=True) data_test = data_manager.Data(size=args.chunk_size, batch=args.batch_size, path=test_path, test=True) train_losses, eval_losses = model.train( data_train, data_dev, losses, optimizer, X, Y, Yhat, epochs=args.epochs, dense_refeeding=args.dense_refeeding) model.test(data_test, X, Y, YhatDev) t, = plt.plot([i + 1 for i in range(len(train_losses))], train_losses, label="Train") e, = plt.plot([i + 1 for i in range(len(eval_losses))], eval_losses, label="Dev") plt.legend(handles=[t, e]) plt.xlabel("Epoch") plt.ylabel("Loss") plt.show() print([i + 1 for i in range(len(train_losses))]) print(train_losses) print([i + 1 for i in range(len(eval_losses))]) print(eval_losses)
# learn (75%) test (25%) trainX, testX = train_test_split(data, test_size=0.2) trainX = np.asarray(trainX).astype("float32") / 255.0 testX = np.asarray(testX).astype("float32") / 255.0 # Noises trainNoise = np.random.normal(loc=0.5, scale=0.5, size=trainX.shape) testNoise = np.random.normal(loc=0.5, scale=0.5, size=testX.shape) trainXNoisy = np.clip(trainX + trainNoise, 0, 1) testXNoisy = np.clip(testX + testNoise, 0, 1) print("[INFO] building autoencoder...") input_img = Input(shape=(IMAGE_HEIGHT, IMAGE_WIDTH, 3)) autoencoder = Model(input_img, autoencoder(input_img)) autoencoder.compile(loss="mean_squared_error", optimizer=RMSprop()) H = autoencoder.fit(trainXNoisy, trainX, validation_data=(testXNoisy, testX), epochs=EPOCHS, batch_size=BS, shuffle=True, callbacks=[TensorBoard(log_dir='/tmp/autoencoder')]) N = np.arange(0, EPOCHS) plt.style.use("ggplot") plt.figure() plt.plot(N, H.history["loss"], label="train_loss") plt.plot(N, H.history["val_loss"], label="val_loss")